Changeset 0153c87 in mainline for uspace/app/bithenge/expression.c

Timestamp:

2012-08-10T20:09:36Z (12 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

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

Children:

6be4142

Parents:

c9797067

Message:

Bithenge: more FAT, operators, and fixes

File:

• uspace/app/bithenge/expression.c (modified) (3 diffs)

uspace/app/bithenge/expression.c

@@ -104 +104 @@
         case BITHENGE_EXPRESSION_ADD: /* fallthrough */
         case BITHENGE_EXPRESSION_SUBTRACT: /* fallthrough */
-        case BITHENGE_EXPRESSION_MULTIPLY:
+        case BITHENGE_EXPRESSION_MULTIPLY: /* fallthrough */
+        case BITHENGE_EXPRESSION_INTEGER_DIVIDE: /* fallthrough */
+        case BITHENGE_EXPRESSION_MODULO: /* fallthrough */
+        case BITHENGE_EXPRESSION_LESS_THAN: /* fallthrough */
+        case BITHENGE_EXPRESSION_LESS_THAN_OR_EQUAL: /* fallthrough */
+        case BITHENGE_EXPRESSION_GREATER_THAN: /* fallthrough */
+        case BITHENGE_EXPRESSION_GREATER_THAN_OR_EQUAL:
                 rc = EINVAL;
                 if (bithenge_node_type(a) != BITHENGE_NODE_INTEGER)
@@ -127 +133 @@
                 rc = bithenge_new_integer_node(out, a_int * b_int);
                 break;
+        case BITHENGE_EXPRESSION_INTEGER_DIVIDE:
+                /* Integer division can behave in three major ways when the
+                 * operands are signed: truncated, floored, or Euclidean. When
+                 * b > 0, we give the same result as floored and Euclidean;
+                 * otherwise, we currently raise an error. See
+                 * https://en.wikipedia.org/wiki/Modulo_operation and its
+                 * references. */
+                if (b_int <= 0) {
+                        rc = EINVAL;
+                        break;
+                }
+                rc = bithenge_new_integer_node(out,
+                    (a_int / b_int) + (a_int % b_int < 0 ? -1 : 0));
+                break;
+        case BITHENGE_EXPRESSION_MODULO:
+                /* This is consistent with division; see above. */
+                if (b_int <= 0) {
+                        rc = EINVAL;
+                        break;
+                }
+                rc = bithenge_new_integer_node(out,
+                    (a_int % b_int) + (a_int % b_int < 0 ? b_int : 0));
+                break;
+        case BITHENGE_EXPRESSION_LESS_THAN:
+                rc = bithenge_new_boolean_node(out, a_int < b_int);
+                break;
+        case BITHENGE_EXPRESSION_LESS_THAN_OR_EQUAL:
+                rc = bithenge_new_boolean_node(out, a_int <= b_int);
+                break;
+        case BITHENGE_EXPRESSION_GREATER_THAN:
+                rc = bithenge_new_boolean_node(out, a_int > b_int);
+                break;
+        case BITHENGE_EXPRESSION_GREATER_THAN_OR_EQUAL:
+                rc = bithenge_new_boolean_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_NOT_EQUALS:
+                rc = bithenge_new_boolean_node(out,
+                    ~bithenge_node_equal(a, b));
                 break;
         case BITHENGE_EXPRESSION_INVALID_BINARY_OP:
@@ -495 +540 @@
         for (; scope && !bithenge_scope_is_barrier(scope);
             scope = bithenge_scope_outer(scope)) {
+                bithenge_node_t *cur = bithenge_scope_get_current_node(scope);
+                if (!cur)
+                        continue;
                 bithenge_node_inc_ref(self->key);
-                bithenge_node_t *cur = bithenge_scope_get_current_node(scope);
                 int rc = bithenge_node_get(cur, self->key, out);
                 bithenge_node_dec_ref(cur);