Changeset ad5c8a48 in mainline

Timestamp:

2012-08-07T21:35:50Z (12 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

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

Children:

a66ea217

Parents:

c12b2ae

Message:

Bithenge: add expressions with binary operators

Location:

uspace/app/bithenge

Files:

• expression.c (modified) (1 diff)
• expression.h (modified) (1 diff)
• script.c (modified) (5 diffs)

uspace/app/bithenge/expression.c

@@ -94 +94 @@
                 return rc;
         }
+
+        /* Check types and get values. */
+        bithenge_int_t a_int, b_int;
         switch (self->op) {
+        case BITHENGE_EXPRESSION_ADD: /* fallthrough */
+        case BITHENGE_EXPRESSION_SUBTRACT: /* fallthrough */
+        case BITHENGE_EXPRESSION_MULTIPLY:
+                rc = EINVAL;
+                if (bithenge_node_type(a) != BITHENGE_NODE_INTEGER)
+                        goto error;
+                if (bithenge_node_type(b) != BITHENGE_NODE_INTEGER)
+                        goto error;
+                a_int = bithenge_integer_node_value(a);
+                b_int = bithenge_integer_node_value(b);
+                break;
+        default:
+                break;
+        }
+
+        switch (self->op) {
+        case BITHENGE_EXPRESSION_ADD:
+                rc = bithenge_new_integer_node(out, a_int + b_int);
+                break;
+        case BITHENGE_EXPRESSION_SUBTRACT:
+                rc = bithenge_new_integer_node(out, a_int - b_int);
+                break;
+        case BITHENGE_EXPRESSION_MULTIPLY:
+                rc = bithenge_new_integer_node(out, a_int * b_int);
+                break;
         case BITHENGE_EXPRESSION_EQUALS:
                 rc = bithenge_new_boolean_node(out, bithenge_node_equal(a, b));
                 break;
-        }
+        case BITHENGE_EXPRESSION_INVALID_BINARY_OP:
+                assert(false);
+                break;
+        }
+
+error:
         bithenge_node_dec_ref(a);
         bithenge_node_dec_ref(b);

uspace/app/bithenge/expression.h

@@ -92 +92 @@
 
 typedef enum {
+        BITHENGE_EXPRESSION_INVALID_BINARY_OP,
+        BITHENGE_EXPRESSION_ADD,
+        BITHENGE_EXPRESSION_SUBTRACT,
+        BITHENGE_EXPRESSION_MULTIPLY,
         BITHENGE_EXPRESSION_EQUALS,
 } bithenge_binary_op_t;

uspace/app/bithenge/script.c

@@ -52 +52 @@
  * other token uses one of these values: */
 typedef enum {
-        TOKEN_ERROR = -128,
+        TOKEN_EQUALS = -128,
+        TOKEN_ERROR,
         TOKEN_EOF,
         TOKEN_IDENTIFIER,
@@ -261 +262 @@
                         state->token = TOKEN_LEFT_ARROW;
                 }
+        } else if (ch == '=') {
+                state->token = ch;
+                state->buffer_pos++;
+                if (state->buffer[state->buffer_pos] == '=') {
+                        state->token = TOKEN_EQUALS;
+                        state->buffer_pos++;
+                }
         } else {
                 state->token = ch;
@@ -360 +368 @@
 static bithenge_transform_t *parse_transform(state_t *state);
 static bithenge_transform_t *parse_struct(state_t *state);
-
-static bithenge_expression_t *parse_expression(state_t *state)
+static bithenge_expression_t *parse_expression(state_t *state);
+
+
+
+/***************** Expressions                               *****************/
+
+typedef enum {
+        PRECEDENCE_NONE,
+        PRECEDENCE_EQUALS,
+        PRECEDENCE_ADD,
+        PRECEDENCE_MULTIPLY,
+} precedence_t;
+
+static bithenge_binary_op_t token_as_binary_operator(token_type_t token)
+{
+        switch ((int)token) {
+        case '+':
+                return BITHENGE_EXPRESSION_ADD;
+        case '-':
+                return BITHENGE_EXPRESSION_SUBTRACT;
+        case '*':
+                return BITHENGE_EXPRESSION_MULTIPLY;
+        case TOKEN_EQUALS:
+                return BITHENGE_EXPRESSION_EQUALS;
+        default:
+                return BITHENGE_EXPRESSION_INVALID_BINARY_OP;
+        }
+}
+
+static precedence_t binary_operator_precedence(bithenge_binary_op_t op)
+{
+        switch (op) {
+        case BITHENGE_EXPRESSION_ADD: /* fallthrough */
+        case BITHENGE_EXPRESSION_SUBTRACT:
+                return PRECEDENCE_ADD;
+        case BITHENGE_EXPRESSION_MULTIPLY:
+                return PRECEDENCE_MULTIPLY;
+        case BITHENGE_EXPRESSION_EQUALS:
+                return PRECEDENCE_EQUALS;
+        default:
+                assert(false);
+                return PRECEDENCE_NONE;
+        }
+}
+
+static bithenge_expression_t *parse_term(state_t *state)
 {
         int rc;
@@ -451 +503 @@
 
                 return expr;
+        } else if (state->token == '(') {
+                next_token(state);
+                bithenge_expression_t *expr = parse_expression(state);
+                expect(state, ')');
+                return expr;
         } else {
                 syntax_error(state, "expression expected");
@@ -457 +514 @@
 }
 
-// state->token must be TOKEN_IDENTIFIER when this is called
+static bithenge_expression_t *parse_expression_precedence(state_t *state,
+    precedence_t prev_precedence)
+{
+        bithenge_expression_t *expr = parse_term(state);
+        while (state->error == EOK) {
+                bithenge_binary_op_t op =
+                    token_as_binary_operator(state->token);
+                if (op == BITHENGE_EXPRESSION_INVALID_BINARY_OP)
+                        break;
+                precedence_t precedence = binary_operator_precedence(op);
+                if (precedence <= prev_precedence)
+                        break;
+                next_token(state);
+
+                bithenge_expression_t *expr2 = parse_term(state);
+                if (state->error != EOK) {
+                        bithenge_expression_dec_ref(expr2);
+                        break;
+                }
+                int rc = bithenge_binary_expression(&expr, op, expr, expr2);
+                if (rc != EOK)
+                        error_errno(state, rc);
+        }
+        if (state->error != EOK) {
+                bithenge_expression_dec_ref(expr);
+                expr = NULL;
+        }
+        return expr;
+}
+
+static bithenge_expression_t *parse_expression(state_t *state)
+{
+        return parse_expression_precedence(state, PRECEDENCE_NONE);
+}
+
+
+
+/* state->token must be TOKEN_IDENTIFIER when this is called. */
 static bithenge_transform_t *parse_invocation(state_t *state)
 {