← Back to branch summary

~jsvoboda/helenos/sysel

« back to all changes in this revision

Viewing changes to uspace/app/sbi/src/run_texpr.c

  • Committer: Jiri Svoboda
  • Date: 2010-05-08 08:10:44 UTC
  • Revision ID: jiri@wiwaxia-20100508081044-5hvcjwu15rsfvgnv
Update SBI to rev. 244.

Show diffs side-by-side

added added

removed removed

Lines of Context:
uspace/app/sbi/src/run_texpr.c
30
30
 
31
31
#include <assert.h>
32
32
#include <stdlib.h>
 
33
#include "cspan.h"
33
34
#include "debug.h"
34
35
#include "list.h"
35
36
#include "mytypes.h"
101
102
        tdata_object_t *tobject;
102
103
        tdata_deleg_t *tdeleg;
103
104
        stree_csi_t *base_csi;
 
105
        stree_deleg_t *deleg;
 
106
        stree_enum_t *enum_d;
 
107
        tdata_enum_t *tenum;
104
108
 
105
109
#ifdef DEBUG_RUN_TRACE
106
110
        printf("Evaluating type access operation.\n");
114
118
        }
115
119
 
116
120
        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");
118
124
                *res = tdata_item_new(tic_ignore);
119
125
                return;
120
126
        }
124
130
 
125
131
        sym = symbol_lookup_in_csi(prog, base_csi, taccess->member_name);
126
132
        if (sym == NULL) {
127
 
                printf("Error: CSI '");
 
133
                cspan_print(taccess->member_name->cspan);
 
134
                printf(" Error: CSI '");
128
135
                symbol_print_fqn(csi_to_symbol(base_csi));
129
136
                printf("' has no member named '%s'.\n",
130
137
                    strtab_get_str(taccess->member_name->sid));
141
148
 
142
149
                tobject->static_ref = b_false;
143
150
                tobject->csi = sym->u.csi;
144
 
                list_init(&tobject->targs); /* XXX */
 
151
                list_init(&tobject->targs);
145
152
                break;
 
153
        case sc_ctor:
 
154
                /* It is not possible to reference a constructor explicitly. */
 
155
                assert(b_false);
146
156
        case sc_deleg:
147
 
                /* Construct type item. */
148
 
                titem = tdata_item_new(tic_tdeleg);
149
 
                tdeleg = tdata_deleg_new();
150
 
                titem->u.tdeleg = tdeleg;
 
157
                /* Fetch stored delegate type. */
 
158
                deleg = symbol_to_deleg(sym);
 
159
                assert(deleg != NULL);
 
160
                if (deleg->titem == NULL) {
 
161
                        /*
 
162
                         * Prepare a partial delegate which will be completed
 
163
                         * later.
 
164
                         */
 
165
                        titem = tdata_item_new(tic_tdeleg);
 
166
                        tdeleg = tdata_deleg_new();
 
167
                        titem->u.tdeleg = tdeleg;
 
168
                        tdeleg->deleg = deleg;
 
169
                        tdeleg->tsig = NULL;
151
170
 
152
 
                tdeleg->deleg = sym->u.deleg;
 
171
                        deleg->titem = titem;
 
172
                } else {
 
173
                        titem = deleg->titem;
 
174
                }
 
175
                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
                }
153
192
                break;
154
193
        case sc_fun:
155
194
        case sc_var:
156
195
        case sc_prop:
157
 
                printf("Error: Symbol '");
 
196
                cspan_print(taccess->member_name->cspan);
 
197
                printf(" Error: Symbol '");
158
198
                symbol_print_fqn(sym);
159
199
                printf("' is not a type.\n");
160
200
                titem = tdata_item_new(tic_ignore);
263
303
        tdata_vref_t *tvref;
264
304
        stree_deleg_t *deleg;
265
305
        tdata_deleg_t *tdeleg;
 
306
        stree_enum_t *enum_d;
 
307
        tdata_enum_t *tenum;
266
308
 
267
309
#ifdef DEBUG_RUN_TRACE
268
310
        printf("Evaluating type name reference.\n");
292
334
        /* Look for symbol */
293
335
        sym = symbol_lookup_in_csi(prog, ctx, tnameref->name);
294
336
        if (sym == NULL) {
295
 
                printf("Error: Symbol '%s' not found.\n",
 
337
                cspan_print(tnameref->texpr->cspan);
 
338
                printf(" Error: Symbol '%s' not found.\n",
296
339
                    strtab_get_str(tnameref->name->sid));
297
340
                *res = tdata_item_new(tic_ignore);
298
341
                return;
307
350
 
308
351
                tobject->static_ref = b_false;
309
352
                tobject->csi = sym->u.csi;
310
 
                list_init(&tobject->targs); /* XXX */
 
353
                list_init(&tobject->targs);
311
354
                break;
 
355
        case sc_ctor:
 
356
                /* It is not possible to reference a constructor explicitly. */
 
357
                assert(b_false);
312
358
        case sc_deleg:
313
359
                /* Fetch stored delegate type. */
314
360
                deleg = symbol_to_deleg(sym);
329
375
                        titem = deleg->titem;
330
376
                }
331
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;
332
395
        case sc_fun:
333
396
        case sc_var:
334
397
        case sc_prop:
335
 
                printf("Error: Symbol '");
 
398
                cspan_print(tnameref->texpr->cspan);
 
399
                printf(" Error: Symbol '");
336
400
                symbol_print_fqn(sym);
337
401
                printf("' is not a type.\n");
338
402
                titem = tdata_item_new(tic_ignore);
378
442
        run_texpr(prog, ctx, tapply->gtype, &base_ti);
379
443
 
380
444
        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 "
382
447
                    "a CSI.\n");
383
448
                *res = tdata_item_new(tic_ignore);
384
449
                return;
409
474
        }
410
475
 
411
476
        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");
413
479
                *res = tdata_item_new(tic_ignore);
414
480
                return;
415
481
        }