Changeset 5e718d9 for uspace/lib/bithenge – HelenOS

uspace/lib/bithenge/blob.c

-              r0da6c04
+              r5e718d9
         assert(ops->size);
+        if (bithenge_should_fail())
+                return ENOMEM;
         blob->base.type = BITHENGE_NODE_BLOB;
         blob->base.refs = 1;
 …
+{
         memory_blob_t *blob = blob_as_memory(base);
+        if (bithenge_should_fail())
+                return EIO;
         *size = blob->size;
         return EOK;
 …
         .destroy = memory_destroy,
 };
-/** Create a blob node from data. Unlike with @a
- * bithenge_blob_t::bithenge_new_blob_from_buffer, the data is copied into a
- * new buffer and the original data can be changed after this call. The blob
- * must be freed with @a bithenge_node_t::bithenge_node_destroy after it is
- * used.
- * @memberof bithenge_blob_t
- * @param[out] out Stores the created blob node.
- * @param[in] data The data.
- * @param len The length of the data.
- * @return EOK on success or an error code from errno.h. */
-int bithenge_new_blob_from_data(bithenge_node_t **out, const void *data,
-    size_t len)
+{
-        int rc;
-        assert(data || !len);
-        memory_blob_t *blob = malloc(sizeof(*blob));
-        if (!blob)
-                return ENOMEM;
-        rc = bithenge_init_random_access_blob(memory_as_blob(blob),
-            &memory_ops);
-        if (rc != EOK) {
-                free(blob);
-                return rc;
+        }
-        char *buffer = malloc(len);
-        if (!buffer) {
-                free(blob);
-                return rc;
+        }
-        memcpy(buffer, data, len);
-        blob->buffer = buffer;
-        blob->size = len;
-        blob->needs_free = true;
-        *out = bithenge_blob_as_node(memory_as_blob(blob));
-        return EOK;
+}
 /** Create a blob node from a buffer. The buffer must exist as long as the blob
 …
         memory_blob_t *blob = malloc(sizeof(*blob));
+        if (!blob)
+                return ENOMEM;
+        if (!blob) {
+                rc = ENOMEM;
+                goto error;
+        }
         rc = bithenge_init_random_access_blob(memory_as_blob(blob),
             &memory_ops);
+        if (rc != EOK) {
+                free(blob);
+                return rc;
+        }
+        if (rc != EOK)
+                goto error;
         blob->buffer = buffer;
         blob->size = len;
 …
         *out = bithenge_blob_as_node(memory_as_blob(blob));
         return EOK;
+}
+error:
+        if (needs_free)
+                free((void *)buffer);
+        free(blob);
+        return rc;
+}
+/** Create a blob node from data. Unlike with @a
+ * bithenge_blob_t::bithenge_new_blob_from_buffer, the data is copied into a
+ * new buffer and the original data can be changed after this call. The blob
+ * must be freed with @a bithenge_node_t::bithenge_node_destroy after it is
+ * used.
+ * @memberof bithenge_blob_t
+ * @param[out] out Stores the created blob node.
+ * @param[in] data The data.
+ * @param len The length of the data.
+ * @return EOK on success or an error code from errno.h. */
+int bithenge_new_blob_from_data(bithenge_node_t **out, const void *data,
+    size_t len)
+{
+        char *buffer = malloc(len);
+        if (!buffer)
+                return ENOMEM;
+        memcpy(buffer, data, len);
+        return bithenge_new_blob_from_buffer(out, buffer, len, true);
+}
 typedef struct {
 …
 /** Check whether the contents of two blobs are equal.
  * @memberof bithenge_blob_t
+ * @param[out] out Holds whether the blobs are equal.
  * @param a, b Blobs to compare.
  * @return Whether the blobs are equal. If an error occurs, returns false.
  */
 bool bithenge_blob_equal(bithenge_blob_t *a, bithenge_blob_t *b)
+ * @return EOK on success, or an error code from errno.h.
+ */
+int bithenge_blob_equal(bool *out, bithenge_blob_t *a, bithenge_blob_t *b)
+{
         assert(a);
 …
                 rc = bithenge_blob_read(a, offset, buffer_a, &size_a);
                 if (rc != EOK)
                         return false;
+                        return rc;
                 rc = bithenge_blob_read(b, offset, buffer_b, &size_b);
                 if (rc != EOK)
+                        return false;
+                if (size_a != size_b || bcmp(buffer_a, buffer_b, size_a))
+                        return false;
+                        return rc;
+                if (size_a != size_b || bcmp(buffer_a, buffer_b, size_a)) {
+                        *out = false;
+                        return EOK;
+                }
                 offset += size_a;
         } while (size_a == sizeof(buffer_a));
+        return true;
+        *out = true;
+        return EOK;
+}

uspace/lib/bithenge/blob.h

-              r0da6c04
+              r5e718d9
+}
+/** @memberof bithenge_blob_t */
 int bithenge_init_random_access_blob(bithenge_blob_t *,
     const bithenge_random_access_blob_ops_t *);
+/** @memberof bithenge_sequential_blob_t */
 int bithenge_init_sequential_blob(bithenge_sequential_blob_t *,
     const bithenge_sequential_blob_ops_t *);
+/** @memberof bithenge_blob_t */
 int bithenge_new_blob_from_data(bithenge_node_t **, const void *, size_t);
+/** @memberof bithenge_blob_t */
 int bithenge_new_blob_from_buffer(bithenge_node_t **, const void *, size_t,
     bool);
 …
 int bithenge_new_subblob(bithenge_node_t **, bithenge_blob_t *, aoff64_t,
     aoff64_t);
+bool bithenge_blob_equal(bithenge_blob_t *, bithenge_blob_t *);
+/** @memberof bithenge_blob_t */
+int bithenge_blob_equal(bool *, bithenge_blob_t *, bithenge_blob_t *);
 #endif

uspace/lib/bithenge/expression.c

-              r0da6c04
+              r5e718d9
 #include "blob.h"
 #include "expression.h"
+#include "os.h"
 #include "transform.h"
 #include "tree.h"
 …
         assert(ops->evaluate);
         assert(ops->destroy);
+        if (bithenge_should_fail())
+                return ENOMEM;
         self->ops = ops;
         self->refs = 1;
 …
     bithenge_scope_t *scope, bithenge_node_t **out)
