Changeset 0d1a8fd in mainline

Timestamp:

2012-06-24T18:44:34Z (12 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

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

Children:

f2da0bb

Parents:

03b2b2c

Message:

Bithenge: allow primitive transforms in scripts

Location:

uspace/app/bithenge

Files:

• linux/os.h (modified) (2 diffs)
• script.c (modified) (1 diff)
• transform.c (modified) (4 diffs)
• transform.h (modified) (1 diff)

uspace/app/bithenge/linux/os.h

@@ -85 +85 @@
 }
 
+static inline char *str_dup(const char *s)
+{
+        return strdup(s);
+}
+
 static inline char *str_ndup(const char *s, size_t max_len)
 {
@@ -100 +105 @@
 }
 
+static inline uint32_t uint32_t_be2host(uint32_t val)
+{
+        return be32toh(val);
+}
+
 #endif

uspace/app/bithenge/script.c

@@ -232 +232 @@
 }
 
-/** Find a transform by name.
+/** Find a transform by name. A reference will be added to the transform.
  * @return The found transform, or NULL if none was found. */
 static bithenge_transform_t *get_named_transform(state_t *state,
     const char *name)
 {
-        for (transform_list_t *e = state->transform_list; e; e = e->next)
-                if (!str_cmp(e->name, name))
+        for (transform_list_t *e = state->transform_list; e; e = e->next) {
+                if (!str_cmp(e->name, name)) {
+                        bithenge_transform_inc_ref(e->transform);
                         return e->transform;
+                }
+        }
+        for (int i = 0; bithenge_primitive_transforms[i].name; i++) {
+                if (!str_cmp(bithenge_primitive_transforms[i].name, name)) {
+                        bithenge_transform_t *xform =
+                            bithenge_primitive_transforms[i].transform;
+                        bithenge_transform_inc_ref(xform);
+                        return xform;
+                }
+        }
         return NULL;
 }

uspace/app/bithenge/transform.c

@@ -35 +35 @@
  */
 
+#include <assert.h>
 #include <errno.h>
+#include <stdlib.h>
 #include "blob.h"
 #include "transform.h"
@@ -41 +43 @@
 static int transform_indestructible(bithenge_transform_t *xform)
 {
-        return EINVAL;
+        assert(false);
+        return EOK;
 }
 
@@ -64 +67 @@
 }
 
-static int uint32le_prefix_length(bithenge_transform_t *xform,
-    bithenge_blob_t *blob, aoff64_t *out)
+static int uint32be_apply(bithenge_transform_t *xform, bithenge_node_t *in,
+    bithenge_node_t **out)
+{
+        int rc;
+        if (bithenge_node_type(in) != BITHENGE_NODE_BLOB)
+                return EINVAL;
+        bithenge_blob_t *blob = bithenge_node_as_blob(in);
+
+        // Try to read 5 bytes and fail if the blob is too long.
+        uint32_t val[2];
+        aoff64_t size = sizeof(val[0]) + 1;
+        rc = bithenge_blob_read(blob, 0, (char *)val, &size);
+        if (rc != EOK)
+                return rc;
+        if (size != 4)
+                return EINVAL;
+
+        return bithenge_new_integer_node(out, uint32_t_be2host(val[0]));
+}
+
+static int prefix_length_4(bithenge_transform_t *xform, bithenge_blob_t *blob,
+    aoff64_t *out)
 {
         *out = 4;
@@ -73 +96 @@
 static const bithenge_transform_ops_t uint32le_ops = {
         .apply = uint32le_apply,
-        .prefix_length = uint32le_prefix_length,
+        .prefix_length = prefix_length_4,
         .destroy = transform_indestructible,
 };
 
-static bithenge_transform_t uint32le_transform = {
+static const bithenge_transform_ops_t uint32be_ops = {
+        .apply = uint32be_apply,
+        .prefix_length = prefix_length_4,
+        .destroy = transform_indestructible,
+};
+
+/** The little-endian 32-bit unsigned integer transform. */
+bithenge_transform_t bithenge_uint32le_transform = {
         &uint32le_ops, 1
 };
 
-/** Create a little-endian 32-bit unsigned integer transform.
- * @param out Holds the transform.
- * @return EOK on success or an error code from errno.h. */
-int bithenge_uint32le_transform(bithenge_transform_t **out)
-{
-        *out = &uint32le_transform;
-        return EOK;
-}
+/** The big-endian 32-bit unsigned integer transform. */
+bithenge_transform_t bithenge_uint32be_transform = {
+        &uint32be_ops, 1
+};
+
+static bithenge_named_transform_t primitive_transforms[] = {
+        {"uint32le", &bithenge_uint32le_transform},
+        {"uint32be", &bithenge_uint32be_transform},
+        {NULL, NULL}
+};
+
+/** An array of named built-in transforms. */
+bithenge_named_transform_t *bithenge_primitive_transforms = primitive_transforms;
 
 /** @}

uspace/app/bithenge/transform.h

@@ -117 +117 @@
 }
 
-int bithenge_uint32le_transform(bithenge_transform_t **out);
+/** A transform with a name. */
+typedef struct {
+        const char *name;
+        bithenge_transform_t *transform;
+} bithenge_named_transform_t;
+
+extern bithenge_transform_t bithenge_uint32le_transform;
+extern bithenge_transform_t bithenge_uint32be_transform;
+extern bithenge_named_transform_t *bithenge_primitive_transforms;
 
 #endif