Changeset fa36f29 in mainline for uspace/app/sbi/src/rdata.c

Timestamp:

2010-02-27T17:59:14Z (14 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

94d484a

Parents:

09ababb7

Message:

Update SBI to rev. 75.

File:

• uspace/app/sbi/src/rdata.c (modified) (6 diffs)

uspace/app/sbi/src/rdata.c

@@ -100 +100 @@
 }
 
+rdata_ref_t *rdata_ref_new(void)
+{
+        rdata_ref_t *ref;
+
+        ref = calloc(1, sizeof(rdata_ref_t));
+        if (ref == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        return ref;
+}
+
 rdata_deleg_t *rdata_deleg_new(void)
 {
@@ -111 +124 @@
 
         return deleg;
+}
+
+rdata_object_t *rdata_object_new(void)
+{
+        rdata_object_t *object;
+
+        object = calloc(1, sizeof(rdata_object_t));
+        if (object == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        return object;
 }
 
@@ -181 +207 @@
 static void rdata_ref_copy(rdata_ref_t *src, rdata_ref_t **dest)
 {
-        printf("Unimplemented: Copy reference.\n");
-        exit(1);
+        *dest = rdata_ref_new();
+        (*dest)->vref = src->vref;
 }
 
 static void rdata_deleg_copy(rdata_deleg_t *src, rdata_deleg_t **dest)
 {
+        (void) src; (void) dest;
         printf("Unimplemented: Copy delegate.\n");
         exit(1);
@@ -193 +220 @@
 static void rdata_object_copy(rdata_object_t *src, rdata_object_t **dest)
 {
+        (void) src; (void) dest;
         printf("Unimplemented: Copy object.\n");
         exit(1);
+}
+
+/** Convert item to value item.
+ *
+ * If @a item is a value, we just return a copy. If @a item is an address,
+ * we read from the address.
+ */
+void rdata_cvt_value_item(rdata_item_t *item, rdata_item_t **ritem)
+{
+        rdata_value_t *value;
+
+        /* 
+         * This can happen when trying to use output of a function which
+         * does not return a value.
+         */
+        if (item == NULL) {
+                printf("Error: Sub-expression has no value.\n");
+                exit(1);
+        }
+
+        /* Address item. Perform read operation. */
+        if (item->ic == ic_address) {
+                rdata_address_read(item->u.address, ritem);
+                return;
+        }
+
+        /* It already is a value, we can share the @c var. */
+        value = rdata_value_new();
+        value->var = item->u.value->var;
+        *ritem = rdata_item_new(ic_value);
+        (*ritem)->u.value = value;
+}
+
+/** Return reference to a variable.
+ *
+ * Constructs a reference (value item) pointing to @a var.
+ */
+void rdata_reference(rdata_var_t *var, rdata_item_t **res)
+{
+        rdata_ref_t *ref;
+        rdata_var_t *ref_var;
+        rdata_value_t *ref_value;
+        rdata_item_t *ref_item;
+
+        /* Create reference to the variable. */
+        ref = rdata_ref_new();
+        ref_var = rdata_var_new(vc_ref);
+        ref->vref = var;
+        ref_var->u.ref_v = ref;
+
+        /* Construct value of the reference to return. */
+        ref_item = rdata_item_new(ic_value);
+        ref_value = rdata_value_new();
+        ref_item->u.value = ref_value;
+        ref_value->var = ref_var;
+
+        *res = ref_item;
+}
+
+/** Return address of reference target.
+ *
+ * Takes a reference (address or value) and returns the address (item) of
+ * the target of the reference.
+ */
+void rdata_dereference(rdata_item_t *ref, rdata_item_t **ritem)
+{
+        rdata_item_t *ref_val;
+        rdata_item_t *item;
+        rdata_address_t *address;
+
+#ifdef DEBUG_RUN_TRACE
+        printf("run_dereference()\n");
+#endif
+        rdata_cvt_value_item(ref, &ref_val);
+        assert(ref_val->u.value->var->vc == vc_ref);
+
+        item = rdata_item_new(ic_address);
+        address = rdata_address_new();
+        item->u.address = address;
+        address->vref = ref_val->u.value->var->u.ref_v->vref;
+
+        if (address->vref == NULL) {
+                printf("Error: Accessing null reference.\n");
+                exit(1);
+        }
+
+#ifdef DEBUG_RUN_TRACE
+        printf("vref set to %p\n", address->vref);
+#endif
+        *ritem = item;
+}
+
+/** Read data from an address.
+ *
+ * Return value stored in a variable at the specified address.
+ */
+void rdata_address_read(rdata_address_t *address, rdata_item_t **ritem)
+{
+        rdata_value_t *value;
+        rdata_var_t *rvar;
+
+        /* Perform a shallow copy of @c var. */
+        rdata_var_copy(address->vref, &rvar);
+
+        value = rdata_value_new();
+        value->var = rvar;
+        *ritem = rdata_item_new(ic_value);
+        (*ritem)->u.value = value;
+}
+
+/** Write data to an address.
+ *
+ * Store @a value to the variable at @a address.
+ */
+void rdata_address_write(rdata_address_t *address, rdata_value_t *value)
+{
+        rdata_var_t *nvar;
+        rdata_var_t *orig_var;
+
+        /* Perform a shallow copy of @c value->var. */
+        rdata_var_copy(value->var, &nvar);
+        orig_var = address->vref;
+
+        /* XXX do this in a prettier way. */
+
+        orig_var->vc = nvar->vc;
+        switch (nvar->vc) {
+        case vc_int: orig_var->u.int_v = nvar->u.int_v; break;
+        case vc_ref: orig_var->u.ref_v = nvar->u.ref_v; break;
+        case vc_deleg: orig_var->u.deleg_v = nvar->u.deleg_v; break;
+        case vc_object: orig_var->u.object_v = nvar->u.object_v; break;
+        default: assert(b_false);
+        }
+
+        /* XXX We should free some stuff around here. */
 }
 
@@ -232 +395 @@
                 printf("int(%d)", var->u.int_v->value);
                 break;
+        case vc_string:
+                printf("string(\"%s\")", var->u.string_v->value);
+                break;
         case vc_ref:
                 printf("ref");
@@ -242 +408 @@
                 break;
         default:
+                printf("print(%d)\n", var->vc);
                 assert(b_false);
         }