+{
+        int rc;
         binary_expression_t *self = expression_as_binary(base);
         bithenge_node_t *a, *b;
         int rc = bithenge_expression_evaluate(self->a, scope, &a);
+        rc = bithenge_expression_evaluate(self->a, scope, &a);
         if (rc != EOK)
                 return rc;
+        rc = bithenge_expression_evaluate(self->b, scope, &b);
+        if (rc != EOK) {
+                bithenge_node_dec_ref(a);
+                return rc;
+        if (self->op != BITHENGE_EXPRESSION_CONCAT) {
+                rc = bithenge_expression_evaluate(self->b, scope, &b);
+                if (rc != EOK) {
+                        bithenge_node_dec_ref(a);
+                        return rc;
+                }
+        }
 …
         /* Assigning 0 only to make the compiler happy. */
         bithenge_int_t a_int = 0, b_int = 0;
+        bool a_bool = false, b_bool = false, out_bool = false;
         switch (self->op) {
         case BITHENGE_EXPRESSION_ADD: /* fallthrough */
         case BITHENGE_EXPRESSION_SUBTRACT: /* fallthrough */
+        case BITHENGE_EXPRESSION_MULTIPLY:
+        case BITHENGE_EXPRESSION_MULTIPLY: /* fallthrough */
+        case BITHENGE_EXPRESSION_INTEGER_DIVIDE: /* fallthrough */
+        case BITHENGE_EXPRESSION_MODULO: /* fallthrough */
+        case BITHENGE_EXPRESSION_LESS_THAN: /* fallthrough */
+        case BITHENGE_EXPRESSION_LESS_THAN_OR_EQUAL: /* fallthrough */
+        case BITHENGE_EXPRESSION_GREATER_THAN: /* fallthrough */
+        case BITHENGE_EXPRESSION_GREATER_THAN_OR_EQUAL:
                 rc = EINVAL;
                 if (bithenge_node_type(a) != BITHENGE_NODE_INTEGER)
 …
                 b_int = bithenge_integer_node_value(b);
                 break;
+        case BITHENGE_EXPRESSION_AND: /* fallthrough */
+        case BITHENGE_EXPRESSION_OR:
+                rc = EINVAL;
+                if (bithenge_node_type(a) != BITHENGE_NODE_BOOLEAN)
+                        goto error;
+                if (bithenge_node_type(b) != BITHENGE_NODE_BOOLEAN)
+                        goto error;
+                a_bool = bithenge_boolean_node_value(a);
+                b_bool = bithenge_boolean_node_value(b);
+                break;
+        case BITHENGE_EXPRESSION_CONCAT:
+                if (bithenge_node_type(a) != BITHENGE_NODE_BLOB)
+                        goto error;
+                break;
         default:
                 break;
 …
                 rc = bithenge_new_integer_node(out, a_int * b_int);
                 break;
+        case BITHENGE_EXPRESSION_INTEGER_DIVIDE:
+                /* Integer division can behave in three major ways when the
+                  operands are signed: truncated, floored, or Euclidean. When
+                 * b > 0, we give the same result as floored and Euclidean;
+                 * otherwise, we currently raise an error. See
+                 * https://en.wikipedia.org/wiki/Modulo_operation and its
+                 * references. */
+                if (b_int <= 0) {
+                        rc = EINVAL;
+                        break;
+                }
+                rc = bithenge_new_integer_node(out,
+                    (a_int / b_int) + (a_int % b_int < 0 ? -1 : 0));
+                break;
+        case BITHENGE_EXPRESSION_MODULO:
+                /* This is consistent with division; see above. */
+                if (b_int <= 0) {
+                        rc = EINVAL;
+                        break;
+                }
+                rc = bithenge_new_integer_node(out,
+                    (a_int % b_int) + (a_int % b_int < 0 ? b_int : 0));
+                break;
+        case BITHENGE_EXPRESSION_LESS_THAN:
+                rc = bithenge_new_boolean_node(out, a_int < b_int);
+                break;
+        case BITHENGE_EXPRESSION_LESS_THAN_OR_EQUAL:
+                rc = bithenge_new_boolean_node(out, a_int <= b_int);
+                break;
+        case BITHENGE_EXPRESSION_GREATER_THAN:
+                rc = bithenge_new_boolean_node(out, a_int > b_int);
+                break;
+        case BITHENGE_EXPRESSION_GREATER_THAN_OR_EQUAL:
+                rc = bithenge_new_boolean_node(out, a_int >= b_int);
+                break;
         case BITHENGE_EXPRESSION_EQUALS:
+                rc = bithenge_new_boolean_node(out, bithenge_node_equal(a, b));
+                rc = bithenge_node_equal(&out_bool, a, b);
+                if (rc != EOK)
+                        break;
+                rc = bithenge_new_boolean_node(out, out_bool);
+                break;
+        case BITHENGE_EXPRESSION_NOT_EQUALS:
+                rc = bithenge_node_equal(&out_bool, a, b);
+                if (rc != EOK)
+                        break;
+                rc = bithenge_new_boolean_node(out, !out_bool);
+                break;
+        case BITHENGE_EXPRESSION_AND:
+                rc = bithenge_new_boolean_node(out, a_bool && b_bool);
+                break;
+        case BITHENGE_EXPRESSION_OR:
+                rc = bithenge_new_boolean_node(out, a_bool || b_bool);
+                break;
+        case BITHENGE_EXPRESSION_MEMBER:
+                rc = bithenge_node_get(a, b, out);
+                b = NULL;
+                break;
+        case BITHENGE_EXPRESSION_CONCAT:
+                bithenge_expression_inc_ref(self->b);
+                bithenge_scope_inc_ref(scope);
+                rc = bithenge_concat_blob_lazy(out, bithenge_node_as_blob(a),
+                    self->b, scope);
+                a = NULL;
+                b = NULL;
                 break;
         case BITHENGE_EXPRESSION_INVALID_BINARY_OP:
 …
     bithenge_scope_t *scope, bithenge_node_t **out)
+{
+        for (; scope && !bithenge_scope_is_barrier(scope);
+            scope = bithenge_scope_outer(scope)) {
+        for (; scope; scope = bithenge_scope_outer(scope)) {
                 *out = bithenge_scope_in_node(scope);
                 if (*out)
 …
 int bithenge_in_node_expression(bithenge_expression_t **out)
+{
+        if (bithenge_should_fail())
+                return ENOMEM;
         bithenge_expression_inc_ref(&in_node_expression);
         *out = &in_node_expression;
 …
-/***************** member_expression                         *****************/
-typedef struct {
-        bithenge_expression_t base;
-        bithenge_expression_t *expr;
-        bithenge_node_t *key;
-} member_expression_t;
-static member_expression_t *expression_as_member(bithenge_expression_t *base)
+{
-        return (member_expression_t *)base;
+}
-static bithenge_expression_t *member_as_expression(member_expression_t *expr)
+{
-        return &expr->base;
+}
-static int member_expression_evaluate(bithenge_expression_t *base,
-    bithenge_scope_t *scope, bithenge_node_t **out)
+{
-        member_expression_t *self = expression_as_member(base);
-        bithenge_node_t *node;
-        int rc = bithenge_expression_evaluate(self->expr, scope, &node);
-        if (rc != EOK)
-                return rc;
-        bithenge_node_inc_ref(self->key);
-        rc = bithenge_node_get(node, self->key, out);
-        bithenge_node_dec_ref(node);
-        return rc;
+}
-static void member_expression_destroy(bithenge_expression_t *base)
+{
-        member_expression_t *self = expression_as_member(base);
-        bithenge_expression_dec_ref(self->expr);
-        bithenge_node_dec_ref(self->key);
-        free(self);
+}
-static const bithenge_expression_ops_t member_expression_ops = {
-        .evaluate = member_expression_evaluate,
-        .destroy = member_expression_destroy,
-};
-/** Create an expression that gets a member from a node. Takes references to
- * @a expr and @a key.
- * @param[out] out Holds the new expression.
- * @param expr Calculates the node to get the member of.
- * @param key The member to get.
- * @return EOK on success or an error code from errno.h. */
-int bithenge_member_expression(bithenge_expression_t **out,
-    bithenge_expression_t *expr, bithenge_node_t *key)
+{
-        int rc;
-        member_expression_t *self = malloc(sizeof(*self));
-        if (!self) {
-                rc = ENOMEM;
-                goto error;
+        }
-        rc = bithenge_init_expression(member_as_expression(self),
-            &member_expression_ops);
-        if (rc != EOK)
-                goto error;
-        self->expr = expr;
-        self->key = key;
-        *out = member_as_expression(self);
-        return EOK;
-error:
-        bithenge_expression_dec_ref(expr);
-        bithenge_node_dec_ref(key);
-        free(self);
-        return rc;
+}
 /***************** scope_member_expression                   *****************/
 …
         for (; scope && !bithenge_scope_is_barrier(scope);
             scope = bithenge_scope_outer(scope)) {
+                bithenge_node_t *cur = bithenge_scope_get_current_node(scope);
+                if (!cur)
+                        continue;
                 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);
 …
                         return rc;
+        }
         return ENOENT;
+        return bithenge_scope_error(scope, "No scope member %t", self->key);
+}
 …
 };
+/** Create an expression that gets a member from one of the current nodes being
+ * created. It searches from the current scope outwards, stopping at barrier
+ * scopes.
+ * @param[out] out Holds the new expression.
+ * @param key The key to search for in nodes being created.
+ * @return EOK on success or an error code from errno.h. */
 int bithenge_scope_member_expression(bithenge_expression_t **out,
     bithenge_node_t *key)
 …
+/***************** subblob_expression                        *****************/
+typedef struct {
+        bithenge_expression_t base;
+        bithenge_expression_t *blob, *start, *limit;
+        bool absolute_limit;
+} subblob_expression_t;
+static subblob_expression_t *expression_as_subblob(bithenge_expression_t *base)
+{
+        return (subblob_expression_t *)base;
+}
+static bithenge_expression_t *subblob_as_expression(subblob_expression_t *expr)
+{
+        return &expr->base;
+}
+static int subblob_expression_evaluate(bithenge_expression_t *base,
+    bithenge_scope_t *scope, bithenge_node_t **out)
+{
+        subblob_expression_t *self = expression_as_subblob(base);
+        bithenge_node_t *start_node;
+        int rc = bithenge_expression_evaluate(self->start, scope, &start_node);
+        if (rc != EOK)
+                return rc;
+        if (bithenge_node_type(start_node) != BITHENGE_NODE_INTEGER) {
+                bithenge_node_dec_ref(start_node);
+                return EINVAL;
+        }
+        bithenge_int_t start = bithenge_integer_node_value(start_node);
+        bithenge_node_dec_ref(start_node);
+        bithenge_int_t limit = -1;
+        if (self->limit) {
+                bithenge_node_t *limit_node;
+                rc = bithenge_expression_evaluate(self->limit, scope,
+                    &limit_node);
+                if (rc != EOK)
+                        return rc;
+                if (bithenge_node_type(limit_node) != BITHENGE_NODE_INTEGER) {
+                        bithenge_node_dec_ref(limit_node);
+                        return EINVAL;
+                }
+                limit = bithenge_integer_node_value(limit_node);
+                bithenge_node_dec_ref(limit_node);
+                if (self->absolute_limit)
+                        limit -= start;
+        }
+        if (start < 0 || (self->limit && limit < 0))
+                return EINVAL;
+        bithenge_node_t *blob;
+        rc = bithenge_expression_evaluate(self->blob, scope, &blob);
+        if (rc != EOK)
+                return rc;
+        if (bithenge_node_type(blob) != BITHENGE_NODE_BLOB) {
+                bithenge_node_dec_ref(blob);
+                return EINVAL;
+        }
+        if (self->limit)
+                return bithenge_new_subblob(out, bithenge_node_as_blob(blob),
+                    start, limit);
+        else
+                return bithenge_new_offset_blob(out,
+                    bithenge_node_as_blob(blob), start);
+}
+static void subblob_expression_destroy(bithenge_expression_t *base)
+{
+        subblob_expression_t *self = expression_as_subblob(base);
+        bithenge_expression_dec_ref(self->blob);
+        bithenge_expression_dec_ref(self->start);
+        bithenge_expression_dec_ref(self->limit);
+        free(self);
+}
+static const bithenge_expression_ops_t subblob_expression_ops = {
+        .evaluate = subblob_expression_evaluate,
+        .destroy = subblob_expression_destroy,
+};
+/** Create an expression that gets a subblob. Takes references to @a blob,
+ * @a start, and @a limit.
+ * @param[out] out Holds the new expression.
+ * @param blob Calculates the blob.
+ * @param start Calculates the start offset within the blob.
+ * @param limit Calculates the limit. Can be NULL, in which case an offset blob
+ * is returned.
+ * @param absolute_limit If true, the limit is an absolute offset; otherwise,
+ * it is relative to the start.
+ * @return EOK on success or an error code from errno.h. */
+int bithenge_subblob_expression(bithenge_expression_t **out,
+    bithenge_expression_t *blob, bithenge_expression_t *start,
+    bithenge_expression_t *limit, bool absolute_limit)
+{
+        int rc;
+        subblob_expression_t *self = malloc(sizeof(*self));
+        if (!self) {
+                rc = ENOMEM;
+                goto error;
+        }
+        rc = bithenge_init_expression(subblob_as_expression(self),
+            &subblob_expression_ops);
+        if (rc != EOK)
+                goto error;
+        self->blob = blob;
+        self->start = start;
+        self->limit = limit;
+        self->absolute_limit = absolute_limit;
+        *out = subblob_as_expression(self);
+        return EOK;
+error:
+        bithenge_expression_dec_ref(blob);
+        bithenge_expression_dec_ref(start);
+        bithenge_expression_dec_ref(limit);
+        free(self);
+        return rc;
+}
 /***************** param_wrapper                             *****************/
 …
+{
         expression_transform_t *self = transform_as_expression(base);
+        *out_size = 0;
+        if (out_size)
+                *out_size = 0;
         return bithenge_expression_evaluate(self->expr, scope, out_node);
+}
 …
 /***************** if_transform                              *****************/
+/***************** concat_blob                    *****************/
 typedef struct {
+        bithenge_transform_t base;
+        bithenge_expression_t *expr;
+        bithenge_transform_t *true_xform, *false_xform;
+} if_transform_t;
+static inline bithenge_transform_t *if_as_transform(if_transform_t *self)
+{
+        return &self->base;
+}
+static inline if_transform_t *transform_as_if(bithenge_transform_t *base)
+{
+        return (if_transform_t *)base;
+}
+static int if_transform_choose(if_transform_t *self, bithenge_scope_t *scope,
+    bool *out)
+{
+        bithenge_node_t *cond_node;
+        int rc = bithenge_expression_evaluate(self->expr, scope, &cond_node);
+        bithenge_blob_t base;
+        bithenge_blob_t *a, *b;
+        aoff64_t a_size;
+        bithenge_expression_t *b_expr;
+        bithenge_scope_t *scope;
+} concat_blob_t;
+static inline concat_blob_t *blob_as_concat(bithenge_blob_t *base)
+{
+        return (concat_blob_t *)base;
+}
+static inline bithenge_blob_t *concat_as_blob(concat_blob_t *blob)
+{
+        return &blob->base;
+}
+static int concat_blob_evaluate_b(concat_blob_t *self)
+{
+        if (self->b)
+                return EOK;
+        bithenge_node_t *b_node;
+        int rc = bithenge_expression_evaluate(self->b_expr, self->scope,
+            &b_node);
         if (rc != EOK)
                 return rc;
+        if (bithenge_node_type(cond_node) != BITHENGE_NODE_BOOLEAN) {
+                bithenge_node_dec_ref(cond_node);
+                return EINVAL;
+        }
+        *out = bithenge_boolean_node_value(cond_node);
+        bithenge_node_dec_ref(cond_node);
+        return EOK;
+}
+static int if_transform_apply(bithenge_transform_t *base,
+    bithenge_scope_t *scope, bithenge_node_t *in, bithenge_node_t **out)
+{
+        if_transform_t *self = transform_as_if(base);
+        bool cond;
+        int rc = if_transform_choose(self, scope, &cond);
+        if (bithenge_node_type(b_node) != BITHENGE_NODE_BLOB) {
+                bithenge_node_dec_ref(b_node);
+                return bithenge_scope_error(self->scope,
+                    "Concatenation arguments must be blobs");
+        }
+        self->b = bithenge_node_as_blob(b_node);
+        bithenge_expression_dec_ref(self->b_expr);
+        bithenge_scope_dec_ref(self->scope);
+        self->b_expr = NULL;
+        self->scope = NULL;
+        return EOK;
+}
+static int concat_blob_size(bithenge_blob_t *base, aoff64_t *size)
+{
+        concat_blob_t *self = blob_as_concat(base);
+        int rc = concat_blob_evaluate_b(self);
         if (rc != EOK)
                 return rc;
+        return bithenge_transform_apply(
+            cond ? self->true_xform : self->false_xform, scope, in, out);
+}
+static int if_transform_prefix_length(bithenge_transform_t *base,
+    bithenge_scope_t *scope, bithenge_blob_t *in, aoff64_t *out)
+{
+        if_transform_t *self = transform_as_if(base);
+        bool cond;
+        int rc = if_transform_choose(self, scope, &cond);
+        if (rc != EOK)
+                return rc;
+        return bithenge_transform_prefix_length(
+            cond ? self->true_xform : self->false_xform, scope, in, out);
+}
+static void if_transform_destroy(bithenge_transform_t *base)
+{
+        if_transform_t *self = transform_as_if(base);
+        bithenge_expression_dec_ref(self->expr);
+        bithenge_transform_dec_ref(self->true_xform);
+        bithenge_transform_dec_ref(self->false_xform);
+        free(self);
+}
+static const bithenge_transform_ops_t if_transform_ops = {
+        .apply = if_transform_apply,
+        .prefix_length = if_transform_prefix_length,
+        .destroy = if_transform_destroy,
+        rc = bithenge_blob_size(self->b, size);
+        *size += self->a_size;
+        return rc;
+}
+static int concat_blob_read(bithenge_blob_t *base, aoff64_t offset,
+    char *buffer, aoff64_t *size)
+{
+        int rc;
+        concat_blob_t *self = blob_as_concat(base);
+        aoff64_t a_size = 0, b_size = 0;
+        if (offset < self->a_size) {
+                a_size = *size;
+                rc = bithenge_blob_read(self->a, offset, buffer, &a_size);
+                if (rc != EOK)
+                        return rc;
+        }
+        if (offset + *size > self->a_size) {
+                rc = concat_blob_evaluate_b(self);
+                if (rc != EOK)
+                        return rc;
+                b_size = *size - a_size;
+                rc = bithenge_blob_read(self->b,
+                    offset + a_size - self->a_size, buffer + a_size, &b_size);
+                if (rc != EOK)
+                        return rc;
+        }
+        assert(a_size + b_size <= *size);
+        *size = a_size + b_size;
+        return EOK;
+}
+static int concat_blob_read_bits(bithenge_blob_t *base, aoff64_t offset,
+    char *buffer, aoff64_t *size, bool little_endian)
+{
+        int rc;
+        concat_blob_t *self = blob_as_concat(base);
+        aoff64_t a_size = 0, b_size = 0;
+        if (offset < self->a_size) {
+                a_size = *size;
+                rc = bithenge_blob_read_bits(self->a, offset, buffer, &a_size,
+                    little_endian);
+                if (rc != EOK)
+                        return rc;
+        }
+        if (offset + *size > self->a_size) {
+                rc = concat_blob_evaluate_b(self);
+                if (rc != EOK)
+                        return rc;
+                b_size = *size - a_size;
+                assert(a_size % 8 == 0); /* TODO: don't require this */
+                rc = bithenge_blob_read_bits(self->b,
+                    offset + a_size - self->a_size, buffer + a_size / 8,
+                    &b_size, little_endian);
+                if (rc != EOK)
+                        return rc;
+        }
+        assert(a_size + b_size <= *size);
+        *size = a_size + b_size;
+        return EOK;
+}
+static void concat_blob_destroy(bithenge_blob_t *base)
+{
+        concat_blob_t *self = blob_as_concat(base);
+        bithenge_blob_dec_ref(self->a);
+        bithenge_blob_dec_ref(self->b);
+        bithenge_expression_dec_ref(self->b_expr);
+        bithenge_scope_dec_ref(self->scope);
+        free(self);
+}
+static const bithenge_random_access_blob_ops_t concat_blob_ops = {
+        .size = concat_blob_size,
+        .read = concat_blob_read,
+        .read_bits = concat_blob_read_bits,
+        .destroy = concat_blob_destroy,
 };
+/** Create a transform that applies either of two transforms depending on a
+ * boolean expression. Takes references to @a expr, @a true_xform, and
+ * @a false_xform.
+ * @param[out] out Holds the new transform.
+ * @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.
+/** Create a concatenated blob. Takes references to @a a and @a b.
+ * @param[out] out Holds the new blob.
+ * @param a The first blob.
+ * @param b The second blob.
  * @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,
+    bithenge_transform_t *false_xform)
+{
+        int rc;
+        if_transform_t *self = malloc(sizeof(*self));
+int bithenge_concat_blob(bithenge_node_t **out, bithenge_blob_t *a,
+    bithenge_blob_t *b)
+{
+        assert(out);
+        assert(a);
+        assert(b);
+        int rc;
+        concat_blob_t *self = malloc(sizeof(*self));
         if (!self) {
                 rc = ENOMEM;
 …
+        }
+        rc = bithenge_init_transform(if_as_transform(self), &if_transform_ops,
+);
+        if (rc != EOK)
+                goto error;
+        self->expr = expr;
+        self->true_xform = true_xform;
+        self->false_xform = false_xform;
+        *out = if_as_transform(self);
+        rc = bithenge_blob_size(a, &self->a_size);
+        if (rc != EOK)
+                goto error;
+        rc = bithenge_init_random_access_blob(concat_as_blob(self),
+            &concat_blob_ops);
+        if (rc != EOK)
+                goto error;
+        self->a = a;
+        self->b = b;
+        self->b_expr = NULL;
+        self->scope = NULL;
+        *out = bithenge_blob_as_node(concat_as_blob(self));
         return EOK;
 error:
+        free(self);
+        bithenge_expression_dec_ref(expr);
+        bithenge_transform_dec_ref(true_xform);
+        bithenge_transform_dec_ref(false_xform);
+        bithenge_blob_dec_ref(a);
+        bithenge_blob_dec_ref(b);
+        free(self);
+        return rc;
+}
+/** Create a lazy concatenated blob. Takes references to @a a, @a b_expr, and
+ * @a scope.
+ * @param[out] out Holds the new blob.
+ * @param a The first blob.
+ * @param b_expr An expression to calculate the second blob.
+ * @param scope The scope in which @a b_expr should be evaluated.
+ * @return EOK on success or an error code from errno.h. */
+int bithenge_concat_blob_lazy(bithenge_node_t **out, bithenge_blob_t *a,
+    bithenge_expression_t *b_expr, bithenge_scope_t *scope)
+{
+        assert(out);
+        assert(a);
+        assert(b_expr);
+        assert(scope);
+        int rc;
+        concat_blob_t *self = malloc(sizeof(*self));
+        if (!self) {
+                rc = ENOMEM;
+                goto error;
+        }
+        rc = bithenge_blob_size(a, &self->a_size);
+        if (rc != EOK)
+                goto error;
+        rc = bithenge_init_random_access_blob(concat_as_blob(self),
+            &concat_blob_ops);
+        if (rc != EOK)
+                goto error;
+        self->a = a;
+        self->b = NULL;
+        self->b_expr = b_expr;
+        self->scope = scope;
+        *out = bithenge_blob_as_node(concat_as_blob(self));
+        return EOK;
+error:
+        bithenge_blob_dec_ref(a);
+        bithenge_expression_dec_ref(b_expr);
+        bithenge_scope_dec_ref(scope);
+        free(self);
         return rc;
+}

uspace/lib/bithenge/expression.h

-              r0da6c04
+              r5e718d9
 #define BITHENGE_EXPRESSION_H_
+#include "blob.h"
 #include "transform.h"
 #include "tree.h"
 …
                 return;
         assert(self->ops);
+        assert(self->refs > 0);
         if (--self->refs == 0)
                 self->ops->destroy(self);
 …
+}
+/** The binary operators supported by @a bithenge_binary_expression(). */
 typedef enum {
         BITHENGE_EXPRESSION_INVALID_BINARY_OP,
         BITHENGE_EXPRESSION_ADD,
         BITHENGE_EXPRESSION_SUBTRACT,
         BITHENGE_EXPRESSION_MULTIPLY,
+        BITHENGE_EXPRESSION_INTEGER_DIVIDE,
+        BITHENGE_EXPRESSION_MODULO,
+        BITHENGE_EXPRESSION_LESS_THAN,
+        BITHENGE_EXPRESSION_GREATER_THAN,
+        BITHENGE_EXPRESSION_LESS_THAN_OR_EQUAL,
+        BITHENGE_EXPRESSION_GREATER_THAN_OR_EQUAL,
         BITHENGE_EXPRESSION_EQUALS,
+        BITHENGE_EXPRESSION_NOT_EQUALS,
+        BITHENGE_EXPRESSION_AND,
+        BITHENGE_EXPRESSION_OR,
+        BITHENGE_EXPRESSION_MEMBER,
+        BITHENGE_EXPRESSION_CONCAT,
 } bithenge_binary_op_t;
 …
 int bithenge_param_expression(bithenge_expression_t **, int);
 int bithenge_const_expression(bithenge_expression_t **, bithenge_node_t *);
-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_subblob_expression(bithenge_expression_t **,
+    bithenge_expression_t *, bithenge_expression_t *, bithenge_expression_t *,
+    bool);
 int bithenge_param_wrapper(bithenge_transform_t **, bithenge_transform_t *,
     bithenge_expression_t **);
 …
 int bithenge_inputless_transform(bithenge_transform_t **,
     bithenge_expression_t *);
+int bithenge_if_transform(bithenge_transform_t **, bithenge_expression_t *,
+    bithenge_transform_t *, bithenge_transform_t *);
+int bithenge_concat_blob(bithenge_node_t **, bithenge_blob_t *,
+    bithenge_blob_t *);
+int bithenge_concat_blob_lazy(bithenge_node_t **, bithenge_blob_t *,
+    bithenge_expression_t *, bithenge_scope_t *);
 #endif

uspace/lib/bithenge/file.c

r0da6c04	r5e718d9
79	79	return ELIMIT;
80	80	if (lseek(blob->fd, offset, SEEK_SET) < 0)
81		return errno;
	81	return errno == EINVAL ? EIO : errno;
82	82
83	83	ssize_t amount_read;

uspace/lib/bithenge/helenos/block.c

-              r0da6c04
+              r5e718d9
 #include <assert.h>
+#include <block.h>
 #include <errno.h>
-#include <libblock.h>
 #include <loc.h>
 #include <macros.h>

uspace/lib/bithenge/helenos/os.h

-              r0da6c04
+              r5e718d9
  */
 #ifndef BITHENGE_OS_H_
 #define BITHENGE_OS_H_
+#ifndef BITHENGE_HELENOS_OS_H_
+#define BITHENGE_HELENOS_OS_H_
 #include <bool.h>

uspace/lib/bithenge/linux/os.h

-              r0da6c04
+              r5e718d9
  */
 #ifndef BITHENGE_OS_H_
 #define BITHENGE_OS_H_
+#ifndef BITHENGE_LINUX_OS_H_
+#define BITHENGE_LINUX_OS_H_
 #include <endian.h>

uspace/lib/bithenge/print.c

-              r0da6c04
+              r5e718d9
 #include <errno.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include "blob.h"
 …
         bool first;
         int depth;
+        char *buffer;
+        size_t buffer_size;
 } state_t;
+static void state_printf(state_t *state, const char *format, ...)
+{
+        va_list ap;
+        va_start(ap, format);
+        if (state->buffer) {
+                int rc = vsnprintf(state->buffer, state->buffer_size, format,
+                    ap);
+                if (rc > 0 && (size_t)rc >= state->buffer_size)
+                        rc = state->buffer_size - 1;
+                if (rc > 0) {
+                        state->buffer += rc;
+                        state->buffer_size -= rc;
+                }
+        } else {
+                vprintf(format, ap);
+        }
+        va_end(ap);
+}
 static int print_node(state_t *, bithenge_node_t *);
 static void newline(state_t *state)
+{
         printf("\n");
+        state_printf(state, "\n");
         for (int i = 0; i < state->depth; i++) {
                 printf("    ");
+                state_printf(state, "    ");
+        }
+}
 …
         int rc = EOK;
         if (!state->first)
                 printf(",");
+                state_printf(state, ",");
         newline(state);
         state->first = false;
 …
             && bithenge_node_type(key) != BITHENGE_NODE_STRING;
         if (add_quotes)
                 printf("\"");
+                state_printf(state, "\"");
         rc = print_node(state, key);
         if (rc != EOK)
                 goto end;
         if (add_quotes)
                 printf("\"");
         printf(": ");
+                state_printf(state, "\"");
+        state_printf(state, ": ");
         rc = print_node(state, value);
         if (rc != EOK)
 …
+{
         int rc;
         printf("{");
+        state_printf(state, "{");
         increase_depth(state);
         state->first = true;
 …
                 newline(state);
         state->first = false;
         printf("}");
+        state_printf(state, "}");
         return EOK;
+}
 …
         switch (state->type) {
         case BITHENGE_PRINT_PYTHON:
                 printf(value ? "True" : "False");
+                state_printf(state, value ? "True" : "False");
                 break;
         case BITHENGE_PRINT_JSON:
                 printf(value ? "true" : "false");
+                state_printf(state, value ? "true" : "false");
                 break;
+        }
 …
+{
         bithenge_int_t value = bithenge_integer_node_value(node);
         printf("%" BITHENGE_PRId, value);
+        state_printf(state, "%" BITHENGE_PRId, value);
         return EOK;
+}
 …
+{
         const char *value = bithenge_string_node_value(node);
         printf("\"");
+        state_printf(state, "\"");
         for (string_iterator_t i = string_iterator(value); !string_iterator_done(&i); ) {
                 wchar_t ch;
 …
                         return rc;
                 if (ch == '"' || ch == '\\') {
                         printf("\\%lc", (wint_t) ch);
+                        state_printf(state, "\\%lc", (wint_t) ch);
                 } else if (ch <= 0x1f) {
                         printf("\\u%04x", (unsigned int) ch);
+                        state_printf(state, "\\u%04x", (unsigned int) ch);
                 } else {
                         printf("%lc", (wint_t) ch);
+                        state_printf(state, "%lc", (wint_t) ch);
+                }
+        }
         printf("\"");
+        state_printf(state, "\"");
         return EOK;
+}
 …
         bithenge_blob_t *blob = bithenge_node_as_blob(node);
         aoff64_t pos = 0;
         char buffer[1024];
+        uint8_t buffer[1024];
         aoff64_t size = sizeof(buffer);
         int rc;
+        printf(state->type == BITHENGE_PRINT_PYTHON ? "b\"" : "\"");
+        state_printf(state,
+            state->type == BITHENGE_PRINT_PYTHON ? "b\"" : "\"");
         do {
                 rc = bithenge_blob_read(blob, pos, buffer, &size);
+                rc = bithenge_blob_read(blob, pos, (char *)buffer, &size);
                 if (rc != EOK)
                         return rc;
                 for (aoff64_t i = 0; i < size; i++)
+                        printf("\\x%02x", (unsigned int)(uint8_t)buffer[i]);
+                        state_printf(state, "\\x%02x",
+                            (unsigned int)buffer[i]);
                 pos += size;
         } while (size == sizeof(buffer));
         printf("\"");
+        state_printf(state, "\"");
         return EOK;
+}
 …
