Changeset 39e8406 in mainline for uspace/app/sbi/src/run.c


Ignore:
Timestamp:
2010-03-20T21:57:13Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
b535aeb
Parents:
6ba20a6b
Message:

Update SBI to rev. 128.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r6ba20a6b r39e8406  
    4343#include "strtab.h"
    4444#include "symbol.h"
     45#include "tdata.h"
    4546
    4647#include "run.h"
    … …  
    5758
    5859static bool_t run_exc_match(run_t *run, stree_except_t *except_c);
     60static rdata_var_t *run_aprop_get_tpos(run_t *run, rdata_address_t *aprop);
    5961
    6062static void run_aprop_read(run_t *run, rdata_addr_prop_t *addr_prop,
    … …  
    102104
    103105#ifdef DEBUG_RUN_TRACE
    104         printf("Found function '"); symbol_print_fqn(prog, main_fun_sym);
     106        printf("Found function '"); symbol_print_fqn(main_fun_sym);
    105107        printf("'.\n");
    106108#endif
    … …  
    108110        /* Run function @c main. */
    109111        list_init(&main_args);
    110         run_proc_ar_create(run, NULL, main_fun_sym, main_fun->body, &proc_ar);
     112        run_proc_ar_create(run, NULL, main_fun->proc, &proc_ar);
    111113        run_proc_ar_set_args(run, proc_ar, &main_args);
    112114        run_proc(run, proc_ar, &res);
    … …  
    123125void run_proc(run_t *run, run_proc_ar_t *proc_ar, rdata_item_t **res)
    124126{
    125         stree_symbol_t *proc_sym;
     127        stree_proc_t *proc;
    126128        list_node_t *node;
    127129
    128         proc_sym = proc_ar->proc_sym;
     130        proc = proc_ar->proc;
    129131
    130132#ifdef DEBUG_RUN_TRACE
    131133        printf("Start executing function '");
    132         symbol_print_fqn(run->program, proc_sym);
     134        symbol_print_fqn(proc_sym);
    133135        printf("'.\n");
    134136#endif
    … …  
    137139
    138140        /* Run main procedure block. */
    139         if (proc_ar->proc_block != NULL) {
    140                 run_block(run, proc_ar->proc_block);
     141        if (proc->body != NULL) {
     142                run_block(run, proc->body);
    141143        } else {
    142                 builtin_run_proc(run, proc_sym);
     144                builtin_run_proc(run, proc);
    143145        }
    144146
    … …  
    157159#ifdef DEBUG_RUN_TRACE
    158160        printf("Done executing procedure '");
    159         symbol_print_fqn(run->program, proc_sym);
     161        symbol_print_fqn(proc);
    160162        printf("'.\n");
    161163
    … …  
    469471        rdata_var_t *payload_v;
    470472        rdata_object_t *payload_o;
    471         rdata_titem_t *etype;
     473        tdata_item_t *etype;
    472474
    473475        payload = run->thread_ar->exc_payload;
    … …  
    491493#ifdef DEBUG_RUN_TRACE
    492494        printf("Active exception: '");
    493         symbol_print_fqn(run->program, payload_o->class_sym);
     495        symbol_print_fqn(payload_o->class_sym);
    494496        printf("'.\n");
    495497#endif
    … …  
    498500
    499501        /* Evaluate type expression in except clause. */
    500         run_texpr(run, except_c->etype, &etype);
    501 
    502         return rdata_is_csi_derived_from_ti(payload_o->class_sym->u.csi,
     502        run_texpr(run->program, run_get_current_csi(run), except_c->etype,
     503            &etype);
     504
     505        return tdata_is_csi_derived_from_ti(payload_o->class_sym->u.csi,
    503506            etype);
    504507}
    … …  
    556559
    557560        proc_ar = run_get_current_proc_ar(run);
    558         return proc_ar->proc_sym->outer_csi;
     561        return proc_ar->proc->outer_symbol->outer_csi;
    559562}
    560563
    … …  
    606609
    607610/** Construct a function AR. */
    608 void run_proc_ar_create(run_t *run, rdata_var_t *obj, stree_symbol_t *proc_sym,
    609     stree_block_t *proc_block, run_proc_ar_t **rproc_ar)
     611void run_proc_ar_create(run_t *run, rdata_var_t *obj, stree_proc_t *proc,
     612    run_proc_ar_t **rproc_ar)
    610613{
    611614        run_proc_ar_t *proc_ar;
    … …  
    617620        proc_ar = run_proc_ar_new();
    618621        proc_ar->obj = obj;
    619         proc_ar->proc_sym = proc_sym;
    620         proc_ar->proc_block = proc_block;
     622        proc_ar->proc = proc;
    621623        list_init(&proc_ar->block_ar);
    622624
    … …  
    642644        list_t *args;
    643645        stree_proc_arg_t *varg;
     646        stree_symbol_t *outer_symbol;
    644647
    645648        run_block_ar_t *block_ar;
    … …  
    655658        int n_vargs, idx;
    656659
     660        (void) run;
     661
    657662        /* AR should have been created with run_proc_ar_create(). */
    658         assert(proc_ar->proc_sym != NULL);
     663        assert(proc_ar->proc != NULL);
     664        outer_symbol = proc_ar->proc->outer_symbol;
    659665
    660666        /*
    661          * The procedure being activated should be a member function or
     667         * The procedure being activated should belong to a member function or
    662668         * property getter/setter.
    663669         */
    664         switch (proc_ar->proc_sym->sc) {
     670        switch (outer_symbol->sc) {
    665671        case sc_fun:
    666                 fun = symbol_to_fun(proc_ar->proc_sym);
     672                fun = symbol_to_fun(outer_symbol);
    667673                args = &fun->args;
    668674                varg = fun->varg;
    669675                break;
    670676        case sc_prop:
    671                 prop = symbol_to_prop(proc_ar->proc_sym);
     677                prop = symbol_to_prop(outer_symbol);
    672678                args = &prop->args;
    673679                varg = prop->varg;
    … …  
    688694        while (parg_n != NULL) {
    689695                if (rarg_n == NULL) {
    690                         printf("Error: Too few arguments to function '");
    691                         symbol_print_fqn(run->program, proc_ar->proc_sym);
     696                        printf("Error: Too few arguments to '");
     697                        symbol_print_fqn(outer_symbol);
    692698                        printf("'.\n");
    693699                        exit(1);
    … …  
    752758        /* Check for excess real parameters. */
    753759        if (rarg_n != NULL) {
    754                 printf("Error: Too many arguments to function '");
    755                 symbol_print_fqn(run->program, proc_ar->proc_sym);
     760                printf("Error: Too many arguments to '");
     761                symbol_print_fqn(outer_symbol);
    756762                printf("'.\n");
    757763                exit(1);
    … …  
    775781
    776782        /* AR should have been created with run_proc_ar_create(). */
    777         assert(proc_ar->proc_sym != NULL);
    778 
    779         /* The procedure being activated should be a property setter. */
    780         prop = symbol_to_prop(proc_ar->proc_sym);
     783        assert(proc_ar->proc != NULL);
     784
     785        /* The procedure being activated should belong to a property setter. */
     786        prop = symbol_to_prop(proc_ar->proc->outer_symbol);
    781787        assert(prop != NULL);
     788        assert(proc_ar->proc == prop->setter);
    782789
    783790        /* Fetch first block activation record. */
    … …  
    792799
    793800        /* Declare variable using name of formal argument. */
    794         intmap_set(&block_ar->vars, prop->setter_arg_name->sid, var);
     801        intmap_set(&block_ar->vars, prop->setter_arg->name->sid, var);
    795802}
    796803
    … …  
    806813                printf(" * ");
    807814                proc_ar = list_node_data(node, run_proc_ar_t *);
    808                 symbol_print_fqn(run->program, proc_ar->proc_sym);
     815                symbol_print_fqn(proc_ar->proc->outer_symbol);
    809816                printf("\n");
    810817
    … …  
    844851}
    845852
     853/** Get item var-class.
     854 *
     855 * Get var-class of @a item, regardless whether it is a value or address.
     856 * (I.e. the var class of the value or variable at the given address).
     857 */
     858var_class_t run_item_get_vc(run_t *run, rdata_item_t *item)
     859{
     860        var_class_t vc;
     861        rdata_var_t *tpos;
     862
     863        (void) run;
     864
     865        switch (item->ic) {
     866        case ic_value:
     867                vc = item->u.value->var->vc;
     868                break;
     869        case ic_address:
     870                switch (item->u.address->ac) {
     871                case ac_var:
     872                        vc = item->u.address->u.var_a->vref->vc;
     873                        break;
     874                case ac_prop:
     875                        /* Prefetch the value of the property. */
     876                        tpos = run_aprop_get_tpos(run, item->u.address);
     877                        vc = tpos->vc;
     878                        break;
     879                default:
     880                        assert(b_false);
     881                }
     882                break;
     883        default:
     884                assert(b_false);
     885        }
     886
     887        return vc;
     888}
     889
     890/** Get pointer to current var node in temporary copy in property address.
     891 *
     892 * A property address refers to a specific @c var node in a property.
     893 * This function will fetch a copy of the property value (by running
     894 * its getter) if there is not a temporary copy in the address yet.
     895 * It returns a pointer to the relevant @c var node in the temporary
     896 * copy.
     897 *
     898 * @param run   Runner object.
     899 * @param addr  Address of class @c ac_prop.
     900 * @param       Pointer to var node.
     901 */
     902static rdata_var_t *run_aprop_get_tpos(run_t *run, rdata_address_t *addr)
     903{
     904        rdata_item_t *ritem;
     905
     906        assert(addr->ac == ac_prop);
     907
     908        if (addr->u.prop_a->tvalue == NULL) {
     909                /* Fetch value of the property. */
     910                run_address_read(run, addr, &ritem);
     911                assert(ritem->ic == ic_value);
     912                addr->u.prop_a->tvalue = ritem->u.value;
     913                addr->u.prop_a->tpos = addr->u.prop_a->tvalue->var;
     914        }
     915
     916        return addr->u.prop_a->tpos;
     917}
    846918
    847919/** Read data from an address.
    … …  
    894966
    895967        run_proc_ar_t *proc_ar;
     968
     969        rdata_var_t *cvar;
    896970
    897971#ifdef DEBUG_RUN_TRACE
    … …  
    903977         */
    904978        if (addr_prop->tvalue != NULL) {
    905                 printf("Unimplemented: Property field access.\n");
    906                 exit(1);
     979                /* Copy the value */
     980                rdata_var_copy(addr_prop->tpos, &cvar);
     981                *ritem = rdata_item_new(ic_value);
     982                (*ritem)->u.value = rdata_value_new();
     983                (*ritem)->u.value->var = cvar;
     984                return;
    907985        }
    908986
    … …  
    917995        assert(prop != NULL);
    918996
    919         if (prop->getter_body == NULL) {
     997        if (prop->getter == NULL) {
    920998                printf("Error: Property is not readable.\n");
    921999                exit(1);
    … …  
    9231001
    9241002        /* Create procedure activation record. */
    925         run_proc_ar_create(run, obj, prop_sym, prop->getter_body, &proc_ar);
     1003        run_proc_ar_create(run, obj, prop->getter, &proc_ar);
    9261004
    9271005        /* Fill in arguments (indices). */
    … …  
    9731051        assert(prop != NULL);
    9741052
    975         if (prop->setter_body == NULL) {
     1053        if (prop->setter == NULL) {
    9761054                printf("Error: Property is not writable.\n");
    9771055                exit(1);
    … …  
    9821060
    9831061        /* Create procedure activation record. */
    984         run_proc_ar_create(run, obj, prop_sym, prop->setter_body, &proc_ar);
     1062        run_proc_ar_create(run, obj, prop->setter, &proc_ar);
    9851063
    9861064        /* Fill in arguments (indices). */
Note: See TracChangeset for help on using the changeset viewer.