Changeset 94d484a in mainline

Timestamp:

2010-03-07T17:45:33Z (15 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

d0febca

Parents:

fa36f29

Message:

Update SBI to rev. 90.

Location:

uspace

Files:

• app/sbi/Makefile (modified) (2 diffs)
• app/sbi/src/ancr.c (modified) (1 diff)
• app/sbi/src/builtin.c (modified) (7 diffs)
• app/sbi/src/compat.h (modified) (1 diff)
• app/sbi/src/lex.c (modified) (9 diffs)
• app/sbi/src/lex_t.h (modified) (1 diff)
• app/sbi/src/os/helenos.c (added)
• app/sbi/src/os/os.h (added)
• app/sbi/src/os/posix.c (added)
• app/sbi/src/p_expr.c (modified) (5 diffs)
• app/sbi/src/p_type.c (modified) (4 diffs)
• app/sbi/src/parse.c (modified) (10 diffs)
• app/sbi/src/rdata.c (modified) (7 diffs)
• app/sbi/src/rdata.h (modified) (2 diffs)
• app/sbi/src/rdata_t.h (modified) (6 diffs)
• app/sbi/src/run.c (modified) (9 diffs)
• app/sbi/src/run.h (modified) (1 diff)
• app/sbi/src/run_expr.c (modified) (10 diffs)
• app/sbi/src/run_t.h (modified) (2 diffs)
• app/sbi/src/run_texpr.c (added)
• app/sbi/src/run_texpr.h (added)
• app/sbi/src/stree.c (modified) (6 diffs)
• app/sbi/src/stree.h (modified) (5 diffs)
• app/sbi/src/stree_t.h (modified) (13 diffs)
• app/sbi/src/strtab.c (modified) (4 diffs)
• dist/sysel/array.sy (added)
• dist/sysel/count.sy (modified) (1 diff)
• dist/sysel/except.sy (added)
• dist/sysel/hello.sy (modified) (1 diff)
• dist/sysel/hexec.sy (added)
• dist/sysel/inherit.sy (modified) (1 diff)
• dist/sysel/list.sy (modified) (2 diffs)
• dist/sysel/string.sy (added)
• dist/sysel/varargs.sy (added)

uspace/app/sbi/Makefile

@@ -34 +34 @@
 
 SOURCES = \
+        src/os/helenos.c \
         src/ancr.c \
         src/builtin.c \
@@ -47 +48 @@
         src/run.c \
         src/run_expr.c \
+        src/run_texpr.c \
         src/stree.c \
         src/strtab.c \

uspace/app/sbi/src/ancr.c

@@ -151 +151 @@
                 /* Process base CSI. */
                 ancr_csi_process(prog, base_csi);
+        } else {
+                base_csi = NULL;
         }
 
+        /* Store base CSI and update node state. */
         node->ancr_state = ws_visited;
+        node->base_csi = base_csi;
 }
 

uspace/app/sbi/src/builtin.c

@@ -34 +34 @@
 #include "list.h"
 #include "mytypes.h"
+#include "os/os.h"
 #include "run.h"
 #include "stree.h"
 #include "strtab.h"
+#include "symbol.h"
 
 #include "builtin.h"
 
+static stree_symbol_t *builtin_declare_fun(stree_csi_t *csi, char *name);
+static void builtin_fun_add_arg(stree_symbol_t *fun_sym, char *name);
+static void builtin_fun_add_vararg(stree_symbol_t *fun_sym, char *name);
+
 static void builtin_write_line(run_t *run);
+static void builtin_exec(run_t *run);
 
 static stree_symbol_t *bi_write_line;
+static stree_symbol_t *bi_exec;
 
 /** Declare builtin symbols in the program.
@@ -53 +61 @@
         stree_csi_t *csi;
         stree_ident_t *ident;
-        stree_csimbr_t *csimbr;
-        stree_fun_t *fun;
-        stree_fun_arg_t *fun_arg;
         stree_symbol_t *symbol;
 
@@ -76 +81 @@
 
         /* Declare builtin functions. */
-        ident = stree_ident_new();
-        ident->sid = strtab_get_sid("WriteLine");
-
-        fun = stree_fun_new();
-        fun->name = ident;
-        fun->body = NULL;
-        list_init(&fun->args);
-
-        csimbr = stree_csimbr_new(csimbr_fun);
-        csimbr->u.fun = fun;
-
-        symbol = stree_symbol_new(sc_fun);
-        symbol->u.fun = fun;
-        symbol->outer_csi = csi;
-        fun->symbol = symbol;
-
-        list_append(&csi->members, csimbr);
-
-        fun_arg = stree_fun_arg_new();
-        fun_arg->name = stree_ident_new();
-        fun_arg->name->sid = strtab_get_sid("arg");
-        fun_arg->type = NULL; /* XXX */
-
-        list_append(&fun->args, fun_arg);
-
-        bi_write_line = symbol;
+
+        bi_write_line = builtin_declare_fun(csi, "WriteLine");
+        builtin_fun_add_arg(bi_write_line, "arg");
+
+        bi_exec = builtin_declare_fun(csi, "Exec");
+        builtin_fun_add_vararg(bi_exec, "args");
 }
 
@@ -111 +96 @@
         if (fun_sym == bi_write_line) {
                 builtin_write_line(run);
+        } else if (fun_sym == bi_exec) {
+                builtin_exec(run);
         } else {
                 assert(b_false);
@@ -116 +103 @@
 }
 
+/** Declare a builtin function in @a csi. */
+static stree_symbol_t *builtin_declare_fun(stree_csi_t *csi, char *name)
+{
+        stree_ident_t *ident;
+        stree_fun_t *fun;
+        stree_csimbr_t *csimbr;
+        stree_symbol_t *symbol;
+
+        ident = stree_ident_new();
+        ident->sid = strtab_get_sid(name);
+
+        fun = stree_fun_new();
+        fun->name = ident;
+        fun->body = NULL;
+        list_init(&fun->args);
+
+        csimbr = stree_csimbr_new(csimbr_fun);
+        csimbr->u.fun = fun;
+
+        symbol = stree_symbol_new(sc_fun);
+        symbol->u.fun = fun;
+        symbol->outer_csi = csi;
+        fun->symbol = symbol;
+
+        list_append(&csi->members, csimbr);
+
+        return symbol;
+}
+
+/** Add one formal parameter to function. */
+static void builtin_fun_add_arg(stree_symbol_t *fun_sym, char *name)
+{
+        stree_fun_arg_t *fun_arg;
+        stree_fun_t *fun;
+
+        fun = symbol_to_fun(fun_sym);
+        assert(fun != NULL);
+
+        fun_arg = stree_fun_arg_new();
+        fun_arg->name = stree_ident_new();
+        fun_arg->name->sid = strtab_get_sid(name);
+        fun_arg->type = NULL; /* XXX */
+
+        list_append(&fun->args, fun_arg);
+}
+
+/** Add variadic formal parameter to function. */
+static void builtin_fun_add_vararg(stree_symbol_t *fun_sym, char *name)
+{
+        stree_fun_arg_t *fun_arg;
+        stree_fun_t *fun;
+
+        fun = symbol_to_fun(fun_sym);
+        assert(fun != NULL);
+
+        fun_arg = stree_fun_arg_new();
+        fun_arg->name = stree_ident_new();
+        fun_arg->name->sid = strtab_get_sid(name);
+        fun_arg->type = NULL; /* XXX */
+
+        fun->varg = fun_arg;
+}
+
 static void builtin_write_line(run_t *run)
 {
@@ -121 +171 @@
 
 #ifdef DEBUG_RUN_TRACE
-        printf("Called Builtin.writeLine()\n");
+        printf("Called Builtin.WriteLine()\n");
 #endif
         var = run_local_vars_lookup(run, strtab_get_sid("arg"));
@@ -138 +188 @@
         }
 }