+}
 /** Print a tree as text.
+/** Print a tree as text to stdout.
  * @param type The format to use.
  * @param tree The root node of the tree to print.
 …
 int bithenge_print_node(bithenge_print_type_t type, bithenge_node_t *tree)
+{
         state_t state = {type, true, 0};
+        state_t state = {type, true, 0, NULL, 0};
         return print_node(&state, tree);
+}
+/** Print a tree as text into a buffer.
+ * @param[in,out] str Holds a pointer to the buffer; changed to point to the
+ * null character.
+ * @param[in,out] size Holds the size of the buffer; changed to hold the
+ * remaining size.
+ * @param type The format to use.
+ * @param tree The root node of the tree to print.
+ * @return EOK on success or an error code from errno.h. */
+int bithenge_print_node_to_string(char **str, size_t *size,
+    bithenge_print_type_t type, bithenge_node_t *tree)
+{
+        state_t state = {type, true, 0, *str, *size};
+        int rc = print_node(&state, tree);
+        *str = state.buffer;
+        *size = state.buffer_size;
+        return rc;
+}
 /** @}
  */

uspace/lib/bithenge/print.h

r0da6c04	r5e718d9
51	51
52	52	int bithenge_print_node(bithenge_print_type_t, bithenge_node_t *);
	53	int bithenge_print_node_to_string(char *, size_t , bithenge_print_type_t,
	54	bithenge_node_t *);
