Changeset 4056ad0 in mainline for uspace/app/bithenge/script.c

Timestamp:

2012-07-28T01:57:31Z (12 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

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

Children:

32eb01b

Parents:

03cad47

Message:

Bithenge: basic parameter passing (integer literals only)

File:

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

uspace/app/bithenge/script.c

@@ -38 +38 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include "expression.h"
 #include "os.h"
 #include "script.h"
@@ -53 +54 @@
         TOKEN_EOF,
         TOKEN_IDENTIFIER,
+        TOKEN_INTEGER,
         TOKEN_LEFT_ARROW,
 
@@ -95 +97 @@
                  * NULL, it will be freed when the next token is read. */
                 char *token_string;
+                /** The value of a TOKEN_INTEGER token. */
+                bithenge_int_t token_int;
         };
 } state_t;
@@ -202 +206 @@
                         state->token_string = value;
                 }
+        } else if (isdigit(ch)) {
+                while (isdigit(state->buffer[state->buffer_pos]))
+                        state->buffer_pos++;
+                state->token = TOKEN_INTEGER;
+                int rc = bithenge_parse_int(state->buffer +
+                    state->old_buffer_pos, &state->token_int);
+                if (rc != EOK)
+                        error_errno(state, rc);
         } else if (ch == '<') {
                 state->token = ch;
@@ -307 +319 @@
 
 static bithenge_transform_t *parse_transform(state_t *state);
+
+static bithenge_expression_t *parse_expression(state_t *state)
+{
+        if (state->token == TOKEN_INTEGER) {
+                bithenge_int_t val = state->token_int;
+                next_token(state);
+                bithenge_node_t *node;
+                int rc = bithenge_new_integer_node(&node, val);
+                if (rc != EOK) {
+                        error_errno(state, rc);
+                        return NULL;
+                }
+
+                bithenge_expression_t *expr;
+                rc = bithenge_const_expression(&expr, node);
+                if (rc != EOK) {
+                        error_errno(state, rc);
+                        return NULL;
+                }
+
+                return expr;
+        } else {
+                syntax_error(state, "expression expected");
+                return NULL;
+        }
+}
+
+// state->token must be TOKEN_IDENTIFIER when this is called
+static bithenge_transform_t *parse_invocation(state_t *state)
+{
+        bithenge_transform_t *result = get_named_transform(state,
+            state->token_string);
+        if (!result)
+                syntax_error(state, "transform not found");
+        next_token(state);
+
+        bithenge_expression_t **params = NULL;
+        int num_params = 0;
+        if (state->token == '(') {
+                next_token(state);
+                while (state->error == EOK && state->token != ')') {
+                        if (num_params)
+                                expect(state, ',');
+                        params = state_realloc(state, params,
+                            (num_params + 1)*sizeof(*params));
+                        if (state->error != EOK)
+                                break;
+                        params[num_params] = parse_expression(state);
+                        num_params++;
+                }
+                expect(state, ')');
+        }
+
+        /* TODO: show correct error position */
+        if (state->error == EOK
+            && bithenge_transform_num_params(result) != num_params)
+                syntax_error(state, "incorrect number of parameters before");
+
+        if (state->error != EOK) {
+                while (num_params--)
+                        bithenge_expression_dec_ref(params[num_params]);
+                free(params);
+                bithenge_transform_dec_ref(result);
+                return NULL;
+        }
+
+        if (num_params) {
+                int rc = bithenge_param_wrapper(&result, result, params);
+                if (rc != EOK) {
+                        error_errno(state, rc);
+                        result = NULL;
+                }
+        }
+
+        return result;
+}
 
 static bithenge_transform_t *parse_struct(state_t *state)
@@ -358 +446 @@
 {
         if (state->token == TOKEN_IDENTIFIER) {
-                bithenge_transform_t *result = get_named_transform(state,
-                    state->token_string);
-                if (!result)
-                        syntax_error(state, "transform not found");
-                next_token(state);
-                return result;
+                return parse_invocation(state);
         } else if (state->token == TOKEN_STRUCT) {
                 return parse_struct(state);