+
+/** Start an executable and wait for it to finish. */
+static void builtin_exec(run_t *run)
+{
+        rdata_var_t *args;
+        rdata_var_t *var;
+        rdata_array_t *array;
+        rdata_var_t *arg;
+        int idx, dim;
+        char **cmd;
+
+#ifdef DEBUG_RUN_TRACE
+        printf("Called Builtin.Exec()\n");
+#endif
+        args = run_local_vars_lookup(run, strtab_get_sid("args"));
+
+        assert(args);
+        assert(args->vc == vc_ref);
+
+        var = args->u.ref_v->vref;
+        assert(var->vc == vc_array);
+
+        array = var->u.array_v;
+        assert(array->rank == 1);
+        dim = array->extent[0];
+
+        if (dim == 0) {
+                printf("Error: Builtin.Exec() expects at least one argument.\n");
+                exit(1);
+        }
+
+        cmd = calloc(dim + 1, sizeof(char *));
+        if (cmd == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        for (idx = 0; idx < dim; ++idx) {
+                arg = array->element[idx];
+                if (arg->vc != vc_string) {
+                        printf("Error: Argument to Builtin.Exec() must be "
+                            "string (found %d).\n", arg->vc);
+                        exit(1);
+                }
+
+                cmd[idx] = arg->u.string_v->value;
+        }
+
+        cmd[dim] = '\0';
+
+        if (os_exec(cmd) != EOK) {
+                printf("Error: Exec failed.\n");
+                exit(1);
+        }
+}

uspace/app/sbi/src/compat.h

@@ -45 +45 @@
 #define list_remove sbi_list_remove
 
-/*
- * These functions can be simply mapped to HelenOS string API.
- */
-#define strcmp str_cmp
-#define strdup str_dup
-
 #endif
 

uspace/app/sbi/src/lex.c

@@ -35 +35 @@
 #include <stdlib.h>
 #include <string.h>
-#include "compat.h"
 #include "mytypes.h"
 #include "input.h"
+#include "os/os.h"
 #include "strtab.h"
 
@@ -44 +44 @@
 #define TAB_WIDTH 8
 
+static bool_t lex_next_try(lex_t *lex);
+
+static void lex_skip_comment(lex_t *lex);
 static void lex_skip_ws(lex_t *lex);
 static bool_t is_wstart(char c);
@@ -87 +90 @@
         { lc_nil,       "nil" },
         { lc_override,  "override" },
+        { lc_packed,    "packed" },
         { lc_private,   "private" },
         { lc_prop,      "prop" },
@@ -222 +226 @@
 void lex_next(lex_t *lex)
 {
+        bool_t got_lem;
+
+        do {
+                got_lem = lex_next_try(lex);
+        } while (got_lem == b_false);
+}
+
+/** Try reading next lexical element.
+ *
+ * @return @c b_true on success or @c b_false if it needs restarting.
+ */
+static bool_t lex_next_try(lex_t *lex)
+{
         char *bp;
 
@@ -240 +257 @@
                 /* End of input */
                 lex->current.lclass = lc_eof;
-                return;
+                return b_true;
         }
 
         if (is_wstart(bp[0])) {
                 lex_word(lex);
-                return;
+                return b_true;
         }
 
         if (is_digit(bp[0])) {
                 lex_number(lex);
-                return;
+                return b_true;
         }
 
         if (bp[0] == '"') {
                 lex_string(lex);
-                return;
+                return b_true;
+        }
+
+        if (bp[0] == '-' && bp[1] == '-') {
+                lex_skip_comment(lex);
+                return b_false;
         }
 
@@ -305 +327 @@
 
         lex->ibp = bp;
-        return;
+        return b_true;
 
 invalid:
@@ -311 +333 @@
         ++bp;
         lex->ibp = bp;
+
+        return b_true;
 }
 
