Changeset 32eb01b in mainline

Timestamp:

2012-07-28T04:19:00Z (12 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

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

Children:

f85ca3f

Parents:

4056ad0

Message:

Bithenge: allow defining transforms with parameters

Location:

uspace/app/bithenge

Files:

• helenos/os.h (modified) (1 diff)
• script.c (modified) (7 diffs)
• transform.c (modified) (5 diffs)
• transform.h (modified) (1 diff)

uspace/app/bithenge/helenos/os.h

@@ -82 +82 @@
 static inline int bithenge_parse_int(const char *start, bithenge_int_t *result)
 {
-        return str_uint64_t(start, NULL, 10, false, result);
+        const char *real_start = *start == '-' ? start + 1 : start;
+        uint64_t val;
+        int rc = str_uint64_t(real_start, NULL, 10, false, &val);
+        *result = val;
+        if (*start == '-')
+                *result = -*result;
+        return rc;
 }
 

uspace/app/bithenge/script.c

@@ -74 +74 @@
          * to indicate whether an error has occurred. */
         int error;
+
         /** The list of named transforms. */
         transform_list_t *transform_list;
+
         /** The name of the script file. */
         const char *filename;
@@ -91 +93 @@
         /** Added to a buffer position to find the column number. */
         int line_offset;
+
         /** The type of the current token. */
         token_type_t token;
@@ -100 +103 @@
                 bithenge_int_t token_int;
         };
+
+        /** The names of the current transform's parameters. */
+        char **parameter_names;
+        /** The number of parameters. */
+        int num_params;
 } state_t;
 
@@ -340 +348 @@
 
                 return expr;
+        } else if (state->token == TOKEN_IDENTIFIER) {
+                int i;
+                for (i = 0; i < state->num_params; i++)
+                        if (!str_cmp(state->parameter_names[i],
+                            state->token_string))
+                                break;
+
+                if (i == state->num_params) {
+                        syntax_error(state, "unknown identifier");
+                        return NULL;
+                }
+
+                bithenge_expression_t *expr;
+                int rc = bithenge_param_expression(&expr, i);
+                if (rc != EOK) {
+                        error_errno(state, rc);
+                        return NULL;
+                }
+
+                next_token(state);
+
+                return expr;
         } else {
                 syntax_error(state, "expression expected");
@@ -494 +524 @@
         expect(state, TOKEN_TRANSFORM);
         char *name = expect_identifier(state);
+
+        if (state->token == '(') {
+                next_token(state);
+                while (state->error == EOK && state->token != ')') {
+                        if (state->num_params)
+                                expect(state, ',');
+                        state->parameter_names = state_realloc(state,
+                            state->parameter_names,
+                            (state->num_params + 1)*sizeof(*state->parameter_names));
+                        if (state->error != EOK)
+                                break;
+                        state->parameter_names[state->num_params++] =
+                            expect_identifier(state);
+                }
+                expect(state, ')');
+        }
+
         expect(state, '=');
         bithenge_transform_t *xform = parse_transform(state);
         expect(state, ';');
+
+        if (state->error == EOK && state->num_params) {
+                int rc = bithenge_new_param_transform(&xform, xform,
+                    state->num_params);
+                if (rc != EOK) {
+                        xform = NULL;
+                        error_errno(state, rc);
+                }
+        }
+
         add_named_transform(state, xform, name);
+
+        for (int i = 0; i < state->num_params; i++)
+                free(state->parameter_names[i]);
+        free(state->parameter_names);
+        state->parameter_names = NULL;
+        state->num_params = 0;
 }
 
@@ -505 +568 @@
         state->error = EOK;
         state->transform_list = NULL;
+        state->parameter_names = NULL;
+        state->num_params = 0;
         state->token = TOKEN_ERROR;
         state->old_buffer_pos = state->buffer_pos = BUFFER_SIZE - 1;
@@ -532 +597 @@
                 entry = next;
         }
+        for (int i = 0; i < state->num_params; i++)
+                free(state->parameter_names[i]);
+        free(state->parameter_names);
 }
 

uspace/app/bithenge/transform.c

@@ -385 +385 @@
         bithenge_node_t base;
         struct struct_transform *transform;
-        bithenge_scope_t *scope;
+        bithenge_scope_t scope;
         bithenge_blob_t *blob;
 } struct_node_t;
@@ -491 +491 @@
         for (size_t i = 0; subxforms[i].transform; i++) {
                 rc = struct_node_for_one(subxforms[i].name,
-                    subxforms[i].transform, struct_node->scope, &blob, func,
+                    subxforms[i].transform, &struct_node->scope, &blob, func,
                     data);
                 if (rc != EOK)
@@ -516 +516 @@
         bithenge_transform_dec_ref(struct_as_transform(node->transform));
         bithenge_blob_dec_ref(node->blob);
+        bithenge_scope_destroy(&node->scope);
         free(node);
 }
@@ -533 +534 @@
         if (!node)
                 return ENOMEM;
-        int rc = bithenge_init_internal_node(struct_as_node(node),
+        bithenge_scope_init(&node->scope);
+        int rc = bithenge_scope_copy(&node->scope, scope);
+        if (rc != EOK) {
+                free(node);
+                return rc;
+        }
+        rc = bithenge_init_internal_node(struct_as_node(node),
             &struct_node_ops);
         if (rc != EOK) {
+                bithenge_scope_destroy(&node->scope);
                 free(node);
                 return rc;
@@ -542 +550 @@
         node->transform = self;
         bithenge_node_inc_ref(in);
-        node->scope = scope;
         node->blob = bithenge_node_as_blob(in);
         *out = struct_as_node(node);

uspace/app/bithenge/transform.h

@@ -88 +88 @@
 }
 
+/** Copy a scope.
+ * @param[out] out The scope to fill in; must have been initialized with @a
+ * bithenge_scope_init.
+ * @param scope The scope to copy.
+ * @return EOK on success or an error code from errno.h. */
+static inline int bithenge_scope_copy(bithenge_scope_t *out,
+    bithenge_scope_t *scope)
+{
+        out->params = malloc(sizeof(*out->params) * scope->num_params);
+        if (!out->params)
+                return ENOMEM;
+        memcpy(out->params, scope->params, sizeof(*out->params) *
+            scope->num_params);
+        out->num_params = scope->num_params;
+        for (int i = 0; i < out->num_params; i++)
+                bithenge_node_inc_ref(out->params[i]);
+        return EOK;
+}
+
 /** Allocate parameters. The parameters must then be set with @a
  * bithenge_scope_set_param.