Changes in / [640ffe6:1317380] in mainline


Ignore:
Location:
uspace
Files:
9 deleted
45 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/sbi/Makefile

    r640ffe6 r1317380  
    3838        src/builtin/bi_fun.c \
    3939        src/builtin/bi_textfile.c \
    40         src/builtin/bi_string.c \
    4140        src/os/helenos.c \
    4241        src/ancr.c \
    4342        src/bigint.c \
    4443        src/builtin.c \
    45         src/cspan.c \
    4644        src/imode.c \
    4745        src/input.c \

  • uspace/app/sbi/src/ancr.c

    r640ffe6 r1317380  
    8181        while (node != NULL) {
    8282                modm = list_node_data(node, stree_modm_t *);
    83 
    84                 switch (modm->mc) {
    85                 case mc_csi:
    86                         ancr_csi_dfs(prog, modm->u.csi);
    87                         break;
    88                 case mc_enum:
    89                         break;
    90                 }
     83                assert(modm->mc == mc_csi); /* XXX */
     84                ancr_csi_dfs(prog, modm->u.csi);
    9185
    9286                node = list_next(&prog->module->members, node);

  • uspace/app/sbi/src/builtin.c

    r640ffe6 r1317380  
    4444#include "builtin/bi_fun.h"
    4545#include "builtin/bi_textfile.h"
    46 #include "builtin/bi_string.h"
    4746#include "input.h"
    4847#include "intmap.h"
    … …  
    9190        bi_fun_declare(bi);
    9291        bi_textfile_declare(bi);
    93         bi_string_declare(bi);
    9492}
    9593
    … …  
    107105        bi_fun_bind(bi);
    108106        bi_textfile_bind(bi);
    109         bi_string_bind(bi);
    110107}
    111108

  • uspace/app/sbi/src/builtin/bi_textfile.c

    r640ffe6 r1317380  
    7171                        "fun WriteLine(line : string), builtin;\n"
    7272                        "\n"
    73                         "prop EOF : bool is\n"
     73                        "prop EOF : int is\n"
    7474                                "get is\n"
    7575                                        "return is_eof();\n"
    … …  
    7777                        "end\n"
    7878                        "\n"
    79                         "fun is_eof() : bool, builtin;\n"
     79                        "fun is_eof() : int, builtin;\n"
    8080                "end\n");
    8181
    … …  
    342342        rdata_var_t *self_f_var;
    343343
    344         bool_t eof_flag;
    345         rdata_bool_t *eof_bool;
     344        int eof_flag;
     345        rdata_int_t *eof_int;
    346346        rdata_var_t *eof_var;
    347347        rdata_value_t *eof_val;
    … …  
    362362        /* Get status of EOF flag. */
    363363
    364         eof_flag = feof(file) ? b_true : b_false;
    365 
    366 #ifdef DEBUG_RUN_TRACE
    367         printf("Read EOF flag '%s'.\n", eof_flag ? "true" : "false");
     364        eof_flag = feof(file) ? 1 : 0;
     365
     366#ifdef DEBUG_RUN_TRACE
     367        printf("Read EOF flag '%d'.\n", eof_flag);
    368368#endif
    369369        /* Construct return value. */
    370         eof_bool = rdata_bool_new();
    371         eof_bool->value = eof_flag;
    372 
    373         eof_var = rdata_var_new(vc_bool);
    374         eof_var->u.bool_v = eof_bool;
     370        eof_int = rdata_int_new();
     371        bigint_init(&eof_int->value, eof_flag);
     372
     373        eof_var = rdata_var_new(vc_int);
     374        eof_var->u.int_v = eof_int;
    375375        eof_val = rdata_value_new();
    376376        eof_val->var = eof_var;

  • uspace/app/sbi/src/imode.c

    r640ffe6 r1317380  
    116116        fun->name = stree_ident_new();
    117117        fun->name->sid = strtab_get_sid("$imode");
    118         fun->sig = stree_fun_sig_new();
    119118
    120119        stype.proc_vr->proc = proc;

  • uspace/app/sbi/src/input.c

    r640ffe6 r1317380  
    118118        }
    119119
    120         input->name = os_str_dup(fname);
    121120        input->str = NULL;
    122121        input->line_no = 0;
    … …  
    137136        }
    138137
    139         input->name = "<user-input>";
    140138        input->str = NULL;
    141139        input->line_no = 0;
    … …  
    156154        }
    157155
    158         input->name = "<builtin>";
    159156        input->str = str;
    160157        input->line_no = 0;
    … …  
    229226/** Get number of the last provided line of input.
    230227 *
    231  * @param input         Input object.
     228 * @param input         Input module.
    232229 * @return              Line number of the last provided input line (counting
    233230 *                      from 1 up).

  • uspace/app/sbi/src/input_t.h

    r640ffe6 r1317380  
    3434/** Input state object */
    3535typedef struct input {
    36         /** Input name (for error output) */
    37         const char *name;
    38 
    3936        /** Input file if reading from file. */
    4037        FILE *fin;

  • uspace/app/sbi/src/lex.c

    r640ffe6 r1317380  
    3535#include <stdlib.h>
    3636#include "bigint.h"
    37 #include "cspan.h"
    3837#include "mytypes.h"
    3938#include "input.h"
    … …  
    7574/** Keyword names. Used both for printing and recognition. */
    7675static struct lc_name keywords[] = {
    77         { lc_and,       "and" },
    7876        { lc_as,        "as" },
    7977        { lc_bool,      "bool" },
    80         { lc_break,     "break" },
     78        { lc_char,      "char" },
    8179        { lc_builtin,   "builtin" },
    82         { lc_char,      "char" },
    8380        { lc_class,     "class" },
     81        { lc_constructor,       "constructor" },
    8482        { lc_deleg,     "deleg" },
    8583        { lc_do,        "do" },
    86         { lc_elif,      "elif" },
    8784        { lc_else,      "else" },
    8885        { lc_end,       "end" },
    89         { lc_enum,      "enum" },
    9086        { lc_except,    "except" },
    9187        { lc_false,     "false" },
    … …  
    10096        { lc_is,        "is" },
    10197        { lc_new,       "new" },
    102         { lc_not,       "not" },
    10398        { lc_nil,       "nil" },
    104         { lc_or,        "or" },
    10599        { lc_override,  "override" },
    106100        { lc_packed,    "packed" },
    … …  
    239233void lem_print_coords(lem_t *lem)
    240234{
    241         cspan_print(lem->cspan);
     235        printf("%d:%d", lem->line_no, lem->col_0);
    242236}
    243237
    … …  
    261255        lex->ibp = lex->inbuf;
    262256        lex->col_adj = 0;
    263         lex->prev_valid = b_false;
    264257        lex->current_valid = b_true;
    265258}
    … …  
    286279 * @param lex           Lexer object.
    287280 * @return              Pointer to current lem. Owned by @a lex and only valid
    288  *                      until next call to lex_xxx().
     281 *                      until next call to lex_next().
    289282 */
    290283lem_t *lex_get_current(lex_t *lex)
    … …  
    294287}
    295288
    296 /** Get previous lem if valid.
    297  *
    298  * The returned pointer is invalidated by next call to lex_next()
    299  *
    300  * @param lex           Lexer object.
    301  * @return              Pointer to previous lem. Owned by @a lex and only valid
    302  *                      until next call to lex_xxx().
    303  */
    304 lem_t *lex_peek_prev(lex_t *lex)
    305 {
    306         if (lex->current_valid == b_false) {
    307                 /*
    308                  * This means the head is advanced but next lem was not read.
    309                  * Thus the previous lem is still in @a current.
    310                  */
    311                 return &lex->current;
    312         }
    313 
    314         if (lex->prev_valid != b_true) {
    315                 /* Looks like we are still at the first lem. */
    316                 return NULL;
    317         }
    318 
    319         /*
    320          * Current lem has been read in. Thus the previous lem was moved to
    321          * @a previous.
    322          */
    323         return &lex->prev;
    324 }
    325 
    326289/** Read in the current lexical element (unless already read in).
    327290 *
    … …  
    334297        if (lex->current_valid == b_true)
    335298                return;
    336 
    337         /* Copy previous lem */
    338         lex->prev = lex->current;
    339         lex->prev_valid = b_true;
    340299
    341300        do {
    … …  
    359318static bool_t lex_read_try(lex_t *lex)
    360319{
    361         char *bp, *lsp;
    362         int line0, col0;
     320        char *bp;
    363321
    364322        lex_skip_ws(lex);
    … …  
    370328         * separately using col_adj.
    371329         */
    372         line0 = input_get_line_no(lex->input);
    373         col0 = 1 + lex->col_adj + (lex->ibp - lex->inbuf);
    374 
    375         lex->current.cspan = cspan_new(lex->input, line0, col0, line0, col0);
    376 
    377         lsp = lex->ibp;
     330        lex->current.line_no = input_get_line_no(lex->input);
     331        lex->current.col_0 = 1 + lex->col_adj + (lex->ibp - lex->inbuf);
     332
    378333        bp = lex->ibp;
    379334
    … …  
    381336                /* End of input */
    382337                lex->current.lclass = lc_eof;
    383                 goto finish;
     338                return b_true;
    384339        }
    385340
    386341        if (is_wstart(bp[0])) {
    387342                lex_word(lex);
    388                 goto finish;
     343                return b_true;
    389344        }
    390345
    391346        if (bp[0] == '\'') {
    392347                lex_char(lex);
    393                 goto finish;
     348                return b_true;
    394349        }
    395350
    396351        if (is_digit(bp[0])) {
    397352                lex_number(lex);
    398                 goto finish;
     353                return b_true;
    399354        }
    400355
    401356        if (bp[0] == '"') {
    402357                lex_string(lex);
    403                 goto finish;
     358                return b_true;
    404359        }
    405360
    406361        if (bp[0] == '-' && bp[1] == '-') {
    407362                lex_skip_comment(lex);
    408 
    409                 /* Compute ending column number */
    410                 lex->current.cspan->col1 = col0 + (lex->ibp - lsp) - 1;
    411 
    412                 /* Try again */
    413363                return b_false;
    414364        }
    … …  
    467417
    468418        lex->ibp = bp;
    469 
    470 finish:
    471         /* Compute ending column number */
    472         lex->current.cspan->col1 = col0 + (lex->ibp - lsp) - 1;
    473419        return b_true;
    474420

  • uspace/app/sbi/src/lex.h

    r640ffe6 r1317380  
    3939void lex_next(lex_t *lex);
    4040lem_t *lex_get_current(lex_t *lex);
    41 lem_t *lex_peek_prev(lex_t *lex);
    4241
    4342#endif

  • uspace/app/sbi/src/lex_t.h

    r640ffe6 r1317380  
    4343
    4444        /* Keywords */
    45         lc_and,
    4645        lc_as,
    47         lc_break,
    4846        lc_bool,
    4947        lc_builtin,
    5048        lc_char,
    5149        lc_class,
     50        lc_constructor,
    5251        lc_deleg,
    5352        lc_do,
    54         lc_elif,
    5553        lc_else,
    5654        lc_end,
    57         lc_enum,
    5855        lc_except,
    5956        lc_false,
    … …  
    6966        lc_is,
    7067        lc_nil,
    71         lc_not,
    72         lc_or,
    7368        lc_override,
    7469        lc_packed,
    … …  
    153148
    154149        /** Coordinates of this lexical element */
    155         struct cspan *cspan;
     150        int line_no, col_0;
    156151} lem_t;
    157152
    … …  
    173168        int col_adj;
    174169
    175         /** @c b_true if we have the previous lem in @c prev */
    176         bool_t prev_valid;
    177 
    178         /** Previous lem (only valid if @c current_valid is true) */
    179         lem_t prev;
    180 
    181         /** @c b_true if we have the current lem in @c current */
     170        /** @c b_true if we have the next lem in @c current */
    182171        bool_t current_valid;
    183172

  • uspace/app/sbi/src/mytypes.h

    r640ffe6 r1317380  
    4949#include "bigint_t.h"
    5050#include "builtin_t.h"
    51 #include "cspan_t.h"
    5251#include "input_t.h"
    5352#include "intmap_t.h"

  • uspace/app/sbi/src/os/helenos.c

    r640ffe6 r1317380  
    2929/** @file HelenOS-specific code. */
    3030
    31 #include <assert.h>
    3231#include <errno.h>
    3332#include <stdio.h>
    … …  
    7675}
    7776
    78 /** Return slice (substring) of a string.
    79  *
    80  * Copies the specified range of characters from @a str and returns it
    81  * as a newly allocated string. @a start + @a length must be less than
    82  * or equal to the length of @a str.
    83  *
    84  * @param str           String
    85  * @param start         Index of first character (starting from zero).
    86  * @param length        Number of characters to copy.
    87  *
    88  * @return              Newly allocated string holding the slice.
    89  */
    90 char *os_str_aslice(const char *str, size_t start, size_t length)
    91 {
    92         char *slice;
    93         size_t offset;
    94         size_t i;
    95         size_t size;
    96         wchar_t c;
    97 
    98         assert(start + length <= str_length(str));
    99 
    100         offset = 0;
    101         for (i = 0; i < start; ++i) {
    102                 c = str_decode(str, &offset, STR_NO_LIMIT);
    103                 assert(c != '\0');
    104                 assert(c != U_SPECIAL);
    105                 (void) c;
    106         }
    107 
    108         size = str_lsize(str, length);
    109         slice = str_ndup(str + offset, size);
    110 
    111         return slice;
    112 }
    113 
    11477/** Compare two strings.
    11578 *

  • uspace/app/sbi/src/os/os.h

    r640ffe6 r1317380  
    3131
    3232char *os_str_acat(const char *a, const char *b);
    33 char *os_str_aslice(const char *str, size_t start, size_t length);
    3433int os_str_cmp(const char *a, const char *b);
    3534char *os_str_dup(const char *str);

  • uspace/app/sbi/src/os/posix.c

    r640ffe6 r1317380  
    2929/** @file POSIX-specific code. */
    3030
    31 #include <assert.h>
    3231#include <libgen.h>
    3332#include <stdio.h>
    … …  
    7978}
    8079
    81 /** Return slice (substring) of a string.
    82  *
    83  * Copies the specified range of characters from @a str and returns it
    84  * as a newly allocated string. @a start + @a length must be less than
    85  * or equal to the length of @a str.
    86  *
    87  * @param str           String
    88  * @param start         Index of first character (starting from zero).
    89  * @param length        Number of characters to copy.
    90  *
    91  * @return              Newly allocated string holding the slice.
    92  */
    93 char *os_str_aslice(const char *str, size_t start, size_t length)
    94 {
    95         char *slice;
    96 
    97         assert(start + length <= strlen(str));
    98         slice = malloc(length + 1);
    99         if (slice == NULL) {
    100                 printf("Memory allocation error.\n");
    101                 exit(1);
    102         }
    103 
    104         strncpy(slice, str + start, length);
    105         slice[length] = '\0';
    106 
    107         return slice;
    108 }
    109 
    11080/** Compare two strings.
    11181 *

  • uspace/app/sbi/src/p_expr.c

    r640ffe6 r1317380  
    3232#include <stdlib.h>
    3333#include "bigint.h"
    34 #include "cspan.h"
    3534#include "debug.h"
    3635#include "lex.h"
    … …  
    4443
    4544static stree_expr_t *parse_assign(parse_t *parse);
    46 static stree_expr_t *parse_disjunctive(parse_t *parse);
    47 static stree_expr_t *parse_conjunctive(parse_t *parse);
    4845static stree_expr_t *parse_comparative(parse_t *parse);
    4946static stree_expr_t *parse_additive(parse_t *parse);
    … …  
    9895        stree_assign_t *assign;
    9996
    100         a = parse_disjunctive(parse);
     97        a = parse_comparative(parse);
    10198
    10299        switch (lcur_lc(parse)) {
    … …  
    112109
    113110        lskip(parse);
    114         b = parse_disjunctive(parse);
     111        b = parse_comparative(parse);
    115112
    116113        assign->dest = a;
    … …  
    119116        tmp = stree_expr_new(ec_assign);
    120117        tmp->u.assign = assign;
    121         tmp->cspan = cspan_merge(a->cspan, b->cspan);
    122 
    123         assign->expr = tmp;
    124 
    125118        return tmp;
    126 }
    127 
    128 /** Parse disjunctive expression.
    129  *
    130  * @param parse         Parser object.
    131  */
    132 static stree_expr_t *parse_disjunctive(parse_t *parse)
    133 {
    134         stree_expr_t *a, *b, *tmp;
    135         stree_binop_t *binop;
    136         cspan_t *cs;
    137 
    138         a = parse_conjunctive(parse);
    139         cs = a->cspan;
    140 
    141         while (lcur_lc(parse) == lc_or) {
    142                 if (parse_is_error(parse))
    143                         break;
    144 
    145                 lskip(parse);
    146                 b = parse_conjunctive(parse);
    147 
    148                 binop = stree_binop_new(bo_or);
    149                 binop->arg1 = a;
    150                 binop->arg2 = b;
    151 
    152                 tmp = stree_expr_new(ec_binop);
    153                 tmp->u.binop = binop;
    154                 tmp->cspan = cspan_merge(cs, b->cspan);
    155                 binop->expr = tmp;
    156 
    157                 a = tmp;
    158                 cs = tmp->cspan;
    159         }
    160 
    161         return a;
    162 }
    163 
    164 /** Parse conjunctive expression.
    165  *
    166  * @param parse         Parser object.
    167  */
    168 static stree_expr_t *parse_conjunctive(parse_t *parse)
    169 {
    170         stree_expr_t *a, *b, *tmp;
    171         stree_binop_t *binop;
    172         cspan_t *cs;
    173 
    174         a = parse_comparative(parse);
    175         cs = a->cspan;
    176 
    177         while (lcur_lc(parse) == lc_and) {
    178                 if (parse_is_error(parse))
    179                         break;
    180 
    181                 lskip(parse);
    182                 b = parse_comparative(parse);
    183 
    184                 binop = stree_binop_new(bo_and);
    185                 binop->arg1 = a;
    186                 binop->arg2 = b;
    187 
    188                 tmp = stree_expr_new(ec_binop);
    189                 tmp->u.binop = binop;
    190                 tmp->cspan = cspan_merge(cs, b->cspan);
    191                 binop->expr = tmp;
    192 
    193                 a = tmp;
    194                 cs = tmp->cspan;
    195         }
    196 
    197         return a;
    198119}
    199120
    … …  
    207128        stree_binop_t *binop;
    208129        binop_class_t bc;
    209         cspan_t *cs;
    210130
    211131        a = parse_additive(parse);
    212         cs = a->cspan;
    213132
    214133        while (lcur_lc(parse) == lc_equal || lcur_lc(parse) == lc_notequal ||
    … …  
    238157                tmp = stree_expr_new(ec_binop);
    239158                tmp->u.binop = binop;
    240                 tmp->cspan = cspan_merge(cs, b->cspan);
    241                 binop->expr = tmp;
    242 
    243159                a = tmp;
    244                 cs = tmp->cspan;
    245160        }
    246161
    … …  
    257172        stree_binop_t *binop;
    258173        binop_class_t bc;
    259         cspan_t *cs;
    260174
    261175        a = parse_multip(parse);
    262         cs = a->cspan;
    263 
    264176        while (lcur_lc(parse) == lc_plus || lcur_lc(parse) == lc_minus) {
    265177                if (parse_is_error(parse))
    … …  
    281193                tmp = stree_expr_new(ec_binop);
    282194                tmp->u.binop = binop;
    283                 tmp->cspan = cspan_merge(cs, b->cspan);
    284                 binop->expr = tmp;
    285 
    286195                a = tmp;
    287                 cs = tmp->cspan;
    288196        }
    289197
    … …  
    300208        stree_binop_t *binop;
    301209        binop_class_t bc;
    302         cspan_t *cs;
    303210
    304211        a = parse_prefix(parse);
    305         cs = a->cspan;
    306 
    307212        while (lcur_lc(parse) == lc_mult) {
    308213                if (parse_is_error(parse))
    … …  
    323228                tmp = stree_expr_new(ec_binop);
    324229                tmp->u.binop = binop;
    325                 tmp->cspan = cspan_merge(cs, b->cspan);
    326                 binop->expr = tmp;
    327 
    328230                a = tmp;
    329                 cs = tmp->cspan;
    330231        }
    331232
    … …  
    343244        stree_unop_t *unop;
    344245        unop_class_t uc;
    345         cspan_t *cs0;
    346246
    347247        switch (lcur_lc(parse)) {
    348248        case lc_plus:
    349249        case lc_minus:
    350         case lc_not:
    351250                if (parse_is_error(parse))
    352251                        return parse_recovery_expr(parse);
    … …  
    355254                case lc_plus: uc = uo_plus; break;
    356255                case lc_minus: uc = uo_minus; break;
    357                 case lc_not: uc = uo_not; break;
    358256                default: assert(b_false);
    359257                }
    360258
    361                 cs0 = lcur_span(parse);
    362259                lskip(parse);
    363260                a = parse_postfix(parse);
    … …  
    368265                tmp = stree_expr_new(ec_unop);
    369266                tmp->u.unop = unop;
    370                 tmp->cspan = cspan_merge(cs0, a->cspan);
    371                 unop->expr = tmp;
    372267                a = tmp;
    373268                break;
    … …  
    392287        stree_new_t *new_op;
    393288        stree_expr_t *expr;
    394         stree_expr_t *arg;
    395         cspan_t *cs0, *cs1;
    396 
    397         cs0 = lcur_span(parse);
     289
    398290        lmatch(parse, lc_new);
    399291        texpr = parse_texpr(parse);
    400292
    401         /* XXX Take span from texpr */
    402         cs1 = lprev_span(parse);
     293        /* Parenthesis should be present except for arrays. */
     294        if (texpr->tc != tc_tindex) {
     295                lmatch(parse, lc_lparen);
     296                lmatch(parse, lc_rparen);
     297        }
    403298
    404299        new_op = stree_new_new();
    … …  
    407302        expr->u.new_op = new_op;
    408303
    409         list_init(&new_op->ctor_args);
    410 
    411         /* Parenthesized arguments should be present except for arrays. */
    412         if (texpr->tc != tc_tindex) {
    413                 lmatch(parse, lc_lparen);
    414 
    415                 /* Parse constructor arguments */
    416 
    417                 if (lcur_lc(parse) != lc_rparen) {
    418                         while (!parse_is_error(parse)) {
    419                                 arg = parse_expr(parse);
    420                                 list_append(&new_op->ctor_args, arg);
    421 
    422                                 if (lcur_lc(parse) == lc_rparen)
    423                                         break;
    424                                 lmatch(parse, lc_comma);
    425                         }
    426                 }
    427 
    428                 lmatch(parse, lc_rparen);
    429                 cs1 = cspan_merge(cs0, lprev_span(parse));
    430         }
    431 
    432         expr->cspan = cspan_merge(cs0, cs1);
    433         new_op->expr = expr;
    434 
    435304        return expr;
    436305}
    … …  
    485354        stree_expr_t *expr;
    486355        stree_access_t *access;
    487         cspan_t *cs1;
    488356
    489357        lmatch(parse, lc_period);
    490358        ident = parse_ident(parse);
    491 
    492         /* XXX Take span from ident */
    493         cs1 = lprev_span(parse);
    494359
    495360        access = stree_access_new();
    … …  
    499364        expr = stree_expr_new(ec_access);
    500365        expr->u.access = access;
    501         expr->cspan = cspan_merge(a->cspan, cs1);
    502 
    503         access->expr = expr;
    504366
    505367        return expr;
    … …  
    515377        stree_call_t *call;
    516378        stree_expr_t *arg;
    517         cspan_t *cs1;
    518379
    519380        lmatch(parse, lc_lparen);
    … …  
    537398
    538399        lmatch(parse, lc_rparen);
    539         cs1 = lprev_span(parse);
    540400
    541401        expr = stree_expr_new(ec_call);
    542402        expr->u.call = call;
    543         expr->cspan = cspan_merge(a->cspan, cs1);
    544         call->expr = expr;
    545403
    546404        return expr;
    … …  
    556414        stree_index_t *index;
    557415        stree_expr_t *arg;
    558         cspan_t *cs1;
    559416
    560417        lmatch(parse, lc_lsbr);
    … …  
    578435
    579436        lmatch(parse, lc_rsbr);
    580         cs1 = lprev_span(parse);
    581437
    582438        expr = stree_expr_new(ec_index);
    583439        expr->u.index = index;
    584         expr->cspan = cspan_merge(a->cspan, cs1);
    585         index->expr = expr;
    586440
    587441        return expr;
    … …  
    597451        stree_texpr_t *texpr;
    598452        stree_as_t *as_op;
    599         cspan_t *cs1;
    600453
    601454        lmatch(parse, lc_as);
    602455        texpr = parse_texpr(parse);
    603 
    604         /* XXX Take span from texpr */
    605         cs1 = lprev_span(parse);
    606456
    607457        as_op = stree_as_new();
    608458        as_op->arg = a;
    609459        as_op->dtype = texpr;
    610 
    611460        expr = stree_expr_new(ec_as);
    612461        expr->u.as_op = as_op;
    613         expr->cspan = cspan_merge(a->cspan, cs1);
    614 
    615         as_op->expr = expr;
    616462
    617463        return expr;
    … …  
    625471{
    626472        stree_expr_t *expr;
    627         cspan_t *cs0, *cs1;
    628473
    629474        if (lcur_lc(parse) == lc_lparen) {
    630                 cs0 = lcur_span(parse);
    631475                lskip(parse);
    632476                expr = parse_expr(parse);
    633477                lmatch(parse, lc_rparen);
    634                 cs1 = lprev_span(parse);
    635 
    636                 expr->cspan = cspan_merge(cs0, cs1);
    637478        } else {
    638479                expr = parse_primitive(parse);
    … …  
    641482        return expr;
    642483}
     484
    643485
    644486/** Parse primitive expression.
    … …  
    694536        expr = stree_expr_new(ec_nameref);
    695537        expr->u.nameref = nameref;
    696         expr->cspan = lprev_span(parse);
    697         nameref->expr = expr;
    698538
    699539        return expr;
    … …  
    723563        expr = stree_expr_new(ec_literal);
    724564        expr->u.literal = literal;
    725         expr->cspan = lprev_span(parse);
    726         literal->expr = expr;
    727565
    728566        return expr;
    … …  
    748586        expr = stree_expr_new(ec_literal);
    749587        expr->u.literal = literal;
    750         expr->cspan = lprev_span(parse);
    751         literal->expr = expr;
    752588
    753589        return expr;
    … …  
    773609        expr = stree_expr_new(ec_literal);
    774610        expr->u.literal = literal;
    775         expr->cspan = lprev_span(parse);
    776         literal->expr = expr;
    777611
    778612        return expr;
    … …  
    794628        expr = stree_expr_new(ec_literal);
    795629        expr->u.literal = literal;
    796         expr->cspan = lprev_span(parse);
    797         literal->expr = expr;
    798630
    799631        return expr;
    … …  
    818650        expr = stree_expr_new(ec_literal);
    819651        expr->u.literal = literal;
    820         expr->cspan = lprev_span(parse);
    821         literal->expr = expr;
    822652
    823653        return expr;
    … …  
    839669        expr = stree_expr_new(ec_self_ref);
    840670        expr->u.self_ref = self_ref;
    841         expr->cspan = lprev_span(parse);
    842         self_ref->expr = expr;
    843671
    844672        return expr;
    … …  
    860688        expr = stree_expr_new(ec_literal);
    861689        expr->u.literal = literal;
    862         literal->expr = expr;
    863 
    864         return expr;
    865 }
     690
     691        return expr;
     692}

  • uspace/app/sbi/src/p_type.c

    r640ffe6 r1317380  
    3131#include <assert.h>
    3232#include <stdlib.h>
    33 #include "cspan.h"
    3433#include "debug.h"
    3534#include "lex.h"
    … …  
    4645static stree_texpr_t *parse_pf_taccess(parse_t *parse, stree_texpr_t *a);
    4746static stree_texpr_t *parse_pf_tindex(parse_t *parse, stree_texpr_t *a);
    48 static stree_texpr_t *parse_tparen(parse_t *parse);
    4947static stree_texpr_t *parse_tprimitive(parse_t *parse);
    50 static stree_texpr_t *parse_tliteral(parse_t *parse);
    51 static stree_texpr_t *parse_tnameref(parse_t *parse);
     48static stree_tliteral_t *parse_tliteral(parse_t *parse);
     49static stree_tnameref_t *parse_tnameref(parse_t *parse);
    5250
    5351static stree_texpr_t *parse_recovery_texpr(parse_t *parse);
    … …  
    9391        list_init(&tapply->targs);
    9492
    95         targ = NULL;
    96 
    9793        while (lcur_lc(parse) == lc_slash) {
    9894
    … …  
    108104        aexpr = stree_texpr_new(tc_tapply);
    109105        aexpr->u.tapply = tapply;
    110         tapply->texpr = aexpr;
    111 
    112         if (targ != NULL)
    113                 aexpr->cspan = cspan_merge(gtype->cspan, targ->cspan);
    114         else
    115                 aexpr->cspan = gtype->cspan;
    116 
    117106        return aexpr;
    118107}
    … …  
    127116        stree_texpr_t *tmp;
    128117
    129         a = parse_tparen(parse);
     118        a = parse_tprimitive(parse);
    130119
    131120        while (lcur_lc(parse) == lc_period || lcur_lc(parse) == lc_lsbr) {
    … …  
    173162        texpr = stree_texpr_new(tc_taccess);
    174163        texpr->u.taccess = taccess;
    175         taccess->texpr = texpr;
    176         texpr->cspan = cspan_merge(a->cspan, ident->cspan);
    177164
    178165        return texpr;
    … …  
    189176        stree_tindex_t *tindex;
    190177        stree_expr_t *expr;
    191         cspan_t *cs1;
    192178
    193179        tindex = stree_tindex_new();
    … …  
    223209
    224210        lmatch(parse, lc_rsbr);
    225         cs1 = lprev_span(parse);
    226211
    227212        texpr = stree_texpr_new(tc_tindex);
    228213        texpr->u.tindex = tindex;
    229         tindex->texpr = texpr;
    230         texpr->cspan = cspan_merge(a->cspan, cs1);
    231214
    232215        return texpr;
    233216}
    234 
    235 /** Parse possibly partenthesized type expression.
    236  *
    237  * @param parse         Parser object.
    238  */
    239 static stree_texpr_t *parse_tparen(parse_t *parse)
    240 {
    241         stree_texpr_t *texpr;
    242         cspan_t *cs0, *cs1;
    243 
    244         if (lcur_lc(parse) == lc_lparen) {
    245                 cs0 = lcur_span(parse);
    246                 lskip(parse);
    247                 texpr = parse_texpr(parse);
    248                 lmatch(parse, lc_rparen);
    249                 cs1 = lprev_span(parse);
    250                 texpr->cspan = cspan_merge(cs0, cs1);
    251         } else {
    252                 texpr = parse_tprimitive(parse);
    253         }
    254 
    255         return texpr;
    256 }
    257 
    258217
    259218/** Parse primitive type expression.
    … …  
    267226        switch (lcur_lc(parse)) {
    268227        case lc_ident:
    269                 texpr = parse_tnameref(parse);
     228                texpr = stree_texpr_new(tc_tnameref);
     229                texpr->u.tnameref = parse_tnameref(parse);
    270230                break;
    271231        case lc_bool:
    … …  
    274234        case lc_string:
    275235        case lc_resource:
    276                 texpr = parse_tliteral(parse);
     236                texpr = stree_texpr_new(tc_tliteral);
     237                texpr->u.tliteral = parse_tliteral(parse);
    277238                break;
    278239        default:
    … …  
    289250 * @param parse         Parser object.
    290251 */
    291 static stree_texpr_t *parse_tliteral(parse_t *parse)
     252static stree_tliteral_t *parse_tliteral(parse_t *parse)
    292253{
    293254        stree_tliteral_t *tliteral;
    294255        tliteral_class_t tlc;
    295         stree_texpr_t *texpr;
    296256
    297257        switch (lcur_lc(parse)) {
    … …  
    318278
    319279        tliteral = stree_tliteral_new(tlc);
     280        return tliteral;
     281}
     282
     283/** Parse type identifier.
     284 *
     285 * @param parse         Parser object.
     286 */
     287static stree_tnameref_t *parse_tnameref(parse_t *parse)
     288{
     289        stree_tnameref_t *tnameref;
     290
     291        tnameref = stree_tnameref_new();
     292        tnameref->name = parse_ident(parse);
     293
     294        return tnameref;
     295}
     296
     297/** Construct a special type expression fore recovery.
     298 *
     299 * @param parse         Parser object.
     300 */
     301static stree_texpr_t *parse_recovery_texpr(parse_t *parse)
     302{
     303        stree_tliteral_t *tliteral;
     304        stree_texpr_t *texpr;
     305
     306        (void) parse;
     307
     308        tliteral = stree_tliteral_new(tlc_int);
     309
    320310        texpr = stree_texpr_new(tc_tliteral);
    321311        texpr->u.tliteral = tliteral;
    322         tliteral->texpr = texpr;
    323         texpr->cspan = lprev_span(parse);
    324312
    325313        return texpr;
    326314}
    327 
    328 /** Parse type identifier.
    329  *
    330  * @param parse         Parser object.
    331  */
    332 static stree_texpr_t *parse_tnameref(parse_t *parse)
    333 {
    334         stree_tnameref_t *tnameref;
    335         stree_texpr_t *texpr;
    336 
    337         tnameref = stree_tnameref_new();
    338         tnameref->name = parse_ident(parse);
    339 
    340         texpr = stree_texpr_new(tc_tnameref);
    341         texpr->u.tnameref = tnameref;
    342         tnameref->texpr = texpr;
    343         texpr->cspan = tnameref->name->cspan;
    344 
    345         return texpr;
    346 }
    347 
    348 /** Construct a special type expression fore recovery.
    349  *
    350  * @param parse         Parser object.
    351  */
    352 static stree_texpr_t *parse_recovery_texpr(parse_t *parse)
    353 {
    354         stree_tliteral_t *tliteral;
    355         stree_texpr_t *texpr;
    356 
    357         (void) parse;
    358 
    359         tliteral = stree_tliteral_new(tlc_int);
    360 
    361         texpr = stree_texpr_new(tc_tliteral);
    362         texpr->u.tliteral = tliteral;
    363         tliteral->texpr = texpr;
    364 
    365         return texpr;
    366 }

  • uspace/app/sbi/src/parse.c

    r640ffe6 r1317380  
    4848
    4949/*
    50  * Module and CSI members
     50 * Module members
    5151 */
    5252static stree_csi_t *parse_csi(parse_t *parse, lclass_t dclass,
    5353    stree_csi_t *outer_csi);
    5454static stree_csimbr_t *parse_csimbr(parse_t *parse, stree_csi_t *outer_csi);
    55 
    56 static stree_ctor_t *parse_ctor(parse_t *parse, stree_csi_t *outer_csi);
    57 
    58 static stree_enum_t *parse_enum(parse_t *parse, stree_csi_t *outer_csi);
    59 static stree_embr_t *parse_embr(parse_t *parse, stree_enum_t *outer_enum);
    6055
    6156static stree_deleg_t *parse_deleg(parse_t *parse, stree_csi_t *outer_csi);
    … …  
    8176static stree_for_t *parse_for(parse_t *parse);
    8277static stree_raise_t *parse_raise(parse_t *parse);
    83 static stree_break_t *parse_break(parse_t *parse);
    8478static stree_return_t *parse_return(parse_t *parse);
    8579static stree_wef_t *parse_wef(parse_t *parse);
    … …  
    129123{
    130124        stree_csi_t *csi;
    131         stree_enum_t *enum_d;
    132125        stree_modm_t *modm;
    133126
    … …  
    143136                        list_append(&parse->cur_mod->members, modm);
    144137                        break;
    145                 case lc_enum:
    146                         enum_d = parse_enum(parse, NULL);
    147                         modm = stree_modm_new(mc_enum);
    148                         modm->u.enum_d = enum_d;
    149 
    150                         list_append(&parse->cur_mod->members, modm);
    151                         break;
    152138                default:
    153139                        lunexpected_error(parse);
    … …  
    237223 *
    238224 * @param parse         Parser object.
    239  * @param outer_csi     CSI containing this declaration.
     225 * @param outer_csi     CSI containing this declaration or @c NULL if global.
    240226 * @return              New syntax tree node. In case of parse error,
    241227 *                      @c NULL may (but need not) be returned.
    … …  
    246232
    247233        stree_csi_t *csi;
    248         stree_ctor_t *ctor;
    249234        stree_deleg_t *deleg;
    250         stree_enum_t *enum_d;
    251235        stree_fun_t *fun;
    252236        stree_var_t *var;
    … …  
    261245                csimbr->u.csi = csi;
    262246                break;
    263         case lc_new:
    264                 ctor = parse_ctor(parse, outer_csi);
    265                 csimbr = stree_csimbr_new(csimbr_ctor);
    266                 csimbr->u.ctor = ctor;
    267                 break;
    268247        case lc_deleg:
    269248                deleg = parse_deleg(parse, outer_csi);
    … …  
    271250                csimbr->u.deleg = deleg;
    272251                break;
    273         case lc_enum:
    274                 enum_d = parse_enum(parse, outer_csi);
    275                 csimbr = stree_csimbr_new(csimbr_enum);
    276                 csimbr->u.enum_d = enum_d;
    277                 break;
    278252        case lc_fun:
    279253                fun = parse_fun(parse, outer_csi);
    … …  
    299273
    300274        return csimbr;
    301 }
    302 
    303 /** Parse constructor.
    304  *
    305  * @param parse         Parser object.
    306  * @param outer_csi     CSI containing this declaration or @c NULL if global.
    307  * @return              New syntax tree node.
    308  */
    309 static stree_ctor_t *parse_ctor(parse_t *parse, stree_csi_t *outer_csi)
    310 {
    311         stree_ctor_t *ctor;
    312         stree_symbol_t *symbol;
    313         stree_symbol_attr_t *attr;
    314 
    315         ctor = stree_ctor_new();
    316         symbol = stree_symbol_new(sc_ctor);
    317 
    318         symbol->u.ctor = ctor;
    319         symbol->outer_csi = outer_csi;
    320         ctor->symbol = symbol;
    321 
    322         lmatch(parse, lc_new);
    323 
    324         /* Fake identifier. */
    325         ctor->name = stree_ident_new();
    326         ctor->name->sid = strtab_get_sid(CTOR_IDENT);
    327         ctor->name->cspan = lprev_span(parse);
    328 
    329 #ifdef DEBUG_PARSE_TRACE
    330         printf("Parsing constructor of CSI '");
    331         symbol_print_fqn(csi_to_symbol(outer_csi));
    332         printf("'.\n");
    333 #endif
    334         ctor->sig = parse_fun_sig(parse);
    335         if (ctor->sig->rtype != NULL) {
    336                 printf("Error: Constructor of CSI '");
    337                 symbol_print_fqn(csi_to_symbol(outer_csi));
    338                 printf("' has a return type.\n");
    339                 parse_note_error(parse);
    340         }
    341 
    342         list_init(&symbol->attr);
    343 
    344         /* Parse attributes. */
    345         while (lcur_lc(parse) == lc_comma && !parse_is_error(parse)) {
    346                 lskip(parse);
    347                 attr = parse_symbol_attr(parse);
    348                 list_append(&symbol->attr, attr);
    349         }
    350 
    351         ctor->proc = stree_proc_new();
    352         ctor->proc->outer_symbol = symbol;
    353 
    354         if (lcur_lc(parse) == lc_scolon) {
    355                 lskip(parse);
    356 
    357                 /* This constructor has no body. */
    358                 printf("Error: Constructor of CSI '");
    359                 symbol_print_fqn(csi_to_symbol(outer_csi));
    360                 printf("' has no body.\n");
    361                 parse_note_error(parse);
    362 
    363                 ctor->proc->body = NULL;
    364         } else {
    365                 lmatch(parse, lc_is);
    366                 ctor->proc->body = parse_block(parse);
    367                 lmatch(parse, lc_end);
    368         }
    369 
    370         return ctor;
    371 }
    372 
    373 /** Parse @c enum declaration.
    374  *
    375  * @param parse         Parser object.
    376  * @param outer_csi     CSI containing this declaration or @c NULL if global.
    377  * @return              New syntax tree node.
    378  */
    379 static stree_enum_t *parse_enum(parse_t *parse, stree_csi_t *outer_csi)
    380 {
    381         stree_enum_t *enum_d;
    382         stree_symbol_t *symbol;
    383         stree_embr_t *embr;
    384 
    385         enum_d = stree_enum_new();
    386         symbol = stree_symbol_new(sc_enum);
    387 
    388         symbol->u.enum_d = enum_d;
    389         symbol->outer_csi = outer_csi;
    390         enum_d->symbol = symbol;
    391 
    392         lmatch(parse, lc_enum);
    393         enum_d->name = parse_ident(parse);
    394         list_init(&enum_d->members);
    395 
    396 #ifdef DEBUG_PARSE_TRACE
    397         printf("Parse enum '%s'.\n", strtab_get_str(enum_d->name->sid));
    398 #endif
    399         lmatch(parse, lc_is);
    400 
    401         /* Parse enum members. */
    402         while (lcur_lc(parse) != lc_end && !parse_is_error(parse)) {
    403                 embr = parse_embr(parse, enum_d);
    404                 if (embr == NULL)
    405                         break;
    406 
    407                 list_append(&enum_d->members, embr);
    408         }
    409 
    410         if (list_is_empty(&enum_d->members)) {
    411                 printf("Error: Enum type '%s' has no members.\n",
    412                     strtab_get_str(enum_d->name->sid));
    413                 parse_note_error(parse);
    414         }
    415 
    416         lmatch(parse, lc_end);
    417 
    418         return enum_d;
    419 }
    420 
    421 /** Parse enum member.
    422  *
    423  * @param parse         Parser object.
    424  * @param outer_enum    Enum containing this declaration.
    425  * @return              New syntax tree node. In case of parse error,
    426  *                      @c NULL may (but need not) be returned.
    427  */
    428 static stree_embr_t *parse_embr(parse_t *parse, stree_enum_t *outer_enum)
    429 {
    430         stree_embr_t *embr;
    431 
    432         embr = stree_embr_new();
    433         embr->outer_enum = outer_enum;
    434         embr->name = parse_ident(parse);
    435 
    436         lmatch(parse, lc_scolon);
    437 
    438         return embr;
    439275}
    440276
    … …  
    845681        stree_for_t *for_s;
    846682        stree_raise_t *raise_s;
    847         stree_break_t *break_s;
    848683        stree_return_t *return_s;
    849684        stree_wef_t *wef_s;
    … …  
    879714                stat->u.raise_s = raise_s;
    880715                break;
    881         case lc_break:
    882                 break_s = parse_break(parse);
    883                 stat = stree_stat_new(st_break);
    884                 stat->u.break_s = break_s;
    885                 break;
    886716        case lc_return:
    887717                return_s = parse_return(parse);
    … …  
    947777{
    948778        stree_if_t *if_s;
    949         stree_if_clause_t *if_c;
    950779
    951780#ifdef DEBUG_PARSE_TRACE
    … …  
    953782#endif
    954783        if_s = stree_if_new();
    955         list_init(&if_s->if_clauses);
    956 
    957         /* Parse @c if clause. */
     784
    958785        lmatch(parse, lc_if);
    959 
    960         if_c = stree_if_clause_new();
    961         if_c->cond = parse_expr(parse);
     786        if_s->cond = parse_expr(parse);
    962787        lmatch(parse, lc_then);
    963         if_c->block = parse_block(parse);
    964 
    965         list_append(&if_s->if_clauses, if_c);
    966 
    967         /* Parse @c elif clauses. */
    968         while (lcur_lc(parse) == lc_elif) {
    969                 lskip(parse);
    970                 if_c = stree_if_clause_new();
    971                 if_c->cond = parse_expr(parse);
    972                 lmatch(parse, lc_then);
    973                 if_c->block = parse_block(parse);
    974 
    975                 list_append(&if_s->if_clauses, if_c);
    976         }
    977 
    978         /* Parse @c else clause. */
     788        if_s->if_block = parse_block(parse);
     789
    979790        if (lcur_lc(parse) == lc_else) {
    980791                lskip(parse);
    … …  
    1056867}
    1057868
    1058 /** Parse @c break statement.
    1059  *
    1060  * @param parse         Parser object.
    1061  * @return              New syntax tree node.
    1062  */
    1063 static stree_break_t *parse_break(parse_t *parse)
    1064 {
    1065         stree_break_t *break_s;
    1066 
    1067 #ifdef DEBUG_PARSE_TRACE
    1068         printf("Parse 'break' statement.\n");
    1069 #endif
    1070         break_s = stree_break_new();
    1071 
    1072         lmatch(parse, lc_break);
    1073         lmatch(parse, lc_scolon);
    1074 
    1075         return break_s;
    1076 }
    1077 
    1078869/** Parse @c return statement.
    1079870 *
    … …  
    1091882
    1092883        lmatch(parse, lc_return);
    1093 
    1094         if (lcur_lc(parse) != lc_scolon)
    1095                 return_s->expr = parse_expr(parse);
    1096 
     884        return_s->expr = parse_expr(parse);
    1097885        lmatch(parse, lc_scolon);
    1098886
    … …  
    1208996        ident = stree_ident_new();
    1209997        ident->sid = lcur(parse)->u.ident.sid;
    1210         ident->cspan = lcur_span(parse);
    1211998        lskip(parse);
    1212999
    … …  
    12721059/** Return current lem lclass.
    12731060 *
    1274  * @param parse         Parser object
    1275  * @return              Lclass of the current lem
     1061 * @param parse         Parser object.
     1062 * @return              Lclass of the current lem.
    12761063 */
    12771064lclass_t lcur_lc(parse_t *parse)
    … …  
    12941081}
    12951082
    1296 /** Return coordinate span of current lem.
    1297  *
    1298  * @param parse         Parser object
    1299  * @return              Coordinate span of current lem or @c NULL if a
    1300  *                      parse error is active
    1301  */
    1302 cspan_t *lcur_span(parse_t *parse)
    1303 {
    1304         lem_t *lem;
    1305 
    1306         if (parse_is_error(parse))
    1307                 return NULL;
    1308 
    1309         lem = lcur(parse);
    1310         return lem->cspan;
    1311 }
    1312 
    1313 /** Return coordinate span of previous lem.
    1314  *
    1315  * @param parse         Parser object
    1316  * @return              Coordinate span of previous lem or @c NULL if
    1317  *                      parse error is active or previous lem is not
    1318  *                      available.
    1319  */
    1320 cspan_t *lprev_span(parse_t *parse)
    1321 {
    1322         lem_t *lem;
    1323 
    1324         if (parse_is_error(parse))
    1325                 return NULL;
    1326 
    1327         lem = lex_peek_prev(parse->lex);
    1328         if (lem == NULL)
    1329                 return NULL;
    1330 
    1331         return lem->cspan;
    1332 }
    1333 
    13341083/** Skip to next lem.
    13351084 *
    … …  
    14211170{
    14221171        switch (lclass) {
    1423         case lc_elif:
    14241172        case lc_else:
    14251173        case lc_end:

  • uspace/app/sbi/src/parse.h

    r640ffe6 r1317380  
    4848lem_t *lcur(parse_t *parse);
    4949lclass_t lcur_lc(parse_t *parse);
    50 cspan_t *lcur_span(parse_t *parse);
    51 cspan_t *lprev_span(parse_t *parse);
    52 
    5350void lskip(parse_t *parse);
    5451void lcheck(parse_t *parse, lclass_t lc);

  • uspace/app/sbi/src/rdata.c

    r640ffe6 r1317380  
    5252#include "stree.h"
    5353#include "symbol.h"
    54 #include "strtab.h"
    5554
    5655#include "rdata.h"
    … …  
    6261static void rdata_ref_copy(rdata_ref_t *src, rdata_ref_t **dest);
    6362static void rdata_deleg_copy(rdata_deleg_t *src, rdata_deleg_t **dest);
    64 static void rdata_enum_copy(rdata_enum_t *src, rdata_enum_t **dest);
    6563static void rdata_array_copy(rdata_array_t *src, rdata_array_t **dest);
    6664static void rdata_object_copy(rdata_object_t *src, rdata_object_t **dest);
    6765static void rdata_resource_copy(rdata_resource_t *src,
    6866    rdata_resource_t **dest);
    69 static void rdata_symbol_copy(rdata_symbol_t *src, rdata_symbol_t **dest);
    7067
    7168static int rdata_array_get_dim(rdata_array_t *array);
    … …  
    250247
    251248        return deleg;
    252 }
    253 
    254 /** Allocate new enum value.
    255  *
    256  * @return      New enum value.
    257  */
    258 rdata_enum_t *rdata_enum_new(void)
    259 {
    260         rdata_enum_t *enum_v;
    261 
    262         enum_v = calloc(1, sizeof(rdata_enum_t));
    263         if (enum_v == NULL) {
    264                 printf("Memory allocation failed.\n");
    265                 exit(1);
    266         }
    267 
    268         return enum_v;
    269249}
    270250
    … …  
    393373
    394374        return resource_v;
    395 }
    396 
    397 /** Allocate new symbol reference.
    398  *
    399  * @return      New symbol reference.
    400  */
    401 rdata_symbol_t *rdata_symbol_new(void)
    402 {
    403         rdata_symbol_t *symbol_v;
    404 
    405         symbol_v = calloc(1, sizeof(rdata_symbol_t));
    406         if (symbol_v == NULL) {
    407                 printf("Memory allocation failed.\n");
    408                 exit(1);
    409         }
    410 
    411         return symbol_v;
    412375}
    413376
    … …  
    490453                rdata_deleg_copy(src->u.deleg_v, &nvar->u.deleg_v);
    491454                break;
    492         case vc_enum:
    493                 rdata_enum_copy(src->u.enum_v, &nvar->u.enum_v);
    494                 break;
    495455        case vc_array:
    496456                rdata_array_copy(src->u.array_v, &nvar->u.array_v);
    … …  
    501461        case vc_resource:
    502462                rdata_resource_copy(src->u.resource_v, &nvar->u.resource_v);
    503                 break;
    504         case vc_symbol:
    505                 rdata_symbol_copy(src->u.symbol_v, &nvar->u.symbol_v);
    506463                break;
    507464        }
    … …  
    577534}
    578535
    579 /** Copy enum value.
    580  *
    581  * @param src           Source enum value.
    582  * @param dest          Place to store pointer to new enum value.
    583  */
    584 static void rdata_enum_copy(rdata_enum_t *src, rdata_enum_t **dest)
    585 {
    586         *dest = rdata_enum_new();
    587         (*dest)->value = src->value;
    588 }
    589 
    590536/** Copy array.
    591537 *
    … …  
    621567        *dest = rdata_resource_new();
    622568        (*dest)->data = src->data;
    623 }
    624 
    625 /** Copy symbol.
    626  *
    627  * @param src           Source symbol.
    628  * @param dest          Place to store pointer to new symbol.
    629  */
    630 static void rdata_symbol_copy(rdata_symbol_t *src, rdata_symbol_t **dest)
    631 {
    632         *dest = rdata_symbol_new();
    633         (*dest)->sym = src->sym;
    634569}
    635570
    … …  
    686621        case vc_ref: var->u.ref_v = nvar->u.ref_v; break;
    687622        case vc_deleg: var->u.deleg_v = nvar->u.deleg_v; break;
    688         case vc_enum: var->u.enum_v = nvar->u.enum_v; break;
    689623        case vc_array: var->u.array_v = nvar->u.array_v; break;
    690624        case vc_object: var->u.object_v = nvar->u.object_v; break;
    691625        case vc_resource: var->u.resource_v = nvar->u.resource_v; break;
    692         case vc_symbol: var->u.symbol_v = nvar->u.symbol_v; break;
    693626        }
    694627
    … …  
    799732                printf(")");
    800733                break;
    801         case vc_enum:
    802                 symbol_print_fqn(
    803                     enum_to_symbol(var->u.enum_v->value->outer_enum));
    804                 printf(".%s",
    805                     strtab_get_str(var->u.enum_v->value->name->sid));
    806                 break;
    807734        case vc_array:
    808735                printf("array");
    … …  
    814741                printf("resource(%p)", var->u.resource_v->data);
    815742                break;
    816         case vc_symbol:
    817                 printf("symbol(");
    818                 if (var->u.symbol_v->sym != NULL) {
    819                         symbol_print_fqn(var->u.symbol_v->sym);
    820                 } else {
    821                         printf("nil");
    822                 }
    823                 printf(")");
    824                 break;
    825         }
    826 }
     743        }
     744}

  • uspace/app/sbi/src/rdata.h

    r640ffe6 r1317380  
    4343rdata_ref_t *rdata_ref_new(void);
    4444rdata_deleg_t *rdata_deleg_new(void);
    45 rdata_enum_t *rdata_enum_new(void);
    4645rdata_array_t *rdata_array_new(int rank);
    4746rdata_object_t *rdata_object_new(void);
    … …  
    5150rdata_string_t *rdata_string_new(void);
    5251rdata_resource_t *rdata_resource_new(void);
    53 rdata_symbol_t *rdata_symbol_new(void);
    5452
    5553void rdata_array_alloc_element(rdata_array_t *array);

  • uspace/app/sbi/src/rdata_t.h

    r640ffe6 r1317380  
    8282} rdata_deleg_t;
    8383
    84 /** Enumerated type value. */
    85 typedef struct {
    86         /** Enum member declaration */
    87         struct stree_embr *value;
    88 } rdata_enum_t;
    89 
    9084/** Array variable */
    9185typedef struct {
    … …  
    122116} rdata_resource_t;
    123117
    124 /** Symbol reference variable
    125  *
    126  * A symbol reference points to a program symbol.
    127  */
    128 typedef struct {
    129         /** Program symbol. */
    130         struct stree_symbol *sym;
    131 } rdata_symbol_t;
    132 
    133118typedef enum var_class {
    134119        /** Boolean */
    … …  
    150135        vc_deleg,
    151136
    152         /** Enumerated type value */
    153         vc_enum,
    154 
    155137        /** Array */
    156138        vc_array,
    … …  
    160142
    161143        /** Interpreter builtin resource */
    162         vc_resource,
    163 
    164         /** Symbol reference */
    165         vc_symbol
     144        vc_resource
    166145} var_class_t;
    167146
    … …  
    182161                rdata_ref_t *ref_v;
    183162                rdata_deleg_t *deleg_v;
    184                 rdata_enum_t *enum_v;
    185163                rdata_array_t *array_v;
    186164                rdata_object_t *object_v;
    187165                rdata_resource_t *resource_v;
    188                 rdata_symbol_t *symbol_v;
    189166        } u;
    190167} rdata_var_t;

  • uspace/app/sbi/src/run.c

    r640ffe6 r1317380  
    3434#include "bigint.h"
    3535#include "builtin.h"
    36 #include "cspan.h"
    3736#include "debug.h"
    3837#include "intmap.h"
    … …  
    5554static void run_while(run_t *run, stree_while_t *while_s);
    5655static void run_raise(run_t *run, stree_raise_t *raise_s);
    57 static void run_break(run_t *run, stree_break_t *break_s);
    5856static void run_return(run_t *run, stree_return_t *return_s);
    5957static void run_wef(run_t *run, stree_wef_t *wef_s);
    … …  
    7371static void run_var_new_null_ref(run_t *run, rdata_var_t **rvar);
    7472static void run_var_new_deleg(run_t *run, rdata_var_t **rvar);
    75 static void run_var_new_enum(run_t *run, tdata_enum_t *tenum,
    76     rdata_var_t **rvar);
     73
    7774
    7875/** Initialize runner instance.
    … …  
    180177        switch (run->thread_ar->bo_mode) {
    181178        case bm_stat:
    182                 /* Break bailout was not caught. */
    183                 assert(b_false);
     179                printf("Error: Misplaced 'break' statement.\n");
     180                exit(1);
    184181        case bm_proc:
    185182                run->thread_ar->bo_mode = bm_none;
    … …  
    286283                run_raise(run, stat->u.raise_s);
    287284                break;
    288         case st_break:
    289                 run_break(run, stat->u.break_s);
    290                 break;
    291285        case st_return:
    292286                run_return(run, stat->u.return_s);
    … …  
    298292                printf("Ignoring unimplemented statement type %d.\n", stat->sc);
    299293                break;
     294        default:
     295                assert(b_false);
    300296        }
    301297}
    … …  
    368364{
    369365        rdata_item_t *rcond;
    370         list_node_t *ifc_node;
    371         stree_if_clause_t *ifc;
    372         bool_t clause_fired;
    373366
    374367#ifdef DEBUG_RUN_TRACE
    375368        printf("Executing if statement.\n");
    376369#endif
    377         clause_fired = b_false;
    378         ifc_node = list_first(&if_s->if_clauses);
    379 
    380         /* Walk through all if/elif clauses and see if they fire. */
    381 
    382         while (ifc_node != NULL) {
    383                 /* Get if/elif clause */
    384                 ifc = list_node_data(ifc_node, stree_if_clause_t *);
    385 
    386                 run_expr(run, ifc->cond, &rcond);
    387                 if (run_is_bo(run))
    388                         return;
    389 
    390                 if (run_item_boolean_value(run, rcond) == b_true) {
    391 #ifdef DEBUG_RUN_TRACE
    392                         printf("Taking non-default path.\n");
    393 #endif
    394                         run_block(run, ifc->block);
    395                         clause_fired = b_true;
    396                         break;
    397                 }
    398 
    399                 ifc_node = list_next(&if_s->if_clauses, ifc_node);
    400         }
    401 
    402         /* If no if/elif clause fired, invoke the else clause. */
    403         if (clause_fired == b_false && if_s->else_block != NULL) {
    404 #ifdef DEBUG_RUN_TRACE
    405                 printf("Taking default path.\n");
    406 #endif
    407                 run_block(run, if_s->else_block);
     370        run_expr(run, if_s->cond, &rcond);
     371        if (run_is_bo(run))
     372                return;
     373
     374        if (run_item_boolean_value(run, rcond) == b_true) {
     375#ifdef DEBUG_RUN_TRACE
     376                printf("Taking true path.\n");
     377#endif
     378                run_block(run, if_s->if_block);
     379        } else {
     380#ifdef DEBUG_RUN_TRACE
     381                printf("Taking false path.\n");
     382#endif
     383                if (if_s->else_block != NULL)
     384                        run_block(run, if_s->else_block);
    408385        }
    409386
    … …  
    433410                run_expr(run, while_s->cond, &rcond);
    434411                if (run_is_bo(run))
     412                        return;
     413
     414                if (run->thread_ar->bo_mode != bm_none)
    435415                        break;
    436         }
    437 
    438         if (run->thread_ar->bo_mode == bm_stat) {
    439                 /* Bailout due to break statement */
    440                 run->thread_ar->bo_mode = bm_none;
    441416        }
    442417
    … …  
    465440        run_cvt_value_item(run, rexpr, &rexpr_vi);
    466441
    467         /* Store expression cspan in thread AR. */
    468         run->thread_ar->exc_cspan = raise_s->expr->cspan;
    469 
    470442        /* Store expression result in thread AR. */
    471443        run->thread_ar->exc_payload = rexpr_vi->u.value;
    … …  
    475447}
    476448
    477 /** Run @c break statement.
    478  *
    479  * Forces control to return from the active breakable statement by setting
    480  * bailout mode to @c bm_stat.
    481  *
    482  * @param run           Runner object
    483  * @param break_s       Break statement to run
    484  */
    485 static void run_break(run_t *run, stree_break_t *break_s)
    486 {
    487 #ifdef DEBUG_RUN_TRACE
    488         printf("Executing 'break' statement.\n");
    489 #endif
    490         (void) break_s;
    491 
    492         /* Force control to ascend and leave the procedure. */
    493         if (run->thread_ar->bo_mode == bm_none)
    494                 run->thread_ar->bo_mode = bm_stat;
    495 }
    496 
    497449/** Run @c return statement.
    498450 *
    … …  
    501453 *
    502454 * @param run           Runner object
    503  * @param return_s      Return statement to run
     455 * @param raise_s       Return statement to run
    504456 */
    505457static void run_return(run_t *run, stree_return_t *return_s)
    … …  
    512464        printf("Executing return statement.\n");
    513465#endif
    514         if (return_s->expr != NULL) {
    515                 run_expr(run, return_s->expr, &rexpr);
    516                 if (run_is_bo(run))
    517                         return;
    518 
    519                 run_cvt_value_item(run, rexpr, &rexpr_vi);
    520 
    521                 /* Store expression result in procedure AR. */
    522                 proc_ar = run_get_current_proc_ar(run);
    523                 proc_ar->retval = rexpr_vi;
    524         }
     466        run_expr(run, return_s->expr, &rexpr);
     467        if (run_is_bo(run))
     468                return;
     469
     470        run_cvt_value_item(run, rexpr, &rexpr_vi);
     471
     472        /* Store expression result in procedure AR. */
     473        proc_ar = run_get_current_proc_ar(run);
     474        proc_ar->retval = rexpr_vi;
    525475
    526476        /* Force control to ascend and leave the procedure. */
    … …  
    682632                exc_csi = run_exc_payload_get_csi(run);
    683633
    684                 if (run->thread_ar->exc_cspan != NULL) {
    685                         cspan_print(run->thread_ar->exc_cspan);
    686                         putchar(' ');
    687                 }
    688 
    689634                printf("Error: Unhandled exception '");
    690635                symbol_print_fqn(csi_to_symbol(exc_csi));
    … …  
    804749        rdata_char_t *char_v;
    805750        rdata_deleg_t *deleg_v;
    806         rdata_enum_t *enum_v;
    807751        rdata_int_t *int_v;
    808752        rdata_string_t *string_v;
    … …  
    836780                deleg_v->obj = item->u.value->var->u.deleg_v->obj;
    837781                deleg_v->sym = item->u.value->var->u.deleg_v->sym;
    838                 break;
    839         case vc_enum:
    840                 *var = rdata_var_new(vc_enum);
    841                 enum_v = rdata_enum_new();
    842 
    843                 (*var)->u.enum_v = enum_v;
    844                 enum_v->value = item->u.value->var->u.enum_v->value;
    845782                break;
    846783        case vc_int:
    … …  
    917854void run_proc_ar_set_args(run_t *run, run_proc_ar_t *proc_ar, list_t *arg_vals)
    918855{
    919         stree_ctor_t *ctor;
    920856        stree_fun_t *fun;
    921857        stree_prop_t *prop;
    … …  
    942878        outer_symbol = proc_ar->proc->outer_symbol;
    943879
    944         /* Make compiler happy. */
    945         args = NULL;
    946         varg = NULL;
    947 
    948880        /*
    949881         * The procedure being activated should belong to a member function or
    … …  
    951883         */
    952884        switch (outer_symbol->sc) {
    953         case sc_ctor:
    954                 ctor = symbol_to_ctor(outer_symbol);
    955                 args = &ctor->sig->args;
    956                 varg = ctor->sig->varg;
    957                 break;
    958885        case sc_fun:
    959886                fun = symbol_to_fun(outer_symbol);
    … …  
    966893                varg = prop->varg;
    967894                break;
    968         case sc_csi:
    969         case sc_deleg:
    970         case sc_enum:
    971         case sc_var:
     895        default:
    972896                assert(b_false);
    973897        }
    … …  
    14531377 * @param run           Runner object
    14541378 * @param ref           Reference
    1455  * @param cspan         Cspan to put into exception if reference is nil
    1456  *                      or @c NULL if no cspan is provided.
    14571379 * @param rtitem        Place to store pointer to the resulting address.
    14581380 */
    1459 void run_dereference(run_t *run, rdata_item_t *ref, cspan_t *cspan,
    1460     rdata_item_t **ritem)
     1381void run_dereference(run_t *run, rdata_item_t *ref, rdata_item_t **ritem)
    14611382{
    14621383        rdata_item_t *ref_val;
    … …  
    14831404#endif
    14841405                /* Raise Error.NilReference */
    1485                 run_raise_exc(run, run->program->builtin->error_nilreference,
    1486                     cspan);
     1406                run_raise_exc(run, run->program->builtin->error_nilreference);
    14871407                *ritem = run_recovery_item(run);
    14881408                return;
    … …  
    15021422 * @param run           Runner object
    15031423 * @param csi           Exception class
    1504  * @param cspan         Cspan of code that caused exception (for debugging)
    1505  */
    1506 void run_raise_exc(run_t *run, stree_csi_t *csi, cspan_t *cspan)
     1424 */
     1425void run_raise_exc(run_t *run, stree_csi_t *csi)
    15071426{
    15081427        rdata_item_t *exc_vi;
    1509 
    1510         /* Store exception cspan in thread AR. */
    1511         run->thread_ar->exc_cspan = cspan;
    15121428
    15131429        /* Create exception object. */
    … …  
    15561472                break;
    15571473        case tic_tdeleg:
    1558                 run_var_new_deleg(run, rvar);
    1559                 break;
    1560         case tic_tebase:
    1561                 /*
    1562                  * One cannot declare variable of ebase type. It is just
    1563                  * type of expressions referring to enum types.
    1564                  */
    1565                 assert(b_false);
    1566         case tic_tenum:
    1567                 run_var_new_enum(run, ti->u.tenum, rvar);
    1568                 break;
    15691474        case tic_tfun:
    15701475                run_var_new_deleg(run, rvar);
    … …  
    16731578}
    16741579
    1675 /** Construct a new variable containing default value of an enum type.
    1676  *
    1677  * @param run           Runner object
    1678  * @param rvar          Place to store pointer to new variable
    1679  */
    1680 static void run_var_new_enum(run_t *run, tdata_enum_t *tenum,
    1681     rdata_var_t **rvar)
    1682 {
    1683         rdata_var_t *var;
    1684         list_node_t *embr_n;
    1685         stree_embr_t *embr;
    1686 
    1687         (void) run;
    1688 
    1689         /* Get first member of enum which will serve as default value. */
    1690         embr_n = list_first(&tenum->enum_d->members);
    1691         assert(embr_n != NULL);
    1692 
    1693         embr = list_node_data(embr_n, stree_embr_t *);
    1694 
    1695         /* Return null reference. */
    1696         var = rdata_var_new(vc_enum);
    1697         var->u.enum_v = rdata_enum_new();
    1698         var->u.enum_v->value = embr;
    1699 
    1700         *rvar = var;
    1701 }
    1702 
    17031580/** Construct a new thread activation record.
    17041581 *

  • uspace/app/sbi/src/run.h

    r640ffe6 r1317380  
    6363    rdata_value_t *value);
    6464void run_reference(run_t *run, rdata_var_t *var, rdata_item_t **res);
    65 void run_dereference(run_t *run, rdata_item_t *ref, cspan_t *cspan,
    66     rdata_item_t **ritem);
     65void run_dereference(run_t *run, rdata_item_t *ref, rdata_item_t **ritem);
    6766
    68 void run_raise_exc(run_t *run, stree_csi_t *csi, cspan_t *cspan);
     67void run_raise_exc(run_t *run, stree_csi_t *csi);
    6968bool_t run_is_bo(run_t *run);
    7069

  • uspace/app/sbi/src/run_expr.c

    r640ffe6 r1317380  
    7878static void run_binop_ref(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    7979    rdata_value_t *v2, rdata_item_t **res);
    80 static void run_binop_enum(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    81     rdata_value_t *v2, rdata_item_t **res);
    8280
    8381static void run_unop(run_t *run, stree_unop_t *unop, rdata_item_t **res);
    84 static void run_unop_bool(run_t *run, stree_unop_t *unop, rdata_value_t *val,
    85     rdata_item_t **res);
    8682static void run_unop_int(run_t *run, stree_unop_t *unop, rdata_value_t *val,
    8783    rdata_item_t **res);
    … …  
    9288static void run_new_object(run_t *run, stree_new_t *new_op,
    9389    tdata_item_t *titem, rdata_item_t **res);
    94 
    95 static void run_object_ctor(run_t *run, rdata_var_t *obj, list_t *arg_vals);
    9690
    9791static void run_access(run_t *run, stree_access_t *access, rdata_item_t **res);
    … …  
    10498static void run_access_object(run_t *run, stree_access_t *access,
    10599    rdata_item_t *arg, rdata_item_t **res);
    106 static void run_access_symbol(run_t *run, stree_access_t *access,
    107     rdata_item_t *arg, rdata_item_t **res);
    108100
    109101static void run_call(run_t *run, stree_call_t *call, rdata_item_t **res);
    110 static void run_call_args(run_t *run, list_t *args, list_t *arg_vals);
    111 
    112102static void run_index(run_t *run, stree_index_t *index, rdata_item_t **res);
    113103static void run_index_array(run_t *run, stree_index_t *index,
    … …  
    199189        rdata_var_t *var;
    200190        rdata_deleg_t *deleg_v;
    201         rdata_symbol_t *symbol_v;
    202191
    203192        run_proc_ar_t *proc_ar;
    … …  
    257246        case sc_csi:
    258247#ifdef DEBUG_RUN_TRACE
    259                 printf("Referencing CSI.\n");
     248                printf("Referencing class.\n");
    260249#endif
    261250                item = rdata_item_new(ic_value);
    … …  
    271260                deleg_v->sym = sym;
    272261                *res = item;
    273                 break;
    274         case sc_ctor:
    275                 /* It is not possible to reference a constructor explicitly. */
    276                 assert(b_false);
    277         case sc_enum:
    278 #ifdef DEBUG_RUN_TRACE
    279                 printf("Referencing enum.\n");
    280 #endif
    281                 item = rdata_item_new(ic_value);
    282                 value = rdata_value_new();
    283                 var = rdata_var_new(vc_symbol);
    284                 symbol_v = rdata_symbol_new();
    285 
    286                 item->u.value = value;
    287                 value->var = var;
    288                 var->u.symbol_v = symbol_v;
    289 
    290                 symbol_v->sym = sym;
    291                 *res = item;
    292                 break;
    293         case sc_deleg:
    294                 /* XXX TODO */
    295                 printf("Unimplemented: Delegate name reference.\n");
    296                 abort();
    297262                break;
    298263        case sc_fun:
    … …  
    364329                *res = item;
    365330                break;
    366         case sc_prop:
    367                 /* XXX TODO */
    368                 printf("Unimplemented: Property name reference.\n");
    369                 abort();
     331        default:
     332                printf("Referencing symbol class %d unimplemented.\n", sym->sc);
     333                *res = NULL;
    370334                break;
    371335        }
    … …  
    607571        }
    608572
     573        switch (binop->bc) {
     574        case bo_plus:
     575        case bo_minus:
     576        case bo_mult:
     577        case bo_equal:
     578        case bo_notequal:
     579        case bo_lt:
     580        case bo_gt:
     581        case bo_lt_equal:
     582        case bo_gt_equal:
     583                /* These are implemented so far. */
     584                break;
     585        default:
     586                printf("Unimplemented: Binary operation type %d.\n",
     587                    binop->bc);
     588                exit(1);
     589        }
     590
    609591#ifdef DEBUG_RUN_TRACE
    610592        printf("Check binop argument results.\n");
    … …  
    639621                run_binop_ref(run, binop, v1, v2, res);
    640622                break;
    641         case vc_enum:
    642                 run_binop_enum(run, binop, v1, v2, res);
    643                 break;
    644623        case vc_deleg:
    645624        case vc_array:
    646625        case vc_object:
    647626        case vc_resource:
    648         case vc_symbol:
    649627                assert(b_false);
    650628        }
    … …  
    707685                bool_v->value = (b1 == b_true) || (b2 == b_false);
    708686                break;
    709 
    710         case bo_and:
    711                 bool_v->value = (b1 == b_true) && (b2 == b_true);
    712                 break;
    713         case bo_or:
    714                 bool_v->value = (b1 == b_true) || (b2 == b_true);
    715                 break;
    716687        }
    717688
    … …  
    782753                bool_v->value = !nf;
    783754                break;
    784 
    785         case bo_and:
    786         case bo_or:
     755        default:
    787756                assert(b_false);
    788757        }
    … …  
    863832
    864833        switch (binop->bc) {
    865         case bo_plus:
    866         case bo_minus:
    867         case bo_mult:
    868                 assert(b_false);
    869 
    870834        case bo_equal:
    871835                bool_v->value = zf;
    … …  
    886850                bool_v->value = !nf;
    887851                break;
    888         case bo_and:
    889         case bo_or:
     852        default:
    890853                assert(b_false);
    891854        }
    … …  
    909872        rdata_var_t *var;
    910873        rdata_string_t *string_v;
    911         rdata_bool_t *bool_v;
    912         bool_t done;
    913         bool_t zf;
    914874
    915875        const char *s1, *s2;
    … …  
    919879        item = rdata_item_new(ic_value);
    920880        value = rdata_value_new();
     881        var = rdata_var_new(vc_string);
     882        string_v = rdata_string_new();
    921883
    922884        item->u.value = value;
     885        value->var = var;
     886        var->u.string_v = string_v;
    923887
    924888        s1 = v1->var->u.string_v->value;
    925889        s2 = v2->var->u.string_v->value;
    926 
    927         done = b_true;
    928890
    929891        switch (binop->bc) {
    930892        case bo_plus:
    931893                /* Concatenate strings. */
    932                 string_v = rdata_string_new();
    933894                string_v->value = os_str_acat(s1, s2);
    934                 break;
    935         default:
    936                 done = b_false;
    937                 break;
    938         }
    939 
    940         if (done) {
    941                 var = rdata_var_new(vc_string);
    942                 var->u.string_v = string_v;
    943                 value->var = var;
    944                 *res = item;
    945                 return;
    946         }
    947 
    948         var = rdata_var_new(vc_bool);
    949         bool_v = rdata_bool_new();
    950         var->u.bool_v = bool_v;
    951         value->var = var;
    952 
    953         /* Relational operation. */
    954 
    955         zf = os_str_cmp(s1, s2) == 0;
    956 
    957         switch (binop->bc) {
    958         case bo_equal:
    959                 bool_v->value = zf;
    960                 break;
    961         case bo_notequal:
    962                 bool_v->value = !zf;
    963895                break;
    964896        default:
    … …  
    1019951}
    1020952
    1021 /** Evaluate binary operation on enum arguments.
    1022  *
    1023  * @param run           Runner object
    1024  * @param binop         Binary operation
    1025  * @param v1            Value of first argument
    1026  * @param v2            Value of second argument
    1027  * @param res           Place to store result
    1028  */
    1029 static void run_binop_enum(run_t *run, stree_binop_t *binop, rdata_value_t *v1,
    1030     rdata_value_t *v2, rdata_item_t **res)
    1031 {
    1032         rdata_item_t *item;
    1033         rdata_value_t *value;
    1034         rdata_var_t *var;
    1035         rdata_bool_t *bool_v;
    1036 
    1037         rdata_var_t *ref1, *ref2;
    1038 
    1039         (void) run;
    1040 
    1041         item = rdata_item_new(ic_value);
    1042         value = rdata_value_new();
    1043         var = rdata_var_new(vc_bool);
    1044         bool_v = rdata_bool_new();
    1045 
    1046         item->u.value = value;
    1047         value->var = var;
    1048         var->u.bool_v = bool_v;
    1049 
    1050         ref1 = v1->var->u.ref_v->vref;
    1051         ref2 = v2->var->u.ref_v->vref;
    1052 
    1053         switch (binop->bc) {
    1054         case bo_equal:
    1055                 bool_v->value = (ref1 == ref2);
    1056                 break;
    1057         case bo_notequal:
    1058                 bool_v->value = (ref1 != ref2);
    1059                 break;
    1060         default:
    1061                 /* Should have been caught by static typing. */
    1062                 assert(b_false);
    1063         }
    1064 
    1065         *res = item;
    1066 }
    1067953
    1068954/** Evaluate unary operation.
    … …  
    1095981
    1096982        switch (val->var->vc) {
    1097         case vc_bool:
    1098                 run_unop_bool(run, unop, val, res);
    1099                 break;
    1100983        case vc_int:
    1101984                run_unop_int(run, unop, val, res);
    … …  
    1110993}
    1111994
    1112 /** Evaluate unary operation on bool argument.
    1113  *
    1114  * @param run           Runner object
    1115  * @param unop          Unary operation
    1116  * @param val           Value of argument
    1117  * @param res           Place to store result
    1118  */
    1119 static void run_unop_bool(run_t *run, stree_unop_t *unop, rdata_value_t *val,
    1120     rdata_item_t **res)
    1121 {
    1122         rdata_item_t *item;
    1123         rdata_value_t *value;
    1124         rdata_var_t *var;
    1125         rdata_bool_t *bool_v;
    1126 
    1127         (void) run;
    1128 
    1129         item = rdata_item_new(ic_value);
    1130         value = rdata_value_new();
    1131         var = rdata_var_new(vc_bool);
    1132         bool_v = rdata_bool_new();
    1133 
    1134         item->u.value = value;
    1135         value->var = var;
    1136         var->u.bool_v = bool_v;
    1137 
    1138         switch (unop->uc) {
    1139         case uo_plus:
    1140         case uo_minus:
    1141                 assert(b_false);
    1142 
    1143         case uo_not:
    1144                 bool_v->value = !val->var->u.bool_v->value;
    1145                 break;
    1146         }
    1147 
    1148         *res = item;
    1149 }
    1150 
    1151995/** Evaluate unary operation on int argument.
    1152996 *
    … …  
    11831027                    &int_v->value);
    11841028                break;
    1185         case uo_not:
    1186                 assert(b_false);
    11871029        }
    11881030
    11891031        *res = item;
    11901032}
     1033
    11911034
    11921035/** Evaluate @c new operation.
    … …  
    13431186{
    13441187        stree_csi_t *csi;
    1345         rdata_item_t *obj_i;
    1346         list_t arg_vals;
    13471188
    13481189#ifdef DEBUG_RUN_TRACE
    13491190        printf("Create new object.\n");
    13501191#endif
     1192        (void) new_op;
     1193
    13511194        /* Lookup object CSI. */
    13521195        assert(titem->tic == tic_tobject);
    13531196        csi = titem->u.tobject->csi;
    13541197
    1355         /* Evaluate constructor arguments. */
    1356         run_call_args(run, &new_op->ctor_args, &arg_vals);
    1357         if (run_is_bo(run)) {
    1358                 *res = NULL;
    1359                 return;
    1360         }
    1361 
    13621198        /* Create CSI instance. */
    13631199        run_new_csi_inst(run, csi, res);
    1364 
    1365         /* Run the constructor. */
    1366         run_dereference(run, *res, NULL, &obj_i);
    1367         assert(obj_i->ic == ic_address);
    1368         assert(obj_i->u.address->ac == ac_var);
    1369         run_object_ctor(run, obj_i->u.address->u.var_a->vref, &arg_vals);
    13701200}
    13711201
    … …  
    14261256                run_access_object(run, access, arg, res);
    14271257                break;
    1428         case vc_symbol:
    1429                 run_access_symbol(run, access, arg, res);
    1430                 break;
    1431 
    1432         case vc_bool:
    1433         case vc_char:
    1434         case vc_enum:
    1435         case vc_int:
    1436         case vc_string:
    1437         case vc_array:
    1438         case vc_resource:
     1258        default:
    14391259                printf("Unimplemented: Using access operator ('.') "
    14401260                    "with unsupported data type (value/%d).\n", vc);
    … …  
    14561276
    14571277        /* Implicitly dereference. */
    1458         run_dereference(run, arg, access->arg->cspan, &darg);
     1278        run_dereference(run, arg, &darg);
    14591279
    14601280        if (run->thread_ar->bo_mode != bm_none) {
    … …  
    15761396                printf("Error: Accessing object member which is a delegate.\n");
    15771397                exit(1);
    1578         case sc_enum:
    1579                 printf("Error: Accessing object member which is an enum.\n");
    1580                 exit(1);
    1581         case sc_ctor:
    1582                 /* It is not possible to reference a constructor explicitly. */
    1583                 assert(b_false);
    15841398        case sc_fun:
    15851399                /* Construct anonymous delegate. */
    … …  
    16281442}
    16291443
    1630 /** Evaluate symbol member acccess.
    1631  *
    1632  * @param run           Runner object
    1633  * @param access        Access operation
    1634  * @param arg           Evaluated base expression
    1635  * @param res           Place to store result
    1636  */
    1637 static void run_access_symbol(run_t *run, stree_access_t *access,
    1638     rdata_item_t *arg, rdata_item_t **res)
    1639 {
    1640         rdata_item_t *arg_vi;
    1641         rdata_value_t *arg_val;
    1642         rdata_symbol_t *symbol_v;
    1643         stree_embr_t *embr;
    1644 
    1645         rdata_item_t *ritem;
    1646         rdata_value_t *rvalue;
    1647         rdata_var_t *rvar;
    1648         rdata_enum_t *enum_v;
    1649 
    1650 #ifdef DEBUG_RUN_TRACE
    1651         printf("Run symbol access operation.\n");
    1652 #endif
    1653         run_cvt_value_item(run, arg, &arg_vi);
    1654         arg_val = arg_vi->u.value;
    1655         assert(arg_val->var->vc == vc_symbol);
    1656 
    1657         symbol_v = arg_val->var->u.symbol_v;
    1658 
    1659         /* XXX Port CSI symbol reference to using vc_symbol */
    1660         assert(symbol_v->sym->sc == sc_enum);
    1661 
    1662         embr = stree_enum_find_mbr(symbol_v->sym->u.enum_d,
    1663             access->member_name);
    1664 
    1665         /* Member existence should be ensured by static type checking. */
    1666         assert(embr != NULL);
    1667 
    1668 #ifdef DEBUG_RUN_TRACE
    1669         printf("Found enum member '%s'.\n",
    1670             strtab_get_str(access->member_name->sid));
    1671 #endif
    1672         ritem = rdata_item_new(ic_value);
    1673         rvalue = rdata_value_new();
    1674         rvar = rdata_var_new(vc_enum);
    1675         enum_v = rdata_enum_new();
    1676 
    1677         ritem->u.value = rvalue;
    1678         rvalue->var = rvar;
    1679         rvar->u.enum_v = enum_v;
    1680         enum_v->value = embr;
    1681 
    1682         *res = ritem;
    1683 }
    1684 
    16851444/** Call a function.
    16861445 *
    … …  
    16961455        rdata_deleg_t *deleg_v;
    16971456        list_t arg_vals;
     1457        list_node_t *node;
     1458        stree_expr_t *arg;
     1459        rdata_item_t *rarg_i, *rarg_vi;
    16981460
    16991461        stree_fun_t *fun;
    … …  
    17371499#endif
    17381500        /* Evaluate function arguments. */
    1739         run_call_args(run, &call->args, &arg_vals);
    1740         if (run_is_bo(run)) {
    1741                 *res = NULL;
    1742                 return;
     1501        list_init(&arg_vals);
     1502        node = list_first(&call->args);
     1503
     1504        while (node != NULL) {
     1505                arg = list_node_data(node, stree_expr_t *);
     1506                run_expr(run, arg, &rarg_i);
     1507                if (run_is_bo(run)) {
     1508                        *res = NULL;
     1509                        return;
     1510                }
     1511
     1512                run_cvt_value_item(run, rarg_i, &rarg_vi);
     1513
     1514                list_append(&arg_vals, rarg_vi);
     1515                node = list_next(&call->args, node);
    17431516        }
    17441517
    … …  
    17551528        run_proc(run, proc_ar, res);
    17561529
    1757         if (!run_is_bo(run) && fun->sig->rtype != NULL && *res == NULL) {
    1758                 printf("Error: Function '");
    1759                 symbol_print_fqn(deleg_v->sym);
    1760                 printf("' did not return a value.\n");
    1761                 exit(1);
    1762         }
    1763 
    17641530#ifdef DEBUG_RUN_TRACE
    17651531        printf("Returned from function call.\n");
    17661532#endif
    1767 }
    1768 
    1769 /** Evaluate call arguments.
    1770  *
    1771  * Evaluate arguments to function or constructor.
    1772  *
    1773  * @param run           Runner object
    1774  * @param args          Real arguments (list of stree_expr_t)
    1775  * @param arg_vals      Address of uninitialized list to store argument values
    1776  *                      (list of rdata_item_t).
    1777  */
    1778 static void run_call_args(run_t *run, list_t *args, list_t *arg_vals)
    1779 {
    1780         list_node_t *arg_n;
    1781         stree_expr_t *arg;
    1782         rdata_item_t *rarg_i, *rarg_vi;
    1783 
    1784         /* Evaluate function arguments. */
    1785         list_init(arg_vals);
    1786         arg_n = list_first(args);
    1787 
    1788         while (arg_n != NULL) {
    1789                 arg = list_node_data(arg_n, stree_expr_t *);
    1790                 run_expr(run, arg, &rarg_i);
    1791                 if (run_is_bo(run))
    1792                         return;
    1793 
    1794                 run_cvt_value_item(run, rarg_i, &rarg_vi);
    1795 
    1796                 list_append(arg_vals, rarg_vi);
    1797                 arg_n = list_next(args, arg_n);
    1798         }
    17991533}
    18001534
    … …  
    18301564        /* Implicitly dereference. */
    18311565        if (vc == vc_ref) {
    1832                 run_dereference(run, rbase, index->base->cspan, &base_i);
    1833                 if (run_is_bo(run)) {
    1834                         *res = NULL;
    1835                         return;
    1836                 }
     1566                run_dereference(run, rbase, &base_i);
    18371567        } else {
    18381568                base_i = rbase;
    … …  
    19041634#endif
    19051635        (void) run;
     1636        (void) index;
    19061637
    19071638        assert(base->ic == ic_address);
    … …  
    19451676                        /* Raise Error.OutOfBounds */
    19461677                        run_raise_exc(run,
    1947                             run->program->builtin->error_outofbounds,
    1948                             index->expr->cspan);
    1949                         /* XXX It should be cspan of the argument. */
     1678                            run->program->builtin->error_outofbounds);
    19501679                        *res = run_recovery_item(run);
    19511680                        return;
    … …  
    20851814#endif
    20861815        (void) run;
     1816        (void) index;
    20871817
    20881818        run_cvt_value_item(run, base, &base_vi);
    … …  
    21361866#endif
    21371867                /* Raise Error.OutOfBounds */
    2138                 run_raise_exc(run, run->program->builtin->error_outofbounds,
    2139                     index->expr->cspan);
     1868                run_raise_exc(run, run->program->builtin->error_outofbounds);
    21401869                *res = run_recovery_item(run);
    21411870                return;
    … …  
    22411970        }
    22421971
    2243         run_dereference(run, rarg_vi, NULL, &rarg_di);
     1972        run_dereference(run, rarg_vi, &rarg_di);
    22441973
    22451974        /* Now we should have a variable address. */
    … …  
    23192048        case vc_ref:
    23202049        case vc_deleg:
    2321         case vc_enum:
    23222050        case vc_array:
    23232051        case vc_object:
    23242052        case vc_resource:
    2325         case vc_symbol:
    23262053                assert(b_false);
    23272054        }
    … …  
    24202147}
    24212148
    2422 /** Run constructor on an object.
    2423  *
    2424  * @param run           Runner object
    2425  * @param obj           Object to run constructor on
    2426  * @param arg_vals      Argument values (list of rdata_item_t)
    2427  */
    2428 static void run_object_ctor(run_t *run, rdata_var_t *obj, list_t *arg_vals)
    2429 {
    2430         stree_ident_t *ctor_ident;
    2431         stree_symbol_t *csi_sym;
    2432         stree_csi_t *csi;
    2433         stree_symbol_t *ctor_sym;
    2434         stree_ctor_t *ctor;
    2435         run_proc_ar_t *proc_ar;
    2436         rdata_item_t *res;
    2437 
    2438         csi_sym = obj->u.object_v->class_sym;
    2439         csi = symbol_to_csi(csi_sym);
    2440         assert(csi != NULL);
    2441 
    2442 #ifdef DEBUG_RUN_TRACE
    2443         printf("Run object constructor from CSI '");
    2444         symbol_print_fqn(csi_sym);
    2445         printf("'.\n");
    2446 #endif
    2447         ctor_ident = stree_ident_new();
    2448         ctor_ident->sid = strtab_get_sid(CTOR_IDENT);
    2449 
    2450         /* Find constructor. */
    2451         ctor_sym = symbol_search_csi_no_base(run->program, csi, ctor_ident);
    2452         if (ctor_sym == NULL) {
    2453 #ifdef DEBUG_RUN_TRACE
    2454                 printf("No constructor found.\n");
    2455 #endif
    2456                 return;
    2457         }
    2458 
    2459         ctor = symbol_to_ctor(ctor_sym);
    2460         assert(ctor != NULL);
    2461 
    2462         /* Create procedure activation record. */
    2463         run_proc_ar_create(run, obj, ctor->proc, &proc_ar);
    2464 
    2465         /* Fill in argument values. */
    2466         run_proc_ar_set_args(run, proc_ar, arg_vals);
    2467 
    2468         /* Run the procedure. */
    2469         run_proc(run, proc_ar, &res);
    2470 
    2471         /* Constructor does not return a value. */
    2472         assert(res == NULL);
    2473 
    2474 #ifdef DEBUG_RUN_TRACE
    2475         printf("Returned from constructor..\n");
    2476 #endif
    2477 }
    2478 
    24792149/** Return boolean value of an item.
    24802150 *

  • uspace/app/sbi/src/run_t.h

    r640ffe6 r1317380  
    9797        run_bailout_mode_t bo_mode;
    9898
    99         /** Exception cspan */
    100         struct cspan *exc_cspan;
    101 
    10299        /** Exception payload */
    103100        struct rdata_value *exc_payload;

  • uspace/app/sbi/src/run_texpr.c

    r640ffe6 r1317380  
    3131#include <assert.h>
    3232#include <stdlib.h>
    33 #include "cspan.h"
    3433#include "debug.h"
    3534#include "list.h"
    … …  
    103102        tdata_deleg_t *tdeleg;
    104103        stree_csi_t *base_csi;
    105         stree_deleg_t *deleg;
    106         stree_enum_t *enum_d;
    107         tdata_enum_t *tenum;
    108104
    109105#ifdef DEBUG_RUN_TRACE
    … …  
    119115
    120116        if (targ_i->tic != tic_tobject) {
    121                 cspan_print(taccess->texpr->cspan);
    122                 printf(" Error: Using '.' with type which is not an "
    123                     "object.\n");
     117                printf("Error: Using '.' with type which is not an object.\n");
    124118                *res = tdata_item_new(tic_ignore);
    125119                return;
    … …  
    131125        sym = symbol_lookup_in_csi(prog, base_csi, taccess->member_name);
    132126        if (sym == NULL) {
    133                 cspan_print(taccess->member_name->cspan);
    134                 printf(" Error: CSI '");
     127                printf("Error: CSI '");
    135128                symbol_print_fqn(csi_to_symbol(base_csi));
    136129                printf("' has no member named '%s'.\n",
    … …  
    149142                tobject->static_ref = b_false;
    150143                tobject->csi = sym->u.csi;
    151                 list_init(&tobject->targs);
    152                 break;
    153         case sc_ctor:
    154                 /* It is not possible to reference a constructor explicitly. */
    155                 assert(b_false);
     144                list_init(&tobject->targs); /* XXX */
     145                break;
     146        case sc_deleg:
     147                /* Construct type item. */
     148                titem = tdata_item_new(tic_tdeleg);
     149                tdeleg = tdata_deleg_new();
     150                titem->u.tdeleg = tdeleg;
     151
     152                tdeleg->deleg = sym->u.deleg;
     153                break;
     154        case sc_fun:
     155        case sc_var:
     156        case sc_prop:
     157                printf("Error: Symbol '");
     158                symbol_print_fqn(sym);
     159                printf("' is not a type.\n");
     160                titem = tdata_item_new(tic_ignore);
     161                break;
     162        }
     163
     164        *res = titem;
     165}
     166
     167/** Evaluate type indexing expression.
     168 *
     169 * Evaluate operation per the type indexing ('[', ']') operator.
     170 * A type indexing operation may have extents specified or only rank
     171 * specified.
     172 *
     173 * @param prog          Program
     174 * @param ctx           Current CSI (context)
     175 * @param tindex        Type indexing expression to evaluate
     176 * @param res           Place to store type result
     177 */
     178static void run_tindex(stree_program_t *prog, stree_csi_t *ctx,
     179    stree_tindex_t *tindex, tdata_item_t **res)
     180{
     181        tdata_item_t *base_ti;
     182        tdata_item_t *titem;
     183        tdata_array_t *tarray;
     184        stree_expr_t *arg_expr;
     185        list_node_t *arg_node;
     186
     187#ifdef DEBUG_RUN_TRACE
     188        printf("Evaluating type index operation.\n");
     189#endif
     190        /* Evaluate base type. */
     191        run_texpr(prog, ctx, tindex->base_type, &base_ti);
     192
     193        if (base_ti->tic == tic_ignore) {
     194                *res = tdata_item_new(tic_ignore);
     195                return;
     196        }
     197
     198        /* Construct type item. */
     199        titem = tdata_item_new(tic_tarray);
     200        tarray = tdata_array_new();
     201        titem->u.tarray = tarray;
     202
     203        tarray->base_ti = base_ti;
     204        tarray->rank = tindex->n_args;
     205
     206        /* Copy extents. */
     207        list_init(&tarray->extents);
     208        arg_node = list_first(&tindex->args);
     209
     210        while (arg_node != NULL) {
     211                arg_expr = list_node_data(arg_node, stree_expr_t *);
     212                list_append(&tarray->extents, arg_expr);
     213                arg_node = list_next(&tindex->args, arg_node);
     214        }
     215
     216        *res = titem;
     217}
     218
     219/** Evaluate type literal expression.
     220 *
     221 * @param prog          Program
     222 * @param ctx           Current CSI (context)
     223 * @param tliteral      Type literal
     224 * @param res           Place to store type result
     225 */
     226static void run_tliteral(stree_program_t *prog, stree_csi_t *ctx,
     227    stree_tliteral_t *tliteral, tdata_item_t **res)
     228{
     229        tdata_item_t *titem;
     230        tdata_primitive_t *tprimitive;
     231        tprimitive_class_t tpc;
     232
     233#ifdef DEBUG_RUN_TRACE
     234        printf("Evaluating type literal.\n");
     235#endif
     236        (void) prog;
     237        (void) ctx;
     238        (void) tliteral;
     239
     240        switch (tliteral->tlc) {
     241        case tlc_bool: tpc = tpc_bool; break;
     242        case tlc_char: tpc = tpc_char; break;
     243        case tlc_int: tpc = tpc_int; break;
     244        case tlc_string: tpc = tpc_string; break;
     245        case tlc_resource: tpc = tpc_resource; break;
     246        }
     247
     248        /* Construct type item. */
     249        titem = tdata_item_new(tic_tprimitive);
     250        tprimitive = tdata_primitive_new(tpc);
     251        titem->u.tprimitive = tprimitive;
     252
     253        *res = titem;
     254}
     255
     256static void run_tnameref(stree_program_t *prog, stree_csi_t *ctx,
     257    stree_tnameref_t *tnameref, tdata_item_t **res)
     258{
     259        stree_symbol_t *sym;
     260        tdata_item_t *titem;
     261        tdata_object_t *tobject;
     262        stree_targ_t *targ;
     263        tdata_vref_t *tvref;
     264        stree_deleg_t *deleg;
     265        tdata_deleg_t *tdeleg;
     266
     267#ifdef DEBUG_RUN_TRACE
     268        printf("Evaluating type name reference.\n");
     269        printf("'%s'\n", strtab_get_str(tnameref->name->sid));
     270#endif
     271        /* In interactive mode we are not in a class */
     272        if (ctx != NULL) {
     273                /* Look for type argument */
     274                targ = stree_csi_find_targ(ctx, tnameref->name);
     275
     276                if (targ != NULL) {
     277                        /* Found type argument */
     278#ifdef DEBUG_RUN_TRACE
     279                        printf("Found type argument '%s'.\n",
     280                            strtab_get_str(tnameref->name->sid));
     281#endif
     282                        titem = tdata_item_new(tic_tvref);
     283                        tvref = tdata_vref_new();
     284                        titem->u.tvref = tvref;
     285                        tvref->targ = targ;
     286
     287                        *res = titem;
     288                        return;
     289                }
     290        }
     291
     292        /* Look for symbol */
     293        sym = symbol_lookup_in_csi(prog, ctx, tnameref->name);
     294        if (sym == NULL) {
     295                printf("Error: Symbol '%s' not found.\n",
     296                    strtab_get_str(tnameref->name->sid));
     297                *res = tdata_item_new(tic_ignore);
     298                return;
     299        }
     300
     301        switch (sym->sc) {
     302        case sc_csi:
     303                /* Construct type item. */
     304                titem = tdata_item_new(tic_tobject);
     305                tobject = tdata_object_new();
     306                titem->u.tobject = tobject;
     307
     308                tobject->static_ref = b_false;
     309                tobject->csi = sym->u.csi;
     310                list_init(&tobject->targs); /* XXX */
     311                break;
    156312        case sc_deleg:
    157313                /* Fetch stored delegate type. */
    … …  
    174330                }
    175331                break;
    176         case sc_enum:
    177                 /* Fetch stored enum type. */
    178                 enum_d = symbol_to_enum(sym);
    179                 assert(enum_d != NULL);
    180                 if (enum_d->titem == NULL) {
    181                         /*
    182                          * Prepare a partial enum whic will be completed
    183                          * later.
    184                          */
    185                         titem = tdata_item_new(tic_tenum);
    186                         tenum = tdata_enum_new();
    187                         titem->u.tenum = tenum;
    188                         tenum->enum_d = enum_d;
    189                 } else {
    190                         titem = enum_d->titem;
    191                 }
    192                 break;
    193332        case sc_fun:
    194333        case sc_var:
    195334        case sc_prop:
    196                 cspan_print(taccess->member_name->cspan);
    197                 printf(" Error: Symbol '");
    198                 symbol_print_fqn(sym);
    199                 printf("' is not a type.\n");
    200                 titem = tdata_item_new(tic_ignore);
    201                 break;
    202         }
    203 
    204         *res = titem;
    205 }
    206 
    207 /** Evaluate type indexing expression.
    208  *
    209  * Evaluate operation per the type indexing ('[', ']') operator.
    210  * A type indexing operation may have extents specified or only rank
    211  * specified.
    212  *
    213  * @param prog          Program
    214  * @param ctx           Current CSI (context)
    215  * @param tindex        Type indexing expression to evaluate
    216  * @param res           Place to store type result
    217  */
    218 static void run_tindex(stree_program_t *prog, stree_csi_t *ctx,
    219     stree_tindex_t *tindex, tdata_item_t **res)
    220 {
    221         tdata_item_t *base_ti;
    222         tdata_item_t *titem;
    223         tdata_array_t *tarray;
    224         stree_expr_t *arg_expr;
    225         list_node_t *arg_node;
    226 
    227 #ifdef DEBUG_RUN_TRACE
    228         printf("Evaluating type index operation.\n");
    229 #endif
    230         /* Evaluate base type. */
    231         run_texpr(prog, ctx, tindex->base_type, &base_ti);
    232 
    233         if (base_ti->tic == tic_ignore) {
    234                 *res = tdata_item_new(tic_ignore);
    235                 return;
    236         }
    237 
    238         /* Construct type item. */
    239         titem = tdata_item_new(tic_tarray);
    240         tarray = tdata_array_new();
    241         titem->u.tarray = tarray;
    242 
    243         tarray->base_ti = base_ti;
    244         tarray->rank = tindex->n_args;
    245 
    246         /* Copy extents. */
    247         list_init(&tarray->extents);
    248         arg_node = list_first(&tindex->args);
    249 
    250         while (arg_node != NULL) {
    251                 arg_expr = list_node_data(arg_node, stree_expr_t *);
    252                 list_append(&tarray->extents, arg_expr);
    253                 arg_node = list_next(&tindex->args, arg_node);
    254         }
    255 
    256         *res = titem;
    257 }
    258 
    259 /** Evaluate type literal expression.
    260  *
    261  * @param prog          Program
    262  * @param ctx           Current CSI (context)
    263  * @param tliteral      Type literal
    264  * @param res           Place to store type result
    265  */
    266 static void run_tliteral(stree_program_t *prog, stree_csi_t *ctx,
    267     stree_tliteral_t *tliteral, tdata_item_t **res)
    268 {
    269         tdata_item_t *titem;
    270         tdata_primitive_t *tprimitive;
    271         tprimitive_class_t tpc;
    272 
    273 #ifdef DEBUG_RUN_TRACE
    274         printf("Evaluating type literal.\n");
    275 #endif
    276         (void) prog;
    277         (void) ctx;
    278         (void) tliteral;
    279 
    280         switch (tliteral->tlc) {
    281         case tlc_bool: tpc = tpc_bool; break;
    282         case tlc_char: tpc = tpc_char; break;
    283         case tlc_int: tpc = tpc_int; break;
    284         case tlc_string: tpc = tpc_string; break;
    285         case tlc_resource: tpc = tpc_resource; break;
    286         }
    287 
    288         /* Construct type item. */
    289         titem = tdata_item_new(tic_tprimitive);
    290         tprimitive = tdata_primitive_new(tpc);
    291         titem->u.tprimitive = tprimitive;
    292 
    293         *res = titem;
    294 }
    295 
    296 static void run_tnameref(stree_program_t *prog, stree_csi_t *ctx,
    297     stree_tnameref_t *tnameref, tdata_item_t **res)
    298 {
    299         stree_symbol_t *sym;
    300         tdata_item_t *titem;
    301         tdata_object_t *tobject;
    302         stree_targ_t *targ;
    303         tdata_vref_t *tvref;
    304         stree_deleg_t *deleg;
    305         tdata_deleg_t *tdeleg;
    306         stree_enum_t *enum_d;
    307         tdata_enum_t *tenum;
    308 
    309 #ifdef DEBUG_RUN_TRACE
    310         printf("Evaluating type name reference.\n");
    311         printf("'%s'\n", strtab_get_str(tnameref->name->sid));
    312 #endif
    313         /* In interactive mode we are not in a class */
    314         if (ctx != NULL) {
    315                 /* Look for type argument */
    316                 targ = stree_csi_find_targ(ctx, tnameref->name);
    317 
    318                 if (targ != NULL) {
    319                         /* Found type argument */
    320 #ifdef DEBUG_RUN_TRACE
    321                         printf("Found type argument '%s'.\n",
    322                             strtab_get_str(tnameref->name->sid));
    323 #endif
    324                         titem = tdata_item_new(tic_tvref);
    325                         tvref = tdata_vref_new();
    326                         titem->u.tvref = tvref;
    327                         tvref->targ = targ;
    328 
    329                         *res = titem;
    330                         return;
    331                 }
    332         }
    333 
    334         /* Look for symbol */
    335         sym = symbol_lookup_in_csi(prog, ctx, tnameref->name);
    336         if (sym == NULL) {
    337                 cspan_print(tnameref->texpr->cspan);
    338                 printf(" Error: Symbol '%s' not found.\n",
    339                     strtab_get_str(tnameref->name->sid));
    340                 *res = tdata_item_new(tic_ignore);
    341                 return;
    342         }
    343 
    344         switch (sym->sc) {
    345         case sc_csi:
    346                 /* Construct type item. */
    347                 titem = tdata_item_new(tic_tobject);
    348                 tobject = tdata_object_new();
    349                 titem->u.tobject = tobject;
    350 
    351                 tobject->static_ref = b_false;
    352                 tobject->csi = sym->u.csi;
    353                 list_init(&tobject->targs);
    354                 break;
    355         case sc_ctor:
    356                 /* It is not possible to reference a constructor explicitly. */
    357                 assert(b_false);
    358         case sc_deleg:
    359                 /* Fetch stored delegate type. */
    360                 deleg = symbol_to_deleg(sym);
    361                 assert(deleg != NULL);
    362                 if (deleg->titem == NULL) {
    363                         /*
    364                          * Prepare a partial delegate which will be completed
    365                          * later.
    366                          */
    367                         titem = tdata_item_new(tic_tdeleg);
    368                         tdeleg = tdata_deleg_new();
    369                         titem->u.tdeleg = tdeleg;
    370                         tdeleg->deleg = deleg;
    371                         tdeleg->tsig = NULL;
    372 
    373                         deleg->titem = titem;
    374                 } else {
    375                         titem = deleg->titem;
    376                 }
    377                 break;
    378         case sc_enum:
    379                 /* Fetch stored enum type. */
    380                 enum_d = symbol_to_enum(sym);
    381                 assert(enum_d != NULL);
    382                 if (enum_d->titem == NULL) {
    383                         /*
    384                          * Prepare a partial enum whic will be completed
    385                          * later.
    386                          */
    387                         titem = tdata_item_new(tic_tenum);
    388                         tenum = tdata_enum_new();
    389                         titem->u.tenum = tenum;
    390                         tenum->enum_d = enum_d;
    391                 } else {
    392                         titem = enum_d->titem;
    393                 }
    394                 break;
    395         case sc_fun:
    396         case sc_var:
    397         case sc_prop:
    398                 cspan_print(tnameref->texpr->cspan);
    399                 printf(" Error: Symbol '");
     335                printf("Error: Symbol '");
    400336                symbol_print_fqn(sym);
    401337                printf("' is not a type.\n");
    … …  
    443379
    444380        if (base_ti->tic != tic_tobject) {
    445                 cspan_print(tapply->gtype->cspan);
    446                 printf(" Error: Base type of generic application is not "
     381                printf("Error: Base type of generic application is not "
    447382                    "a CSI.\n");
    448383                *res = tdata_item_new(tic_ignore);
    … …  
    475410
    476411        if (farg_n != NULL || arg_n != NULL) {
    477                 cspan_print(tapply->texpr->cspan);
    478                 printf(" Error: Incorrect number of type arguments.\n");
     412                printf("Error: Incorrect number of type arguments.\n");
    479413                *res = tdata_item_new(tic_ignore);
    480414                return;

  • uspace/app/sbi/src/stree.c

    r640ffe6 r1317380  
    116116}
    117117
    118 /** Allocate new constructor.
    119  *
    120  * @return      New constructor
    121  */
    122 stree_ctor_t *stree_ctor_new(void)
    123 {
    124         stree_ctor_t *ctor;
    125 
    126         ctor = calloc(1, sizeof(stree_ctor_t));
    127         if (ctor == NULL) {
    128                 printf("Memory allocation failed.\n");
    129                 exit(1);
    130         }
    131 
    132         return ctor;
    133 }
    134 
    135118/** Allocate new member delegate.
    136119 *
    … …  
    150133}
    151134
    152 /** Allocate new enum.
    153  *
    154  * @return      New enum
    155  */
    156 stree_enum_t *stree_enum_new(void)
    157 {
    158         stree_enum_t *enum_d;
    159 
    160         enum_d = calloc(1, sizeof(stree_enum_t));
    161         if (enum_d == NULL) {
    162                 printf("Memory allocation failed.\n");
    163                 exit(1);
    164         }
    165 
    166         return enum_d;
    167 }
    168 
    169 /** Allocate new enum member.
    170  *
    171  * @return      New enum member
    172  */
    173 stree_embr_t *stree_embr_new(void)
    174 {
    175         stree_embr_t *embr;
    176 
    177         embr = calloc(1, sizeof(stree_embr_t));
    178         if (embr == NULL) {
    179                 printf("Memory allocation failed.\n");
    180                 exit(1);
    181         }
    182 
    183         return embr;
    184 }
    185 
    186135/** Allocate new member function.
    187136 *
    … …  
    445394}
    446395
    447 /** Allocate new @c break statement.
    448  *
    449  * @return      New @c break statement
    450  */
    451 stree_break_t *stree_break_new(void)
    452 {
    453         stree_break_t *break_s;
    454 
    455         break_s = calloc(1, sizeof(stree_break_t));
    456         if (break_s == NULL) {
    457                 printf("Memory allocation failed.\n");
    458                 exit(1);
    459         }
    460 
    461         return break_s;
    462 }
    463 
    464396/** Allocate new @c return statement.
    465397 *
    … …  
    530462}
    531463
    532 /** Allocate new @c if/elif clause.
    533  *
    534  * @return      New @c if/elif clause
    535  */
    536 stree_if_clause_t *stree_if_clause_new(void)
    537 {
    538         stree_if_clause_t *if_clause;
    539 
    540         if_clause = calloc(1, sizeof(stree_if_clause_t));
    541         if (if_clause == NULL) {
    542                 printf("Memory allocation failed.\n");
    543                 exit(1);
    544         }
    545 
    546         return if_clause;
    547 }
    548 
    549464/** Allocate new statement block.
    550465 *
    … …  
    954869 * @param symbol        Symbol
    955870 * @param sac           Symbol attribute class
    956  * @return              @c b_true if yes, @c b_false if no
     871 * @return              @c b_true if yes, @c b_false if no.
    957872 */
    958873bool_t stree_symbol_has_attr(stree_symbol_t *symbol, symbol_attr_class_t sac)
    … …  
    1023938/** Search for CSI type argument of the given name.
    1024939 *
    1025  * @param csi           CSI to look in
    1026  * @param ident         Identifier of the type argument
    1027  * @return              Type argument declaration or @c NULL if not found
     940 * @param csi           CSI to look in.
     941 * @param ident         Identifier of the type argument.
     942 * @return              Type argument definition or @c NULL if not found.
    1028943 */
    1029944stree_targ_t *stree_csi_find_targ(stree_csi_t *csi, stree_ident_t *ident)
    … …  
    1044959        return NULL;
    1045960}
    1046 
    1047 /** Search for enum member of the given name.
    1048  *
    1049  * @param enum_d        Enum to look in
    1050  * @param ident         Identifier of the enum member
    1051  * @return              Enum member declaration or @c NULL if not found
    1052  */
    1053 stree_embr_t *stree_enum_find_mbr(stree_enum_t *enum_d, stree_ident_t *ident)
    1054 {
    1055         list_node_t *embr_n;
    1056         stree_embr_t *embr;
    1057 
    1058         embr_n = list_first(&enum_d->members);
    1059         while (embr_n != NULL) {
    1060                 embr = list_node_data(embr_n, stree_embr_t *);
    1061                 if (embr->name->sid == ident->sid)
    1062                         return embr;
    1063 
    1064                 embr_n = list_next(&enum_d->members, embr_n);
    1065         }
    1066 
    1067         /* No match */
    1068         return NULL;
    1069 }
    1070 
    1071 /** Get CSI member name.
    1072  *
    1073  * @param csimbr        CSI member
    1074  * @return              Member name
    1075  */
    1076 stree_ident_t *stree_csimbr_get_name(stree_csimbr_t *csimbr)
    1077 {
    1078         stree_ident_t *mbr_name;
    1079 
    1080         /* Keep compiler happy. */
    1081         mbr_name = NULL;
    1082 
    1083         switch (csimbr->cc) {
    1084         case csimbr_csi: mbr_name = csimbr->u.csi->name; break;
    1085         case csimbr_ctor: mbr_name = csimbr->u.ctor->name; break;
    1086         case csimbr_deleg: mbr_name = csimbr->u.deleg->name; break;
    1087         case csimbr_enum: mbr_name = csimbr->u.enum_d->name; break;
    1088         case csimbr_fun: mbr_name = csimbr->u.fun->name; break;
    1089         case csimbr_var: mbr_name = csimbr->u.var->name; break;
    1090         case csimbr_prop: mbr_name = csimbr->u.prop->name; break;
    1091         }
    1092 
    1093         return mbr_name;
    1094 }

  • uspace/app/sbi/src/stree.h

    r640ffe6 r1317380  
    3636stree_csi_t *stree_csi_new(csi_class_t cc);
    3737stree_csimbr_t *stree_csimbr_new(csimbr_class_t cc);
    38 stree_ctor_t *stree_ctor_new(void);
    3938stree_deleg_t *stree_deleg_new(void);
    40 stree_enum_t *stree_enum_new(void);
    41 stree_embr_t *stree_embr_new(void);
    4239stree_fun_t *stree_fun_new(void);
    4340stree_var_t *stree_var_new(void);
    … …  
    5855stree_for_t *stree_for_new(void);
    5956stree_raise_t *stree_raise_new(void);
    60 stree_break_t *stree_break_new(void);
    6157stree_return_t *stree_return_new(void);
    6258stree_wef_t *stree_wef_new(void);
    … …  
    6460
    6561stree_except_t *stree_except_new(void);
    66 stree_if_clause_t *stree_if_clause_new(void);
    6762stree_block_t *stree_block_new(void);
    6863
    … …  
    9792bool_t stree_is_csi_derived_from_csi(stree_csi_t *a, stree_csi_t *b);
    9893stree_targ_t *stree_csi_find_targ(stree_csi_t *csi, stree_ident_t *ident);
    99 stree_embr_t *stree_enum_find_mbr(stree_enum_t *enum_d, stree_ident_t *ident);
    100 stree_ident_t *stree_csimbr_get_name(stree_csimbr_t *csimbr);
    10194
    10295#endif

  • uspace/app/sbi/src/stree_t.h

    r640ffe6 r1317380  
    4343typedef struct {
    4444        int sid;
    45         struct cspan *cspan;
    4645} stree_ident_t;
    4746
    4847/** Name reference */
    4948typedef struct {
    50         /** Expression backlink */
    51         struct stree_expr *expr;
    52 
    5349        stree_ident_t *name;
    5450} stree_nameref_t;
     51
     52/** Reference to currently active object. */
     53typedef struct {
     54} stree_self_ref_t;
    5555
    5656/** Boolean literal */
    … …  
    8888/** Literal */
    8989typedef struct {
    90         /** Expression backlink */
    91         struct stree_expr *expr;
    92 
    9390        literal_class_t ltc;
    9491        union {
    … …  
    10198} stree_literal_t;
    10299
    103 /** Reference to currently active object. */
    104 typedef struct {
    105         /** Expression backlink */
    106         struct stree_expr *expr;
    107 } stree_self_ref_t;
    108 
    109100/** Binary operation class */
    110101typedef enum {
    … …  
    117108        bo_plus,
    118109        bo_minus,
    119         bo_mult,
    120         bo_and,
    121         bo_or
     110        bo_mult
    122111} binop_class_t;
    123112
    … …  
    126115        uo_plus,
    127116        uo_minus,
    128         uo_not
    129117} unop_class_t;
    130118
    131119/** Binary operation */
    132120typedef struct {
    133         /** Expression backlink */
    134         struct stree_expr *expr;
    135 
    136121        /** Binary operation class */
    137122        binop_class_t bc;
    … …  
    143128/** Unary operation */
    144129typedef struct {
    145         /** Expression backlink */
    146         struct stree_expr *expr;
    147 
    148130        /** Operation class */
    149131        unop_class_t uc;
    … …  
    155137/** New operation */
    156138typedef struct {
    157         /** Expression backlink */
    158         struct stree_expr *expr;
    159 
    160139        /** Type of object to construct. */
    161140        struct stree_texpr *texpr;
    162 
    163         /** Constructor arguments */
    164         list_t ctor_args; /* of stree_expr_t */
    165141} stree_new_t;
    166142
    167143/** Member access operation */
    168144typedef struct {
    169         /** Expression backlink */
    170         struct stree_expr *expr;
    171 
    172145        /** Argument */
    173146        struct stree_expr *arg;
    … …  
    178151/** Function call operation */
    179152typedef struct {
    180         /** Expression backlink */
    181         struct stree_expr *expr;
    182 
    183153        /** Function */
    184154        struct stree_expr *fun;
    … …  
    195165/** Assignment */
    196166typedef struct {
    197         /** Expression backlink */
    198         struct stree_expr *expr;
    199 
    200167        assign_class_t ac;
    201168        struct stree_expr *dest, *src;
    … …  
    204171/** Indexing operation */
    205172typedef struct {
    206         /** Expression backlink */
    207         struct stree_expr *expr;
    208 
    209173        /** Base */
    210174        struct stree_expr *base;
    … …  
    216180/** @c as conversion operation */
    217181typedef struct {
    218         /** Expression backlink */
    219         struct stree_expr *expr;
    220 
    221182        /** Expression to convert */
    222183        struct stree_expr *arg;
    223 
    224184        /** Destination type of conversion. */
    225185        struct stree_texpr *dtype;
    … …  
    233193 */
    234194typedef struct {
    235         /** Expression backlink */
    236         struct stree_expr *expr;
    237 
    238195        /* Primitive type expression */
    239196        struct stree_expr *arg;
    … …  
    260217        expr_class_t ec;
    261218
    262         /** Type of this expression or @c NULL if not typed yet */
    263219        struct tdata_item *titem;
    264 
    265         /** Coordinate span */
    266         struct cspan *cspan;
    267220
    268221        union {
    … …  
    299252/** Type literal */
    300253typedef struct {
    301         /** Type expression backlink */
    302         struct stree_texpr *texpr;
    303 
    304254        tliteral_class_t tlc;
    305255} stree_tliteral_t;
    … …  
    307257/** Type name reference */
    308258typedef struct {
    309         /** Type expression backlink */
    310         struct stree_texpr *texpr;
    311 
    312259        stree_ident_t *name;
    313260} stree_tnameref_t;
    … …  
    315262/** Type member access operation */
    316263typedef struct {
    317         /** Type expression backlink */
    318         struct stree_texpr *texpr;
    319 
    320264        /** Argument */
    321265        struct stree_texpr *arg;
    322 
    323266        /** Name of member being accessed. */
    324267        stree_ident_t *member_name;
    … …  
    327270/** Type application operation */
    328271typedef struct {
    329         /** Type expression backlink */
    330         struct stree_texpr *texpr;
    331 
    332272        /* Base type */
    333273        struct stree_texpr *gtype;
    … …  
    339279/** Type index operation */
    340280typedef struct {
    341         /** Type expression backlink */
    342         struct stree_texpr *texpr;
    343 
    344281        /** Base type */
    345282        struct stree_texpr *base_type;
    … …  
    367304typedef struct stree_texpr {
    368305        texpr_class_t tc;
    369 
    370         /** Coordinate span */
    371         struct cspan *cspan;
    372306
    373307        union {
    … …  
    403337} stree_except_t;
    404338
    405 /** @c if or @c elif clause */
     339/** If statement */
    406340typedef struct {
    407341        stree_expr_t *cond;
    408         stree_block_t *block;
    409 } stree_if_clause_t;
    410 
    411 /** If statement */
    412 typedef struct {
    413         /** If and elif clauses */
    414         list_t if_clauses; /* of stree_if_clause_t */
    415 
    416         /** Else block */
     342        stree_block_t *if_block;
    417343        stree_block_t *else_block;
    418344} stree_if_t;
    … …  
    433359        stree_expr_t *expr;
    434360} stree_raise_t;
    435 
    436 /** Break statement */
    437 typedef struct {
    438 } stree_break_t;
    439361
    440362/** Return statement */
    … …  
    462384        st_for,
    463385        st_raise,
    464         st_break,
    465386        st_return,
    466387        st_exps,
    … …  
    478399                stree_for_t *for_s;
    479400                stree_raise_t *raise_s;
    480                 stree_break_t *break_s;
    481401                stree_return_t *return_s;
    482402                stree_exps_t *exp_s;
    … …  
    541461} stree_proc_t;
    542462
    543 /** Constructor declaration */
    544 typedef struct stree_ctor {
    545         /** Constructor 'name'. Points to the @c new keyword. */
    546         stree_ident_t *name;
    547 
    548         /** Symbol */
    549         struct stree_symbol *symbol;
    550 
    551         /** Signature (arguments, return type is always none) */
    552         stree_fun_sig_t *sig;
    553 
    554         /** Constructor implementation */
    555         stree_proc_t *proc;
    556 
    557         /** Type item describing the constructor */
    558         struct tdata_item *titem;
    559 } stree_ctor_t;
    560 
    561463/** Delegate declaration */
    562464typedef struct stree_deleg {
    … …  
    574476} stree_deleg_t;
    575477
    576 /** Enum member */
    577 typedef struct stree_embr {
    578         /** Enum containing this declaration */
    579         struct stree_enum *outer_enum;
    580 
    581         /** Enum member name */
    582         stree_ident_t *name;
    583 } stree_embr_t;
    584 
    585 /** Enum declaration */
    586 typedef struct stree_enum {
    587         /** Enum name */
    588         stree_ident_t *name;
    589 
    590         /** Symbol */
    591         struct stree_symbol *symbol;
    592 
    593         /** List of enum members */
    594         list_t members; /* of stree_embr_t */
    595 
    596         /** Type item describing the enum */
    597         struct tdata_item *titem;
    598 } stree_enum_t;
    599 
    600478/** Member function declaration */
    601479typedef struct stree_fun {
    … …  
    643521/**
    644522 * Fake identifiers used with symbols that do not really have one.
    645  */
    646 #define CTOR_IDENT "$ctor"
     523 * (Mostly for error messages.)
     524 */
    647525#define INDEXER_IDENT "$indexer"
    648526
    649527typedef enum {
    650528        csimbr_csi,
    651         csimbr_ctor,
    652529        csimbr_deleg,
    653         csimbr_enum,
    654530        csimbr_fun,
    655531        csimbr_var,
    … …  
    663539        union {
    664540                struct stree_csi *csi;
    665                 stree_ctor_t *ctor;
    666541                stree_deleg_t *deleg;
    667                 stree_enum_t *enum_d;
    668542                stree_fun_t *fun;
    669543                stree_var_t *var;
    … …  
    713587typedef enum {
    714588        /* Class, struct or interface declaration */
    715         mc_csi,
    716         /* Enum declaration */
    717         mc_enum
     589        mc_csi
    718590} modm_class_t;
    719591
    … …  
    723595        union {
    724596                stree_csi_t *csi;
    725                 stree_enum_t *enum_d;
    726597        } u;
    727598} stree_modm_t;
    … …  
    747618        /** CSI (class, struct or interface) */
    748619        sc_csi,
    749         /** Constructor */
    750         sc_ctor,
    751620        /** Member delegate */
    752621        sc_deleg,
    753         /** Enum */
    754         sc_enum,
    755622        /** Member function */
    756623        sc_fun,
    … …  
    771638        union {
    772639                struct stree_csi *csi;
    773                 stree_ctor_t *ctor;
    774640                stree_deleg_t *deleg;
    775                 stree_enum_t *enum_d;
    776641                stree_fun_t *fun;
    777642                stree_var_t *var;

  • uspace/app/sbi/src/stype.c

    r640ffe6 r1317380  
    3838#include <stdlib.h>
    3939#include <assert.h>
    40 #include "cspan.h"
    4140#include "debug.h"
    4241#include "intmap.h"
    … …  
    5352
    5453static void stype_csi(stype_t *stype, stree_csi_t *csi);
    55 static void stype_ctor(stype_t *stype, stree_ctor_t *ctor);
    56 static void stype_ctor_body(stype_t *stype, stree_ctor_t *ctor);
    5754static void stype_fun(stype_t *stype, stree_fun_t *fun);
    5855static void stype_var(stype_t *stype, stree_var_t *var);
    … …  
    6966static void stype_for(stype_t *stype, stree_for_t *for_s);
    7067static void stype_raise(stype_t *stype, stree_raise_t *raise_s);
    71 static void stype_break(stype_t *stype, stree_break_t *break_s);
    7268static void stype_return(stype_t *stype, stree_return_t *return_s);
    7369static void stype_exps(stype_t *stype, stree_exps_t *exp_s, bool_t want_value);
    … …  
    8480static stree_expr_t *stype_convert_tdeleg(stype_t *stype, stree_expr_t *expr,
    8581    tdata_item_t *dest);
    86 static stree_expr_t *stype_convert_tenum(stype_t *stype, stree_expr_t *expr,
    87     tdata_item_t *dest);
    8882static stree_expr_t *stype_convert_tfun_tdeleg(stype_t *stype,
    8983    stree_expr_t *expr, tdata_item_t *dest);
    9084static stree_expr_t *stype_convert_tvref(stype_t *stype, stree_expr_t *expr,
    9185    tdata_item_t *dest);
    92 static void stype_convert_failure(stype_t *stype, stree_expr_t *expr,
     86static void stype_convert_failure(stype_t *stype, tdata_item_t *src,
    9387    tdata_item_t *dest);
    9488
    … …  
    118112        while (mbr_n != NULL) {
    119113                mbr = list_node_data(mbr_n, stree_modm_t *);
    120 
    121                 switch (mbr->mc) {
    122                 case mc_csi:
    123                         stype_csi(stype, mbr->u.csi);
    124                         break;
    125                 case mc_enum:
    126                         stype_enum(stype, mbr->u.enum_d);
    127                         break;
    128                 }
     114                assert(mbr->mc == mc_csi);
     115
     116                stype_csi(stype, mbr->u.csi);
    129117
    130118                mbr_n = list_next(&module->members, mbr_n);
    … …  
    157145                switch (csimbr->cc) {
    158146                case csimbr_csi: stype_csi(stype, csimbr->u.csi); break;
    159                 case csimbr_ctor: stype_ctor(stype, csimbr->u.ctor); break;
    160147                case csimbr_deleg: stype_deleg(stype, csimbr->u.deleg); break;
    161                 case csimbr_enum: stype_enum(stype, csimbr->u.enum_d); break;
    162148                case csimbr_fun: stype_fun(stype, csimbr->u.fun); break;
    163149                case csimbr_var: stype_var(stype, csimbr->u.var); break;
    … …  
    169155
    170156        stype->current_csi = prev_ctx;
    171 }
    172 
    173 /** Type a constructor.
    174  *
    175  * @param stype         Static typing object.
    176  * @param ctor          Constructor to type.
    177  */
    178 static void stype_ctor(stype_t *stype, stree_ctor_t *ctor)
    179 {
    180 #ifdef DEBUG_TYPE_TRACE
    181         printf("Type constructor '");
    182         symbol_print_fqn(ctor_to_symbol(ctor));
    183         printf("'.\n");
    184 #endif
    185         if (ctor->titem == NULL)
    186                 stype_ctor_header(stype, ctor);
    187 
    188         stype_ctor_body(stype, ctor);
    189 }
    190 
    191 /** Type constructor header.
    192  *
    193  * @param stype         Static typing object.
    194  * @param ctor          Constructor to type.
    195  */
    196 void stype_ctor_header(stype_t *stype, stree_ctor_t *ctor)
    197 {
    198         stree_symbol_t *ctor_sym;
    199         tdata_item_t *ctor_ti;
    200         tdata_fun_t *tfun;
    201         tdata_fun_sig_t *tsig;
    202 
    203 #ifdef DEBUG_TYPE_TRACE
    204         printf("Type constructor '");
    205         symbol_print_fqn(ctor_to_symbol(ctor));
    206         printf("' header.\n");
    207 #endif
    208         if (ctor->titem != NULL)
    209                 return; /* Constructor header has already been typed. */
    210 
    211         ctor_sym = ctor_to_symbol(ctor);
    212 
    213         /* Type function signature. */
    214         stype_fun_sig(stype, ctor_sym->outer_csi, ctor->sig, &tsig);
    215 
    216         ctor_ti = tdata_item_new(tic_tfun);
    217         tfun = tdata_fun_new();
    218         ctor_ti->u.tfun = tfun;
    219         tfun->tsig = tsig;
    220 
    221         ctor->titem = ctor_ti;
    222 }
    223 
    224 /** Type constructor body.
    225  *
    226  * @param stype         Static typing object
    227  * @param ctor          Constructor
    228  */
    229 static void stype_ctor_body(stype_t *stype, stree_ctor_t *ctor)
    230 {
    231 #ifdef DEBUG_TYPE_TRACE
    232         printf("Type constructor '");
    233         symbol_print_fqn(ctor_to_symbol(ctor));
    234         printf("' body.\n");
    235 #endif
    236         assert(stype->proc_vr == NULL);
    237 
    238         stype->proc_vr = stype_proc_vr_new();
    239         stype->proc_vr->proc = ctor->proc;
    240         list_init(&stype->proc_vr->block_vr);
    241 
    242         stype_block(stype, ctor->proc->body);
    243 
    244         free(stype->proc_vr);
    245         stype->proc_vr = NULL;
    246157}
    247158
    … …  
    286197}
    287198
    288 /** Type enum.
    289  *
    290  * @param stype         Static typing object
    291  * @param enum_d        Enum to type
    292  */
    293 void stype_enum(stype_t *stype, stree_enum_t *enum_d)
    294 {
    295         tdata_item_t *titem;
    296         tdata_enum_t *tenum;
    297 
    298         (void) stype;
    299 
    300 #ifdef DEBUG_TYPE_TRACE
    301         printf("Type enum '");
    302         symbol_print_fqn(enum_to_symbol(enum_d));
    303         printf("'.\n");
    304 #endif
    305         if (enum_d->titem == NULL) {
    306                 titem = tdata_item_new(tic_tenum);
    307                 tenum = tdata_enum_new();
    308                 titem->u.tenum = tenum;
    309                 tenum->enum_d = enum_d;
    310 
    311                 enum_d->titem = titem;
    312         } else {
    313                 titem = enum_d->titem;
    314         }
    315 }
    316 
    317199/** Type function.
    318200 *
    … …  
    575457        case st_for: stype_for(stype, stat->u.for_s); break;
    576458        case st_raise: stype_raise(stype, stat->u.raise_s); break;
    577         case st_break: stype_break(stype, stat->u.break_s); break;
    578459        case st_return: stype_return(stype, stat->u.return_s); break;
    579460        case st_exps: stype_exps(stype, stat->u.exp_s, want_value); break;
    … …  
    625506{
    626507        stree_expr_t *ccond;
    627         list_node_t *ifc_node;
    628         stree_if_clause_t *ifc;
    629508
    630509#ifdef DEBUG_TYPE_TRACE
    631510        printf("Type 'if' statement.\n");
    632511#endif
    633         ifc_node = list_first(&if_s->if_clauses);
    634 
    635         /* Walk through all if/elif clauses. */
    636 
    637         while (ifc_node != NULL) {
    638                 /* Get if/elif clause */
    639                 ifc = list_node_data(ifc_node, stree_if_clause_t *);
    640 
    641                 /* Convert condition to boolean type. */
    642                 stype_expr(stype, ifc->cond);
    643                 ccond = stype_convert(stype, ifc->cond,
    644                     stype_boolean_titem(stype));
    645 
    646                 /* Patch code with augmented expression. */
    647                 ifc->cond = ccond;
    648 
    649                 /* Type the @c if/elif block */
    650                 stype_block(stype, ifc->block);
    651 
    652                 ifc_node = list_next(&if_s->if_clauses, ifc_node);
    653         }
     512        /* Convert condition to boolean type. */
     513        stype_expr(stype, if_s->cond);
     514        ccond = stype_convert(stype, if_s->cond, stype_boolean_titem(stype));
     515
     516        /* Patch code with augmented expression. */
     517        if_s->cond = ccond;
     518
     519        /* Type the @c if block */
     520        stype_block(stype, if_s->if_block);
    654521
    655522        /* Type the @c else block */
    … …  
    678545        while_s->cond = ccond;
    679546
    680         /* While is a breakable statement. Increment counter. */
    681         stype->proc_vr->bstat_cnt += 1;
    682 
    683547        /* Type the body of the loop */
    684548        stype_block(stype, while_s->body);
    685 
    686         stype->proc_vr->bstat_cnt -= 1;
    687549}
    688550
    … …  
    697559        printf("Type 'for' statement.\n");
    698560#endif
    699         /* For is a breakable statement. Increment counter. */
    700         stype->proc_vr->bstat_cnt += 1;
    701 
    702561        stype_block(stype, for_s->body);
    703 
    704         stype->proc_vr->bstat_cnt -= 1;
    705562}
    706563
    … …  
    716573#endif
    717574        stype_expr(stype, raise_s->expr);
    718 }
    719 
    720 /** Type @c break statement */
    721 static void stype_break(stype_t *stype, stree_break_t *break_s)
    722 {
    723 #ifdef DEBUG_TYPE_TRACE
    724         printf("Type 'break' statement.\n");
    725 #endif
    726         (void) break_s;
    727 
    728         /* Check whether there is an active statement to break from. */
    729         if (stype->proc_vr->bstat_cnt == 0) {
    730                 printf("Error: Break statement outside of while or for.\n");
    731                 stype_note_error(stype);
    732         }
    733575}
    734576
    … …  
    746588        printf("Type 'return' statement.\n");
    747589#endif
    748         if (return_s->expr != NULL)
    749                 stype_expr(stype, return_s->expr);
     590        stype_expr(stype, return_s->expr);
    750591
    751592        /* Determine the type we need to return. */
    … …  
    758599
    759600                /* XXX Memoize to avoid recomputing. */
    760                 if (fun->sig->rtype != NULL) {
    761                         run_texpr(stype->program, outer_sym->outer_csi,
    762                             fun->sig->rtype, &dtype);
    763 
    764                         if (return_s->expr == NULL) {
    765                                 printf("Error: Return without a value in "
    766                                     "function returning value.\n");
    767                                 stype_note_error(stype);
    768                         }
    769                 } else {
    770                         dtype = NULL;
    771 
    772                         if (return_s->expr != NULL) {
    773                                 printf("Error: Return with a value in "
    774                                     "value-less function.\n");
    775                                 stype_note_error(stype);
    776                         }
    777                 }
     601                run_texpr(stype->program, outer_sym->outer_csi,
     602                    fun->sig->rtype, &dtype);
    778603                break;
    779604        case sc_prop:
    … …  
    781606                assert(prop != NULL);
    782607
    783                 if (stype->proc_vr->proc == prop->getter) {
    784                         if (return_s->expr == NULL) {
    785                                 printf("Error: Return without a value in "
    786                                     "getter.\n");
    787                                 stype_note_error(stype);
    788                         }
    789                 } else {
    790                         if (return_s->expr == NULL) {
    791                                 printf("Error: Return with a value in "
    792                                     "setter.\n");
    793                                 stype_note_error(stype);
    794                         }
     608                if (stype->proc_vr->proc != prop->getter) {
     609                        printf("Error: Return statement in "
     610                            "setter.\n");
     611                        stype_note_error(stype);
    795612                }
    796613
    … …  
    803620        }
    804621
    805         if (dtype != NULL && return_s->expr != NULL) {
    806                 /* Convert to the return type. */
    807                 cexpr = stype_convert(stype, return_s->expr, dtype);
    808 
    809                 /* Patch code with the augmented expression. */
    810                 return_s->expr = cexpr;
    811         }
     622        /* Convert to the return type. */
     623        cexpr = stype_convert(stype, return_s->expr, dtype);
     624
     625        /* Patch code with the augmented expression. */
     626        return_s->expr = cexpr;
    812627}
    813628
    … …  
    899714
    900715        if (src == NULL) {
    901                 cspan_print(expr->cspan);
    902                 printf(" Error: Conversion source is not valid.\n");
     716                printf("Error: Conversion source is not valid.\n");
    903717                stype_note_error(stype);
    904718                return expr;
    … …  
    924738        }
    925739
    926         if (src->tic == tic_tebase) {
    927                 stype_convert_failure(stype, expr, dest);
    928                 printf("Invalid use of reference to enum type in "
    929                     "expression.\n");
    930                 return expr;
    931         }
    932 
    933740        if (src->tic != dest->tic) {
    934                 stype_convert_failure(stype, expr, dest);
     741                stype_convert_failure(stype, src, dest);
    935742                return expr;
    936743        }
    … …  
    949756                expr = stype_convert_tdeleg(stype, expr, dest);
    950757                break;
    951         case tic_tebase:
    952                 /* Conversion destination should never be enum-base */
    953                 assert(b_false);
    954         case tic_tenum:
    955                 expr = stype_convert_tenum(stype, expr, dest);
    956                 break;
    957758        case tic_tfun:
    958759                assert(b_false);
    … …  
    987788        /* Check if both have the same tprimitive class. */
    988789        if (src->u.tprimitive->tpc != dest->u.tprimitive->tpc)
    989                 stype_convert_failure(stype, expr, dest);
     790                stype_convert_failure(stype, src, dest);
    990791
    991792        return expr;
    … …  
    994795/** Convert expression of primitive type to object type.
    995796 *
    996  * This function implements autoboxing. It modifies the code by inserting
    997  * the boxing operation.
     797 * This function implements autoboxing. It modified the code.
    998798 *
    999799 * @param stype         Static typing object
    … …  
    1028828        case tpc_string: bp_sym = bi->boxed_string; break;
    1029829        case tpc_resource:
    1030                 stype_convert_failure(stype, expr, dest);
     830                stype_convert_failure(stype, src, dest);
    1031831                return expr;
    1032832        }
    … …  
    1034834        /* Target type must be boxed @a src or Object */
    1035835        if (csi_sym != bp_sym && csi_sym != bi->gf_class)
    1036                 stype_convert_failure(stype, expr, dest);
     836                stype_convert_failure(stype, src, dest);
    1037837
    1038838        /* Patch the code to box the primitive value */
    … …  
    1041841        bexpr = stree_expr_new(ec_box);
    1042842        bexpr->u.box = box;
    1043         bexpr->titem = dest;
    1044843
    1045844        /* No action needed to optionally convert boxed type to Object */
    … …  
    1102901                } else {
    1103902                        /* No match */
    1104                         stype_convert_failure(stype, expr, dest);
     903                        stype_convert_failure(stype, src, dest);
    1105904                        return expr;
    1106905                }
    … …  
    1117916                if (tdata_item_equal(carg, darg) != b_true) {
    1118917                        /* Diferent argument type */
    1119                         stype_convert_failure(stype, expr, dest);
     918                        stype_convert_failure(stype, src, dest);
    1120919                        printf("Different argument type '");
    1121920                        tdata_item_print(carg);
    … …  
    1132931        if (ca_n != NULL || da_n != NULL) {
    1133932                /* Diferent number of arguments */
    1134                 stype_convert_failure(stype, expr, dest);
     933                stype_convert_failure(stype, src, dest);
    1135934                printf("Different number of arguments.\n");
    1136935                return expr;
    … …  
    1160959        /* Compare rank and base type. */
    1161960        if (src->u.tarray->rank != dest->u.tarray->rank) {
    1162                 stype_convert_failure(stype, expr, dest);
     961                stype_convert_failure(stype, src, dest);
    1163962                return expr;
    1164963        }
    … …  
    1167966        if (tdata_item_equal(src->u.tarray->base_ti,
    1168967            dest->u.tarray->base_ti) != b_true) {
    1169                 stype_convert_failure(stype, expr, dest);
     968                stype_convert_failure(stype, src, dest);
    1170969        }
    1171970
    … …  
    12051004        /* Both must be the same delegate. */
    12061005        if (sdeleg->deleg != ddeleg->deleg) {
    1207                 stype_convert_failure(stype, expr, dest);
    1208                 return expr;
    1209         }
    1210 
    1211         return expr;
    1212 }
    1213 
    1214 /** Convert expression of enum type to enum type.
    1215  *
    1216  * @param stype         Static typing object
    1217  * @param expr          Expression
    1218  * @param dest          Destination type
    1219  */
    1220 static stree_expr_t *stype_convert_tenum(stype_t *stype, stree_expr_t *expr,
    1221     tdata_item_t *dest)
    1222 {
    1223         tdata_item_t *src;
    1224         tdata_enum_t *senum, *denum;
    1225 
    1226 #ifdef DEBUG_TYPE_TRACE
    1227         printf("Convert enum type.\n");
    1228 #endif
    1229         src = expr->titem;
    1230         assert(src->tic == tic_tenum);
    1231         assert(dest->tic == tic_tenum);
    1232 
    1233         senum = src->u.tenum;
    1234         denum = dest->u.tenum;
    1235 
    1236         /*
    1237          * XXX How should enum types interact with generics?
    1238          */
    1239 
    1240         /* Both must be of the same enum type (with the same declaration). */
    1241         if (senum->enum_d != denum->enum_d) {
    1242                 stype_convert_failure(stype, expr, dest);
     1006                stype_convert_failure(stype, src, dest);
    12431007                return expr;
    12441008        }
    … …  
    12791043
    12801044        if (!stype_fun_sig_equal(stype, ssig, dsig)) {
    1281                 stype_convert_failure(stype, expr, dest);
     1045                stype_convert_failure(stype, src, dest);
    12821046                return expr;
    12831047        }
    … …  
    13111075        /* Currently only allow if both types are the same. */
    13121076        if (src->u.tvref->targ != dest->u.tvref->targ) {
    1313                 stype_convert_failure(stype, expr, dest);
     1077                stype_convert_failure(stype, src, dest);
    13141078                return expr;
    13151079        }
    … …  
    13211085 *
    13221086 * @param stype         Static typing object
    1323  * @param expr          Original expression
     1087 * @param src           Original type
    13241088 * @param dest          Destination type
    13251089 */
    1326 static void stype_convert_failure(stype_t *stype, stree_expr_t *expr,
     1090static void stype_convert_failure(stype_t *stype, tdata_item_t *src,
    13271091    tdata_item_t *dest)
    13281092{
    1329         cspan_print(expr->cspan);
    1330         printf(" Error: Cannot convert ");
    1331         tdata_item_print(expr->titem);
     1093        printf("Error: Cannot convert ");
     1094        tdata_item_print(src);
    13321095        printf(" to ");
    13331096        tdata_item_print(dest);
    … …  
    13361099        stype_note_error(stype);
    13371100}
    1338 
    1339 /** Box value.
    1340  *
    1341  * This function implements implicit boxing. It modifies the code by inserting
    1342  * the boxing operation.
    1343  *
    1344  * @param stype         Static typing object
    1345  * @param expr          Expression
    1346  * @return              Modified expression.
    1347  */
    1348 stree_expr_t *stype_box_expr(stype_t *stype, stree_expr_t *expr)
    1349 {
    1350         tdata_item_t *src;
    1351         builtin_t *bi;
    1352         stree_symbol_t *bp_sym;
    1353         stree_box_t *box;
    1354         stree_expr_t *bexpr;
    1355         tdata_object_t *tobject;
    1356 
    1357 #ifdef DEBUG_TYPE_TRACE
    1358         printf("Boxing.\n");
    1359 #endif
    1360         src = expr->titem;
    1361         assert(src->tic == tic_tprimitive);
    1362 
    1363         bi = stype->program->builtin;
    1364 
    1365         /* Make compiler happy. */
    1366         bp_sym = NULL;
    1367 
    1368         switch (src->u.tprimitive->tpc) {
    1369         case tpc_bool: bp_sym = bi->boxed_bool; break;
    1370         case tpc_char: bp_sym = bi->boxed_char; break;
    1371         case tpc_int: bp_sym = bi->boxed_int; break;
    1372         case tpc_nil: assert(b_false);
    1373         case tpc_string: bp_sym = bi->boxed_string; break;
    1374         case tpc_resource:
    1375                 cspan_print(expr->cspan);
    1376                 printf(" Error: Cannot use ");
    1377                 tdata_item_print(expr->titem);
    1378                 printf(" as an object.\n");
    1379 
    1380                 stype_note_error(stype);
    1381                 return expr;
    1382         }
    1383 
    1384         /* Patch the code to box the primitive value */
    1385         box = stree_box_new();
    1386         box->arg = expr;
    1387         bexpr = stree_expr_new(ec_box);
    1388         bexpr->u.box = box;
    1389         bexpr->titem = tdata_item_new(tic_tobject);
    1390         tobject = tdata_object_new();
    1391         bexpr->titem->u.tobject = tobject;
    1392 
    1393         tobject->csi = symbol_to_csi(bp_sym);
    1394         assert(tobject->csi != NULL);
    1395 
    1396         return bexpr;
    1397 }
    1398 
    1399 
    14001101
    14011102/** Determine if two type signatures are equal.
    … …  
    15951296
    15961297        stree_symbol_t *outer_sym;
    1597         stree_ctor_t *ctor;
    15981298        stree_fun_t *fun;
    15991299        stree_prop_t *prop;
    … …  
    16141314#endif
    16151315
    1616         /* Make compiler happy. */
    1617         args = NULL;
    1618         varg = NULL;
    1619 
    16201316        switch (outer_sym->sc) {
    1621         case sc_ctor:
    1622                 ctor = symbol_to_ctor(outer_sym);
    1623                 assert(ctor != NULL);
    1624                 args = &ctor->sig->args;
    1625                 varg = ctor->sig->varg;
    1626                 break;
    16271317        case sc_fun:
    16281318                fun = symbol_to_fun(outer_sym);
    … …  
    16411331                        setter_arg = prop->setter_arg;
    16421332                break;
    1643         case sc_csi:
    1644         case sc_deleg:
    1645         case sc_enum:
    1646         case sc_var:
     1333        default:
    16471334                assert(b_false);
    16481335        }

  • uspace/app/sbi/src/stype.h

    r640ffe6 r1317380  
    3333
    3434void stype_module(stype_t *stype, stree_module_t *module);
    35 void stype_ctor_header(stype_t *stype, stree_ctor_t *ctor);
    3635void stype_deleg(stype_t *stype, stree_deleg_t *deleg);
    37 void stype_enum(stype_t *stype, stree_enum_t *enum_d);
    3836void stype_fun_header(stype_t *stype, stree_fun_t *fun);
    3937void stype_stat(stype_t *stype, stree_stat_t *stat, bool_t want_value);
    … …  
    4442stree_expr_t *stype_convert(stype_t *stype, stree_expr_t *expr,
    4543    tdata_item_t *dest);
    46 stree_expr_t *stype_box_expr(stype_t *stype, stree_expr_t *expr);
    4744
    4845tdata_fun_sig_t *stype_deleg_get_sig(stype_t *stype, tdata_deleg_t *tdeleg);

  • uspace/app/sbi/src/stype_expr.c

    r640ffe6 r1317380  
    4646#include <stdlib.h>
    4747#include <assert.h>
    48 #include "cspan.h"
    4948#include "debug.h"
    5049#include "list.h"
    … …  
    8685static void stype_binop_tobject(stype_t *stype, stree_binop_t *binop,
    8786    tdata_item_t *ta, tdata_item_t *tb, tdata_item_t **rtitem);
    88 static void stype_binop_tenum(stype_t *stype, stree_binop_t *binop,
    89     tdata_item_t *ta, tdata_item_t *tb, tdata_item_t **rtitem);
    90 static void stype_binop_tvref(stype_t *stype, stree_binop_t *binop,
    91     tdata_item_t *ta, tdata_item_t *tb, tdata_item_t **rtitem);
    9287
    9388static void stype_unop(stype_t *stype, stree_unop_t *unop,
    … …  
    9792static void stype_new(stype_t *stype, stree_new_t *new,
    9893    tdata_item_t **rtitem);
    99 static void stype_new_object_args(stype_t *stype, stree_new_t *new_op,
    100     tdata_item_t *obj_ti);
    10194
    10295static void stype_access(stype_t *stype, stree_access_t *access,
    … …  
    108101static void stype_access_tarray(stype_t *stype, stree_access_t *access,
    109102    tdata_item_t *arg_ti, tdata_item_t **rtitem);
    110 static void stype_access_tebase(stype_t *stype, stree_access_t *access,
    111     tdata_item_t *arg_ti, tdata_item_t **rtitem);
    112103
    113104static void stype_call(stype_t *stype, stree_call_t *call,
    114105    tdata_item_t **rtitem);
    115 static void stype_call_args(stype_t *stype, cspan_t *cspan, list_t *farg_tis,
    116     tdata_item_t *fvarg_ti, list_t *args);
    117106
    118107static void stype_index(stype_t *stype, stree_index_t *index,
    … …  
    144133
    145134#ifdef DEBUG_TYPE_TRACE
    146         cspan_print(expr->cspan);
    147         printf(" Type expression.\n");
     135        printf("Type expression.\n");
    148136#endif
    149137        /* Silence warning. */
    … …  
    168156
    169157#ifdef DEBUG_TYPE_TRACE
    170         cspan_print(expr->cspan);
    171         printf(" Expression type is '");
     158        printf("Expression type is '");
    172159        tdata_item_print(et);
    173160        printf("'.\n");
    … …  
    191178        stree_csi_t *csi;
    192179        stree_deleg_t *deleg;
    193         stree_enum_t *enum_d;
    194         tdata_ebase_t *tebase;
    195180        stree_fun_t *fun;
    196181
    197182#ifdef DEBUG_TYPE_TRACE
    198         cspan_print(nameref->expr->cspan);
    199         printf(" Evaluate type of name reference '%s'.\n",
     183        printf("Evaluate type of name reference '%s'.\n",
    200184            strtab_get_str(nameref->name->sid));
    201185#endif
    … …  
    242226                /* Not found. */
    243227                if (stype->current_csi != NULL) {
    244                         cspan_print(nameref->expr->cspan);
    245                         printf(" Error: Symbol '%s' not found in '",
     228                        printf("Error: Symbol '%s' not found in '",
    246229                            strtab_get_str(nameref->name->sid));
    247230                        symbol_print_fqn(csi_to_symbol(stype->current_csi));
    248231                        printf("'.\n");
    249232                } else {
    250                         cspan_print(nameref->expr->cspan);
    251                         printf(" Error: Symbol '%s' not found.\n",
     233                        printf("Error: Symbol '%s' not found.\n",
    252234                            strtab_get_str(nameref->name->sid));
    253235                }
    … …  
    278260                tobject->csi = csi;
    279261                break;
    280         case sc_ctor:
    281                 /* It is not possible to reference a constructor explicitly. */
    282                 assert(b_false);
    283262        case sc_deleg:
     263                printf("referenced name is deleg\n");
    284264                deleg = symbol_to_deleg(sym);
    285265                assert(deleg != NULL);
    … …  
    287267                stype_deleg(stype, deleg);
    288268                titem = deleg->titem;
    289                 break;
    290         case sc_enum:
    291                 enum_d = symbol_to_enum(sym);
    292                 assert(enum_d != NULL);
    293 
    294                 titem = tdata_item_new(tic_tebase);
    295                 tebase = tdata_ebase_new();
    296                 titem->u.tebase = tebase;
    297 
    298                 /* This is an enum base reference. */
    299                 tebase->enum_d = enum_d;
    300269                break;
    301270        case sc_fun:
    … …  
    325294
    326295#ifdef DEBUG_TYPE_TRACE
    327         cspan_print(literal->expr->cspan);
    328         printf(" Evaluate type of literal.\n");
     296        printf("Evaluate type of literal.\n");
    329297#endif
    330298        (void) stype;
    … …  
    354322    tdata_item_t **rtitem)
    355323{
    356         stree_csi_t *cur_csi;
    357         tdata_item_t *titem;
    358         tdata_object_t *tobject;
    359 
    360 #ifdef DEBUG_TYPE_TRACE
    361         cspan_print(self_ref->expr->cspan);
    362         printf(" Evaluate type of self reference.\n");
     324#ifdef DEBUG_TYPE_TRACE
     325        printf("Evaluate type of self reference.\n");
    363326#endif
    364327        (void) stype;
    365328        (void) self_ref;
    366329
    367         cur_csi = stype->proc_vr->proc->outer_symbol->outer_csi;
    368 
    369         /* No global symbols should have procedures. */
    370         assert(cur_csi != NULL);
    371 
    372         /* Construct type item. */
    373         titem = tdata_item_new(tic_tobject);
    374         tobject = tdata_object_new();
    375         titem->u.tobject = tobject;
    376 
    377         tobject->static_ref = b_false;
    378         tobject->csi = cur_csi;
    379         list_init(&tobject->targs);
    380 
    381         *rtitem = titem;
     330        *rtitem = NULL;
    382331}
    383332
    … …  
    395344
    396345#ifdef DEBUG_TYPE_TRACE
    397         cspan_print(binop->expr->cspan);
    398         printf(" Evaluate type of binary operation.\n");
     346        printf("Evaluate type of binary operation.\n");
    399347#endif
    400348        stype_expr(stype, binop->arg1);
    … …  
    404352        titem2 = binop->arg2->titem;
    405353
    406         if (titem1 == NULL) {
    407                 cspan_print(binop->arg1->cspan);
    408                 printf(" Error: Binary operand has no value.\n");
    409                 stype_note_error(stype);
    410                 *rtitem = stype_recovery_titem(stype);
    411                 return;
    412         }
    413 
    414         if (titem2 == NULL) {
    415                 cspan_print(binop->arg2->cspan);
    416                 printf(" Error: Binary operand has no value.\n");
     354        if (titem1 == NULL || titem2 == NULL) {
     355                printf("Error: Binary operand has no value.\n");
    417356                stype_note_error(stype);
    418357                *rtitem = stype_recovery_titem(stype);
    … …  
    427366        equal = tdata_item_equal(titem1, titem2);
    428367        if (equal != b_true) {
    429                 cspan_print(binop->expr->cspan);
    430                 printf(" Error: Binary operation arguments "
     368                printf("Error: Binary operation arguments "
    431369                    "have different types ('");
    432370                tdata_item_print(titem1);
    … …  
    446384                stype_binop_tobject(stype, binop, titem1, titem2, rtitem);
    447385                break;
    448         case tic_tenum:
    449                 stype_binop_tenum(stype, binop, titem1, titem2, rtitem);
    450                 break;
    451         case tic_tvref:
    452                 stype_binop_tvref(stype, binop, titem1, titem2, rtitem);
    453                 break;
    454386        default:
    455                 cspan_print(binop->expr->cspan);
    456                 printf(" Error: Binary operation on value which is not of a "
     387                printf("Error: Binary operation on value which is not of a "
    457388                    "supported type (found '");
    458389                tdata_item_print(titem1);
    … …  
    527458        case bo_mult:
    528459                /* Arithmetic -> error */
    529                 cspan_print(binop->expr->cspan);
    530                 printf(" Error: Binary operation (%d) on booleans.\n",
     460                printf("Error: Binary operation (%d) on booleans.\n",
    531461                    binop->bc);
    532462                stype_note_error(stype);
    533463                *rtitem = stype_recovery_titem(stype);
    534464                return;
    535         case bo_and:
    536         case bo_or:
    537                 /* Boolean -> boolean type */
    538                 rtpc = tpc_bool;
    539                 break;
    540465        }
    541466
    … …  
    573498        case bo_minus:
    574499        case bo_mult:
    575         case bo_and:
    576         case bo_or:
    577                 /* Arithmetic, boolean -> error */
    578                 cspan_print(binop->expr->cspan);
    579                 printf(" Error: Binary operation (%d) on characters.\n",
     500                /* Arithmetic -> error */
     501                printf("Error: Binary operation (%d) on characters.\n",
    580502                    binop->bc);
    581503                stype_note_error(stype);
    … …  
    620542                rtpc = tpc_int;
    621543                break;
    622         case bo_and:
    623         case bo_or:
    624                 /* Boolean -> error */
    625                 cspan_print(binop->expr->cspan);
    626                 printf(" Error: Binary operation (%d) on integers.\n",
    627                     binop->bc);
    628                 stype_note_error(stype);
    629                 rtpc = tpc_char;
    630                 break;
    631544        }
    632545
    … …  
    648561        (void) binop;
    649562
    650         cspan_print(binop->expr->cspan);
    651         printf(" Unimplemented: Binary operation on nil.\n");
     563        printf("Unimplemented; Binary operation on nil.\n");
    652564        stype_note_error(stype);
    653565        *rtitem = stype_recovery_titem(stype);
    … …  
    666578        tdata_item_t *res_ti;
    667579
    668         switch (binop->bc) {
    669         case bo_equal:
    670         case bo_notequal:
    671                 /* Comparison -> boolean type */
    672                 rtpc = tpc_bool;
    673                 break;
    674         case bo_plus:
    675                 /* Concatenation -> string type */
    676                 rtpc = tpc_string;
    677                 break;
    678 
    679         case bo_lt:
    680         case bo_gt:
    681         case bo_lt_equal:
    682         case bo_gt_equal:
    683 
    684         case bo_minus:
    685         case bo_mult:
    686         case bo_and:
    687         case bo_or:
    688                 /* Ordering, arithmetic, boolean -> error */
    689                 cspan_print(binop->expr->cspan);
    690                 printf(" Error: Binary operation (%d) on strings.\n",
    691                     binop->bc);
    692                 stype_note_error(stype);
    693                 rtpc = tpc_char;
    694                 break;
    695         }
     580        if (binop->bc != bo_plus) {
     581                printf("Unimplemented: Binary operation(%d) "
     582                    "on strings.\n", binop->bc);
     583                stype_note_error(stype);
     584                *rtitem = stype_recovery_titem(stype);
     585                return;
     586        }
     587
     588        rtpc = tpc_string;
    696589
    697590        res_ti = tdata_item_new(tic_tprimitive);
    … …  
    715608        (void) binop;
    716609
    717         cspan_print(binop->expr->cspan);
    718         printf(" Error: Cannot apply operator to resource type.\n");
     610        printf("Error: Cannot apply operator to resource type.\n");
    719611        stype_note_error(stype);
    720612        rtpc = tpc_resource;
    … …  
    753645                break;
    754646        default:
    755                 cspan_print(binop->expr->cspan);
    756                 printf(" Error: Binary operation (%d) on objects.\n",
     647                printf("Error: Binary operation (%d) on objects.\n",
    757648                    binop->bc);
    758649                stype_note_error(stype);
    … …  
    764655}
    765656
    766 /** Type a binary operation with arguments of an enum type.
    767  *
    768  * @param stype         Static typing object
    769  * @param binop         Binary operation
    770  * @param ta            Type of first argument
    771  * @param tb            Type of second argument
    772  * @param rtitem        Place to store result type
    773  */
    774 static void stype_binop_tenum(stype_t *stype, stree_binop_t *binop,
    775     tdata_item_t *ta, tdata_item_t *tb, tdata_item_t **rtitem)
    776 {
    777         tdata_item_t *res_ti;
    778 
    779         assert(ta->tic == tic_tenum);
    780         assert(tb->tic == tic_tenum);
    781 
    782         switch (binop->bc) {
    783         case bo_equal:
    784         case bo_notequal:
    785                 /* Comparison -> boolean type */
    786                 res_ti = stype_boolean_titem(stype);
    787                 break;
    788         default:
    789                 cspan_print(binop->expr->cspan);
    790                 printf(" Error: Binary operation (%d) on values of enum "
    791                     "type.\n", binop->bc);
    792                 stype_note_error(stype);
    793                 *rtitem = stype_recovery_titem(stype);
    794                 return;
    795         }
    796 
    797         *rtitem = res_ti;
    798 }
    799 
    800 /** Type a binary operation with arguments of a variable type.
    801  *
    802  * @param stype         Static typing object
    803  * @param binop         Binary operation
    804  * @param ta            Type of first argument
    805  * @param tb            Type of second argument
    806  * @param rtitem        Place to store result type
    807  */
    808 static void stype_binop_tvref(stype_t *stype, stree_binop_t *binop,
    809     tdata_item_t *ta, tdata_item_t *tb, tdata_item_t **rtitem)
    810 {
    811         tdata_item_t *res_ti;
    812 
    813         assert(ta->tic == tic_tvref || (ta->tic == tic_tprimitive &&
    814             ta->u.tprimitive->tpc == tpc_nil));
    815         assert(tb->tic == tic_tvref || (tb->tic == tic_tprimitive &&
    816             tb->u.tprimitive->tpc == tpc_nil));
    817 
    818         switch (binop->bc) {
    819         case bo_equal:
    820         case bo_notequal:
    821                 /* Comparison -> boolean type */
    822                 res_ti = stype_boolean_titem(stype);
    823                 break;
    824         default:
    825                 cspan_print(binop->expr->cspan);
    826                 printf(" Error: Binary operation (%d) on variable types.\n",
    827                     binop->bc);
    828                 stype_note_error(stype);
    829                 *rtitem = stype_recovery_titem(stype);
    830                 return;
    831         }
    832 
    833         *rtitem = res_ti;
    834 }
    835657
    836658/** Type a unary operation.
    … …  
    846668
    847669#ifdef DEBUG_TYPE_TRACE
    848         cspan_print(unop->expr->cspan);
    849         printf(" Evaluate type of unary operation.\n");
     670        printf("Evaluate type of unary operation.\n");
    850671#endif
    851672        stype_expr(stype, unop->arg);
    … …  
    863684                break;
    864685        default:
    865                 cspan_print(unop->arg->cspan);
    866                 printf(" Error: Unary operation on value which is not of a "
     686                printf("Error: Unary operation on value which is not of a "
    867687                    "supported type (found '");
    868688                tdata_item_print(titem);
    … …  
    900720                break;
    901721        default:
    902                 cspan_print(unop->arg->cspan);
    903                 printf(" Error: Unary operator applied on unsupported "
     722                printf("Error: Unary operator applied on unsupported "
    904723                    "primitive type %d.\n", ta->u.tprimitive->tpc);
    905724                stype_note_error(stype);
    … …  
    924743{
    925744#ifdef DEBUG_TYPE_TRACE
    926         cspan_print(new_op->expr->cspan);
    927745        printf("Evaluate type of 'new' operation.\n");
    928746#endif
    … …  
    936754                /* An error occured when evaluating the type expression. */
    937755                stype_note_error(stype);
    938                 *rtitem = stype_recovery_titem(stype);
    939                 return;
    940         }
    941 
    942         if ((*rtitem)->tic == tic_tobject)
    943                 stype_new_object_args(stype, new_op, *rtitem);
    944 }
    945 
    946 /** Type a new object operation arguments.
    947  *
    948  * @param stype         Static typing object
    949  * @param new_op        @c new operation
    950  */
    951 static void stype_new_object_args(stype_t *stype, stree_new_t *new_op,
    952     tdata_item_t *obj_ti)
    953 {
    954         stree_csi_t *csi;
    955         stree_ctor_t *ctor;
    956         stree_symbol_t *ctor_sym;
    957         stree_ident_t *ctor_ident;
    958         tdata_fun_sig_t *tsig;
    959 
    960         assert(obj_ti->tic == tic_tobject);
    961         csi = obj_ti->u.tobject->csi;
    962         ctor_ident = stree_ident_new();
    963         ctor_ident->sid = strtab_get_sid(CTOR_IDENT);
    964 
    965         /* Find constructor. */
    966         ctor_sym = symbol_search_csi_no_base(stype->program, csi,
    967             ctor_ident);
    968 
    969         if (ctor_sym == NULL && !list_is_empty(&new_op->ctor_args)) {
    970                 cspan_print(new_op->expr->cspan);
    971                 printf(" Error: Passing arguments to 'new' but no "
    972                     "constructor found.\n");
    973                 stype_note_error(stype);
    974                 return;
    975         }
    976 
    977         if (ctor_sym == NULL)
    978                 return;
    979 
    980         ctor = symbol_to_ctor(ctor_sym);
    981         assert(ctor != NULL);
    982 
    983         /* Type constructor header if it has not been typed yet. */
    984         stype_ctor_header(stype, ctor);
    985         if (ctor->titem->tic == tic_ignore)
    986                 return;
    987 
    988         assert(ctor->titem->tic == tic_tfun);
    989         tsig = ctor->titem->u.tfun->tsig;
    990 
    991         stype_call_args(stype, new_op->expr->cspan, &tsig->arg_ti,
    992             tsig->varg_ti, &new_op->ctor_args);
     756        }
    993757}
    994758
    … …  
    1005769
    1006770#ifdef DEBUG_TYPE_TRACE
    1007         cspan_print(access->expr->cspan);
    1008         printf(" Evaluate type of access operation.\n");
     771        printf("Evaluate type of access operation.\n");
    1009772#endif
    1010773        stype_expr(stype, access->arg);
    … …  
    1012775
    1013776        if (arg_ti == NULL) {
    1014                 cspan_print(access->arg->cspan);
    1015                 printf(" Error: Argument of access operation has no value.\n");
     777                printf("Error: Argument of access has no value.\n");
    1016778                stype_note_error(stype);
    1017779                *rtitem = stype_recovery_titem(stype);
    … …  
    1030792                break;
    1031793        case tic_tdeleg:
    1032                 cspan_print(access->arg->cspan);
    1033                 printf(" Error: Using '.' operator on a delegate.\n");
    1034                 stype_note_error(stype);
    1035                 *rtitem = stype_recovery_titem(stype);
    1036                 break;
    1037         case tic_tebase:
    1038                 stype_access_tebase(stype, access, arg_ti, rtitem);
    1039                 break;
    1040         case tic_tenum:
    1041                 cspan_print(access->arg->cspan);
    1042                 printf(" Error: Using '.' operator on expression of enum "
    1043                     "type.\n");
     794                printf("Error: Using '.' operator on a function.\n");
    1044795                stype_note_error(stype);
    1045796                *rtitem = stype_recovery_titem(stype);
    1046797                break;
    1047798        case tic_tfun:
    1048                 cspan_print(access->arg->cspan);
    1049                 printf(" Error: Using '.' operator on a function.\n");
     799                printf("Error: Using '.' operator on a delegate.\n");
    1050800                stype_note_error(stype);
    1051801                *rtitem = stype_recovery_titem(stype);
    … …  
    1053803        case tic_tvref:
    1054804                /* Cannot allow this without some constraint. */
    1055                 cspan_print(access->arg->cspan);
    1056                 printf(" Error: Using '.' operator on generic data.\n");
     805                printf("Error: Using '.' operator on generic data.\n");
    1057806                *rtitem = stype_recovery_titem(stype);
    1058807                break;
    … …  
    1073822    tdata_item_t *arg_ti, tdata_item_t **rtitem)
    1074823{
    1075         (void) arg_ti;
    1076 
    1077         /* Box the value. */
    1078         access->arg = stype_box_expr(stype, access->arg);
    1079         if (access->arg->titem->tic == tic_ignore) {
    1080                 *rtitem = stype_recovery_titem(stype);
    1081                 return;
    1082         }
    1083 
    1084         /* Access the boxed object. */
    1085         stype_access_tobject(stype, access, access->arg->titem, rtitem);
     824        (void) stype;
     825        (void) access;
     826        (void) rtitem;
     827
     828        printf("Error: Unimplemented: Accessing primitive type '");
     829        tdata_item_print(arg_ti);
     830        printf("'.\n");
     831        stype_note_error(stype);
     832        *rtitem = stype_recovery_titem(stype);
    1086833}
    1087834
    … …  
    1098845        stree_symbol_t *member_sym;
    1099846        stree_var_t *var;
    1100         stree_enum_t *enum_d;
    1101847        stree_fun_t *fun;
    1102848        stree_prop_t *prop;
    … …  
    1117863        if (member_sym == NULL) {
    1118864                /* No such member found. */
    1119                 cspan_print(access->member_name->cspan);
    1120                 printf(" Error: CSI '");
     865                printf("Error: CSI '");
    1121866                symbol_print_fqn(csi_to_symbol(tobject->csi));
    1122867                printf("' has no member named '%s'.\n",
    … …  
    1134879        switch (member_sym->sc) {
    1135880        case sc_csi:
    1136                 cspan_print(access->member_name->cspan);
    1137                 printf(" Error: Accessing object member which is nested "
     881                printf("Error: Accessing object member which is nested "
    1138882                    "CSI.\n");
    1139883                stype_note_error(stype);
    1140884                *rtitem = stype_recovery_titem(stype);
    1141885                return;
    1142         case sc_ctor:
    1143                 /* It is not possible to reference a constructor explicitly. */
    1144                 assert(b_false);
    1145886        case sc_deleg:
    1146                 cspan_print(access->member_name->cspan);
    1147                 printf(" Error: Accessing object member which is a "
     887                printf("Error: Accessing object member which is a "
    1148888                    "delegate.\n");
    1149889                stype_note_error(stype);
    1150890                *rtitem = stype_recovery_titem(stype);
    1151891                return;
    1152         case sc_enum:
    1153                 enum_d = symbol_to_enum(member_sym);
    1154                 assert(enum_d != NULL);
    1155                 /* Type enum if it has not been typed yet. */
    1156                 stype_enum(stype, enum_d);
    1157                 mtitem = enum_d->titem;
    1158                 break;
    1159892        case sc_fun:
    1160893                fun = symbol_to_fun(member_sym);
    … …  
    1204937        (void) rtitem;
    1205938
    1206         cspan_print(access->arg->cspan);
    1207         printf(" Error: Unimplemented: Accessing array type '");
     939        printf("Error: Unimplemented: Accessing array type '");
    1208940        tdata_item_print(arg_ti);
    1209941        printf("'.\n");
    … …  
    1212944}
    1213945
    1214 /** Type an enum access operation.
    1215  *
    1216  * @param stype         Static typing object
    1217  * @param access        Member access operation
    1218  * @param arg_ti        Base type
    1219  * @param rtitem        Place to store result type
    1220 */
    1221 static void stype_access_tebase(stype_t *stype, stree_access_t *access,
    1222     tdata_item_t *arg_ti, tdata_item_t **rtitem)
    1223 {
    1224         tdata_ebase_t *tebase;
    1225         tdata_enum_t *tenum;
    1226         tdata_item_t *mtitem;
    1227         stree_embr_t *embr;
    1228 
    1229 #ifdef DEBUG_TYPE_TRACE
    1230         printf("Type an ebase access operation.\n");
    1231 #endif
    1232         assert(arg_ti->tic == tic_tebase);
    1233         tebase = arg_ti->u.tebase;
    1234 
    1235         /* Look for a member with the specified name. */
    1236         embr = stree_enum_find_mbr(tebase->enum_d, access->member_name);
    1237 
    1238         if (embr == NULL) {
    1239                 /* No such member found. */
    1240                 cspan_print(access->member_name->cspan);
    1241                 printf(" Error: Enum type '");
    1242                 symbol_print_fqn(enum_to_symbol(tebase->enum_d));
    1243                 printf("' has no member named '%s'.\n",
    1244                     strtab_get_str(access->member_name->sid));
    1245                 stype_note_error(stype);
    1246                 *rtitem = stype_recovery_titem(stype);
    1247                 return;
    1248         }
    1249 
    1250 #ifdef DEBUG_RUN_TRACE
    1251         printf("Found member '%s'.\n",
    1252             strtab_get_str(access->member_name->sid));
    1253 #endif
    1254 
    1255         mtitem = tdata_item_new(tic_tenum);
    1256         tenum = tdata_enum_new();
    1257         mtitem->u.tenum = tenum;
    1258         tenum->enum_d = tebase->enum_d;
    1259 
    1260         *rtitem = mtitem;
    1261 }
    1262 
    1263 
    1264946/** Type a call operation.
    1265947 *
    … …  
    1271953    tdata_item_t **rtitem)
    1272954{
     955        list_node_t *fargt_n;
     956        tdata_item_t *farg_ti;
     957        tdata_item_t *varg_ti;
     958
     959        list_node_t *arg_n;
     960        stree_expr_t *arg;
     961        stree_expr_t *carg;
     962
    1273963        tdata_item_t *fun_ti;
    1274964        tdata_fun_sig_t *tsig;
    1275965
    1276 #ifdef DEBUG_TYPE_TRACE
    1277         cspan_print(call->expr->cspan);
    1278         printf(" Evaluate type of call operation.\n");
     966        int cnt;
     967
     968#ifdef DEBUG_TYPE_TRACE
     969        printf("Evaluate type of call operation.\n");
    1279970#endif
    1280971        /* Type the function */
    … …  
    1295986                return;
    1296987        default:
    1297                 cspan_print(call->fun->cspan);
    1298                 printf(" Error: Calling something which is not a function ");
     988                printf("Error: Calling something which is not a function ");
    1299989                printf("(found '");
    1300990                tdata_item_print(fun_ti);
    … …  
    1305995        }
    1306996
    1307         /* Type call arguments. */
    1308         stype_call_args(stype, call->expr->cspan, &tsig->arg_ti, tsig->varg_ti,
    1309             &call->args);
     997        /* Type and check the arguments. */
     998        fargt_n = list_first(&tsig->arg_ti);
     999        arg_n = list_first(&call->args);
     1000
     1001        cnt = 0;
     1002        while (fargt_n != NULL && arg_n != NULL) {
     1003                farg_ti = list_node_data(fargt_n, tdata_item_t *);
     1004                arg = list_node_data(arg_n, stree_expr_t *);
     1005                stype_expr(stype, arg);
     1006
     1007                /* XXX Because of overloaded bultin WriteLine */
     1008                if (farg_ti == NULL) {
     1009                        /* Skip the check */
     1010                        fargt_n = list_next(&tsig->arg_ti, fargt_n);
     1011                        arg_n = list_next(&call->args, arg_n);
     1012                        continue;
     1013                }
     1014
     1015                /* Convert expression to type of formal argument. */
     1016                carg = stype_convert(stype, arg, farg_ti);
     1017
     1018                /* Patch code with augmented expression. */
     1019                list_node_setdata(arg_n, carg);
     1020
     1021                fargt_n = list_next(&tsig->arg_ti, fargt_n);
     1022                arg_n = list_next(&call->args, arg_n);
     1023        }
     1024
     1025        /* Type and check variadic arguments. */
     1026        if (tsig->varg_ti != NULL) {
     1027                /* Obtain type of packed argument. */
     1028                farg_ti = tsig->varg_ti;
     1029
     1030                /* Get array element type */
     1031                assert(farg_ti->tic == tic_tarray);
     1032                varg_ti = farg_ti->u.tarray->base_ti;
     1033
     1034                while (arg_n != NULL) {
     1035                        arg = list_node_data(arg_n, stree_expr_t *);
     1036                        stype_expr(stype, arg);
     1037
     1038                        /* Convert expression to type of formal argument. */
     1039                        carg = stype_convert(stype, arg, varg_ti);
     1040
     1041                        /* Patch code with augmented expression. */
     1042                        list_node_setdata(arg_n, carg);
     1043
     1044                        arg_n = list_next(&call->args, arg_n);
     1045                }
     1046        }
     1047
     1048        if (fargt_n != NULL) {
     1049                printf("Error: Too few arguments to function.\n");
     1050                stype_note_error(stype);
     1051        }
     1052
     1053        if (arg_n != NULL) {
     1054                printf("Error: Too many arguments to function.\n");
     1055                stype_note_error(stype);
     1056        }
    13101057
    13111058        if (tsig->rtype != NULL) {
    … …  
    13171064}
    13181065
    1319 /** Type call arguments.
    1320  *
    1321  * Type arguments in call to a function or constructor.
    1322  *
    1323  * @param stype         Static typing object
    1324  * @param cpsan         Cspan to print in case of error.
    1325  * @param farg_tis      Formal argument types (list of tdata_item_t)
    1326  * @param args          Real arguments (list of stree_expr_t)
    1327  */
    1328 static void stype_call_args(stype_t *stype, cspan_t *cspan, list_t *farg_tis,
    1329     tdata_item_t *fvarg_ti, list_t *args)
    1330 {
    1331         list_node_t *fargt_n;
    1332         tdata_item_t *farg_ti;
    1333         tdata_item_t *varg_ti;
    1334 
    1335         list_node_t *arg_n;
    1336         stree_expr_t *arg;
    1337         stree_expr_t *carg;
    1338 
    1339         int cnt;
    1340 
    1341         /* Type and check regular arguments. */
    1342         fargt_n = list_first(farg_tis);
    1343         arg_n = list_first(args);
    1344 
    1345         cnt = 0;
    1346         while (fargt_n != NULL && arg_n != NULL) {
    1347                 farg_ti = list_node_data(fargt_n, tdata_item_t *);
    1348                 arg = list_node_data(arg_n, stree_expr_t *);
    1349                 stype_expr(stype, arg);
    1350 
    1351                 /* XXX Because of overloaded bultin WriteLine */
    1352                 if (farg_ti == NULL) {
    1353                         /* Skip the check */
    1354                         fargt_n = list_next(farg_tis, fargt_n);
    1355                         arg_n = list_next(args, arg_n);
    1356                         continue;
    1357                 }
    1358 
    1359                 /* Convert expression to type of formal argument. */
    1360                 carg = stype_convert(stype, arg, farg_ti);
    1361 
    1362                 /* Patch code with augmented expression. */
    1363                 list_node_setdata(arg_n, carg);
    1364 
    1365                 fargt_n = list_next(farg_tis, fargt_n);
    1366                 arg_n = list_next(args, arg_n);
    1367         }
    1368 
    1369         /* Type and check variadic arguments. */
    1370         if (fvarg_ti != NULL) {
    1371                 /* Obtain type of packed argument. */
    1372                 farg_ti = fvarg_ti;
    1373 
    1374                 /* Get array element type */
    1375                 assert(farg_ti->tic == tic_tarray);
    1376                 varg_ti = farg_ti->u.tarray->base_ti;
    1377 
    1378                 while (arg_n != NULL) {
    1379                         arg = list_node_data(arg_n, stree_expr_t *);
    1380                         stype_expr(stype, arg);
    1381 
    1382                         /* Convert expression to type of formal argument. */
    1383                         carg = stype_convert(stype, arg, varg_ti);
    1384 
    1385                         /* Patch code with augmented expression. */
    1386                         list_node_setdata(arg_n, carg);
    1387 
    1388                         arg_n = list_next(args, arg_n);
    1389                 }
    1390         }
    1391 
    1392         if (fargt_n != NULL) {
    1393                 cspan_print(cspan);
    1394                 printf(" Error: Too few arguments.\n");
    1395                 stype_note_error(stype);
    1396         }
    1397 
    1398         if (arg_n != NULL) {
    1399                 cspan_print(cspan);
    1400                 printf(" Error: Too many arguments.\n");
    1401                 stype_note_error(stype);
    1402         }
    1403 }
    1404 
    14051066/** Type an indexing operation.
    14061067 *
    … …  
    14171078
    14181079#ifdef DEBUG_TYPE_TRACE
    1419         cspan_print(index->expr->cspan);
    1420         printf(" Evaluate type of index operation.\n");
     1080        printf("Evaluate type of index operation.\n");
    14211081#endif
    14221082        stype_expr(stype, index->base);
    … …  
    14431103                break;
    14441104        case tic_tdeleg:
    1445                 cspan_print(index->base->cspan);
    1446                 printf(" Error: Indexing a delegate.\n");
    1447                 stype_note_error(stype);
    1448                 *rtitem = stype_recovery_titem(stype);
    1449                 break;
    1450         case tic_tebase:
    1451                 cspan_print(index->base->cspan);
    1452                 printf(" Error: Indexing an enum declaration.\n");
    1453                 stype_note_error(stype);
    1454                 *rtitem = stype_recovery_titem(stype);
    1455                 break;
    1456         case tic_tenum:
    1457                 cspan_print(index->base->cspan);
    1458                 printf(" Error: Indexing an enum value.\n");
     1105                printf("Error: Indexing a delegate.\n");
    14591106                stype_note_error(stype);
    14601107                *rtitem = stype_recovery_titem(stype);
    14611108                break;
    14621109        case tic_tfun:
    1463                 cspan_print(index->base->cspan);
    1464                 printf(" Error: Indexing a function.\n");
     1110                printf("Error: Indexing a function.\n");
    14651111                stype_note_error(stype);
    14661112                *rtitem = stype_recovery_titem(stype);
    … …  
    14681114        case tic_tvref:
    14691115                /* Cannot allow this without some constraint. */
    1470                 cspan_print(index->base->cspan);
    1471                 printf(" Error: Indexing generic data.\n");
     1116                printf("Error: Indexing generic data.\n");
    14721117                *rtitem = stype_recovery_titem(stype);
    14731118                break;
    … …  
    15041149        }
    15051150
    1506         cspan_print(index->base->cspan);
    1507         printf(" Error: Indexing primitive type '");
     1151        printf("Error: Indexing primitive type '");
    15081152        tdata_item_print(base_ti);
    15091153        printf("'.\n");
    … …  
    15321176
    15331177#ifdef DEBUG_TYPE_TRACE
    1534         cspan_print(index->expr->cspan);
    1535         printf(" Indexing object type '");
     1178        printf("Indexing object type '");
    15361179        tdata_item_print(base_ti);
    15371180        printf("'.\n");
    … …  
    15471190
    15481191        if (idx_sym == NULL) {
    1549                 cspan_print(index->base->cspan);
    1550                 printf(" Error: Indexing object of type '");
     1192                printf("Error: Indexing object of type '");
    15511193                tdata_item_print(base_ti);
    15521194                printf("' which does not have an indexer.\n");
    … …  
    16041246                    arg->titem->u.tprimitive->tpc != tpc_int) {
    16051247
    1606                         cspan_print(arg->cspan);
    1607                         printf(" Error: Array index is not an integer.\n");
     1248                        printf("Error: Array index is not an integer.\n");
    16081249                        stype_note_error(stype);
    16091250                }
    … …  
    16131254
    16141255        if (arg_count != base_ti->u.tarray->rank) {
    1615                 cspan_print(index->expr->cspan);
    1616                 printf(" Error: Using %d indices with array of rank %d.\n",
     1256                printf("Error: Using %d indices with array of rank %d.\n",
    16171257                    arg_count, base_ti->u.tarray->rank);
    16181258                stype_note_error(stype);
    … …  
    16341274
    16351275#ifdef DEBUG_TYPE_TRACE
    1636         cspan_print(assign->expr->cspan);
    1637         printf(" Evaluate type of assignment.\n");
     1276        printf("Evaluate type of assignment.\n");
    16381277#endif
    16391278        stype_expr(stype, assign->dest);
    … …  
    16581297
    16591298#ifdef DEBUG_TYPE_TRACE
    1660         cspan_print(as_op->expr->cspan);
    1661         printf(" Evaluate type of @c as conversion.\n");
     1299        printf("Evaluate type of @c as conversion.\n");
    16621300#endif
    16631301        stype_expr(stype, as_op->arg);
    … …  
    16661304        /* Check that target type is derived from argument type. */
    16671305        if (tdata_is_ti_derived_from_ti(titem, as_op->arg->titem) != b_true) {
    1668                 cspan_print(as_op->dtype->cspan);
    1669                 printf(" Error: Target of 'as' operator '");
     1306                printf("Error: Target of 'as' operator '");
    16701307                tdata_item_print(titem);
    16711308                printf("' is not derived from '");
    … …  
    16951332
    16961333#ifdef DEBUG_TYPE_TRACE
    1697         cspan_print(box->expr->cspan);
    1698         printf(" Evaluate type of boxing operation.\n");
     1334        printf("Evaluate type of boxing operation.\n");
    16991335#endif
    17001336        bi = stype->program->builtin;

  • uspace/app/sbi/src/stype_t.h

    r640ffe6 r1317380  
    5454        /** Block activation records */
    5555        list_t block_vr; /* of run_block_ar_t */
    56 
    57         /** Number of active breakable statements (for break checking). */
    58         int bstat_cnt;
    5956} stype_proc_vr_t;
    6057

  • uspace/app/sbi/src/symbol.c

    r640ffe6 r1317380  
    4242static stree_symbol_t *symbol_find_epoint_rec(stree_program_t *prog,
    4343    stree_ident_t *name, stree_csi_t *csi);
    44 static stree_symbol_t *csimbr_to_symbol(stree_csimbr_t *csimbr);
    4544static stree_ident_t *symbol_get_ident(stree_symbol_t *symbol);
    4645
    … …  
    8988/** Lookup symbol reference in CSI.
    9089 *
    91  * XXX These functions should take just an sid, not a full identifier.
    92  * Sometimes we search for a name which has no associated cspan.
    93  *
    9490 * @param prog  Program to look in
    9591 * @param scope CSI in @a prog which is the base for references
    … …  
    132128    stree_csi_t *scope, stree_ident_t *name)
    133129{
     130        list_node_t *node;
     131        stree_csimbr_t *csimbr;
     132        stree_symbol_t *symbol;
     133        stree_ident_t *mbr_name;
    134134        stree_symbol_t *base_csi_sym;
    135135        stree_csi_t *base_csi;
    136         stree_symbol_t *symbol;
     136
     137        (void) prog;
    137138
    138139        /* Look in new members in this class. */
    139         symbol = symbol_search_csi_no_base(prog, scope, name);
    140         if (symbol != NULL)
    141                 return symbol;
     140
     141        node = list_first(&scope->members);
     142        while (node != NULL) {
     143                csimbr = list_node_data(node, stree_csimbr_t *);
     144
     145                /* Keep compiler happy. */
     146                mbr_name = NULL;
     147
     148                switch (csimbr->cc) {
     149                case csimbr_csi: mbr_name = csimbr->u.csi->name; break;
     150                case csimbr_deleg: mbr_name = csimbr->u.deleg->name; break;
     151                case csimbr_fun: mbr_name = csimbr->u.fun->name; break;
     152                case csimbr_var: mbr_name = csimbr->u.var->name; break;
     153                case csimbr_prop: mbr_name = csimbr->u.prop->name; break;
     154                }
     155
     156                if (name->sid == mbr_name->sid) {
     157                        /* Match */
     158                        switch (csimbr->cc) {
     159                        case csimbr_csi:
     160                                symbol = csi_to_symbol(csimbr->u.csi);
     161                                break;
     162                        case csimbr_deleg:
     163                                symbol = deleg_to_symbol(csimbr->u.deleg);
     164                                break;
     165                        case csimbr_fun:
     166                                symbol = fun_to_symbol(csimbr->u.fun);
     167                                break;
     168                        case csimbr_var:
     169                                symbol = var_to_symbol(csimbr->u.var);
     170                                break;
     171                        case csimbr_prop:
     172                                symbol = prop_to_symbol(csimbr->u.prop);
     173                                break;
     174                        default:
     175                                assert(b_false);
     176                        }
     177                        return symbol;
     178                }
     179                node = list_next(&scope->members, node);
     180        }
    142181
    143182        /* Try inherited members. */
    … …  
    155194}
    156195
    157 /** Look for symbol strictly in CSI.
    158  *
    159  * Look for symbol in definition of a CSI and its ancestors. (But not
    160  * in lexically enclosing CSI or in base CSI.)
    161  *
    162  * @param prog  Program to look in
    163  * @param scope CSI in which to look
    164  * @param name  Identifier of the symbol
    165  *
    166  * @return      Symbol or @c NULL if symbol not found.
    167  */
    168 stree_symbol_t *symbol_search_csi_no_base(stree_program_t *prog,
    169     stree_csi_t *scope, stree_ident_t *name)
    170 {
    171         list_node_t *node;
    172         stree_csimbr_t *csimbr;
    173         stree_ident_t *mbr_name;
    174 
    175         (void) prog;
    176 
    177         /* Look in new members in this class. */
    178 
    179         node = list_first(&scope->members);
    180         while (node != NULL) {
    181                 csimbr = list_node_data(node, stree_csimbr_t *);
    182                 mbr_name = stree_csimbr_get_name(csimbr);
    183 
    184                 if (name->sid == mbr_name->sid) {
    185                         /* Match */
    186                         return csimbr_to_symbol(csimbr);
    187                 }
    188 
    189                 node = list_next(&scope->members, node);
    190         }
    191         /* No match */
    192         return NULL;
    193 }
    194 
    195196/** Look for symbol in global scope.
    196197 *
    … …  
    206207        stree_modm_t *modm;
    207208        stree_symbol_t *symbol;
    208         stree_ident_t *mbr_name;
    209209
    210210        node = list_first(&prog->module->members);
    211211        while (node != NULL) {
    212212                modm = list_node_data(node, stree_modm_t *);
    213 
    214                 switch (modm->mc) {
    215                 case mc_csi: mbr_name = modm->u.csi->name; break;
    216                 case mc_enum: mbr_name = modm->u.enum_d->name; break;
    217                 }
    218 
    219                 if (name->sid == mbr_name->sid) {
     213                if (name->sid == modm->u.csi->name->sid) {
    220214                        /* Match */
    221215                        switch (modm->mc) {
    … …  
    223217                                symbol = csi_to_symbol(modm->u.csi);
    224218                                break;
    225                         case mc_enum:
    226                                 symbol = enum_to_symbol(modm->u.enum_d);
    227                                 break;
     219                        default:
     220                                assert(b_false);
    228221                        }
    229222                        return symbol;
    … …  
    353346}
    354347
    355 /** Convert symbol to enum (base to derived).
    356  *
    357  * @param symbol        Symbol
    358  * @return              Enum or @c NULL if symbol is not a enum
    359  */
    360 stree_enum_t *symbol_to_enum(stree_symbol_t *symbol)
    361 {
    362         if (symbol->sc != sc_enum)
    363                 return NULL;
    364 
    365         return symbol->u.enum_d;
    366 }
    367 
    368 /** Convert enum to symbol (derived to base).
    369  *
    370  * @param deleg         Enum
    371  * @return              Symbol
    372  */
    373 stree_symbol_t *enum_to_symbol(stree_enum_t *enum_d)
    374 {
    375         assert(enum_d->symbol);
    376         return enum_d->symbol;
    377 }
    378 
    379348/** Convert symbol to CSI (base to derived).
    380349 *
    … …  
    401370}
    402371
    403 /** Convert symbol to constructor (base to derived).
    404  *
    405  * @param symbol        Symbol
    406  * @return              Constructor or @c NULL if symbol is not a constructor
    407  */
    408 stree_ctor_t *symbol_to_ctor(stree_symbol_t *symbol)
    409 {
    410         if (symbol->sc != sc_ctor)
    411                 return NULL;
    412 
    413         return symbol->u.ctor;
    414 }
    415 
    416 /** Convert constructor to symbol (derived to base).
    417  *
    418  * @param ctor          Constructor
    419  * @return              Symbol
    420  */
    421 stree_symbol_t *ctor_to_symbol(stree_ctor_t *ctor)
    422 {
    423         assert(ctor->symbol);
    424         return ctor->symbol;
    425 }
    426 
    427 
    428372/** Convert symbol to function (base to derived).
    429373 *
    … …  
    486430        return symbol->u.prop;
    487431}
    488 
    489 /** Get symbol from CSI member.
    490  *
    491  * A symbol corresponds to any CSI member. Return it.
    492  *
    493  * @param csimbr        CSI member
    494  * @return              Symbol
    495  */
    496 static stree_symbol_t *csimbr_to_symbol(stree_csimbr_t *csimbr)
    497 {
    498         stree_symbol_t *symbol;
    499 
    500         /* Keep compiler happy. */
    501         symbol = NULL;
    502 
    503         /* Match */
    504         switch (csimbr->cc) {
    505         case csimbr_csi:
    506                 symbol = csi_to_symbol(csimbr->u.csi);
    507                 break;
    508         case csimbr_ctor:
    509                 symbol = ctor_to_symbol(csimbr->u.ctor);
    510                 break;
    511         case csimbr_deleg:
    512                 symbol = deleg_to_symbol(csimbr->u.deleg);
    513                 break;
    514         case csimbr_enum:
    515                 symbol = enum_to_symbol(csimbr->u.enum_d);
    516                 break;
    517         case csimbr_fun:
    518                 symbol = fun_to_symbol(csimbr->u.fun);
    519                 break;
    520         case csimbr_var:
    521                 symbol = var_to_symbol(csimbr->u.var);
    522                 break;
    523         case csimbr_prop:
    524                 symbol = prop_to_symbol(csimbr->u.prop);
    525                 break;
    526         }
    527 
    528         return symbol;
    529 }
    530 
    531432
    532433/** Convert property to symbol (derived to base).
    … …  
    571472        switch (symbol->sc) {
    572473        case sc_csi: ident = symbol->u.csi->name; break;
    573         case sc_ctor: ident = symbol->u.ctor->name; break;
    574474        case sc_deleg: ident = symbol->u.deleg->name; break;
    575         case sc_enum: ident = symbol->u.enum_d->name; break;
    576475        case sc_fun: ident = symbol->u.fun->name; break;
    577476        case sc_var: ident = symbol->u.var->name; break;

  • uspace/app/sbi/src/symbol.h

    r640ffe6 r1317380  
    3838stree_symbol_t *symbol_search_csi(stree_program_t *prog, stree_csi_t *scope,
    3939    stree_ident_t *name);
    40 stree_symbol_t *symbol_search_csi_no_base(stree_program_t *prog,
    41     stree_csi_t *scope, stree_ident_t *name);
    4240stree_symbol_t *symbol_find_epoint(stree_program_t *prog, stree_ident_t *name);
    4341
    … …  
    4644stree_csi_t *symbol_to_csi(stree_symbol_t *symbol);
    4745stree_symbol_t *csi_to_symbol(stree_csi_t *csi);
    48 stree_ctor_t *symbol_to_ctor(stree_symbol_t *symbol);
    49 stree_symbol_t *ctor_to_symbol(stree_ctor_t *ctor);
    50 stree_enum_t *symbol_to_enum(stree_symbol_t *symbol);
    51 stree_symbol_t *enum_to_symbol(stree_enum_t *enum_d);
    5246stree_fun_t *symbol_to_fun(stree_symbol_t *symbol);
    5347stree_symbol_t *fun_to_symbol(stree_fun_t *fun);

  • uspace/app/sbi/src/tdata.c

    r640ffe6 r1317380  
    4848static void tdata_item_subst_tdeleg(tdata_deleg_t *torig,
    4949    tdata_tvv_t *tvv, tdata_item_t **res);
    50 static void tdata_item_subst_tebase(tdata_ebase_t *tebase,
    51     tdata_tvv_t *tvv, tdata_item_t **res);
    52 static void tdata_item_subst_tenum(tdata_enum_t *tenum,
    53     tdata_tvv_t *tvv, tdata_item_t **res);
    5450static void tdata_item_subst_tfun(tdata_fun_t *torig,
    5551    tdata_tvv_t *tvv, tdata_item_t **res);
    … …  
    6460static void tdata_tarray_print(tdata_array_t *tarray);
    6561static void tdata_tdeleg_print(tdata_deleg_t *tdeleg);
    66 static void tdata_tebase_print(tdata_ebase_t *tebase);
    67 static void tdata_tenum_print(tdata_enum_t *tenum);
    6862static void tdata_tfun_print(tdata_fun_t *tfun);
    6963static void tdata_tvref_print(tdata_vref_t *tvref);
    … …  
    163157                return tdata_item_equal(a->u.tarray->base_ti,
    164158                    b->u.tarray->base_ti);
    165         case tic_tenum:
    166                 /* Check if both use the same enum definition. */
    167                 return (a->u.tenum->enum_d == b->u.tenum->enum_d);
    168159        case tic_tvref:
    169160                /* Check if both refer to the same type argument. */
    … …  
    205196                tdata_item_subst_tdeleg(ti->u.tdeleg, tvv, res);
    206197                break;
    207         case tic_tebase:
    208                 tdata_item_subst_tebase(ti->u.tebase, tvv, res);
    209                 break;
    210         case tic_tenum:
    211                 tdata_item_subst_tenum(ti->u.tenum, tvv, res);
    212                 break;
    213198        case tic_tfun:
    214199                tdata_item_subst_tfun(ti->u.tfun, tvv, res);
    … …  
    328313}
    329314
    330 /** Substitute type variables in a enum-base type item.
    331  *
    332  * @param torig Type item to substitute into.
    333  * @param tvv   Type variable valuation (values of type variables).
    334  * @param res   Place to store pointer to new type item.
    335  */
    336 static void tdata_item_subst_tebase(tdata_ebase_t *tebase,
    337     tdata_tvv_t *tvv, tdata_item_t **res)
    338 {
    339         tdata_ebase_t *tnew;
    340 
    341         (void) tvv;
    342 
    343         /* Plain copy */
    344         tnew = tdata_ebase_new();
    345         *res = tdata_item_new(tic_tebase);
    346         (*res)->u.tebase = tebase;
    347 }
    348 
    349 /** Substitute type variables in a enum type item.
    350  *
    351  * @param torig Type item to substitute into.
    352  * @param tvv   Type variable valuation (values of type variables).
    353  * @param res   Place to store pointer to new type item.
    354  */
    355 static void tdata_item_subst_tenum(tdata_enum_t *tenum,
    356     tdata_tvv_t *tvv, tdata_item_t **res)
    357 {
    358         tdata_enum_t *tnew;
    359 
    360         (void) tvv;
    361 
    362         /* Plain copy */
    363         tnew = tdata_enum_new();
    364         *res = tdata_item_new(tic_tenum);
    365         (*res)->u.tenum = tenum;
    366 }
    367 
    368315/** Substitute type variables in a functional type item.
    369316 *
    … …  
    470417        case tic_tdeleg:
    471418                tdata_tdeleg_print(titem->u.tdeleg);
    472                 break;
    473         case tic_tebase:
    474                 tdata_tebase_print(titem->u.tebase);
    475                 break;
    476         case tic_tenum:
    477                 tdata_tenum_print(titem->u.tenum);
    478419                break;
    479420        case tic_tfun:
    … …  
    556497}
    557498
    558 /** Print enum-base type item.
    559  *
    560  * @param tebase                Enum-base type item
    561  */
    562 static void tdata_tebase_print(tdata_ebase_t *tebase)
    563 {
    564         stree_symbol_t *enum_sym;
    565 
    566         enum_sym = enum_to_symbol(tebase->enum_d);
    567 
    568         printf("typeref(");
    569         symbol_print_fqn(enum_sym);
    570         printf(")");
    571 }
    572 
    573 /** Print enum type item.
    574  *
    575  * @param tenum         Enum type item
    576  */
    577 static void tdata_tenum_print(tdata_enum_t *tenum)
    578 {
    579         stree_symbol_t *enum_sym;
    580 
    581         enum_sym = enum_to_symbol(tenum->enum_d);
    582         symbol_print_fqn(enum_sym);
    583 }
    584 
    585499/** Print function type item.
    586500 *
    … …  
    710624}
    711625
    712 /** Allocate new enum-base type item.
    713  *
    714  * @return      New enum type item
    715  */
    716 tdata_ebase_t *tdata_ebase_new(void)
    717 {
    718         tdata_ebase_t *tebase;
    719 
    720         tebase = calloc(1, sizeof(tdata_ebase_t));
    721         if (tebase == NULL) {
    722                 printf("Memory allocation failed.\n");
    723                 exit(1);
    724         }
    725 
    726         return tebase;
    727 }
    728 
    729 /** Allocate new enum type item.
    730  *
    731  * @return      New enum type item
    732  */
    733 tdata_enum_t *tdata_enum_new(void)
    734 {
    735         tdata_enum_t *tenum;
    736 
    737         tenum = calloc(1, sizeof(tdata_enum_t));
    738         if (tenum == NULL) {
    739                 printf("Memory allocation failed.\n");
    740                 exit(1);
    741         }
    742 
    743         return tenum;
    744 }
    745 
    746626/** Allocate new functional type item.
    747627 *
    … …  
    827707}
    828708
    829 /** Set type variable value.
     709/** Set tyoe variable value.
    830710 *
    831711 * Sets the value of variable with name SID @a name in type variable

  • uspace/app/sbi/src/tdata.h

    r640ffe6 r1317380  
    3737tdata_primitive_t *tdata_primitive_new(tprimitive_class_t tpc);
    3838tdata_deleg_t *tdata_deleg_new(void);
    39 tdata_ebase_t *tdata_ebase_new(void);
    40 tdata_enum_t *tdata_enum_new(void);
    4139tdata_fun_t *tdata_fun_new(void);
    4240tdata_vref_t *tdata_vref_new(void);

  • uspace/app/sbi/src/tdata_t.h

    r640ffe6 r1317380  
    104104} tdata_deleg_t;
    105105
    106 /** Enum-base type.
    107  *
    108  * Type for expression which reference an enum declaration. In run time
    109  * enum type reference is represented by @c rdata_deleg_t. (Which is used
    110  * for any symbol references).
    111  */
    112 typedef struct {
    113         /** Enum definition */
    114         struct stree_enum *enum_d;
    115 } tdata_ebase_t;
    116 
    117 /** Enum type. */
    118 typedef struct {
    119         /** Enum definition */
    120         struct stree_enum *enum_d;
    121 } tdata_enum_t;
    122 
    123106/** Functional type. */
    124107typedef struct {
    … …  
    145128        /** Delegate type item */
    146129        tic_tdeleg,
    147         /** Enum-base type item */
    148         tic_tebase,
    149         /** Enum type item */
    150         tic_tenum,
    151130        /** Function type item */
    152131        tic_tfun,
    … …  
    166145                tdata_array_t *tarray;
    167146                tdata_deleg_t *tdeleg;
    168                 tdata_ebase_t *tebase;
    169                 tdata_enum_t *tenum;
    170147                tdata_fun_t *tfun;
    171148                tdata_vref_t *tvref;

  • uspace/dist/src/sysel/demos/htxtfile.sy

    r640ffe6 r1317380  
    4343                out_file.OpenWrite("/out.txt");
    4444
    45                 while not in_file.EOF do
     45                while in_file.EOF != 1 do
    4646                        line = in_file.ReadLine();
    4747                        Builtin.WriteLine(name + ": " + line);

  • uspace/dist/src/sysel/demos/list.sy

    r640ffe6 r1317380  
    3333
    3434                list = new List/int();
     35                list.Init();
    3536
    3637                list.Append(5);
    … …  
    4344                n = list.First;
    4445                while n != nil do
    45                         Builtin.WriteLine(n.Data);
     46                        Builtin.WriteLine(n.Value);
    4647                        n = n.Next;
    4748                end

  • uspace/dist/src/sysel/demos/string.sy

    r640ffe6 r1317380  
    3939                        i = i + 1;
    4040                end
    41 
    42                 Builtin.WriteLine("Abracadabra".Slice(2, 4));
    4341        end
    4442end

  • uspace/dist/src/sysel/demos/varargs.sy

    r640ffe6 r1317380  
    3535        fun Print(args : string[], packed) is
    3636                var i : int;
    37                 var error : bool;
     37                var error : int;
    3838
    39                 error = false;
     39                error = 0;
    4040                i = 0;
    41                 while not error do
     41                while error == 0 do
    4242                        -- This is definitely the wrong way to determine
    4343                        -- array bounds, but until a better one is
    … …  
    4646                                Builtin.WriteLine(args[i]);
    4747                        except e : Error.OutOfBounds do
    48                                 error = true;
     48                                error = 1;
    4949                        end
    5050

  • uspace/dist/src/sysel/lib/boxed.sy

    r640ffe6 r1317380  
    4646class String is
    4747        var Value : string;
    48 
    49         fun get_length() : int, builtin;
    50 
    51         -- Length of string.
    52         prop Length : int is
    53                 get is
    54                         return get_length();
    55                 end
    56         end
    57 
    58         -- Slice (sub-string).
    59         fun Slice(start : int; length : int) : string, builtin;
    6048end

  • uspace/dist/src/sysel/lib/libflist

    r640ffe6 r1317380  
    22boxed.sy
    33list.sy
    4 map.sy

  • uspace/dist/src/sysel/lib/list.sy

    r640ffe6 r1317380  
    3131        var head : ListNode/t;
    3232
    33         -- New empty list.
    34         new() is
     33        -- Initialize list.
     34        fun Init() is
    3535                head = new ListNode/t();
    3636                head.prev = head;
    … …  
    4646
    4747                n = new ListNode/t();
    48                 n.data = data;
     48                n.value = data;
    4949
    5050                n.prev = ntl;
    … …  
    7474
    7575class ListNode/t is
    76         var data : t;
     76        var value : t;
    7777
    7878        var prev : ListNode/t;
    … …  
    8080        var head : ListNode/t;
    8181
    82         -- Data stored in this node.
    83         prop Data : t is
     82        -- Value stored in this node.
     83        prop Value : t is
    8484                get is
    85                         return data;
     85                        return value;
    8686                end
    8787        end
    … …  
    9999                        return get_next();
    100100                end
    101         end
    102 
    103         -- Remove node from list.
    104         fun Remove() is
    105                 var p : ListNode/t;
    106                 var n : ListNode/t;
    107 
    108                 p = prev; n = next;
    109                 p.next = n;
    110                 n.prev = p;
    111 
    112                 prev = nil;
    113                 next = nil;
    114101        end
    115102
Note: See TracChangeset for help on using the changeset viewer.