@@ -340 +364 @@
         dp = keywords;
         while (dp->name != NULL) {
-                if (strcmp(ident_buf, dp->name) == 0) {
+                if (os_str_cmp(ident_buf, dp->name) == 0) {
                         /* Match */
                         lex->current.lclass = dp->lclass;
@@ -402 +426 @@
 
         lex->current.lclass = lc_lit_string;
-        lex->current.u.lit_string.value = strdup(strlit_buf);
-}
-
+        lex->current.u.lit_string.value = os_str_dup(strlit_buf);
+}
+
+/** Lex a single-line comment. */
+static void lex_skip_comment(lex_t *lex)
+{
+        char *bp;
+
+        bp = lex->ibp + 2;
+
+        while (*bp != '\n' && *bp != '\0') {
+                ++bp;
+        }
+
+        lex->ibp = bp;
+}
 
 /** Skip whitespace characters. */

uspace/app/sbi/src/lex_t.h

@@ -58 +58 @@
         lc_nil,
         lc_override,
+        lc_packed,
         lc_private,
         lc_prop,

uspace/app/sbi/src/p_expr.c

@@ -48 +48 @@
 static stree_expr_t *parse_pf_access(parse_t *parse, stree_expr_t *a);
 static stree_expr_t *parse_pf_call(parse_t *parse, stree_expr_t *a);
+static stree_expr_t *parse_pf_index(parse_t *parse, stree_expr_t *a);
 static stree_expr_t *parse_primitive(parse_t *parse);
 static stree_expr_t *parse_nameref(parse_t *parse);
@@ -181 +182 @@
         lmatch(parse, lc_new);
         texpr = parse_texpr(parse);
-        lmatch(parse, lc_lparen);
-        lmatch(parse, lc_rparen);
+
+        /* Parenthesis should be present except for arrays. */
+        if (texpr->tc != tc_tindex) {
+                lmatch(parse, lc_lparen);
+                lmatch(parse, lc_rparen);
+        }
 
         new_op = stree_new_new();
@@ -200 +205 @@
         a = parse_primitive(parse);
 
-        while (lcur_lc(parse) == lc_period || lcur_lc(parse) == lc_lparen) {
+        while (lcur_lc(parse) == lc_period || lcur_lc(parse) == lc_lparen ||
+            lcur_lc(parse) == lc_lsbr) {
 
                 switch (lcur_lc(parse)) {
@@ -209 +215 @@
                         tmp = parse_pf_call(parse, a);
                         break;
+                case lc_lsbr:
+                        tmp = parse_pf_index(parse, a);
+                        break;
                 default:
                         assert(b_false);
@@ -273 +282 @@
 }
 
+/** Parse index expression. */
+static stree_expr_t *parse_pf_index(parse_t *parse, stree_expr_t *a)
+{
+        stree_expr_t *expr;
+        stree_index_t *index;
+        stree_expr_t *arg;
+
+        lmatch(parse, lc_lsbr);
+
+        index = stree_index_new();
+        index->base = a;
+        list_init(&index->args);
+
+        /* Parse indices */
+
+        if (lcur_lc(parse) != lc_rsbr) {
+                while (b_true) {
+                        arg = parse_expr(parse);
+                        list_append(&index->args, arg);
+
+                        if (lcur_lc(parse) == lc_rsbr)
+                                break;
+                        lmatch(parse, lc_comma);
+                }
+        }
+
+        lmatch(parse, lc_rsbr);
+
+        expr = stree_expr_new(ec_index);
+        expr->u.index = index;
+
+        return expr;
+}
+
 /** Parse primitive expression. */
 static stree_expr_t *parse_primitive(parse_t *parse)

uspace/app/sbi/src/p_type.c

@@ -1 @@
-/*
+/*                              YI
  * Copyright (c) 2010 Jiri Svoboda
  * All rights reserved.
@@ -35 +35 @@
 #include "mytypes.h"
 #include "parse.h"
+#include "p_expr.h"
 #include "stree.h"
 
@@ -41 +42 @@
 static stree_texpr_t *parse_tapply(parse_t *parse);
 static stree_texpr_t *parse_tpostfix(parse_t *parse);
+static stree_texpr_t *parse_pf_taccess(parse_t *parse, stree_texpr_t *a);
+static stree_texpr_t *parse_pf_tindex(parse_t *parse, stree_texpr_t *a);
 static stree_texpr_t *parse_tprimitive(parse_t *parse);
 static stree_tliteral_t *parse_tliteral(parse_t *parse);
@@ -78 +81 @@
 {
         stree_texpr_t *a;
+        stree_texpr_t *tmp;
+
+        a = parse_tprimitive(parse);
+
+        while (lcur_lc(parse) == lc_period || lcur_lc(parse) == lc_lsbr) {
+
+                switch (lcur_lc(parse)) {
+                case lc_period:
+                        tmp = parse_pf_taccess(parse, a);
+                        break;
+                case lc_lsbr:
+                        tmp = parse_pf_tindex(parse, a);
+                        break;
+                default:
+                        lunexpected_error(parse);
+                        exit(1);
+                }
+
+                a = tmp;
+        }
+
+        return a;
+}
+
+/** Parse access type expression. */
+static stree_texpr_t *parse_pf_taccess(parse_t *parse, stree_texpr_t *a)
+{
+        stree_texpr_t *texpr;
         stree_ident_t *ident;
-        stree_texpr_t *tmp;
         stree_taccess_t *taccess;
 
-        a = parse_tprimitive(parse);
-
-        while (lcur_lc(parse) == lc_period) {
-                lskip(parse);
-                ident = parse_ident(parse);
-
-                taccess = stree_taccess_new();
-                taccess->arg = a;
-                taccess->member_name = ident;
-
-                tmp = stree_texpr_new(tc_taccess);
-                tmp->u.taccess = taccess;
-                a = tmp;
-        }
-
-        return a;
+        lmatch(parse, lc_period);
+        ident = parse_ident(parse);
+
+        taccess = stree_taccess_new();
+        taccess->arg = a;
+        taccess->member_name = ident;
+
+        texpr = stree_texpr_new(tc_taccess);
+        texpr->u.taccess = taccess;
+
+        return texpr;
+}
+
+/** Parse index type expression. */
+static stree_texpr_t *parse_pf_tindex(parse_t *parse, stree_texpr_t *a)
+{
+        stree_texpr_t *texpr;
+        stree_tindex_t *tindex;
+        stree_expr_t *expr;
+
+        tindex = stree_tindex_new();
+        tindex->base_type = a;
+
+        tindex->n_args = 0;
+        list_init(&tindex->args);
+
+        lmatch(parse, lc_lsbr);
+
+        if (lcur_lc(parse) != lc_rsbr && lcur_lc(parse) != lc_comma) {
+                while (b_true) {
+                        expr = parse_expr(parse);
+                        tindex->n_args += 1;
+                        list_append(&tindex->args, expr);
+
+                        if (lcur_lc(parse) == lc_rsbr)
+                                break;
+
+                        lmatch(parse, lc_comma);
+                }
+        } else {
+                tindex->n_args = 1;
+                while (lcur_lc(parse) == lc_comma) {
+                        lskip(parse);
+                        tindex->n_args += 1;
+                }
+        }
+
+        lmatch(parse, lc_rsbr);
+
+        texpr = stree_texpr_new(tc_tindex);
+        texpr->u.tindex = tindex;
+
+        return texpr;
 }
 

uspace/app/sbi/src/parse.c

@@ -56 +56 @@
 
 static stree_fun_arg_t *parse_fun_arg(parse_t *parse);
+static stree_arg_attr_t *parse_arg_attr(parse_t *parse);
 
 /*
@@ -72 +73 @@
 static stree_exps_t *parse_exps(parse_t *parse);
 
+static stree_except_t *parse_except(parse_t *parse);
+
 void parse_init(parse_t *parse, stree_program_t *prog, struct lex *lex)
 {
@@ -87 +90 @@
         stree_symbol_t *symbol;
 
-/*      do {
-                lex_next(parse->lex);
-                printf("Read token: "); lem_print(&parse->lex->current);
-                putchar('\n');
-        } while (parse->lex->current.lclass != lc_eof);
-*/
         while (lcur_lc(parse) != lc_eof) {
                 switch (lcur_lc(parse)) {
@@ -245 +242 @@
                 while (b_true) {
                         arg = parse_fun_arg(parse);
-                        list_append(&fun->args, arg);
+                        if (stree_arg_has_attr(arg, aac_packed)) {
+                                fun->varg = arg;
+                                break;
+                        } else {
+                                list_append(&fun->args, arg);
+                        }
 
                         if (lcur_lc(parse) == lc_rparen)
@@ -307 +309 @@
 {
         stree_fun_arg_t *arg;
+        stree_arg_attr_t *attr;
 
         arg = stree_fun_arg_new();
@@ -313 +316 @@
         arg->type = parse_texpr(parse);
 
+        list_init(&arg->attr);
+
+        /* Parse attributes. */
+        while (lcur_lc(parse) == lc_comma) {
+                lskip(parse);
+                attr = parse_arg_attr(parse);
+                list_append(&arg->attr, attr);
+        }
+
         return arg;
+}
+
+/** Parse argument attribute. */
+static stree_arg_attr_t *parse_arg_attr(parse_t *parse)
+{
+        stree_arg_attr_t *attr;
+
+        if (lcur_lc(parse) != lc_packed) {
+                printf("Error: Unexpected attribute '");
+                lem_print(lcur(parse));
+                printf("'.\n");
+                exit(1);
+        }
+
+        lskip(parse);
+
+        attr = stree_arg_attr_new(aac_packed);
+        return attr;
 }
 
@@ -378 +408 @@
                 stat->u.return_s = return_s;
                 break;
+        case lc_do:
         case lc_with:
                 wef_s = parse_wef(parse);
@@ -485 +516 @@
 static stree_raise_t *parse_raise(parse_t *parse)
 {
+        stree_raise_t *raise_s;
+
+        raise_s = stree_raise_new();
         lmatch(parse, lc_raise);
-        (void) parse_expr(parse);
+        raise_s->expr = parse_expr(parse);
         lmatch(parse, lc_scolon);
 
-        return stree_raise_new();
+        return raise_s;
 }
 
@@ -510 +544 @@
 {
         stree_wef_t *wef_s;
-        stree_block_t *block;
+        stree_except_t *except_c;
 
         wef_s = stree_wef_new();
-        list_init(&wef_s->except_blocks);
-
-        lmatch(parse, lc_with);
-        lmatch(parse, lc_ident);
-        lmatch(parse, lc_colon);
-        (void) parse_texpr(parse);
-        lmatch(parse, lc_assign);
-        (void) parse_expr(parse);
-        lmatch(parse, lc_do);
-        wef_s->with_block = parse_block(parse);
-
-        while (lcur_lc(parse) == lc_except) {
-                lmatch(parse, lc_except);
+        list_init(&wef_s->except_clauses);
+
+        if (lcur_lc(parse) == lc_with) {
+                lmatch(parse, lc_with);
                 lmatch(parse, lc_ident);
                 lmatch(parse, lc_colon);
                 (void) parse_texpr(parse);
+                lmatch(parse, lc_assign);
+                (void) parse_expr(parse);
+        }
+
+        lmatch(parse, lc_do);
+        wef_s->with_block = parse_block(parse);
+
+        while (lcur_lc(parse) == lc_except) {
+                except_c = parse_except(parse);
+                list_append(&wef_s->except_clauses, except_c);
+        }
+
+        if (lcur_lc(parse) == lc_finally) {
+                lmatch(parse, lc_finally);
                 lmatch(parse, lc_do);
-
-                block = parse_block(parse);
-                list_append(&wef_s->except_blocks, block);
-        }
-
-        lmatch(parse, lc_finally);
-        lmatch(parse, lc_do);
-        wef_s->finally_block = parse_block(parse);
+                wef_s->finally_block = parse_block(parse);
+        } else {
+                wef_s->finally_block = NULL;
+        }
+
         lmatch(parse, lc_end);
 
@@ -556 +592 @@
 
         return exps;
+}
+
+/* Parse @c except clause. */
+static stree_except_t *parse_except(parse_t *parse)
+{
+        stree_except_t *except_c;
+
+        except_c = stree_except_new();
+
+        lmatch(parse, lc_except);
+        except_c->evar = parse_ident(parse);
+        lmatch(parse, lc_colon);
+        except_c->etype = parse_texpr(parse);
+        lmatch(parse, lc_do);
+
+        except_c->block = parse_block(parse);
+
+        return except_c;
 }
 

uspace/app/sbi/src/rdata.c

@@ -32 +32 @@
 #include <assert.h>
 #include "mytypes.h"
+#include "stree.h"
 
 #include "rdata.h"
@@ -39 +40 @@
 static void rdata_ref_copy(rdata_ref_t *src, rdata_ref_t **dest);
 static void rdata_deleg_copy(rdata_deleg_t *src, rdata_deleg_t **dest);
+static void rdata_array_copy(rdata_array_t *src, rdata_array_t **dest);
 static void rdata_object_copy(rdata_object_t *src, rdata_object_t **dest);
+
+static int rdata_array_get_dim(rdata_array_t *array);
 
 static void rdata_address_print(rdata_address_t *address);
@@ -126 +130 @@
 }
 
+rdata_array_t *rdata_array_new(int rank)
+{
+        rdata_array_t *array;
+
+        array = calloc(1, sizeof(rdata_array_t));
+        if (array == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        array->rank = rank;
+        array->extent = calloc(rank, sizeof(int));
+        if (array == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        return array;
+}
+
 rdata_object_t *rdata_object_new(void)
 {
@@ -163 +187 @@
 
         return string_v;
+}
+
+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)
+{
+        int dim, idx;
+
+        dim = rdata_array_get_dim(array);
+
+        array->element = calloc(dim, sizeof(rdata_var_t *));
+        if (array->element == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        for (idx = 0; idx < dim; ++idx) {
+                array->element[idx] = calloc(1, sizeof(rdata_var_t));
+                if (array->element[idx] == NULL) {
+                        printf("Memory allocation failed.\n");
+                        exit(1);
+                }
+        }
+}
+
+/** Get array dimension.
+ *
+ * Dimension is the total number of elements in an array, in other words,
+ * the product of all extents.
+ */
+static int rdata_array_get_dim(rdata_array_t *array)
+{
+        int didx, dim;
+
+        dim = 1;
+        for (didx = 0; didx < array->rank; ++didx)
+                dim = dim * array->extent[didx];
+
+        return dim;
 }
 
@@ -185 +299 @@
                 rdata_deleg_copy(src->u.deleg_v, &nvar->u.deleg_v);
                 break;
+        case vc_array:
+                rdata_array_copy(src->u.array_v, &nvar->u.array_v);
+                break;
         case vc_object:
                 rdata_object_copy(src->u.object_v, &nvar->u.object_v);
@@ -215 +332 @@
         (void) src; (void) dest;
         printf("Unimplemented: Copy delegate.\n");
+        exit(1);
+}
+
+static void rdata_array_copy(rdata_array_t *src, rdata_array_t **dest)
+{
+        (void) src; (void) dest;
+        printf("Unimplemented: Copy array.\n");
         exit(1);
 }
@@ -339 +463 @@
 void rdata_address_write(rdata_address_t *address, rdata_value_t *value)
 {
+        rdata_var_write(address->vref, value);
+}
+
+/** Write data to a variable.
+ *
+ * Store @a value to variable @a var.
+ */
+void rdata_var_write(rdata_var_t *var, 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;
+        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);
+        case vc_int: var->u.int_v = nvar->u.int_v; break;
+        case vc_string: var->u.string_v = nvar->u.string_v; break;
+        case vc_ref: var->u.ref_v = nvar->u.ref_v; break;
+        case vc_deleg: var->u.deleg_v = nvar->u.deleg_v; break;
+        case vc_array: var->u.array_v = nvar->u.array_v; break;
+        case vc_object: var->u.object_v = nvar->u.object_v; break;
         }
 
         /* XXX We should free some stuff around here. */
+}
+
+/** 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;
 }
 

uspace/app/sbi/src/rdata.h

@@ -38 +38 @@
 rdata_ref_t *rdata_ref_new(void);
 rdata_deleg_t *rdata_deleg_new(void);
+rdata_array_t *rdata_array_new(int rank);
 rdata_object_t *rdata_object_new(void);
 rdata_int_t *rdata_int_new(void);
 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);
 
@@ -49 +56 @@
 void rdata_address_read(rdata_address_t *address, rdata_item_t **ritem);
 void rdata_address_write(rdata_address_t *address, rdata_value_t *value);
+void rdata_var_write(rdata_var_t *var, rdata_value_t *value);
+
+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

@@ -68 +68 @@
 } rdata_deleg_t;
 
+/** Array variable */
+typedef struct {
+        /** Rank */
+        int rank;
+
+        /** Extents (@c rank entries) */
+        int *extent;
+
+        /**
+         * Elements (extent[0] * extent[1] * ... extent[rank - 1] entries)
+         * stored in lexicographical order. Each element is (rdata_var_t *).
+         */
+        struct rdata_var **element;
+} rdata_array_t;
+
 /** Object variable */
 typedef struct {
@@ -89 +104 @@
         /** Delegate */
         vc_deleg,
+
+        /** Array */
+        vc_array,
 
         /** Object */
@@ -108 +126 @@
                 rdata_ref_t *ref_v;
                 rdata_deleg_t *deleg_v;
+                rdata_array_t *array_v;
                 rdata_object_t *object_v;
         } u;
@@ -113 +132 @@
 
 /** Address item. */
-typedef struct {
+typedef struct rdata_address {
         /** Targeted variable */
         rdata_var_t *vref;
@@ -119 +138 @@
 
 /** Value item. */
-typedef struct {
+typedef struct rdata_value {
         /**
          * Read-only Variable holding a copy of the data. The same @c var
@@ -150 +169 @@
 } 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

@@ -39 +39 @@
 #include "rdata.h"
 #include "run_expr.h"
+#include "run_texpr.h"
 #include "stree.h"
 #include "strtab.h"
@@ -51 +52 @@
 static void run_if(run_t *run, stree_if_t *if_s);
 static void run_while(run_t *run, stree_while_t *while_s);
+static void run_raise(run_t *run, stree_raise_t *raise_s);
 static void run_return(run_t *run, stree_return_t *return_s);
+static void run_wef(run_t *run, stree_wef_t *wef_s);
+
+static bool_t run_exc_match(run_t *run, stree_except_t *except_c);
 
 /** Initialize runner instance. */
@@ -101 +106 @@
         run_fun_ar_set_args(run, fun_ar, &main_args);
         run_fun(run, fun_ar, &res);
+
+        /* Check for unhandled exceptions. */
+        if (run->thread_ar->bo_mode != bm_none) {
+                assert(run->thread_ar->bo_mode == bm_exc);
+                printf("Error: Unhandled exception.\n");
+                exit(1);
+        }
 }
 
@@ -217 +229 @@
                 run_while(run, stat->u.while_s);
                 break;
+        case st_raise:
+                run_raise(run, stat->u.raise_s);
+                break;
         case st_return:
                 run_return(run, stat->u.return_s);
                 break;
+        case st_wef:
+                run_wef(run, stat->u.wef_s);
+                break;
         case st_for:
-        case st_raise:
-        case st_wef:
                 printf("Ignoring unimplemented statement type %d.\n", stat->sc);
                 break;
@@ -331 +347 @@
 }
 
+/** Run @c raise statement. */
+static void run_raise(run_t *run, stree_raise_t *raise_s)
+{
+        rdata_item_t *rexpr;
+        rdata_item_t *rexpr_vi;
+
+#ifdef DEBUG_RUN_TRACE
+        printf("Executing raise statement.\n");
+#endif
+        run_expr(run, raise_s->expr, &rexpr);
+        rdata_cvt_value_item(rexpr, &rexpr_vi);
+
+        /* Store expression result in thread AR. */
+        run->thread_ar->exc_payload = rexpr_vi->u.value;
+
+        /* Start exception bailout. */
+        run->thread_ar->bo_mode = bm_exc;
+}
+
 /** Run @c return statement. */
 static void run_return(run_t *run, stree_return_t *return_s)
@@ -349 +384 @@
         if (run->thread_ar->bo_mode == bm_none)
                 run->thread_ar->bo_mode = bm_fun;
+}
+
+/** Run @c with-except-finally statement. */
+static void run_wef(run_t *run, stree_wef_t *wef_s)
+{
+        list_node_t *except_n;
+        stree_except_t *except_c;
+        rdata_value_t *exc_payload;
+        run_bailout_mode_t bo_mode;
+
+#ifdef DEBUG_RUN_TRACE
+        printf("Executing with-except-finally statement.\n");
+#endif
+        run_block(run, wef_s->with_block);
+
+        if (run->thread_ar->bo_mode == bm_exc) {
+#ifdef DEBUG_RUN_TRACE
+                printf("With statement detected exception.\n");
+#endif
+                /* Reset to normal execution. */
+                run->thread_ar->bo_mode = bm_none;
+
+                /* Look for an except block. */
+                except_n = list_first(&wef_s->except_clauses);
+                while (except_n != NULL) {
+                        except_c = list_node_data(except_n, stree_except_t *);
+                        if (run_exc_match(run, except_c))
+                                break;
+
+                        except_n = list_next(&wef_s->except_clauses, except_n);
+                }
+
+                /* If one was found, execute it. */
+                if (except_n != NULL)
+                        run_block(run, except_c->block);
+
+                /* Execute finally block */
+                if (wef_s->finally_block != NULL) {
+                        /* Put exception on the side temporarily. */
+                        bo_mode = run->thread_ar->bo_mode;
+                        exc_payload = run->thread_ar->exc_payload;
+
+                        run->thread_ar->bo_mode = bm_none;
+                        run->thread_ar->exc_payload = NULL;
+
+                        run_block(run, wef_s->finally_block);
+
+                        if (bo_mode == bm_exc) {
+                                /*
+                                 * Restore the original exception. If another
+                                 * exception occured in the finally block (i.e.
+                                 * double fault), it is forgotten.
+                                 */
+                                run->thread_ar->bo_mode = bm_exc;
+                                run->thread_ar->exc_payload = exc_payload;
+                        }
+                }
+        }
+
+#ifdef DEBUG_RUN_TRACE
+        printf("With-except-finally statement terminated.\n");
+#endif
+}
+
+/** Determine whether currently active exception matches @c except clause.
+ *
+ * Checks if the currently active exception in the runner object @c run
+ * matches except clause @c except_c. Generates an error if the exception
+ * payload has invalid type (i.e. not an object).
+ *
+ * @param run           Runner object.
+ * @param except_c      @c except clause.
+ * @return              @c b_true if there is a match, @c b_false otherwise.
+ */
+static bool_t run_exc_match(run_t *run, stree_except_t *except_c)
+{
+        rdata_value_t *payload;
+        rdata_var_t *payload_v;
+        rdata_object_t *payload_o;
+        rdata_titem_t *etype;
+
+        payload = run->thread_ar->exc_payload;
+        assert(payload != NULL);
+
+        if (payload->var->vc != vc_ref) {
+                printf("Error: Exception payload must be an object "
+                    "(found type %d).\n", payload->var->vc);
+                exit(1);
+        }
+
+        payload_v = payload->var->u.ref_v->vref;
+        if (payload_v->vc != vc_object) {
+                printf("Error: Exception payload must be an object "
+                    "(found type %d).\n", payload_v->vc);
+                exit(1);
+        }
+
+        payload_o = payload_v->u.object_v;
+
+#ifdef DEBUG_RUN_TRACE
+        printf("Active exception: '");
+        symbol_print_fqn(run->program, payload_o->class_sym);
+        printf("'.\n");
+#endif
+        assert(payload_o->class_sym != NULL);
+        assert(payload_o->class_sym->sc == sc_csi);
+
+        /* 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,
+            etype);
 }
 
@@ -395 +542 @@
         node = list_last(&fun_ar->block_ar);
         return list_node_data(node, run_block_ar_t *);
+}
+
+/** Get current CSI. */
+stree_csi_t *run_get_current_csi(run_t *run)
+{
+        run_fun_ar_t *fun_ar;
+
+        fun_ar = run_get_current_fun_ar(run);
+        return fun_ar->fun_sym->outer_csi;
 }
 
@@ -468 +624 @@
         run_block_ar_t *block_ar;
         list_node_t *rarg_n, *farg_n;
+        list_node_t *cn;
         rdata_item_t *rarg;
         stree_fun_arg_t *farg;
         rdata_var_t *var;
+        rdata_var_t *ref_var;
+        rdata_ref_t *ref;
+        rdata_array_t *array;
+        int n_vargs, idx;
 
         /* AR should have been created with run_fun_ar_create(). */
@@ -511 +672 @@
         }
 
+        if (fun->varg != NULL) {
+                /* Function is variadic. Count number of variadic arguments. */
+                cn = rarg_n;
+                n_vargs = 0;
+                while (cn != NULL) {
+                        n_vargs += 1;
+                        cn = list_next(args, cn);
+                }
+
+                /* Prepare array to store variadic arguments. */
+                array = rdata_array_new(1);
+                array->extent[0] = n_vargs;
+                rdata_array_alloc_element(array);
+
+                /* Read variadic arguments. */
+
+                idx = 0;
+                while (rarg_n != NULL) {
+                        rarg = list_node_data(rarg_n, rdata_item_t *);
+                        assert(rarg->ic == ic_value);
+
+                        rdata_var_write(array->element[idx], rarg->u.value);
+
+                        rarg_n = list_next(args, rarg_n);
+                        idx += 1;
+                }
+
+                var = rdata_var_new(vc_array);
+                var->u.array_v = array;
+
+                /* Create reference to the new array. */
+                ref_var = rdata_var_new(vc_ref);
+                ref = rdata_ref_new();
+                ref_var->u.ref_v = ref;
+                ref->vref = var;
+
+                /* Declare variable using name of formal argument. */
+                intmap_set(&block_ar->vars, fun->varg->name->sid,
+                    ref_var);
+        }
+
         /* Check for excess real parameters. */
         if (rarg_n != NULL) {

uspace/app/sbi/src/run.h

@@ -41 +41 @@
 run_fun_ar_t *run_get_current_fun_ar(run_t *run);
 run_block_ar_t *run_get_current_block_ar(run_t *run);
+stree_csi_t *run_get_current_csi(run_t *run);
 
 void run_value_item_to_var(rdata_item_t *item, rdata_var_t **var);

uspace/app/sbi/src/run_expr.c

@@ -36 +36 @@
 #include "list.h"
 #include "mytypes.h"
+#include "os/os.h"
 #include "rdata.h"
 #include "run.h"
+#include "run_texpr.h"
 #include "symbol.h"
 #include "strtab.h"
@@ -61 +63 @@
 static void run_binop_int(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
     rdata_value_t *v2, rdata_item_t **res);
+static void run_binop_string(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
+    rdata_value_t *v2, rdata_item_t **res);
 static void run_binop_ref(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
     rdata_value_t *v2, rdata_item_t **res);
@@ -66 +70 @@
 static void run_unop(run_t *run, stree_unop_t *unop, rdata_item_t **res);
 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);
+static void run_new_object(run_t *run, stree_new_t *new_op,
+    rdata_titem_t *titem, rdata_item_t **res);
 
 static void run_access(run_t *run, stree_access_t *access, rdata_item_t **res);
@@ -78 +86 @@
 
 static void run_call(run_t *run, stree_call_t *call, rdata_item_t **res);
+static void run_index(run_t *run, stree_index_t *index, rdata_item_t **res);
 static void run_assign(run_t *run, stree_assign_t *assign, rdata_item_t **res);
 
@@ -111 +120 @@
         case ec_call:
                 run_call(run, expr->u.call, res);
+                break;
+        case ec_index:
+                run_index(run, expr->u.index, res);
                 break;
         case ec_assign:
@@ -442 +454 @@
                 run_binop_int(run, binop, v1, v2, res);
                 break;
+        case vc_string:
+                run_binop_string(run, binop, v1, v2, res);
+                break;
         case vc_ref:
                 run_binop_ref(run, binop, v1, v2, res);
@@ -508 +523 @@
 }
 
+/** Evaluate binary operation on string arguments. */
+static void run_binop_string(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
+    rdata_value_t *v2, rdata_item_t **res)
+{
+        rdata_item_t *item;
+        rdata_value_t *value;
+        rdata_var_t *var;
+        rdata_string_t *string_v;
+
+        char *s1, *s2;
+
+        (void) run;
+
+        item = rdata_item_new(ic_value);
+        value = rdata_value_new();
+        var = rdata_var_new(vc_string);
+        string_v = rdata_string_new();
+
+        item->u.value = value;
+        value->var = var;
+        var->u.string_v = string_v;
+
+        s1 = v1->var->u.string_v->value;
+        s2 = v2->var->u.string_v->value;
+
+        switch (binop->bc) {
+        case bo_plus:
+                /* Concatenate strings. */
+                string_v->value = os_str_acat(s1, s2);
+                break;
+        default:
+                printf("Error: Invalid binary operation on string "
+                    "arguments (%d).\n", binop->bc);
+                assert(b_false);
+        }
+
+        *res = item;
+}
+
 /** Evaluate binary operation on ref arguments. */
 static void run_binop_ref(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
@@ -566 +620 @@
 static void run_new(run_t *run, stree_new_t *new_op, rdata_item_t **res)
 {
+        rdata_titem_t *titem;
+
+#ifdef DEBUG_RUN_TRACE
+        printf("Run 'new' operation.\n");
+#endif
+        /* Evaluate type expression */
+        run_texpr(run, new_op->texpr, &titem);
+
+        switch (titem->tic) {
+        case tic_tarray:
+                run_new_array(run, new_op, titem, res);
+                break;
+        case tic_tcsi:
+                run_new_object(run, new_op, titem, res);
+                break;
+        default:
+                printf("Error: Invalid argument to operator 'new', "
+                    "expected object.\n");
+                exit(1);
+        }
+}
+
+/** 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;
+        rdata_array_t *array;
+        rdata_var_t *array_var;
+        rdata_var_t *elem_var;
+
+        rdata_item_t *rexpr, *rexpr_vi;
+        rdata_var_t *rexpr_var;
+
+        stree_expr_t *expr;
+
+        list_node_t *node;
+        int length;
+        int i;
+
+#ifdef DEBUG_RUN_TRACE
+        printf("Create new array.\n");
+#endif
+        (void) run;
+        (void) new_op;
+
+        assert(titem->tic == tic_tarray);
+        tarray = titem->u.tarray;
+
+        /* Create the array. */
+        assert(titem->u.tarray->rank > 0);
+        array = rdata_array_new(titem->u.tarray->rank);
+
+        /* Compute extents. */
+        node = list_first(&tarray->extents);
+        if (node == NULL) {
+                printf("Error: Extents must be specified when constructing "
+                    "an array with 'new'.\n");
+                exit(1);
+        }
+
+        i = 0; length = 1;
+        while (node != NULL) {
+                expr = list_node_data(node, stree_expr_t *);
+
+                /* Evaluate extent argument. */
+                run_expr(run, expr, &rexpr);
+                rdata_cvt_value_item(rexpr, &rexpr_vi);
+                assert(rexpr_vi->ic == ic_value);
+                rexpr_var = rexpr_vi->u.value->var;
+
+                if (rexpr_var->vc != vc_int) {
+                        printf("Error: Array extent must be an integer.\n");
+                        exit(1);
+                }
+
+#ifdef DEBUG_RUN_TRACE
+                printf("Array extent: %d.\n", rexpr_var->u.int_v->value);
+#endif
+                array->extent[i] = rexpr_var->u.int_v->value;
+                length = length * array->extent[i];
+
+                node = list_next(&tarray->extents, node);
+                i += 1;
+        }
+
+        array->element = calloc(length, sizeof(rdata_var_t *));
+        if (array->element == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        /* Create member variables */
+        for (i = 0; i < length; ++i) {
+                /* XXX Depends on member variable type. */
+                elem_var = rdata_var_new(vc_int);
+                elem_var->u.int_v = rdata_int_new();
+                elem_var->u.int_v->value = 0;
+
+                array->element[i] = elem_var;
+        }
+
+        /* Create array variable. */
+        array_var = rdata_var_new(vc_array);
+        array_var->u.array_v = array;
+
+        /* Create reference to the new array. */
+        rdata_reference(array_var, res);
+}
+
+/** Create new object. */
+static void run_new_object(run_t *run, stree_new_t *new_op,
+    rdata_titem_t *titem, rdata_item_t **res)
+{
         rdata_object_t *obj;
         rdata_var_t *obj_var;
@@ -578 +746 @@
 
 #ifdef DEBUG_RUN_TRACE
-        printf("Run 'new' operation.\n");
-#endif
+        printf("Create new object.\n");
+#endif
+        (void) run;
+        (void) new_op;
+
         /* Lookup object CSI. */
-        /* XXX Should start in the current CSI. */
-        csi_sym = symbol_xlookup_in_csi(run->program, NULL, new_op->texpr);
-        csi = symbol_to_csi(csi_sym);
-        if (csi == NULL) {
-                printf("Error: Symbol '");
-                symbol_print_fqn(run->program, csi_sym);
-                printf("' is not a CSI. CSI required for 'new' operator.\n");
-                exit(1);
-        }
+        assert(titem->tic == tic_tcsi);
+        csi = titem->u.tcsi->csi;
+        csi_sym = csi_to_symbol(csi);
 
         /* Create the object. */
@@ -875 +1040 @@
 }
 
+/** Run index operation. */
+static void run_index(run_t *run, stree_index_t *index, rdata_item_t **res)
+{
+        rdata_item_t *rbase;
+        rdata_item_t *base_i;
+        list_node_t *node;
+        stree_expr_t *arg;
+        rdata_item_t *rarg_i, *rarg_vi;
+        rdata_array_t *array;
+        var_class_t vc;
+
+        int i;
+        int elem_index;
+        int arg_val;
+
+        rdata_item_t *ritem;
+        rdata_address_t *address;
+
+#ifdef DEBUG_RUN_TRACE
+        printf("Run index operation.\n");
+#endif
+        run_expr(run, index->base, &rbase);
+
+        switch (rbase->ic) {
+        case ic_value:
+                vc = rbase->u.value->var->vc;
+                break;
+        case ic_address:
+                vc = rbase->u.address->vref->vc;
+                break;
+        default:
+                /* Silence warning. */
+                abort();
+        }
+
+        if (vc != vc_ref) {
+                printf("Error: Base of index operation is not a reference.\n");
+                exit(1);
+        }
+
+        rdata_dereference(rbase, &base_i);
+        assert(base_i->ic == ic_address);
+
+        if (base_i->u.value->var->vc != vc_array) {
+                printf("Error: Indexing something which is not an array.\n");
+                exit(1);
+        }
+
+        array = base_i->u.value->var->u.array_v;
+
+        /* Evaluate arguments (indices). */
+        node = list_first(&index->args);
+
+        /*
+         * Linear index of the desired element. Elements are stored in
+         * lexicographic order with the last index changing the fastest.
+         */
+        elem_index = 0;
+
+        i = 0;
+        while (node != NULL) {
+                if (i >= array->rank) {
+                        printf("Error: Too many indices for array of rank %d",
+                            array->rank);
+                        exit(1);
+                }
+
+                arg = list_node_data(node, stree_expr_t *);
+                run_expr(run, arg, &rarg_i);
+                rdata_cvt_value_item(rarg_i, &rarg_vi);
+                assert(rarg_vi->ic == ic_value);
+
+                if (rarg_vi->u.value->var->vc != vc_int) {
+                        printf("Error: Array index is not an integer.\n");
+                        exit(1);
+                }
+
+                arg_val = rarg_vi->u.value->var->u.int_v->value;
+
+                if (arg_val < 0 || arg_val >= array->extent[i]) {
+                        printf("Error: Array index (value: %d) is out of range.\n",
+                            arg_val);
+                        exit(1);
+                }
+
+                elem_index = elem_index * array->extent[i] + arg_val;
+
+                node = list_next(&index->args, node);
+                i += 1;
+        }
+
+        if (i < array->rank) {
+                printf("Error: Too few indices for array of rank %d",
+                    array->rank);
+                exit(1);
+        }
+
+        /* Construct variable address item. */
+        ritem = rdata_item_new(ic_address);
+        address = rdata_address_new();
+        ritem->u.address = address;
+
+        address->vref = array->element[elem_index];
+
+        *res = ritem;
+}
+
 /** Execute assignment. */
 static void run_assign(run_t *run, stree_assign_t *assign, rdata_item_t **res)

uspace/app/sbi/src/run_t.h

@@ -74 +74 @@
 
         /** Return from function */
-        bm_fun
-} run_bailout_mode;
+        bm_fun,
+
+        /** Exception */
+        bm_exc
+} run_bailout_mode_t;
 
 /** Thread activation record
@@ -86 +89 @@
 
         /** Bailout mode */
-        run_bailout_mode bo_mode;
+        run_bailout_mode_t bo_mode;
+
+        /** Exception payload */
+        struct rdata_value *exc_payload;
 } run_thread_ar_t;
 

uspace/app/sbi/src/stree.c

@@ -149 +149 @@
 }
 
+stree_arg_attr_t *stree_arg_attr_new(arg_attr_class_t aac)
+{
+        stree_arg_attr_t *arg_attr;
+
+        arg_attr = calloc(1, sizeof(stree_arg_attr_t));
+        if (arg_attr == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        arg_attr->aac = aac;
+        return arg_attr;
+}
+
 stree_stat_t *stree_stat_new(stat_class_t sc)
 {
@@ -267 +281 @@
 }
 
+stree_except_t *stree_except_new(void)
+{
+        stree_except_t *except_c;
+
+        except_c = calloc(1, sizeof(stree_except_t));
+        if (except_c == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        return except_c;
+}
+
 stree_block_t *stree_block_new(void)
 {
@@ -361 +388 @@
 }
 
+stree_index_t *stree_index_new(void)
+{
+        stree_index_t *index;
+
+        index = calloc(1, sizeof(stree_index_t));
+        if (index == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        return index;
+}
+
 stree_nameref_t *stree_nameref_new(void)
 {
@@ -428 +468 @@
 }
 
+stree_taccess_t *stree_taccess_new(void)
+{
+        stree_taccess_t *taccess;
+
+        taccess = calloc(1, sizeof(stree_taccess_t));
+        if (taccess == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        return taccess;
+}
+
 stree_tapply_t *stree_tapply_new(void)
 {
@@ -441 +494 @@
 }
 
-stree_taccess_t *stree_taccess_new(void)
-{
-        stree_taccess_t *taccess;
-
-        taccess = calloc(1, sizeof(stree_taccess_t));
-        if (taccess == NULL) {
-                printf("Memory allocation failed.\n");
-                exit(1);
-        }
-
-        return taccess;
+stree_tindex_t *stree_tindex_new(void)
+{
+        stree_tindex_t *tindex;
+
+        tindex = calloc(1, sizeof(stree_tindex_t));
+        if (tindex == NULL) {
+                printf("Memory allocation failed.\n");
+                exit(1);
+        }
+
+        return tindex;
 }
 
@@ -506 +559 @@
         return program;
 }
+
+/** Determine if argument @a arg has attribute of class @a aac. */
+bool_t stree_arg_has_attr(stree_fun_arg_t *arg, arg_attr_class_t aac)
+{
+        list_node_t *node;
+        stree_arg_attr_t *attr;
+
+        node = list_first(&arg->attr);
+        while (node != NULL) {
+                attr = list_node_data(node, stree_arg_attr_t *);
+                if (attr->aac == aac)
+                        return b_true;
+
+                node = list_next(&arg->attr, node);
+        }
+
+        return b_false;
+}
+
+/** Determine wheter @a a is derived (transitively) from @a b.
+ *
+ * @param a     Derived CSI.
+ * @param b     Base CSI.
+ * @return      @c b_true if @a a is equal to or directly or indirectly
+ *              derived from @a b.
+ */
+bool_t stree_is_csi_derived_from_csi(stree_csi_t *a, stree_csi_t *b)
+{
+        stree_csi_t *csi;
+
+        csi = a;
+        while (csi != NULL) {
+                if (csi == b)
+                        return b_true;
+
+                csi = csi->base_csi;
+        }
+
+        /* We went all the way to the root and did not find b. */
+        return b_false;
+}

uspace/app/sbi/src/stree.h

@@ -41 +41 @@
 
 stree_fun_arg_t *stree_fun_arg_new(void);
+stree_arg_attr_t *stree_arg_attr_new(arg_attr_class_t aac);
 
 stree_stat_t *stree_stat_new(stat_class_t sc);
@@ -51 +52 @@
 stree_wef_t *stree_wef_new(void);
 stree_exps_t *stree_exps_new(void);
+
+stree_except_t *stree_except_new(void);
 stree_block_t *stree_block_new(void);
 
@@ -59 +62 @@
 stree_access_t *stree_access_new(void);
 stree_call_t *stree_call_new(void);
+stree_index_t *stree_index_new(void);
 stree_nameref_t *stree_nameref_new(void);
 
@@ -66 +70 @@
 
 stree_texpr_t *stree_texpr_new(texpr_class_t tc);
+stree_taccess_t *stree_taccess_new(void);
 stree_tapply_t *stree_tapply_new(void);
-stree_taccess_t *stree_taccess_new(void);
+stree_tindex_t *stree_tindex_new(void);
 stree_tliteral_t *stree_tliteral_new(void);
 stree_tnameref_t *stree_tnameref_new(void);
@@ -74 +79 @@
 stree_program_t *stree_program_new(void);
 
+bool_t stree_arg_has_attr(stree_fun_arg_t *arg, arg_attr_class_t aac);
+bool_t stree_is_csi_derived_from_csi(stree_csi_t *a, stree_csi_t *b);
+
 #endif

uspace/app/sbi/src/stree_t.h

@@ -151 +151 @@
 } stree_assign_t;
 
+/** Indexing operation */
+typedef struct {
+        /** Base */
+        struct stree_expr *base;
+
+        /** Arguments (indices) */
+        list_t args; /* of stree_expr_t */
+} stree_index_t;
+
 /** Arithmetic expression class */
 typedef enum {
@@ -161 +170 @@
         ec_access,
         ec_call,
-        ec_assign
+        ec_assign,
+        ec_index
 } expr_class_t;
 
@@ -177 +187 @@
                 stree_access_t *access;
                 stree_call_t *call;
+                stree_index_t *index;
                 stree_assign_t *assign;
         } u;
@@ -217 +228 @@
 } stree_tapply_t;
 
+/** Type index operation */
+typedef struct {
+        /** Base type */
+        struct stree_texpr *base_type;
+
+        /**
+         * Number of arguments (rank). Needed when only rank is specified
+         * and @c args are not used.
+         */
+        int n_args;
+
+        /** Arguments (extents) */
+        list_t args; /* of stree_expr_t */
+} stree_tindex_t;
+
 /** Type expression class */
 typedef enum {
@@ -222 +248 @@
         tc_tnameref,
         tc_taccess,
-        tc_tapply
+        tc_tapply,
+        tc_tindex
 } texpr_class_t;
 
@@ -234 +261 @@
                 stree_taccess_t *taccess;
                 stree_tapply_t *tapply;
+                stree_tindex_t *tindex;
         } u;
 } stree_texpr_t;
