Changeset 04a7435f in mainline for uspace/app/bithenge/script.c

Timestamp:

2012-06-26T19:56:26Z (12 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

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

Children:

978ccaf1

Parents:

f2da0bb

Message:

Bithenge: add the struct transform

File:

• uspace/app/bithenge/script.c (modified) (7 diffs)

uspace/app/bithenge/script.c

@@ -53 +53 @@
         TOKEN_EOF,
         TOKEN_IDENTIFIER,
+        TOKEN_LEFT_ARROW,
 
         /* Keywords */
+        TOKEN_STRUCT,
         TOKEN_TRANSFORM,
 } token_type_t;
@@ -181 +183 @@
                 if (!value) {
                         error_errno(state, ENOMEM);
+                } else if (!str_cmp(value, "struct")) {
+                        state->token = TOKEN_STRUCT;
+                        free(value);
                 } else if (!str_cmp(value, "transform")) {
                         state->token = TOKEN_TRANSFORM;
@@ -188 +193 @@
                         state->token_string = value;
                 }
+        } else if (ch == '<') {
+                state->token = ch;
+                state->buffer_pos++;
+                if (state->buffer[state->buffer_pos] == '-') {
+                        state->buffer_pos++;
+                        state->token = TOKEN_LEFT_ARROW;
+                }
         } else {
                 state->token = ch;
@@ -207 +219 @@
 }
 
+/** Reallocate memory and handle failure by setting the error in the state. If
+ * an error occurs, the existing pointer will be returned. */
+static void *state_realloc(state_t *state, void *ptr, size_t size)
+{
+        if (state->error != EOK)
+                return ptr;
+        void *result = realloc(ptr, size);
+        if (result == NULL) {
+                error_errno(state, ENOMEM);
+                return ptr;
+        }
+        return result;
+}
+
 /** Expect and consume a certain token. If the next token is of the wrong type,
  * an error is caused. */
@@ -255 +281 @@
 
 /** Add a named transform. This function takes ownership of the name and a
- * reference to the transform. */
+ * reference to the transform. If an error has occurred, either may be null. */
 static void add_named_transform(state_t *state, bithenge_transform_t *xform, char *name)
 {
@@ -269 +295 @@
         entry->next = state->transform_list;
         state->transform_list = entry;
+}
+
+static bithenge_transform_t *parse_transform(state_t *state);
+
+static bithenge_transform_t *parse_struct(state_t *state)
+{
+        size_t num = 0;
+        bithenge_named_transform_t *subxforms;
+        /* We keep an extra space for the {NULL, NULL} terminator. */
+        subxforms = state_malloc(state, sizeof(*subxforms));
+        expect(state, TOKEN_STRUCT);
+        expect(state, '{');
+        while (state->error == EOK && state->token != '}') {
+                expect(state, '.');
+                subxforms[num].name = expect_identifier(state);
+                expect(state, TOKEN_LEFT_ARROW);
+                subxforms[num].transform = parse_transform(state);
+                expect(state, ';');
+                num++;
+                subxforms = state_realloc(state, subxforms,
+                    (num + 1)*sizeof(*subxforms));
+        }
+        expect(state, '}');
+
+        if (state->error != EOK) {
+                while (num--) {
+                        free((void *)subxforms[num].name);
+                        bithenge_transform_dec_ref(subxforms[num].transform);
+                }
+                free(subxforms);
+                return NULL;
+        }
+
+        subxforms[num].name = NULL;
+        subxforms[num].transform = NULL;
+        bithenge_transform_t *result;
+        int rc = bithenge_new_struct(&result, subxforms);
+        if (rc != EOK) {
+                error_errno(state, rc);
+                return NULL;
+        }
+        return result;
 }
 
@@ -282 +350 @@
                 next_token(state);
                 return result;
+        } else if (state->token == TOKEN_STRUCT) {
+                return parse_struct(state);
         } else {
                 syntax_error(state, "unexpected (transform expected)");