53	55
54	56	#endif

uspace/lib/bithenge/script.c

-              r0da6c04
+              r5e718d9
 #include <stdio.h>
 #include <stdlib.h>
+#include "compound.h"
 #include "expression.h"
 #include "os.h"
 …
 #include "tree.h"
+/** @cond internal */
+#define BUFFER_SIZE 4096
+/** @endcond */
 /** Tokens with more characters than this may be read incorrectly. */
+#define MAX_TOKEN_SIZE 256
+#define BUFFER_SIZE 4096
 /** Single-character symbols are represented by the character itself. Every
+static const int MAX_TOKEN_SIZE = 256;
+/** @cond internal
+ * Single-character symbols are represented by the character itself. Every
  * other token uses one of these values: */
 typedef enum {
+        TOKEN_EQUALS = -128,
+        TOKEN_ERROR,
+        TOKEN_ERROR = -128,
+        TOKEN_AND,
+        TOKEN_CONCAT,
+        TOKEN_EQUALS,
         TOKEN_EOF,
+        TOKEN_GREATER_THAN_OR_EQUAL,
         TOKEN_IDENTIFIER,
         TOKEN_INTEGER,
+        TOKEN_INTEGER_DIVIDE,
         TOKEN_LEFT_ARROW,
+        TOKEN_LESS_THAN_OR_EQUAL,
+        TOKEN_NOT_EQUAL,
+        TOKEN_OR,
         /* Keywords */
 …
         TOKEN_IF,
         TOKEN_IN,
+        TOKEN_PARTIAL,
         TOKEN_REPEAT,
         TOKEN_STRUCT,
 …
         TOKEN_WHILE,
 } token_type_t;
+/** @endcond */
 /** Singly-linked list of named transforms. */
 …
                         state->token = TOKEN_IN;
                         free(value);