@@ -252 +280 @@
         stree_texpr_t *type;
 } stree_vdecl_t;
+
+/** @c except clause */
+typedef struct {
+        stree_ident_t *evar;
+        stree_texpr_t *etype;
+        stree_block_t *block;
+} stree_except_t;
 
 /** If statement */
@@ -273 +308 @@
 /** Raise statement */
 typedef struct {
+        stree_expr_t *expr;
 } stree_raise_t;
 
@@ -288 +324 @@
 typedef struct {
         stree_block_t *with_block;
-        list_t except_blocks; /* of stree_block_t */
+        list_t except_clauses; /* of stree_except_t */
         stree_block_t *finally_block;
 } stree_wef_t;
+
 
 /** Statement class */
@@ -320 +357 @@
 } stree_stat_t;
 
+/** Argument attribute class */
+typedef enum {
+        /** Packed argument (for variadic functions) */
+        aac_packed
+} arg_attr_class_t;
+
+/** Argument atribute */
+typedef struct {
+        arg_attr_class_t aac;
+} stree_arg_attr_t;
+
 /** Formal function parameter */
 typedef struct {
@@ -327 +375 @@
         /* Argument type */
         stree_texpr_t *type;
+
+        /* Attributes */
+        list_t attr; /* of stree_arg_attr_t */
 } stree_fun_arg_t;
 
