Changeset 051bc69a in mainline for uspace/app/sbi/src/run_texpr.c


Ignore:
Timestamp:
2010-05-08T08:10:44Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
640ffe6, c5cb943d
Parents:
25a76ab8
Message:

Update SBI to rev. 244.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r25a76ab8 r051bc69a  
    3131#include <assert.h>
    3232#include <stdlib.h>
     33#include "cspan.h"
    3334#include "debug.h"
    3435#include "list.h"
    … …  
    102103        tdata_deleg_t *tdeleg;
    103104        stree_csi_t *base_csi;
     105        stree_deleg_t *deleg;
     106        stree_enum_t *enum_d;
     107        tdata_enum_t *tenum;
    104108
    105109#ifdef DEBUG_RUN_TRACE
    … …  
    115119
    116120        if (targ_i->tic != tic_tobject) {
    117                 printf("Error: Using '.' with type which is not an object.\n");
     121                cspan_print(taccess->texpr->cspan);
     122                printf(" Error: Using '.' with type which is not an "
     123                    "object.\n");
    118124                *res = tdata_item_new(tic_ignore);
    119125                return;
    … …  
    125131        sym = symbol_lookup_in_csi(prog, base_csi, taccess->member_name);
    126132        if (sym == NULL) {
    127                 printf("Error: CSI '");
     133                cspan_print(taccess->member_name->cspan);
     134                printf(" Error: CSI '");
    128135                symbol_print_fqn(csi_to_symbol(base_csi));
    129136                printf("' has no member named '%s'.\n",
    … …  
    142149                tobject->static_ref = b_false;
    143150                tobject->csi = sym->u.csi;
    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  */
    178 static 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  */
    226 static 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 
    256 static 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;
     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);
    312156        case sc_deleg:
    313157                /* Fetch stored delegate type. */
    … …  
    330174                }
    331175                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;
    332193        case sc_fun:
    333194        case sc_var:
    334195        case sc_prop:
    335                 printf("Error: Symbol '");
     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 */
     218static 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 */
     266static 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
     296static 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 '");
    336400                symbol_print_fqn(sym);
    337401                printf("' is not a type.\n");
    … …  
    379443
    380444        if (base_ti->tic != tic_tobject) {
    381                 printf("Error: Base type of generic application is not "
     445                cspan_print(tapply->gtype->cspan);
     446                printf(" Error: Base type of generic application is not "
    382447                    "a CSI.\n");
    383448                *res = tdata_item_new(tic_ignore);
    … …  
    410475
    411476        if (farg_n != NULL || arg_n != NULL) {
    412                 printf("Error: Incorrect number of type arguments.\n");
     477                cspan_print(tapply->texpr->cspan);
     478                printf(" Error: Incorrect number of type arguments.\n");
    413479                *res = tdata_item_new(tic_ignore);
    414480                return;
Note: See TracChangeset for help on using the changeset viewer.