+                } else if (!str_cmp(value, "partial")) {
+                        state->token = TOKEN_PARTIAL;
+                        free(value);
                 } else if (!str_cmp(value, "repeat")) {
                         state->token = TOKEN_REPEAT;
 …
                         state->buffer_pos++;
                         state->token = TOKEN_LEFT_ARROW;
+                } else if (state->buffer[state->buffer_pos] == '=') {
+                        state->buffer_pos++;
+                        state->token = TOKEN_LESS_THAN_OR_EQUAL;
+                }
+        } else if (ch == '>') {
+                state->token = ch;
+                state->buffer_pos++;
+                if (state->buffer[state->buffer_pos] == '=') {
+                        state->buffer_pos++;
+                        state->token = TOKEN_GREATER_THAN_OR_EQUAL;
+                }
         } else if (ch == '=') {
 …
                         state->buffer_pos++;
+                }
+        } else if (ch == '/') {
+                state->token = ch;
+                state->buffer_pos++;
+                if (state->buffer[state->buffer_pos] == '/') {
+                        state->token = TOKEN_INTEGER_DIVIDE;
+                        state->buffer_pos++;
+                }
+        } else if (ch == '!') {
+                state->token = ch;
+                state->buffer_pos++;
+                if (state->buffer[state->buffer_pos] == '=') {
+                        state->token = TOKEN_NOT_EQUAL;
+                        state->buffer_pos++;
+                }
+        } else if (ch == '&') {
+                state->token = ch;
+                state->buffer_pos++;
+                if (state->buffer[state->buffer_pos] == '&') {
+                        state->token = TOKEN_AND;
+                        state->buffer_pos++;
+                }
+        } else if (ch == '|') {
+                state->token = ch;
+                state->buffer_pos++;
+                if (state->buffer[state->buffer_pos] == '|') {
+                        state->token = TOKEN_OR;
+                        state->buffer_pos++;
+                }
+        } else if (ch == '+') {
+                state->token = ch;
+                state->buffer_pos++;
+                if (state->buffer[state->buffer_pos] == '+') {
+                        state->token = TOKEN_CONCAT;
+                        state->buffer_pos++;
+                }
         } else {
                 state->token = ch;
 …
 /***************** Expressions                               *****************/
+/** @cond internal */
 typedef enum {
         PRECEDENCE_NONE,
+        PRECEDENCE_AND,
         PRECEDENCE_EQUALS,
+        PRECEDENCE_COMPARE,
         PRECEDENCE_ADD,
         PRECEDENCE_MULTIPLY,
 } precedence_t;
+/** @endcond */
 static bithenge_binary_op_t token_as_binary_operator(token_type_t token)
 …
         case '*':
                 return BITHENGE_EXPRESSION_MULTIPLY;
+        case TOKEN_INTEGER_DIVIDE:
+                return BITHENGE_EXPRESSION_INTEGER_DIVIDE;
+        case '%':
+                return BITHENGE_EXPRESSION_MODULO;
+        case '<':
+                return BITHENGE_EXPRESSION_LESS_THAN;
+        case TOKEN_LESS_THAN_OR_EQUAL:
+                return BITHENGE_EXPRESSION_LESS_THAN_OR_EQUAL;
+        case '>':
+                return BITHENGE_EXPRESSION_GREATER_THAN;
+        case TOKEN_GREATER_THAN_OR_EQUAL:
+                return BITHENGE_EXPRESSION_GREATER_THAN_OR_EQUAL;
         case TOKEN_EQUALS:
                 return BITHENGE_EXPRESSION_EQUALS;
+        case TOKEN_NOT_EQUAL:
+                return BITHENGE_EXPRESSION_NOT_EQUALS;
+        case TOKEN_AND:
+                return BITHENGE_EXPRESSION_AND;
+        case TOKEN_OR:
+                return BITHENGE_EXPRESSION_OR;
+        case TOKEN_CONCAT:
+                return BITHENGE_EXPRESSION_CONCAT;
         default:
                 return BITHENGE_EXPRESSION_INVALID_BINARY_OP;
 …
         switch (op) {
         case BITHENGE_EXPRESSION_ADD: /* fallthrough */
+        case BITHENGE_EXPRESSION_SUBTRACT:
+        case BITHENGE_EXPRESSION_SUBTRACT: /* fallthrough */
+        case BITHENGE_EXPRESSION_CONCAT:
                 return PRECEDENCE_ADD;
+        case BITHENGE_EXPRESSION_MULTIPLY:
+        case BITHENGE_EXPRESSION_MULTIPLY: /* fallthrough */
+        case BITHENGE_EXPRESSION_INTEGER_DIVIDE: /* fallthrough */
+        case BITHENGE_EXPRESSION_MODULO:
                 return PRECEDENCE_MULTIPLY;
+        case BITHENGE_EXPRESSION_EQUALS:
+        case BITHENGE_EXPRESSION_LESS_THAN: /* fallthrough */
+        case BITHENGE_EXPRESSION_LESS_THAN_OR_EQUAL: /* fallthrough */
+        case BITHENGE_EXPRESSION_GREATER_THAN: /* fallthrough */
+        case BITHENGE_EXPRESSION_GREATER_THAN_OR_EQUAL:
+                return PRECEDENCE_COMPARE;
+        case BITHENGE_EXPRESSION_EQUALS: /* fallthrough */
+        case BITHENGE_EXPRESSION_NOT_EQUALS:
                 return PRECEDENCE_EQUALS;
+        case BITHENGE_EXPRESSION_AND: /* fallthrough */
+        case BITHENGE_EXPRESSION_OR:
+                return PRECEDENCE_AND;
         default:
                 assert(false);
 …
+                }
+                next_token(state);
                 bithenge_expression_t *expr;
                 rc = bithenge_param_expression(&expr, i);
 …
                         return NULL;
+                }
-                next_token(state);
                 return expr;
         } else if (state->token == '.') {
 …
+}
+static bithenge_expression_t *parse_postfix_expression(state_t *state)
+{
+        int rc;
+        bithenge_expression_t *expr = parse_term(state);
+        while (state->error == EOK) {
+                if (state->token == '.') {
+                        next_token(state);
+                        const char *id = expect_identifier(state);
+                        if (state->error != EOK) {
+                                free((char *)id);
+                                bithenge_expression_dec_ref(expr);
+                                return NULL;
+                        }
+                        bithenge_node_t *key = NULL;
+                        rc = bithenge_new_string_node(&key, id, true);
+                        if (rc != EOK) {
+                                error_errno(state, rc);
+                                bithenge_expression_dec_ref(expr);
+                                return NULL;
+                        }
+                        bithenge_expression_t *key_expr;
+                        rc = bithenge_const_expression(&key_expr, key);
+                        if (rc != EOK) {
+                                error_errno(state, rc);
+                                bithenge_expression_dec_ref(expr);
+                                return NULL;
+                        }
+                        rc = bithenge_binary_expression(&expr,
+                            BITHENGE_EXPRESSION_MEMBER, expr, key_expr);
+                        if (rc != EOK) {
+                                error_errno(state, rc);
+                                return NULL;
+                        }
+                } else if (state->token == '[') {
+                        next_token(state);
+                        bithenge_expression_t *start = parse_expression(state);
+                        bool absolute_limit = false;
+                        if (state->token == ',' || state->token == ':') {
+                                absolute_limit = state->token == ':';
+                                next_token(state);
+                                bithenge_expression_t *limit = NULL;
+                                if (!(state->token == ']' && absolute_limit))
+                                        limit = parse_expression(state);
+                                expect(state, ']');
+                                if (state->error != EOK) {
+                                        bithenge_expression_dec_ref(expr);
+                                        bithenge_expression_dec_ref(start);
+                                        bithenge_expression_dec_ref(limit);
+                                        return NULL;
+                                }
+                                rc = bithenge_subblob_expression(&expr, expr, start,
+                                    limit, absolute_limit);
+                                if (rc != EOK) {
+                                        error_errno(state, rc);
+                                        return NULL;
+                                }
+                        } else if (state->token == ']') {
+                                next_token(state);
+                                if (state->error != EOK) {
+                                        bithenge_expression_dec_ref(expr);
+                                        bithenge_expression_dec_ref(start);
+                                        return NULL;
+                                }
+                                rc = bithenge_binary_expression(&expr,
+                                    BITHENGE_EXPRESSION_MEMBER, expr, start);
+                                if (rc != EOK) {
+                                        error_errno(state, rc);
+                                        return NULL;
+                                }
+                        } else {
+                                syntax_error(state, "expected ',', ':', or ']'");
+                                bithenge_expression_dec_ref(expr);
+                                bithenge_expression_dec_ref(start);
+                                return NULL;
+                        }
+                } else {
+                        break;
+                }
+        }
+        return expr;
+}
 static bithenge_expression_t *parse_expression_precedence(state_t *state,
     precedence_t prev_precedence)
+{
         bithenge_expression_t *expr = parse_term(state);
+        bithenge_expression_t *expr = parse_postfix_expression(state);
         while (state->error == EOK) {
                 bithenge_binary_op_t op =
 …
                 next_token(state);
+                bithenge_expression_t *expr2 = parse_term(state);
+                bithenge_expression_t *expr2 =
+                    parse_expression_precedence(state, precedence);
                 if (state->error != EOK) {
                         bithenge_expression_dec_ref(expr2);
 …
+                }
                 int rc = bithenge_binary_expression(&expr, op, expr, expr2);
+                if (rc != EOK)
+                        error_errno(state, rc);
+                if (rc != EOK) {
+                        expr = NULL;
+                        error_errno(state, rc);
+                }
+        }
         if (state->error != EOK) {
 …
                 int rc = bithenge_if_transform(&switch_xform, exprs[num],
                     xforms[num], switch_xform);
+                if (rc != EOK)
+                        error_errno(state, rc);
+                if (rc != EOK) {
+                        switch_xform = NULL;
+                        error_errno(state, rc);
+                }
+        }
 …
+        }
         return do_while_xform;