@@ -339 +390 @@
         /** Formal parameters */
         list_t args; /* of stree_fun_arg_t */
+
+        /** Variadic argument or @c NULL if none. */
+        stree_fun_arg_t *varg;
 
         /** Return type */
@@ -400 +454 @@
         stree_texpr_t *base_csi_ref;
 
+        /** Base CSI. Only available when ancr_state == ws_visited. */
+        struct stree_csi *base_csi;
+
         /** Node state for ancr walks. */
         walk_state_t ancr_state;

uspace/app/sbi/src/strtab.c

@@ -37 +37 @@
 #include <string.h>
 #include "mytypes.h"
-#include "compat.h"
+#include "os/os.h"
 #include "list.h"
 
@@ -59 +59 @@
         while (node != NULL) {
                 ++sid;
-                if (strcmp(str, list_node_data(node, char *)) == 0)
+                if (os_str_cmp(str, list_node_data(node, char *)) == 0)
                         return sid;
 
@@ -66 +66 @@
 
         ++sid;
-        list_append(&str_list, strdup(str));
+        list_append(&str_list, os_str_dup(str));
 
         return sid;
@@ -85 +85 @@
         if (node == NULL) {
                 printf("Internal error: Invalid SID %d", sid);
-                exit(1);
+                abort();
         }
 

uspace/dist/sysel/count.sy

@@ +1 @@
+--
+-- Copyright (c) 2010 Jiri Svoboda
+-- All rights reserved.
+--
+-- Redistribution and use in source and binary forms, with or without
+-- modification, are permitted provided that the following conditions
+-- are met:
+--
+-- o Redistributions of source code must retain the above copyright
+--   notice, this list of conditions and the following disclaimer.
+-- o Redistributions in binary form must reproduce the above copyright
+--   notice, this list of conditions and the following disclaimer in the
+--   documentation and/or other materials provided with the distribution.
+-- o The name of the author may not be used to endorse or promote products
+--   derived from this software without specific prior written permission.
+--
+-- THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+-- IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+-- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+-- IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+-- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+-- NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+-- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+-- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+-- THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--
+
 class CountDemo is
         fun Count(a : int; b : int) is

uspace/dist/sysel/hello.sy

@@ +1 @@
+--
+-- Copyright (c) 2010 Jiri Svoboda
+-- All rights reserved.
+--
+-- Redistribution and use in source and binary forms, with or without
+-- modification, are permitted provided that the following conditions
+-- are met:
+--
+-- o Redistributions of source code must retain the above copyright
+--   notice, this list of conditions and the following disclaimer.
+-- o Redistributions in binary form must reproduce the above copyright
+--   notice, this list of conditions and the following disclaimer in the
+--   documentation and/or other materials provided with the distribution.
+-- o The name of the author may not be used to endorse or promote products
+--   derived from this software without specific prior written permission.
+--
+-- THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+-- IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+-- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+-- IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+-- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+-- NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+-- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+-- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+-- THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--
+
 class HelloWorld is
         fun Main() is

uspace/dist/sysel/inherit.sy

@@ +1 @@
+--
+-- Copyright (c) 2010 Jiri Svoboda
+-- All rights reserved.
+--
+-- Redistribution and use in source and binary forms, with or without
+-- modification, are permitted provided that the following conditions
+-- are met:
+--
+-- o Redistributions of source code must retain the above copyright
+--   notice, this list of conditions and the following disclaimer.
+-- o Redistributions in binary form must reproduce the above copyright
+--   notice, this list of conditions and the following disclaimer in the
+--   documentation and/or other materials provided with the distribution.
+-- o The name of the author may not be used to endorse or promote products
+--   derived from this software without specific prior written permission.
+--
+-- THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+-- IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+-- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+-- IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+-- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+-- NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+-- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+-- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+-- THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--
+
 class A is
         fun Foo() is

uspace/dist/sysel/list.sy

@@ -1 @@
-
-class ListNode is
-        var value : int;
-
-        var prev : ListNode;
-        var next : ListNode;
-        var head : ListNode;
-
-        fun GetNext() : ListNode is
-                if next != head then
-                        return next;
-                else
-                        return nil;
-                end
-        end
-
-        fun GetPrev() : ListNode is
-                if prev != head then
-                        return next;
-                else
-                        return nil;
-                end
-        end
-
-        fun GetValue() : int is
-                return value;
-        end
-end
+--
+-- Copyright (c) 2010 Jiri Svoboda
+-- All rights reserved.
+--
+-- Redistribution and use in source and binary forms, with or without
+-- modification, are permitted provided that the following conditions
+-- are met:
+--
+-- o Redistributions of source code must retain the above copyright
+--   notice, this list of conditions and the following disclaimer.
+-- o Redistributions in binary form must reproduce the above copyright
+--   notice, this list of conditions and the following disclaimer in the
+--   documentation and/or other materials provided with the distribution.
+-- o The name of the author may not be used to endorse or promote products
+--   derived from this software without specific prior written permission.
+--
+-- THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+-- IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+-- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+-- IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+-- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+-- NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+-- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+-- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+-- THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--
 
 class List is
@@ -59 +58 @@
 end
 
+class ListNode is
+        var value : int;
+
+        var prev : ListNode;
+        var next : ListNode;
+        var head : ListNode;
+
+        fun GetNext() : ListNode is
+                if next != head then
+                        return next;
+                else
+                        return nil;
+                end
+        end
+
+        fun GetPrev() : ListNode is
+                if prev != head then
+                        return next;
+                else
+                        return nil;
+                end
+        end
+
+        fun GetValue() : int is
+                return value;
+        end
+end
+
 class ListDemo is
         fun Main() is