Changeset 39e8406 in mainline

Timestamp:

2010-03-20T21:57:13Z (15 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

b535aeb

Parents:

6ba20a6b

Message:

Update SBI to rev. 128.

Location:

uspace/app/sbi

Files:

• Makefile (modified) (1 diff)
• src/ancr.c (modified) (2 diffs)
• src/builtin.c (modified) (7 diffs)
• src/builtin.h (modified) (1 diff)
• src/debug.h (modified) (1 diff)
• src/list.c (modified) (1 diff)
• src/list.h (modified) (1 diff)
• src/main.c (modified) (3 diffs)
• src/mytypes.h (modified) (1 diff)
• src/p_type.c (modified) (2 diffs)
• src/parse.c (modified) (9 diffs)
• src/rdata.c (modified) (2 diffs)
• src/rdata.h (modified) (2 diffs)
• src/rdata_t.h (modified) (2 diffs)
• src/run.c (modified) (27 diffs)
• src/run.h (modified) (1 diff)
• src/run_expr.c (modified) (20 diffs)
• src/run_t.h (modified) (1 diff)
• src/run_texpr.c (modified) (8 diffs)
• src/run_texpr.h (modified) (1 diff)
• src/stree.c (modified) (3 diffs)
• src/stree.h (modified) (2 diffs)
• src/stree_t.h (modified) (7 diffs)
• src/stype.c (added)
• src/stype.h (added)
• src/stype_expr.c (added)
• src/stype_expr.h (added)
• src/stype_t.h (added)
• src/symbol.c (modified) (2 diffs)
• src/symbol.h (modified) (1 diff)
• src/tdata.c (added)
• src/tdata.h (added)
• src/tdata_t.h (added)

uspace/app/sbi/Makefile

@@ -51 +51 @@
         src/stree.c \
         src/strtab.c \
-        src/symbol.c
+        src/stype.c \
+        src/stype_expr.c \
+        src/symbol.c \
+        src/tdata.c
 
 include ../Makefile.common

uspace/app/sbi/src/ancr.c

@@ -174 +174 @@
         do {
                 node_sym = csi_to_symbol(node);
-                symbol_print_fqn(prog, node_sym);
+                symbol_print_fqn(node_sym);
                 printf(", ");
 
@@ -196 +196 @@
 
         node_sym = csi_to_symbol(node);
-        symbol_print_fqn(prog, node_sym);
+        symbol_print_fqn(node_sym);
 }

uspace/app/sbi/src/builtin.c

@@ -44 +44 @@
 static stree_symbol_t *builtin_declare_fun(stree_csi_t *csi, const char *name);
 static void builtin_fun_add_arg(stree_symbol_t *fun_sym, const char *name);
-static void builtin_fun_add_vararg(stree_symbol_t *fun_sym, const char *name);
+static void builtin_fun_add_vararg(stree_symbol_t *fun_sym, const char *name,
+    stree_texpr_t *type);
+
+static stree_texpr_t *builtin_mktype_string_array(void);
 
 static void builtin_write_line(run_t *run);
@@ -86 +89 @@
 
         bi_exec = builtin_declare_fun(csi, "Exec");
-        builtin_fun_add_vararg(bi_exec, "args");
-}
-
-void builtin_run_proc(run_t *run, stree_symbol_t *proc_sym)
-{
+        builtin_fun_add_vararg(bi_exec, "args",
+            builtin_mktype_string_array());
+}
+
+void builtin_run_proc(run_t *run, stree_proc_t *proc)
+{
+        stree_symbol_t *fun_sym;
+
 #ifdef DEBUG_RUN_TRACE
         printf("Run builtin procedure.\n");
 #endif
-        if (proc_sym == bi_write_line) {
+        fun_sym = proc->outer_symbol;
+
+        if (fun_sym == bi_write_line) {
                 builtin_write_line(run);
-        } else if (proc_sym == bi_exec) {
+        } else if (fun_sym == bi_exec) {
                 builtin_exec(run);
         } else {
@@ -109 +117 @@
         stree_fun_t *fun;
         stree_csimbr_t *csimbr;
-        stree_symbol_t *symbol;
+        stree_symbol_t *fun_sym;
 
         ident = stree_ident_new();
@@ -116 +124 @@
         fun = stree_fun_new();
         fun->name = ident;
-        fun->body = NULL;
+        fun->proc = stree_proc_new();
+        fun->proc->body = NULL;
         list_init(&fun->args);
 
@@ -122 +131 @@
         csimbr->u.fun = fun;
 
-        symbol = stree_symbol_new(sc_fun);
-        symbol->u.fun = fun;
-        symbol->outer_csi = csi;
-        fun->symbol = symbol;
+        fun_sym = stree_symbol_new(sc_fun);
+        fun_sym->u.fun = fun;
+        fun_sym->outer_csi = csi;
+        fun->symbol = fun_sym;
+        fun->proc->outer_symbol = fun_sym;
 
         list_append(&csi->members, csimbr);
 
-        return symbol;
+        return fun_sym;
 }
 
@@ -150 +160 @@
 
 /** Add variadic formal parameter to function. */
-static void builtin_fun_add_vararg(stree_symbol_t *fun_sym, const char *name)
+static void builtin_fun_add_vararg(stree_symbol_t *fun_sym, const char *name,
+    stree_texpr_t *type)
 {
         stree_proc_arg_t *proc_arg;
@@ -161 +172 @@
         proc_arg->name = stree_ident_new();
         proc_arg->name->sid = strtab_get_sid(name);
-        proc_arg->type = NULL; /* XXX */
+        proc_arg->type = type;
 
         fun->varg = proc_arg;
+}
+
+/** Construct a @c string[] type expression. */
+static stree_texpr_t *builtin_mktype_string_array(void)
+{
+        stree_texpr_t *tstring;
+        stree_texpr_t *tsarray;
+        stree_tliteral_t *tliteral;
+        stree_tindex_t *tindex;
+
+        /* Construct @c string */
+        tstring = stree_texpr_new(tc_tliteral);
+        tliteral = stree_tliteral_new(tlc_string);
+        tstring->u.tliteral = tliteral;
+
+        /* Construct the indexing node */
+        tsarray = stree_texpr_new(tc_tindex);
+        tindex = stree_tindex_new();
+        tsarray->u.tindex = tindex;
+
+        tindex->base_type = tstring;
+        tindex->n_args = 1;
+        list_init(&tindex->args);
+
+        return tsarray;
 }
 

uspace/app/sbi/src/builtin.h

@@ -33 +33 @@
 
 void builtin_declare(stree_program_t *program);
-void builtin_run_proc(run_t *run, stree_symbol_t *proc_sym);
+void builtin_run_proc(run_t *run, stree_proc_t *proc);
 
 #endif

uspace/app/sbi/src/debug.h

@@ -33 +33 @@
 //#define DEBUG_PARSE_TRACE
 
+/** Uncomment this to get verbose debugging messagges during typing. */
+//#define DEBUG_TYPE_TRACE
+
 /** Uncomment this to get verbose debugging messages during execution. */
 //#define DEBUG_RUN_TRACE

uspace/app/sbi/src/list.c

@@ -130 +130 @@
 }
 
+/** Change node data. */
+void list_node_setdata(list_node_t *node, void *data)
+{
+        node->data = data;
+}
+
 /** Create new node. */
 static list_node_t *list_node_new(void *data)

uspace/app/sbi/src/list.h

@@ -44 +44 @@
 bool_t list_is_empty(list_t *list);
 
+void list_node_setdata(list_node_t *node, void *data);
+
 #define list_node_data(node, dtype) ((dtype)(node->data))
 

uspace/app/sbi/src/main.c

@@ -36 +36 @@
 #include "strtab.h"
 #include "stree.h"
+#include "stype.h"
 #include "input.h"
 #include "lex.h"
@@ -49 +50 @@
         parse_t parse;
         stree_program_t *program;
+        stype_t stype;
         run_t run;
         int rc;
@@ -78 +80 @@
         ancr_module_process(program, parse.cur_mod);
 
+        /* Type program. */
+        stype.program = program;
+        stype_module(&stype, program->module);
+
         /* Run program. */
         run_init(&run);

uspace/app/sbi/src/mytypes.h

@@ -56 +56 @@
 #include "stree_t.h"
 #include "strtab_t.h"
+#include "stype_t.h"
+#include "tdata_t.h"
 
 #endif

uspace/app/sbi/src/p_type.c

@@ -194 +194 @@
 {
         stree_tliteral_t *tliteral;
-
-        tliteral = stree_tliteral_new();
+        tliteral_class_t tlc;
 
         switch (lcur_lc(parse)) {
         case lc_int:
-                tliteral->tlc = tlc_int;
+                tlc = tlc_int;
                 break;
         case lc_string:
-                tliteral->tlc = tlc_string;
+                tlc = tlc_string;
                 break;
         default:
@@ -210 +209 @@
         lskip(parse);
 
+        tliteral = stree_tliteral_new(tlc);
         return tliteral;
 }

uspace/app/sbi/src/parse.c

@@ -35 +35 @@
 #include <assert.h>
 #include <stdlib.h>
+#include "debug.h"
 #include "lex.h"
 #include "list.h"
@@ -133 +134 @@
         csi = stree_csi_new(cc);
         csi->name = parse_ident(parse);
-/*
+
+#ifdef DEBUG_PARSE_TRACE
         printf("parse_csi: csi=%p, csi->name = %p (%s)\n", csi, csi->name,
             strtab_get_str(csi->name->sid));
-*/
+#endif
         if (lcur_lc(parse) == lc_colon) {
                 /* Inheritance list */
@@ -193 +195 @@
                 symbol->outer_csi = outer_csi;
                 fun->symbol = symbol;
+                fun->proc->outer_symbol = symbol;
                 break;
         case lc_var:
@@ -213 +216 @@
                 symbol->outer_csi = outer_csi;
                 prop->symbol = symbol;
+                if (prop->getter)
+                        prop->getter->outer_symbol = symbol;
+                if (prop->setter)
+                        prop->setter->outer_symbol = symbol;
                 break;
         default:
@@ -235 +242 @@
         lmatch(parse, lc_lparen);
 
+#ifdef DEBUG_PARSE_TRACE
+        printf("Parsing function '%s'.\n", strtab_get_str(fun->name->sid));
+#endif
+
         list_init(&fun->args);
 
@@ -242 +253 @@
                 while (b_true) {
                         arg = parse_proc_arg(parse);
+
                         if (stree_arg_has_attr(arg, aac_packed)) {
                                 fun->varg = arg;
@@ -266 +278 @@
 
         lmatch(parse, lc_is);
-        fun->body = parse_block(parse);
+        fun->proc = stree_proc_new();
+        fun->proc->body = parse_block(parse);
         lmatch(parse, lc_end);
 
@@ -342 +355 @@
                         lskip(parse);
                         lmatch(parse, lc_is);
-                        if (prop->getter_body != NULL) {
+                        if (prop->getter != NULL) {
                                 printf("Error: Duplicate getter.\n");
                                 exit(1);
                         }
-                        prop->getter_body = parse_block(parse);
+
+                        /* Create setter procedure */
+                        prop->getter = stree_proc_new();
+                        prop->getter->body = parse_block(parse);
+
                         lmatch(parse, lc_end);
                         break;
                 case lc_set:
                         lskip(parse);
-                        prop->setter_arg_name = parse_ident(parse);
+                        prop->setter_arg = stree_proc_arg_new();
+                        prop->setter_arg->name = parse_ident(parse);
+                        prop->setter_arg->type = prop->type;
                         lmatch(parse, lc_is);
-                        if (prop->setter_body != NULL) {
+                        if (prop->setter != NULL) {
                                 printf("Error: Duplicate setter.\n");
                                 exit(1);
                         }
-                        prop->setter_body = parse_block(parse);
+
+                        /* Create setter procedure */
+                        prop->setter = stree_proc_new();
+                        prop->setter->body = parse_block(parse);
+
                         lmatch(parse, lc_end);
                         break;
@@ -390 +413 @@
         }
 
+#ifdef DEBUG_PARSE_TRACE
+        printf("Parsed arg attr, type=%p.\n", arg->type);
+#endif
         return arg;
 }

uspace/app/sbi/src/rdata.c

@@ -243 +243 @@
 }
 
-rdata_titem_t *rdata_titem_new(titem_class_t tic)
-{
-        rdata_titem_t *titem;
-
-        titem = calloc(1, sizeof(rdata_titem_t));
-        if (titem == NULL) {
-                printf("Memory allocation failed.\n");
-                exit(1);
-        }
-
-        titem->tic = tic;
-        return titem;
-}
-
-rdata_tarray_t *rdata_tarray_new(void)
-{
-        rdata_tarray_t *tarray;
-
-        tarray = calloc(1, sizeof(rdata_tarray_t));
-        if (tarray == NULL) {
-                printf("Memory allocation failed.\n");
-                exit(1);
-        }
-
-        return tarray;
-}
-
-rdata_tcsi_t *rdata_tcsi_new(void)
-{
-        rdata_tcsi_t *tcsi;
-
-        tcsi = calloc(1, sizeof(rdata_tcsi_t));
-        if (tcsi == NULL) {
-                printf("Memory allocation failed.\n");
-                exit(1);
-        }
-
-        return tcsi;
-}
-
-rdata_tprimitive_t *rdata_tprimitive_new(void)
-{
-        rdata_tprimitive_t *tprimitive;
-
-        tprimitive = calloc(1, sizeof(rdata_tprimitive_t));
-        if (tprimitive == NULL) {
-                printf("Memory allocation failed.\n");
-                exit(1);
-        }
-
-        return tprimitive;
-}
-
 void rdata_array_alloc_element(rdata_array_t *array)
 {
@@ -447 +394 @@
 }
 
-/** Get item var-class.
- *
- * Get var-class of @a item, regardless whether it is a value or address.
- * (I.e. the var class of the value or variable at the given address).
- */
-var_class_t rdata_item_get_vc(rdata_item_t *item)
-{
-        var_class_t vc;
-
-        switch (item->ic) {
-        case ic_value:
-                vc = item->u.value->var->vc;
-                break;
-        case ic_address:
-                switch (item->u.address->ac) {
-                case ac_var:
-                        vc = item->u.address->u.var_a->vref->vc;
-                        break;
-                case ac_prop:
-                        printf("Unimplemented: Get property address "
-                            "varclass.\n");
-                        exit(1);
-                default:
-                        assert(b_false);
-                }
-                break;
-        default:
-                assert(b_false);
-        }
-
-        return vc;
-}
-
-/** Determine if CSI @a a is derived from CSI described by type item @a tb. */
-bool_t rdata_is_csi_derived_from_ti(stree_csi_t *a, rdata_titem_t *tb)
-{
-        bool_t res;
-
-        switch (tb->tic) {
-        case tic_tcsi:
-                res = stree_is_csi_derived_from_csi(a, tb->u.tcsi->csi);
-                break;
-        default:
-                printf("Error: Base type is not a CSI.\n");
-                exit(1);
-        }
-
-        return res;
-}
-
 void rdata_item_print(rdata_item_t *item)
 {

uspace/app/sbi/src/rdata.h

@@ -48 +48 @@
 rdata_string_t *rdata_string_new(void);
 
-rdata_titem_t *rdata_titem_new(titem_class_t tic);
-rdata_tarray_t *rdata_tarray_new(void);
-rdata_tcsi_t *rdata_tcsi_new(void);
-rdata_tprimitive_t *rdata_tprimitive_new(void);
-
 void rdata_array_alloc_element(rdata_array_t *array);
 void rdata_var_copy(rdata_var_t *src, rdata_var_t **dest);
@@ -59 +54 @@
 void rdata_var_write(rdata_var_t *var, rdata_value_t *value);
 
-var_class_t rdata_item_get_vc(rdata_item_t *item);
-bool_t rdata_is_csi_derived_from_ti(stree_csi_t *a, rdata_titem_t *tb);
-
 void rdata_item_print(rdata_item_t *item);
 

uspace/app/sbi/src/rdata_t.h

@@ -171 +171 @@
 /** Property address.
  *
- * When accessing part of a property that is non-scalar and mutable,
- * a read-modify-write (or get-modify-set) operation is necessary.
- * To accomodate this, the address item must hold a temporary copy of the
- * property value.
+ * When an access or index operation is performed on a property, the getter
+ * is run and the prefetched value is stored in @c tvalue. If the property
+ * is a non-scalar value type (a struct), then we might want to point to
+ * the proper @c var node inside it. @c tpos is used for this purpose.
+ *
+ * The assignment operator will modify @c tvalue and at the end the setter
+ * is called to store @c tvalue back into the property.
  */
 typedef struct {
@@ -236 +239 @@
 } rdata_item_t;
 
-/** Primitive type. */
-typedef struct {
-} rdata_tprimitive_t;
-
-/** Class, struct or interface type. */
-typedef struct {
-        struct stree_csi *csi;
-} rdata_tcsi_t;
-
-/** Array type. */
-typedef struct {
-        /** Base type item */
-        struct rdata_titem *base_ti;
-
-        /** Rank */
-        int rank;
-
-        /** Extents */
-        list_t extents; /* of stree_expr_t */
-} rdata_tarray_t;
-
-/** Generic type. */
-typedef struct {
-} rdata_tgeneric_t;
-
-typedef enum {
-        tic_tprimitive,
-        tic_tcsi,
-        tic_tarray,
-        tic_tgeneric
-} titem_class_t;
-
-/** Type item, the result of evaluating a type expression. */
-typedef struct rdata_titem {
-        titem_class_t tic;
-
-        union {
-                rdata_tprimitive_t *tprimitive;
-                rdata_tcsi_t *tcsi;
-                rdata_tarray_t *tarray;
-                rdata_tgeneric_t *tgeneric;
-        } u;
-} rdata_titem_t;
-
 #endif

uspace/app/sbi/src/run.c

@@ -43 +43 @@
 #include "strtab.h"
 #include "symbol.h"
+#include "tdata.h"
 
 #include "run.h"
@@ -57 +58 @@
 
 static bool_t run_exc_match(run_t *run, stree_except_t *except_c);
+static rdata_var_t *run_aprop_get_tpos(run_t *run, rdata_address_t *aprop);
 
 static void run_aprop_read(run_t *run, rdata_addr_prop_t *addr_prop,
@@ -102 +104 @@
 
 #ifdef DEBUG_RUN_TRACE
-        printf("Found function '"); symbol_print_fqn(prog, main_fun_sym);
+        printf("Found function '"); symbol_print_fqn(main_fun_sym);
         printf("'.\n");
 #endif
@@ -108 +110 @@
         /* Run function @c main. */
         list_init(&main_args);
-        run_proc_ar_create(run, NULL, main_fun_sym, main_fun->body, &proc_ar);
+        run_proc_ar_create(run, NULL, main_fun->proc, &proc_ar);
         run_proc_ar_set_args(run, proc_ar, &main_args);
         run_proc(run, proc_ar, &res);
@@ -123 +125 @@
 void run_proc(run_t *run, run_proc_ar_t *proc_ar, rdata_item_t **res)
 {
-        stree_symbol_t *proc_sym;
+        stree_proc_t *proc;
         list_node_t *node;
 
-        proc_sym = proc_ar->proc_sym;
+        proc = proc_ar->proc;
 
 #ifdef DEBUG_RUN_TRACE
         printf("Start executing function '");
-        symbol_print_fqn(run->program, proc_sym);
+        symbol_print_fqn(proc_sym);
         printf("'.\n");
 #endif
@@ -137 +139 @@
 
         /* Run main procedure block. */
-        if (proc_ar->proc_block != NULL) {
-                run_block(run, proc_ar->proc_block);
+        if (proc->body != NULL) {
+                run_block(run, proc->body);
         } else {
-                builtin_run_proc(run, proc_sym);
+                builtin_run_proc(run, proc);
         }
 
@@ -157 +159 @@
 #ifdef DEBUG_RUN_TRACE
         printf("Done executing procedure '");
-        symbol_print_fqn(run->program, proc_sym);
+        symbol_print_fqn(proc);
         printf("'.\n");
 
@@ -469 +471 @@
         rdata_var_t *payload_v;
         rdata_object_t *payload_o;
-        rdata_titem_t *etype;
+        tdata_item_t *etype;
 
         payload = run->thread_ar->exc_payload;
@@ -491 +493 @@
 #ifdef DEBUG_RUN_TRACE
         printf("Active exception: '");
-        symbol_print_fqn(run->program, payload_o->class_sym);
+        symbol_print_fqn(payload_o->class_sym);
         printf("'.\n");
 #endif
@@ -498 +500 @@
 
         /* Evaluate type expression in except clause. */
-        run_texpr(run, except_c->etype, &etype);
-
-        return rdata_is_csi_derived_from_ti(payload_o->class_sym->u.csi,
+        run_texpr(run->program, run_get_current_csi(run), except_c->etype,
+            &etype);
+
+        return tdata_is_csi_derived_from_ti(payload_o->class_sym->u.csi,
             etype);
 }
@@ -556 +559 @@
 
         proc_ar = run_get_current_proc_ar(run);
-        return proc_ar->proc_sym->outer_csi;
+        return proc_ar->proc->outer_symbol->outer_csi;
 }
 
@@ -606 +609 @@
 
 /** Construct a function AR. */
-void run_proc_ar_create(run_t *run, rdata_var_t *obj, stree_symbol_t *proc_sym,
-    stree_block_t *proc_block, run_proc_ar_t **rproc_ar)
+void run_proc_ar_create(run_t *run, rdata_var_t *obj, stree_proc_t *proc,
+    run_proc_ar_t **rproc_ar)
 {
         run_proc_ar_t *proc_ar;
@@ -617 +620 @@
         proc_ar = run_proc_ar_new();
         proc_ar->obj = obj;
-        proc_ar->proc_sym = proc_sym;
-        proc_ar->proc_block = proc_block;
+        proc_ar->proc = proc;
         list_init(&proc_ar->block_ar);
 
@@ -642 +644 @@
         list_t *args;
         stree_proc_arg_t *varg;
+        stree_symbol_t *outer_symbol;
 
         run_block_ar_t *block_ar;
@@ -655 +658 @@
         int n_vargs, idx;
 
+        (void) run;
+
         /* AR should have been created with run_proc_ar_create(). */
-        assert(proc_ar->proc_sym != NULL);
+        assert(proc_ar->proc != NULL);
+        outer_symbol = proc_ar->proc->outer_symbol;
 
         /*
-         * The procedure being activated should be a member function or
+         * The procedure being activated should belong to a member function or
          * property getter/setter.
          */
-        switch (proc_ar->proc_sym->sc) {
+        switch (outer_symbol->sc) {
         case sc_fun:
-                fun = symbol_to_fun(proc_ar->proc_sym);
+                fun = symbol_to_fun(outer_symbol);
                 args = &fun->args;
                 varg = fun->varg;
                 break;
         case sc_prop:
-                prop = symbol_to_prop(proc_ar->proc_sym);
+                prop = symbol_to_prop(outer_symbol);
                 args = &prop->args;
                 varg = prop->varg;
@@ -688 +694 @@
         while (parg_n != NULL) {
                 if (rarg_n == NULL) {
-                        printf("Error: Too few arguments to function '");
-                        symbol_print_fqn(run->program, proc_ar->proc_sym);
+                        printf("Error: Too few arguments to '");
+                        symbol_print_fqn(outer_symbol);
                         printf("'.\n");
                         exit(1);
@@ -752 +758 @@
         /* Check for excess real parameters. */
         if (rarg_n != NULL) {
-                printf("Error: Too many arguments to function '");
-                symbol_print_fqn(run->program, proc_ar->proc_sym);
+                printf("Error: Too many arguments to '");
+                symbol_print_fqn(outer_symbol);
                 printf("'.\n");
                 exit(1);
@@ -775 +781 @@
 
         /* AR should have been created with run_proc_ar_create(). */
-        assert(proc_ar->proc_sym != NULL);
-
-        /* The procedure being activated should be a property setter. */
-        prop = symbol_to_prop(proc_ar->proc_sym);
+        assert(proc_ar->proc != NULL);
+
+        /* The procedure being activated should belong to a property setter. */
+        prop = symbol_to_prop(proc_ar->proc->outer_symbol);
         assert(prop != NULL);
+        assert(proc_ar->proc == prop->setter);
 
         /* Fetch first block activation record. */
@@ -792 +799 @@
 
         /* Declare variable using name of formal argument. */
-        intmap_set(&block_ar->vars, prop->setter_arg_name->sid, var);
+        intmap_set(&block_ar->vars, prop->setter_arg->name->sid, var);
 }
 
@@ -806 +813 @@
                 printf(" * ");
                 proc_ar = list_node_data(node, run_proc_ar_t *);
-                symbol_print_fqn(run->program, proc_ar->proc_sym);
+                symbol_print_fqn(proc_ar->proc->outer_symbol);
                 printf("\n");
 
@@ -844 +851 @@
 }
 
+/** Get item var-class.
+ *
+ * Get var-class of @a item, regardless whether it is a value or address.
+ * (I.e. the var class of the value or variable at the given address).
+ */
+var_class_t run_item_get_vc(run_t *run, rdata_item_t *item)
+{
+        var_class_t vc;
+        rdata_var_t *tpos;
+
+        (void) run;
+
+        switch (item->ic) {
+        case ic_value:
+                vc = item->u.value->var->vc;
+                break;
+        case ic_address:
+                switch (item->u.address->ac) {
+                case ac_var:
+                        vc = item->u.address->u.var_a->vref->vc;
+                        break;
+                case ac_prop:
+                        /* Prefetch the value of the property. */
+                        tpos = run_aprop_get_tpos(run, item->u.address);
+                        vc = tpos->vc;
+                        break;
+                default:
+                        assert(b_false);
+                }
+                break;
+        default:
+                assert(b_false);
+        }
+
+        return vc;
+}
+
+/** Get pointer to current var node in temporary copy in property address.
+ *
+ * A property address refers to a specific @c var node in a property.
+ * This function will fetch a copy of the property value (by running
+ * its getter) if there is not a temporary copy in the address yet.
+ * It returns a pointer to the relevant @c var node in the temporary
+ * copy.
+ *
+ * @param run   Runner object.
+ * @param addr  Address of class @c ac_prop.
+ * @param       Pointer to var node.
+ */
+static rdata_var_t *run_aprop_get_tpos(run_t *run, rdata_address_t *addr)
+{
+        rdata_item_t *ritem;
+
+        assert(addr->ac == ac_prop);
+
+        if (addr->u.prop_a->tvalue == NULL) {
+                /* Fetch value of the property. */
+                run_address_read(run, addr, &ritem);
+                assert(ritem->ic == ic_value);
+                addr->u.prop_a->tvalue = ritem->u.value;
+                addr->u.prop_a->tpos = addr->u.prop_a->tvalue->var;
+        }
+
+        return addr->u.prop_a->tpos;
+}
 
 /** Read data from an address.
@@ -894 +966 @@
 
         run_proc_ar_t *proc_ar;
+
+        rdata_var_t *cvar;
 
 #ifdef DEBUG_RUN_TRACE
@@ -903 +977 @@
          */
         if (addr_prop->tvalue != NULL) {
-                printf("Unimplemented: Property field access.\n");
-                exit(1);
+                /* Copy the value */
+                rdata_var_copy(addr_prop->tpos, &cvar);
+                *ritem = rdata_item_new(ic_value);
+                (*ritem)->u.value = rdata_value_new();
+                (*ritem)->u.value->var = cvar;
+                return;
         }
 
@@ -917 +995 @@
         assert(prop != NULL);
 
-        if (prop->getter_body == NULL) {
+        if (prop->getter == NULL) {
                 printf("Error: Property is not readable.\n");
                 exit(1);
@@ -923 +1001 @@
 
         /* Create procedure activation record. */
-        run_proc_ar_create(run, obj, prop_sym, prop->getter_body, &proc_ar);
+        run_proc_ar_create(run, obj, prop->getter, &proc_ar);
 
         /* Fill in arguments (indices). */
@@ -973 +1051 @@
         assert(prop != NULL);
 
-        if (prop->setter_body == NULL) {
+        if (prop->setter == NULL) {
                 printf("Error: Property is not writable.\n");
                 exit(1);
@@ -982 +1060 @@
 
         /* Create procedure activation record. */
-        run_proc_ar_create(run, obj, prop_sym, prop->setter_body, &proc_ar);
+        run_proc_ar_create(run, obj, prop->setter, &proc_ar);
 
         /* Fill in arguments (indices). */

uspace/app/sbi/src/run.h

@@ -48 +48 @@
 void run_proc_ar_set_setter_arg(run_t *run, run_proc_ar_t *proc_ar,
     rdata_item_t *arg_val);
-void run_proc_ar_create(run_t *run, rdata_var_t *obj, stree_symbol_t *proc_sym,
-    stree_block_t *proc_block, run_proc_ar_t **rproc_ar);
+void run_proc_ar_create(run_t *run, rdata_var_t *obj, stree_proc_t *proc,
+    run_proc_ar_t **rproc_ar);
 
+var_class_t run_item_get_vc(run_t *run, rdata_item_t *item);
 void run_cvt_value_item(run_t *run, rdata_item_t *item, rdata_item_t **ritem);
 void run_address_read(run_t *run, rdata_address_t *address,

uspace/app/sbi/src/run_expr.c

@@ -43 +43 @@
 #include "stree.h"
 #include "strtab.h"
+#include "tdata.h"
 
 #include "run_expr.h"
@@ -72 +73 @@
 static void run_new(run_t *run, stree_new_t *new_op, rdata_item_t **res);
 static void run_new_array(run_t *run, stree_new_t *new_op,
-    rdata_titem_t *titem, rdata_item_t **res);
+    tdata_item_t *titem, rdata_item_t **res);
 static void run_new_object(run_t *run, stree_new_t *new_op,
-    rdata_titem_t *titem, rdata_item_t **res);
+    tdata_item_t *titem, rdata_item_t **res);
 
 static void run_access(run_t *run, stree_access_t *access, rdata_item_t **res);
@@ -199 +200 @@
                 assert(csi != NULL);
         } else {
-                csi = proc_ar->proc_sym->outer_csi;
+                csi = proc_ar->proc->outer_symbol->outer_csi;
                 obj = NULL;
         }
@@ -231 +232 @@
                         printf("Error: Cannot access non-static member "
                             "function '");
-                        symbol_print_fqn(run->program, sym);
+                        symbol_print_fqn(sym);
                         printf("' from nested CSI '");
-                        symbol_print_fqn(run->program, csi_sym);
+                        symbol_print_fqn(csi_sym);
                         printf("'.\n");
                         exit(1);
@@ -267 +268 @@
                         printf("Error: Cannot access non-static member "
                             "variable '");
-                        symbol_print_fqn(run->program, sym);
+                        symbol_print_fqn(sym);
                         printf("' from nested CSI '");
-                        symbol_print_fqn(run->program, csi_sym);
+                        symbol_print_fqn(csi_sym);
                         printf("'.\n");
                         exit(1);
@@ -632 +633 @@
 static void run_new(run_t *run, stree_new_t *new_op, rdata_item_t **res)
 {
-        rdata_titem_t *titem;
+        tdata_item_t *titem;
 
 #ifdef DEBUG_RUN_TRACE
@@ -638 +639 @@
 #endif
         /* Evaluate type expression */
-        run_texpr(run, new_op->texpr, &titem);
+        run_texpr(run->program, run_get_current_csi(run), new_op->texpr,
+            &titem);
 
         switch (titem->tic) {
@@ -644 +646 @@
                 run_new_array(run, new_op, titem, res);
                 break;
-        case tic_tcsi:
+        case tic_tobject:
                 run_new_object(run, new_op, titem, res);
                 break;
@@ -656 +658 @@
 /** Create new array. */
 static void run_new_array(run_t *run, stree_new_t *new_op,
-    rdata_titem_t *titem, rdata_item_t **res)
-{
-        rdata_tarray_t *tarray;
+    tdata_item_t *titem, rdata_item_t **res)
+{
+        tdata_array_t *tarray;
         rdata_array_t *array;
         rdata_var_t *array_var;
@@ -744 +746 @@
 /** Create new object. */
 static void run_new_object(run_t *run, stree_new_t *new_op,
-    rdata_titem_t *titem, rdata_item_t **res)
+    tdata_item_t *titem, rdata_item_t **res)
 {
         rdata_object_t *obj;
@@ -764 +766 @@
 
         /* Lookup object CSI. */
-        assert(titem->tic == tic_tcsi);
-        csi = titem->u.tcsi->csi;
+        assert(titem->tic == tic_tobject);
+        csi = titem->u.tobject->csi;
         csi_sym = csi_to_symbol(csi);
 
@@ -823 +825 @@
         printf("Run access operation on pre-evaluated base.\n");
 #endif
-        vc = rdata_item_get_vc(arg);
+        vc = run_item_get_vc(run, arg);
 
         switch (vc) {
@@ -883 +885 @@
         if (member == NULL) {
                 printf("Error: CSI '");
-                symbol_print_fqn(run->program, deleg_v->sym);
+                symbol_print_fqn(deleg_v->sym);
                 printf("' has no member named '%s'.\n",
                     strtab_get_str(access->member_name->sid));
@@ -936 +938 @@
         if (member == NULL) {
                 printf("Error: Object of class '");
-                symbol_print_fqn(run->program, object->class_sym);
+                symbol_print_fqn(object->class_sym);
                 printf("' has no member named '%s'.\n",
                     strtab_get_str(access->member_name->sid));
@@ -1030 +1032 @@
 #ifdef DEBUG_RUN_TRACE
         printf("Call function '");
-        symbol_print_fqn(run->program, deleg_v->sym);
+        symbol_print_fqn(deleg_v->sym);
         printf("'\n");
 #endif
@@ -1050 +1052 @@
 
         /* Create procedure activation record. */
-        run_proc_ar_create(run, deleg_v->obj, deleg_v->sym, fun->body,
-            &proc_ar);
+        run_proc_ar_create(run, deleg_v->obj, fun->proc, &proc_ar);
 
         /* Fill in argument values. */
@@ -1080 +1081 @@
         run_expr(run, index->base, &rbase);
 
-        vc = rdata_item_get_vc(rbase);
+        vc = run_item_get_vc(run, rbase);
 
         /* Implicitly dereference. */
@@ -1089 +1090 @@
         }
 
-        vc = rdata_item_get_vc(base_i);
+        vc = run_item_get_vc(run, base_i);
 
         /* Evaluate arguments (indices). */
@@ -1224 +1225 @@
         printf("Run object index operation.\n");
 #endif
-        (void) run;
         (void) index;
 
@@ -1252 +1252 @@
         indexer_sym = symbol_search_csi(run->program, obj_csi, indexer_ident);
 
+        if (indexer_sym == NULL) {
+                printf("Error: Accessing object which does not have an "
+                    "indexer.\n");
+                exit(1);
+        }
+
         /* Construct delegate. */
         object_d = rdata_deleg_new();

uspace/app/sbi/src/run_t.h

@@ -54 +54 @@
         struct rdata_var *obj;
 
-        /** Definition of function or property being invoked */
-        struct stree_symbol *proc_sym;
-
-        /** Main block of procedure being invoked */
-        struct stree_block *proc_block;
+        /** Procedure being invoked */
+        struct stree_proc *proc;
 
         /** Block activation records */

uspace/app/sbi/src/run_texpr.c

@@ -29 +29 @@
 /** @file Evaluates type expressions. */
 
+#include <assert.h>
 #include <stdlib.h>
 #include "list.h"
 #include "mytypes.h"
-#include "rdata.h"
-#include "run.h"
 #include "symbol.h"
+#include "tdata.h"
 
 #include "run_texpr.h"
 
-static void run_taccess(run_t *run, stree_taccess_t *taccess,
-    rdata_titem_t **res);
-static void run_tindex(run_t *run, stree_tindex_t *tindex,
-    rdata_titem_t **res);
-static void run_tliteral(run_t *run, stree_tliteral_t *tliteral,
-    rdata_titem_t **res);
-static void run_tnameref(run_t *run, stree_tnameref_t *tnameref,
-    rdata_titem_t **res);
-
-void run_texpr(run_t *run, stree_texpr_t *texpr, rdata_titem_t **res)
+static void run_taccess(stree_program_t *prog, stree_csi_t *ctx,
+    stree_taccess_t *taccess, tdata_item_t **res);
+static void run_tindex(stree_program_t *prog, stree_csi_t *ctx,
+    stree_tindex_t *tindex, tdata_item_t **res);
+static void run_tliteral(stree_program_t *prog, stree_csi_t *ctx,
+    stree_tliteral_t *tliteral, tdata_item_t **res);
+static void run_tnameref(stree_program_t *prog, stree_csi_t *ctx,
+    stree_tnameref_t *tnameref, tdata_item_t **res);
+
+void run_texpr(stree_program_t *prog, stree_csi_t *ctx, stree_texpr_t *texpr,
+    tdata_item_t **res)
 {
         switch (texpr->tc) {
         case tc_taccess:
-                run_taccess(run, texpr->u.taccess, res);
+                run_taccess(prog, ctx, texpr->u.taccess, res);
                 break;
         case tc_tindex:
-                run_tindex(run, texpr->u.tindex, res);
+                run_tindex(prog, ctx, texpr->u.tindex, res);
                 break;
         case tc_tliteral:
-                run_tliteral(run, texpr->u.tliteral, res);
+                run_tliteral(prog, ctx, texpr->u.tliteral, res);
                 break;
         case tc_tnameref:
-                run_tnameref(run, texpr->u.tnameref, res);
+                run_tnameref(prog, ctx, texpr->u.tnameref, res);
                 break;
         case tc_tapply:
@@ -69 +70 @@
 }
 
-static void run_taccess(run_t *run, stree_taccess_t *taccess,
-    rdata_titem_t **res)
+static void run_taccess(stree_program_t *prog, stree_csi_t *ctx,
+    stree_taccess_t *taccess, tdata_item_t **res)
 {
         stree_symbol_t *sym;
-        rdata_titem_t *targ_i;
-        rdata_titem_t *titem;
-        rdata_tcsi_t *tcsi;
+        tdata_item_t *targ_i;
+        tdata_item_t *titem;
+        tdata_object_t *tobject;
         stree_csi_t *base_csi;
 
@@ -82 +83 @@
 #endif
         /* Evaluate base type. */
-        run_texpr(run, taccess->arg, &targ_i);
-
-        if (targ_i->tic != tic_tcsi) {
-                printf("Error: Using '.' with type which is not CSI.\n");
+        run_texpr(prog, ctx, taccess->arg, &targ_i);
+
+        if (targ_i->tic != tic_tobject) {
+                printf("Error: Using '.' with type which is not an object.\n");
                 exit(1);
         }
 
         /* Get base CSI. */
-        base_csi = targ_i->u.tcsi->csi;
-
-        sym = symbol_lookup_in_csi(run->program, base_csi,
-            taccess->member_name);
+        base_csi = targ_i->u.tobject->csi;
+
+        sym = symbol_lookup_in_csi(prog, base_csi, taccess->member_name);
         if (sym->sc != sc_csi) {
                 printf("Error: Symbol '");
-                symbol_print_fqn(run->program, sym);
+                symbol_print_fqn(sym);
                 printf("' is not a CSI.\n");
                 exit(1);
@@ -102 +102 @@
 
         /* Construct type item. */
-        titem = rdata_titem_new(tic_tcsi);
-        tcsi = rdata_tcsi_new();
-        titem->u.tcsi = tcsi;
-
-        tcsi->csi = sym->u.csi;
-
-        *res = titem;
-}
-
-static void run_tindex(run_t *run, stree_tindex_t *tindex, rdata_titem_t **res)
-{
-        rdata_titem_t *base_ti;
-        rdata_titem_t *titem;
-        rdata_tarray_t *tarray;
+        titem = tdata_item_new(tic_tobject);
+        tobject = tdata_object_new();
+        titem->u.tobject = tobject;
+
+        tobject->static_ref = b_false;
+        tobject->csi = sym->u.csi;
+
+        *res = titem;
+}
+
+static void run_tindex(stree_program_t *prog, stree_csi_t *ctx,
+    stree_tindex_t *tindex, tdata_item_t **res)
+{
+        tdata_item_t *base_ti;
+        tdata_item_t *titem;
+        tdata_array_t *tarray;
         stree_expr_t *arg_expr;
         list_node_t *arg_node;
@@ -123 +125 @@
 #endif
         /* Evaluate base type. */
-        run_texpr(run, tindex->base_type, &base_ti);
-
-        /* Construct type item. */
-        titem = rdata_titem_new(tic_tarray);
-        tarray = rdata_tarray_new();
+        run_texpr(prog, ctx, tindex->base_type, &base_ti);
+
+        /* Construct type item. */
+        titem = tdata_item_new(tic_tarray);
+        tarray = tdata_array_new();
         titem->u.tarray = tarray;
 
@@ -146 +148 @@
 }
 
-static void run_tliteral(run_t *run, stree_tliteral_t *tliteral,
-    rdata_titem_t **res)
-{
-        rdata_titem_t *titem;
-        rdata_tprimitive_t *tprimitive;
+static void run_tliteral(stree_program_t *prog, stree_csi_t *ctx,
+    stree_tliteral_t *tliteral, tdata_item_t **res)
+{
+        tdata_item_t *titem;
+        tdata_primitive_t *tprimitive;
+        tprimitive_class_t tpc;
 
 #ifdef DEBUG_RUN_TRACE
         printf("Evaluating type literal.\n");
 #endif
-
-        (void) run;
+        (void) prog;
+        (void) ctx;
         (void) tliteral;
 
-        /* Construct type item. */
-        titem = rdata_titem_new(tic_tprimitive);
-        tprimitive = rdata_tprimitive_new();
+        switch (tliteral->tlc) {
+        case tlc_int: tpc = tpc_int; break;
+        case tlc_string: tpc = tpc_string; break;
+        }
+
+        /* Construct type item. */
+        titem = tdata_item_new(tic_tprimitive);
+        tprimitive = tdata_primitive_new(tpc);
         titem->u.tprimitive = tprimitive;
 
@@ -167 +175 @@
 }
 
-static void run_tnameref(run_t *run, stree_tnameref_t *tnameref,
-    rdata_titem_t **res)
-{
-        stree_csi_t *current_csi;
+static void run_tnameref(stree_program_t *prog, stree_csi_t *ctx,
+    stree_tnameref_t *tnameref, tdata_item_t **res)
+{
         stree_symbol_t *sym;
-        rdata_titem_t *titem;
-        rdata_tcsi_t *tcsi;
+        tdata_item_t *titem;
+        tdata_object_t *tobject;
 
 #ifdef DEBUG_RUN_TRACE
         printf("Evaluating type name reference.\n");
 #endif
-        current_csi = run_get_current_csi(run);
-        sym = symbol_lookup_in_csi(run->program, current_csi, tnameref->name);
+        sym = symbol_lookup_in_csi(prog, ctx, tnameref->name);
 
         if (sym->sc != sc_csi) {
                 printf("Error: Symbol '");
-                symbol_print_fqn(run->program, sym);
+                symbol_print_fqn(sym);
                 printf("' is not a CSI.\n");
                 exit(1);
@@ -189 +195 @@
 
         /* Construct type item. */
-        titem = rdata_titem_new(tic_tcsi);
-        tcsi = rdata_tcsi_new();
-        titem->u.tcsi = tcsi;
-
-        tcsi->csi = sym->u.csi;
-
-        *res = titem;
-}
+        titem = tdata_item_new(tic_tobject);
+        tobject = tdata_object_new();
+        titem->u.tobject = tobject;
+
+        tobject->static_ref = b_false;
+        tobject->csi = sym->u.csi;
+
+        *res = titem;
+}

uspace/app/sbi/src/run_texpr.h

@@ -32 +32 @@
 #include "mytypes.h"
 
-void run_texpr(run_t *run, stree_texpr_t *texpr, rdata_titem_t **res);
+void run_texpr(stree_program_t *prog, stree_csi_t *ctx, stree_texpr_t *texpr,
+    tdata_item_t **res);
 
 #endif

uspace/app/sbi/src/stree.c

@@ -136 +136 @@
 }
 
+stree_proc_t *stree_proc_new(void)
+{
+        stree_proc_t *proc;
+
+        proc = calloc(1, sizeof(stree_proc_t));
+        if (proc == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        return proc;
+}
+
 stree_proc_arg_t *stree_proc_arg_new(void)
 {
@@ -507 +520 @@
 }
 
-stree_tliteral_t *stree_tliteral_new(void)
+stree_tliteral_t *stree_tliteral_new(tliteral_class_t tlc)
 {
         stree_tliteral_t *tliteral;
@@ -517 +530 @@
         }
 
+        tliteral->tlc = tlc;
         return tliteral;
 }

uspace/app/sbi/src/stree.h

@@ -40 +40 @@
 stree_prop_t *stree_prop_new(void);
 
+stree_proc_t *stree_proc_new(void);
 stree_proc_arg_t *stree_proc_arg_new(void);
 stree_arg_attr_t *stree_arg_attr_new(arg_attr_class_t aac);
@@ -73 +74 @@
 stree_tapply_t *stree_tapply_new(void);
 stree_tindex_t *stree_tindex_new(void);
-stree_tliteral_t *stree_tliteral_new(void);
+stree_tliteral_t *stree_tliteral_new(tliteral_class_t tlc);
 stree_tnameref_t *stree_tnameref_new(void);
 

uspace/app/sbi/src/stree_t.h

@@ -82 +82 @@
 /** Binary operation class */
 typedef enum {
-        bo_period,
-        bo_slash,
-        bo_sbr,
         bo_equal,
         bo_notequal,
@@ -178 +175 @@
         expr_class_t ec;
 
+        struct tdata_item *titem;
+
         union {
                 stree_nameref_t *nameref;
@@ -379 +378 @@
 } stree_proc_arg_t;
 
+/** Procedure
+ *
+ * Procedure is the common term for a getter, setter or function body.
+ * A procedure can be invoked. However, the arguments are specified by
+ * the containing symbol.
+ */
+typedef struct stree_proc {
+        /** Symbol (function or property) containing the procedure */
+        struct stree_symbol *outer_symbol;
+
+        /** Main block */
+        stree_block_t *body;
+} stree_proc_t;
+
 /** Member function declaration */
-typedef struct {
+typedef struct stree_fun {
         /** Function name */
         stree_ident_t *name;
@@ -396 +409 @@
         stree_texpr_t *rtype;
 
-        /** Function body */
-        stree_block_t *body;
+        /** Function implementation */
+        stree_proc_t *proc;
 } stree_fun_t;
 
 /** Member variable declaration */
-typedef struct {
+typedef struct stree_var {
         stree_ident_t *name;
         struct stree_symbol *symbol;
@@ -408 +421 @@
 
 /** Member property declaration */
-typedef struct {
+typedef struct stree_prop {
         stree_ident_t *name;
         struct stree_symbol *symbol;
         stree_texpr_t *type;
 
-        stree_block_t *getter_body;
-        stree_ident_t *setter_arg_name;
-        stree_block_t *setter_body;
+        stree_proc_t *getter;
+
+        stree_proc_t *setter;
+        stree_proc_arg_t *setter_arg;
 
         /** Formal parameters (for indexed properties) */
@@ -425 +439 @@
 
 /**
- * Fake identifier used with indexed properties. (Mostly for error messages.)
+ * Fake identifiers used with symbols that do not really have one.
+ * (Mostly for error messages.)
  */
 #define INDEXER_IDENT "$indexer"
@@ -504 +519 @@
 } symbol_class_t;
 
-/** Symbol */
+/** Symbol
+ *
+ * A symbol is a common superclass of different program elements that
+ * allow us to refer to them, print their fully qualified names, etc.
+ */
 typedef struct stree_symbol {
         symbol_class_t sc;

uspace/app/sbi/src/symbol.c

@@ -322 +322 @@
 
 /** Print fully qualified name of symbol. */
-void symbol_print_fqn(stree_program_t *prog, stree_symbol_t *symbol)
+void symbol_print_fqn(stree_symbol_t *symbol)
 {
         stree_ident_t *name;
@@ -329 +329 @@
         if (symbol->outer_csi != NULL) {
                 outer_sym = csi_to_symbol(symbol->outer_csi);
-                symbol_print_fqn(prog, outer_sym);
+                symbol_print_fqn( outer_sym);
                 printf(".");
         }

uspace/app/sbi/src/symbol.h

@@ -49 +49 @@
 stree_symbol_t *prop_to_symbol(stree_prop_t *prop);
 
-void symbol_print_fqn(stree_program_t *prog, stree_symbol_t *symbol);
+void symbol_print_fqn(stree_symbol_t *symbol);
 
 #endif