+}
+static bithenge_transform_t *parse_partial(state_t *state)
+{
+        expect(state, TOKEN_PARTIAL);
+        bithenge_transform_t *offset_xform = NULL;
+        if (state->token == '(') {
+                next_token(state);
+                bithenge_expression_t *offset = parse_expression(state);
+                expect(state, ')');
+                bithenge_expression_t *in_expr;
+                int rc = bithenge_in_node_expression(&in_expr);
+                if (rc != EOK)
+                        error_errno(state, rc);
+                if (state->error != EOK) {
+                        bithenge_expression_dec_ref(offset);
+                        return NULL;
+                }
+                rc = bithenge_subblob_expression(&offset, in_expr, offset,
+                    NULL, true);
+                if (rc != EOK) {
+                        error_errno(state, rc);
+                        return NULL;
+                }
+                rc = bithenge_expression_transform(&offset_xform, offset);
+                if (rc != EOK) {
+                        error_errno(state, rc);
+                        return NULL;
+                }
+        }
+        expect(state, '{');
+        bithenge_transform_t *xform = parse_transform(state);
+        expect(state, '}');
+        if (state->error != EOK) {
+                bithenge_transform_dec_ref(offset_xform);
+                bithenge_transform_dec_ref(xform);
+                return NULL;
+        }
+        int rc = bithenge_partial_transform(&xform, xform);
+        if (rc != EOK) {
+                error_errno(state, rc);
+                bithenge_transform_dec_ref(offset_xform);
+                return NULL;
+        }
+        if (offset_xform) {
+                bithenge_transform_t **xforms = malloc(2 * sizeof(*xforms));
+                if (!xforms) {
+                        error_errno(state, ENOMEM);
+                        bithenge_transform_dec_ref(xform);
+                        bithenge_transform_dec_ref(offset_xform);
+                        return NULL;
+                }
+                xforms[0] = xform;
+                xforms[1] = offset_xform;
+                rc = bithenge_new_composed_transform(&xform, xforms, 2);
+                if (rc != EOK) {
+                        error_errno(state, rc);
+                        return NULL;
+                }
+        }
+        return xform;
+}
 …
         } else if (state->token == TOKEN_IF) {
                 return parse_if(state, false);
+        } else if (state->token == TOKEN_PARTIAL) {
+                return parse_partial(state);
         } else if (state->token == TOKEN_REPEAT) {
                 return parse_repeat(state);
 …
                 if (state->error != EOK)
                         break;
+                xforms[num] = parse_transform_no_compose(state);
+                num++;
+                xforms[num++] = parse_transform_no_compose(state);
+        }
         if (state->error != EOK) {
                 while (xforms && num--)
                         bithenge_transform_dec_ref(xforms[num]);
+                while (xforms && num > 1)
+                        bithenge_transform_dec_ref(xforms[--num]);
                 free(xforms);
                 bithenge_transform_dec_ref(result);
 …
+        }
+        bithenge_transform_t *barrier = NULL;
+        if (state->error == EOK) {
+                int rc = bithenge_new_barrier_transform(&barrier,
+                    state->num_params);
+                if (rc != EOK) {
+                        barrier = NULL;
+                        error_errno(state, rc);
+                }
+        }
+        add_named_transform(state, barrier, name);
         expect(state, '=');
         bithenge_transform_t *xform = parse_transform(state);
 …
         if (state->error == EOK) {
                 int rc = bithenge_new_barrier_transform(&xform, xform,
                     state->num_params);
                 if (rc != EOK) {
                         xform = NULL;
                         error_errno(state, rc);
+                }
+        }
         add_named_transform(state, xform, name);
+                int rc = bithenge_barrier_transform_set_subtransform(barrier,
+                    xform);
+                xform = NULL;
+                if (rc != EOK)
+                        error_errno(state, rc);
+        }
+        if (state->error != EOK)
+                bithenge_transform_dec_ref(xform);
         for (int i = 0; i < state->num_params; i++)

uspace/lib/bithenge/sequence.c

-              r0da6c04
+              r5e718d9
         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));
 …
                 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
 …
          * 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);
 …
                 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;
+                }
+        }
 …
 /***************** bithenge_repeat_transform                 *****************/
+/* TODO: ignore errors */
 typedef struct {
         bithenge_transform_t base;
 …
                 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;
+                        }
+                }
+        }
 …
 typedef struct {
         seq_node_t base;
-        bool prefix;
         bithenge_expression_t *expr;
         bithenge_transform_t *xform;
 …
+        }
-        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;
+}
 …
 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));
 …
         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);
+}
 …
+{
         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;
+                }
+        }
 …
 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,

uspace/lib/bithenge/transform.c

-              r0da6c04
+              r5e718d9
 #include <assert.h>
 #include <errno.h>
+#include <stdarg.h>
 #include <stdlib.h>
 #include "blob.h"
+#include "os.h"
+#include "print.h"
 #include "transform.h"
+/***************** transform                                 *****************/
 /** Initialize a new transform.
 …
         assert(ops->apply || ops->prefix_apply);
         assert(ops->destroy);
+        if (bithenge_should_fail())
+                return ENOMEM;
         self->ops = ops;
         self->refs = 1;
 …
  * @param[out] out_node Holds the result of applying this transform to the
  * prefix.
+ * @param[out] out_size Holds the size of the prefix.
+ * @param[out] out_size Holds the size of the prefix. Can be null, in which
+ * case the size is not determined.
  * @return EOK on success, ENOTSUP if not supported, or another error code from
  * errno.h. */
 …
                 return ENOTSUP;
+        int rc = bithenge_transform_prefix_length(self, scope, blob, out_size);
+        aoff64_t size;
+        int rc = bithenge_transform_prefix_length(self, scope, blob, &size);
         if (rc != EOK)
                 return rc;
         bithenge_node_t *prefix_blob;
         bithenge_blob_inc_ref(blob);
         rc = bithenge_new_subblob(&prefix_blob, blob, 0, *out_size);
+        rc = bithenge_new_subblob(&prefix_blob, blob, 0, size);
         if (rc != EOK)
                 return rc;
         rc = bithenge_transform_apply(self, scope, prefix_blob, out_node);
         bithenge_node_dec_ref(prefix_blob);
+        if (out_size)
+                *out_size = size;
         return rc;
+}
+/***************** scope                                     *****************/
 /** Create a transform scope. It must be dereferenced with @a
  * bithenge_scope_dec_ref after it is used. Takes ownership of nothing.
+ * @memberof bithenge_scope_t
  * @param[out] out Holds the new scope.
  * @param outer The outer scope, or NULL.
 …
                 bithenge_scope_inc_ref(outer);
         self->outer = outer;
+        self->error = NULL;
         self->barrier = false;
         self->num_params = 0;
 …
 /** Dereference a transform scope.
+ * @param self The scope to dereference. */
+ * @memberof bithenge_scope_t
+ * @param self The scope to dereference, or NULL. */
 void bithenge_scope_dec_ref(bithenge_scope_t *self)
+{
 …
         bithenge_scope_dec_ref(self->outer);
         free(self->params);
+        free(self->error);
         free(self);
+}
 /** Get the outer scope of a scope, which may be NULL.
+ * @memberof bithenge_scope_t
  * @param self The scope to examine.
  * @return The outer scope, which may be NULL. */
 …
+}
+/** Get the error message stored in the scope, which may be NULL. The error
+ * message only exists as long as the scope does.
+ * @memberof bithenge_scope_t
+ * @param scope The scope to get the error message from.
+ * @return The error message, or NULL. */
+const char *bithenge_scope_get_error(bithenge_scope_t *scope)
+{
+        return scope->error;
+}
+/** Set the error message for the scope. The error message is stored in the
+ * outermost scope, but if any scope already has an error message this error
+ * message is ignored.
+ * @memberof bithenge_scope_t
+ * @param scope The scope.
+ * @param format The format string.
+ * @return EINVAL normally, or another error code from errno.h. */
+int bithenge_scope_error(bithenge_scope_t *scope, const char *format, ...)
+{
+        if (scope->error)
+                return EINVAL;
+        while (scope->outer) {
+                scope = scope->outer;
+                if (scope->error)
+                        return EINVAL;
+        }
+        size_t space_left = 256;
+        scope->error = malloc(space_left);
+        if (!scope->error)
+                return ENOMEM;
+        char *out = scope->error;
+        va_list ap;
+        va_start(ap, format);
+        while (*format) {
+                if (format[0] == '%' && format[1] == 't') {
+                        format += 2;
+                        int rc = bithenge_print_node_to_string(&out,
+                            &space_left, BITHENGE_PRINT_PYTHON,
+                            va_arg(ap, bithenge_node_t *));
+                        if (rc != EOK) {
+                                va_end(ap);
+                                return rc;
+                        }
+                } else {
+                        const char *end = str_chr(format, '%');
+                        if (!end)
+                                end = format + str_length(format);
+                        size_t size = min((size_t)(end - format),
+                            space_left - 1);
+                        memcpy(out, format, size);
+                        format = end;
+                        out += size;
+                        space_left -= size;
+                }
+        }
+        *out = '\0';
+        va_end(ap);
+        return EINVAL;
+}
 /** Get the current node being created, which may be NULL.
+ * @memberof bithenge_scope_t
  * @param scope The scope to get the current node from.
  * @return The node being created, or NULL. */
 …
 /** Set the current node being created. Takes a reference to @a node.
+ * @memberof bithenge_scope_t
  * @param scope The scope to set the current node in.
  * @param node The current node being created, or NULL. */
 …
 /** Get the current input node, which may be NULL.
+ * @memberof bithenge_scope_t
  * @param scope The scope to get the current input node from.
  * @return The input node, or NULL. */
 …
 /** Set the current input node. Takes a reference to @a node.
+ * @memberof bithenge_scope_t
  * @param scope The scope to set the input node in.
  * @param node The input node, or NULL. */
 …
 /** Set a scope as a barrier.
+ * @memberof bithenge_scope_t
  * @param self The scope to change. */
 void bithenge_scope_set_barrier(bithenge_scope_t *self)
 …
 /** Check whether a scope is a barrier, meaning that variable lookup stops at
  * it.
+ * @memberof bithenge_scope_t
  * @param self The scope to check.
  * @return Whether the scope is a barrier. */
 …
  * bithenge_scope_set_param. This must not be called on a scope that already
  * has parameters.
+ * @memberof bithenge_scope_t
  * @param scope The scope in which to allocate parameters.
  * @param num_params The number of parameters to allocate.
 …
+}
 /** Set a parameter. Takes a reference to @a value. Note that range checking is
+/** Set a parameter. Takes a reference to @a node. Note that range checking is
  * not done in release builds.
+ * @memberof bithenge_scope_t
  * @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.
+ * @param node 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,
 …
         assert(scope);
         assert(i >= 0 && i < scope->num_params);
+        if (bithenge_should_fail()) {
+                bithenge_node_dec_ref(node);
+                return ENOMEM;
+        }
         scope->params[i] = node;
         return EOK;
 …
 /** Get a parameter. Note that range checking is not done in release builds.
+ * @memberof bithenge_scope_t
  * @param scope The scope to get the parameter from.
  * @param i The index of the parameter to set.
 …
+}
+/***************** barrier_transform                         *****************/
 typedef struct {
         bithenge_transform_t base;
 …
                 return rc;
         bithenge_scope_set_barrier(inner_scope);
+        rc = bithenge_transform_apply(self->transform, scope, in, out);
+        bithenge_scope_set_in_node(inner_scope, in);
+        rc = bithenge_transform_apply(self->transform, inner_scope, in, out);
         bithenge_scope_dec_ref(inner_scope);
         return rc;
 …
                 return rc;
         bithenge_scope_set_barrier(inner_scope);
+        rc = bithenge_transform_prefix_length(self->transform, scope, in, out);
+        bithenge_scope_set_in_node(inner_scope, bithenge_blob_as_node(in));
+        rc = bithenge_transform_prefix_length(self->transform, inner_scope, in,
+            out);
         bithenge_scope_dec_ref(inner_scope);
         return rc;
 …
                 return rc;
         bithenge_scope_set_barrier(inner_scope);
+        rc = bithenge_transform_prefix_apply(self->transform, scope, in,
+        bithenge_scope_set_in_node(inner_scope, bithenge_blob_as_node(in));
+        rc = bithenge_transform_prefix_apply(self->transform, inner_scope, in,
             out_node, out_length);
         bithenge_scope_dec_ref(inner_scope);
 …
 };
+/** Set the subtransform of a barrier transform. This must be done before the
+ * barrier transform is used. Takes a reference to @a transform.
+ * @param base The barrier transform.
+ * @param transform The subtransform to use for all operations.
+ * @return EOK on success or an error code from errno.h. */
+int bithenge_barrier_transform_set_subtransform(bithenge_transform_t *base,
+    bithenge_transform_t *transform)
+{
+        assert(transform);
+        assert(bithenge_transform_num_params(transform) == 0);
+        if (bithenge_should_fail()) {
+                bithenge_transform_dec_ref(transform);
+                return ENOMEM;
+        }
+        barrier_transform_t *self = transform_as_barrier(base);
+        assert(!self->transform);
+        self->transform = transform;
+        return EOK;
+}
 /** 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.
+ * have a different value for num_params. The subtransform must be set with @a
+ * bithenge_barrier_transform_set_subtransform before the result is used.
  * @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_barrier_transform(bithenge_transform_t **out,
+    bithenge_transform_t *transform, int num_params)
+{
+        assert(transform);
+        assert(bithenge_transform_num_params(transform) == 0);
+int bithenge_new_barrier_transform(bithenge_transform_t **out, int num_params)
+{
         int rc;
         barrier_transform_t *self = malloc(sizeof(*self));
 …
         if (rc != EOK)
                 goto error;
         self->transform = transform;
+        self->transform = NULL;
         *out = barrier_as_transform(self);
         return EOK;
 error:
-        bithenge_transform_dec_ref(transform);
         free(self);
         return rc;
 …
+{
         char buffer;
+        *out_size = 1;
+        int rc = bithenge_blob_read_bits(blob, 0, &buffer, out_size, true);
+        if (rc != EOK)
+                return rc;
+        if (*out_size != 1)
+                return EINVAL;
+        aoff64_t size = 1;
+        int rc = bithenge_blob_read_bits(blob, 0, &buffer, &size, true);
+        if (rc != EOK)
+                return rc;
+        if (size != 1)
+                return EINVAL;
+        if (out_size)
+                *out_size = size;
         return bithenge_new_boolean_node(out_node, (buffer & 1) != 0);
+}
 …
+}
+/** @cond internal */
 #define MAKE_UINT_TRANSFORM(NAME, TYPE, ENDIAN, PREFIX_LENGTH_FUNC)            \
         static int NAME##_apply(bithenge_transform_t *self,                    \
 …
 MAKE_UINT_TRANSFORM(uint32le, uint32_t, uint32_t_le2host, prefix_length_4);
 MAKE_UINT_TRANSFORM(uint32be, uint32_t, uint32_t_be2host, prefix_length_4);
+MAKE_UINT_TRANSFORM(uint64le, uint64_t, uint32_t_le2host, prefix_length_8);
+MAKE_UINT_TRANSFORM(uint64be, uint64_t, uint32_t_be2host, prefix_length_8);
+MAKE_UINT_TRANSFORM(uint64le, uint64_t, uint64_t_le2host, prefix_length_8);
+MAKE_UINT_TRANSFORM(uint64be, uint64_t, uint64_t_be2host, prefix_length_8);
+/** @endcond */
 …
                 return EINVAL;
         *out_size = num_bits;
+        aoff64_t size = num_bits;
         uint8_t buffer[sizeof(bithenge_int_t)];
         rc = bithenge_blob_read_bits(blob, 0, (char *)buffer, out_size,
+        rc = bithenge_blob_read_bits(blob, 0, (char *)buffer, &size,
             little_endian);
         if (rc != EOK)
                 return rc;
+        if (*out_size != (aoff64_t)num_bits)
+                return EINVAL;
+        if (size != (aoff64_t)num_bits)
+                return EINVAL;
+        if (out_size)
+                *out_size = size;
         bithenge_int_t result = 0;
 …
 bithenge_named_transform_t *bithenge_primitive_transforms = primitive_transforms;
-typedef struct {
-        bithenge_transform_t base;
-        bithenge_transform_t **xforms;
-        size_t num;
-} compose_transform_t;
-static bithenge_transform_t *compose_as_transform(compose_transform_t *xform)
+{
-        return &xform->base;
+}
-static compose_transform_t *transform_as_compose(bithenge_transform_t *xform)
+{
-        return (compose_transform_t *)xform;
+}
-static int compose_apply(bithenge_transform_t *base, bithenge_scope_t *scope,
-    bithenge_node_t *in, bithenge_node_t **out)
+{
-        int rc;
-        compose_transform_t *self = transform_as_compose(base);
-        bithenge_node_inc_ref(in);
-        /* i ranges from (self->num - 1) to 0 inside the loop. */
-        for (size_t i = self->num; i--; ) {
-                bithenge_node_t *tmp;
-                rc = bithenge_transform_apply(self->xforms[i], scope, in,
-                    &tmp);
-                bithenge_node_dec_ref(in);
-                if (rc != EOK)
-                        return rc;
-                in = tmp;
+        }
-        *out = in;
-        return rc;
+}
-static int compose_prefix_length(bithenge_transform_t *base,
-    bithenge_scope_t *scope, bithenge_blob_t *blob, aoff64_t *out)
+{
-        compose_transform_t *self = transform_as_compose(base);
-        return bithenge_transform_prefix_length(self->xforms[self->num - 1],
-            scope, blob, out);
+}
-static void compose_destroy(bithenge_transform_t *base)
+{
-        compose_transform_t *self = transform_as_compose(base);
-        for (size_t i = 0; i < self->num; i++)
-                bithenge_transform_dec_ref(self->xforms[i]);
-        free(self->xforms);
-        free(self);
+}
-static const bithenge_transform_ops_t compose_transform_ops = {
-        .apply = compose_apply,
-        .prefix_length = compose_prefix_length,
-        .destroy = compose_destroy,
-};
-/** Create a composition of multiple transforms. When the result is applied to a
- * node, each transform is applied in turn, with the last transform applied
- * first. @a xforms may contain any number of transforms or no transforms at
- * all. This function takes ownership of @a xforms and the references therein.
- * @param[out] out Holds the result.
- * @param[in] xforms The transforms to apply.
- * @param num The number of transforms.
- * @return EOK on success or an error code from errno.h. */
-int bithenge_new_composed_transform(bithenge_transform_t **out,
-    bithenge_transform_t **xforms, size_t num)
+{
-        if (num == 0) {
-                /* TODO: optimize */
-        } else if (num == 1) {
-                *out = xforms[0];
-                free(xforms);
-                return EOK;
+        }
-        int rc;
-        compose_transform_t *self = malloc(sizeof(*self));
-        if (!self) {
-                rc = ENOMEM;
-                goto error;
+        }
-        rc = bithenge_init_transform(compose_as_transform(self),
-            &compose_transform_ops, 0);
-        if (rc != EOK)
-                goto error;
-        self->xforms = xforms;
-        self->num = num;
-        *out = compose_as_transform(self);
-        return EOK;
-error:
-        for (size_t i = 0; i < num; i++)
-                bithenge_transform_dec_ref(xforms[i]);
-        free(xforms);
-        free(self);
-        return rc;
+}
 /** @}
  */

uspace/lib/bithenge/transform.h

-              r0da6c04
+              r5e718d9
         unsigned int refs;
         struct bithenge_scope *outer;
+        char *error;
         bool barrier;
         int num_params;
 …
 } bithenge_scope_t;
+static inline void bithenge_scope_inc_ref(bithenge_scope_t *self) {
+/** Increment a scope's reference count.
+ * @memberof bithenge_scope_t
+ * @param self The scope to reference. */
+static inline void bithenge_scope_inc_ref(bithenge_scope_t *self)
+{
+        assert(self);
         self->refs++;
+}
 …
                 return;
         assert(self->ops);
+        assert(self->refs > 0);
         if (--self->refs == 0)
                 self->ops->destroy(self);
 …
 /** A transform with a name. */
 typedef struct {
+        /** The transform's name. */
         const char *name;
+        /** The transform. */
         bithenge_transform_t *transform;
 } bithenge_named_transform_t;
+/** Transform that decodes an 8-bit unsigned integer */
+extern bithenge_transform_t bithenge_uint8_transform;
+/** Transform that decodes a 16-bit little-endian unsigned integer */
+extern bithenge_transform_t bithenge_uint16le_transform;
+/** Transform that decodes a 16-bit big-endian unsigned integer */
+extern bithenge_transform_t bithenge_uint16be_transform;
+/** Transform that decodes a 32-bit little-endian unsigned integer */
+extern bithenge_transform_t bithenge_uint32le_transform;
+/** Transform that decodes a 32-bit big-endian unsigned integer */
+extern bithenge_transform_t bithenge_uint32be_transform;
+/** Transform that decodes a 64-bit little-endian unsigned integer */
+extern bithenge_transform_t bithenge_uint64le_transform;
+/** Transform that decodes a 64-bit big-endian unsigned integer */
+extern bithenge_transform_t bithenge_uint64be_transform;
+/** @cond */
 extern bithenge_transform_t bithenge_ascii_transform;
 extern bithenge_transform_t bithenge_bit_transform;
 …
 extern bithenge_transform_t bithenge_known_length_transform;
 extern bithenge_transform_t bithenge_nonzero_boolean_transform;
-extern bithenge_transform_t bithenge_uint8_transform;
-extern bithenge_transform_t bithenge_uint16le_transform;
-extern bithenge_transform_t bithenge_uint16be_transform;
-extern bithenge_transform_t bithenge_uint32le_transform;
-extern bithenge_transform_t bithenge_uint32be_transform;
-extern bithenge_transform_t bithenge_uint64le_transform;
-extern bithenge_transform_t bithenge_uint64be_transform;
 extern bithenge_transform_t bithenge_uint_le_transform;
 extern bithenge_transform_t bithenge_uint_be_transform;
 extern bithenge_transform_t bithenge_zero_terminated_transform;
 extern bithenge_named_transform_t *bithenge_primitive_transforms;
+/** @endcond */
+/** @memberof bithenge_transform_t */
 int bithenge_init_transform(bithenge_transform_t *,
     const bithenge_transform_ops_t *, int);
+/** @memberof bithenge_transform_t */
 int bithenge_transform_apply(bithenge_transform_t *, bithenge_scope_t *,
     bithenge_node_t *, bithenge_node_t **);
+/** @memberof bithenge_transform_t */
 int bithenge_transform_prefix_length(bithenge_transform_t *,
     bithenge_scope_t *, bithenge_blob_t *, aoff64_t *);
+/** @memberof bithenge_transform_t */
 int bithenge_transform_prefix_apply(bithenge_transform_t *, bithenge_scope_t *,
     bithenge_blob_t *, bithenge_node_t **, aoff64_t *);
 int bithenge_new_barrier_transform(bithenge_transform_t **,
+    bithenge_transform_t *, int);
+int bithenge_new_composed_transform(bithenge_transform_t **,
+    bithenge_transform_t **, size_t);
+int bithenge_new_barrier_transform(bithenge_transform_t **, int);
+int bithenge_barrier_transform_set_subtransform(bithenge_transform_t *,
+    bithenge_transform_t *);
+/** @memberof bithenge_scope_t */
 int bithenge_scope_new(bithenge_scope_t **, bithenge_scope_t *);
+/** @memberof bithenge_scope_t */
 void bithenge_scope_dec_ref(bithenge_scope_t *);
+/** @memberof bithenge_scope_t */
 bithenge_scope_t *bithenge_scope_outer(bithenge_scope_t *);
+/** @memberof bithenge_scope_t */
+const char *bithenge_scope_get_error(bithenge_scope_t *);
+/** @memberof bithenge_scope_t */
+int bithenge_scope_error(bithenge_scope_t *, const char *, ...);
+/** @memberof bithenge_scope_t */
 bithenge_node_t *bithenge_scope_get_current_node(bithenge_scope_t *);
+/** @memberof bithenge_scope_t */
 void bithenge_scope_set_current_node(bithenge_scope_t *, bithenge_node_t *);
+/** @memberof bithenge_scope_t */
 bithenge_node_t *bithenge_scope_in_node(bithenge_scope_t *);
+/** @memberof bithenge_scope_t */
 void bithenge_scope_set_in_node(bithenge_scope_t *, bithenge_node_t *);
+/** @memberof bithenge_scope_t */
 void bithenge_scope_set_barrier(bithenge_scope_t *);
+/** @memberof bithenge_scope_t */
 bool bithenge_scope_is_barrier(bithenge_scope_t *);
+/** @memberof bithenge_scope_t */
 int bithenge_scope_alloc_params(bithenge_scope_t *, int);
+/** @memberof bithenge_scope_t */
 int bithenge_scope_set_param(bithenge_scope_t *, int, bithenge_node_t *);
+/** @memberof bithenge_scope_t */
 int bithenge_scope_get_param(bithenge_scope_t *, int, bithenge_node_t **);

uspace/lib/bithenge/tree.c

-              r0da6c04
+              r5e718d9
         if (!node)
                 return;
+        assert (node->refs > 0);
         if (--node->refs == 0)
                 node_destroy(node);
 …
+{
         get_for_each_data_t *data = (get_for_each_data_t *)raw_data;
+        bool equal = bithenge_node_equal(key, data->key);
+        bool equal;
+        int rc = bithenge_node_equal(&equal, key, data->key);
         bithenge_node_dec_ref(key);
+        if (rc != EOK)
+                return rc;
         if (equal) {
                 *data->out = value;
 …
 /** Get a child of a node. Takes ownership of the key. If the node does not
  * provide this function, for_each will be used as an alternative, which may be
+ * very slow.
+ * @memberof bithenge_node_t
+ * @param self The internal node to find a child of.
+ * very slow. Also works for blob nodes to find the byte value at a given
+ * index.
+ * @memberof bithenge_node_t
+ * @param self The internal/blob node to find a child of.
  * @param key The key to search for.
  * @param[out] out Holds the found node.
 …
     bithenge_node_t **out)
+{
+        if (self->type == BITHENGE_NODE_BLOB) {
+                if (bithenge_node_type(key) != BITHENGE_NODE_INTEGER) {
+                        bithenge_node_dec_ref(key);
+                        return ENOENT;
+                }
+                bithenge_int_t offset = bithenge_integer_node_value(key);
+                bithenge_node_dec_ref(key);
+                uint8_t byte;
+                aoff64_t size = 1;
+                int rc = bithenge_blob_read(bithenge_node_as_blob(self),
+                    offset, (char *)&byte, &size);
+                if (rc != EOK)
+                        return rc;
+                if (size != 1)
+                        return ENOENT;
+                return bithenge_new_integer_node(out, byte);
+        }
         assert(self->type == BITHENGE_NODE_INTERNAL);
         if (self->internal_ops->get)
 …
 int bithenge_new_empty_internal_node(bithenge_node_t **out)
+{
+        if (bithenge_should_fail())
+                return ENOMEM;
         bithenge_node_inc_ref(&empty_internal_node);
         *out = &empty_internal_node;
 …
+{
         assert(out);
+        if (bithenge_should_fail())
+                return ENOMEM;
         *out = value ? &true_node : &false_node;
         (*out)->refs++;
 …
  * internal nodes. Takes ownership of nothing.
  * @memberof bithenge_node_t
+ * @param[out] out Holds whether the nodes are equal.
  * @param a, b Nodes to compare.
+ * @return Whether the nodes are equal. If an error occurs, returns false.
+ * @todo Add support for internal nodes.
+ */
+bool bithenge_node_equal(bithenge_node_t *a, bithenge_node_t *b)
+{
+        if (a->type != b->type)
+                return false;
+ * @return EOK on success or an error code from errno.h.
+ * @todo Add support for internal nodes. */
+int bithenge_node_equal(bool *out, bithenge_node_t *a, bithenge_node_t *b)
+{
+        if (a->type != b->type) {
+                *out = false;
+                return EOK;
+        }
         switch (a->type) {
         case BITHENGE_NODE_INTERNAL:
+                return false;
+                *out = false;
+                return EOK;
         case BITHENGE_NODE_BOOLEAN:
+                return a->boolean_value == b->boolean_value;
+                *out = a->boolean_value == b->boolean_value;
+                return EOK;
         case BITHENGE_NODE_INTEGER:
+                return a->integer_value == b->integer_value;
+                *out = a->integer_value == b->integer_value;
+                return EOK;
         case BITHENGE_NODE_STRING:
+                return !str_cmp(a->string_value.ptr, b->string_value.ptr);
+                *out = !str_cmp(a->string_value.ptr, b->string_value.ptr);
+                return EOK;
         case BITHENGE_NODE_BLOB:
                 return bithenge_blob_equal(bithenge_node_as_blob(a),
+                return bithenge_blob_equal(out, bithenge_node_as_blob(a),
                     bithenge_node_as_blob(b));
+        }
         return false;
+        return EINVAL;
+}

uspace/lib/bithenge/tree.h

-              r0da6c04
+              r5e718d9
 } bithenge_node_type_t;
+/** A tree node. It can have any of the types in @a bithenge_node_type_t. */
 typedef struct bithenge_node_t {
         /** @privatesection */
 …
         unsigned int refs;
         union {
+                /** @privatesection */
                 const struct bithenge_internal_node_ops_t *internal_ops;
                 bool boolean_value;
                 bithenge_int_t integer_value;
                 struct {
+                        /** @privatesection */
                         const char *ptr;
                         bool needs_free;
 …
+}
+/** @memberof bithenge_node_t */
 void bithenge_node_dec_ref(bithenge_node_t *node);
 …
+}
+/** @memberof bithenge_node_t */
 int bithenge_node_get(bithenge_node_t *, bithenge_node_t *,
     bithenge_node_t **);
 …
+}
+/** @memberof bithenge_node_t */
 int bithenge_init_internal_node(bithenge_node_t *,
     const bithenge_internal_node_ops_t *);
+/** @memberof bithenge_node_t */
 int bithenge_new_empty_internal_node(bithenge_node_t **);
+/** @memberof bithenge_node_t */
 int bithenge_new_simple_internal_node(bithenge_node_t **, bithenge_node_t **,
     bithenge_int_t, bool needs_free);
+/** @memberof bithenge_node_t */
 int bithenge_new_boolean_node(bithenge_node_t **, bool);
+/** @memberof bithenge_node_t */
 int bithenge_new_integer_node(bithenge_node_t **, bithenge_int_t);
+/** @memberof bithenge_node_t */
 int bithenge_new_string_node(bithenge_node_t **, const char *, bool);
+bool bithenge_node_equal(bithenge_node_t *, bithenge_node_t *);
+/** @memberof bithenge_node_t */
+int bithenge_node_equal(bool *, bithenge_node_t *, bithenge_node_t *);
 #endif

Context Navigation

Changeset 5e718d9 in mainline for uspace/lib/bithenge

Legend:

uspace/lib/bithenge/blob.c

uspace/lib/bithenge/blob.h

uspace/lib/bithenge/expression.c

uspace/lib/bithenge/expression.h

uspace/lib/bithenge/file.c

uspace/lib/bithenge/helenos/block.c

uspace/lib/bithenge/helenos/os.h

uspace/lib/bithenge/linux/os.h

uspace/lib/bithenge/print.c

uspace/lib/bithenge/print.h

uspace/lib/bithenge/script.c

uspace/lib/bithenge/sequence.c

uspace/lib/bithenge/transform.c

uspace/lib/bithenge/transform.h

uspace/lib/bithenge/tree.c

uspace/lib/bithenge/tree.h

Download in other formats: