Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r051b3db8 rc5cb943d  
    11/*
    2  * Copyright (c) 2011 Jiri Svoboda
     2 * Copyright (c) 2010 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    113113static void run_call(run_t *run, stree_call_t *call, rdata_item_t **res);
    114114static void run_call_args(run_t *run, list_t *args, list_t *arg_vals);
    115 static void run_destroy_arg_vals(list_t *arg_vals);
    116115
    117116static void run_index(run_t *run, stree_index_t *index, rdata_item_t **res);
    … …  
    201200        rdata_address_t *address;
    202201        rdata_addr_var_t *addr_var;
    203         rdata_addr_prop_t *addr_prop;
    204         rdata_aprop_named_t *aprop_named;
    205         rdata_deleg_t *deleg_p;
    206202        rdata_value_t *value;
    207203        rdata_var_t *var;
    … …  
    338334                break;
    339335        case sc_var:
    340         case sc_prop:
    341 #ifdef DEBUG_RUN_TRACE
    342                 if (sym->sc == sc_var)
    343                         printf("Referencing member variable.\n");
    344                 else
    345                         printf("Referencing unqualified property.\n");
    346 #endif
    347                 /* There should be no global variables or properties. */
     336#ifdef DEBUG_RUN_TRACE
     337                printf("Referencing member variable.\n");
     338#endif
     339                /* There should be no global variables. */
    348340                assert(csi != NULL);
    349341
    350342                if (symbol_search_csi(run->program, csi, nameref->name)
    351343                    == NULL && !stree_symbol_is_static(sym)) {
    352                         /* Symbol is not in the current object. */
     344                        /* Variable is not in the current object. */
    353345                        printf("Error: Cannot access non-static member "
    354346                            "variable '");
    … …  
    360352                }
    361353
    362                 /*
    363                  * Determine object in which the symbol resides
    364                  */
    365354                if (stree_symbol_is_static(sym)) {
    366355                        /*
    367                          * Class object
    368356                         * XXX This is too slow!
    369357                         *
    … …  
    377365                        aobj = sobj->u.object_v;
    378366                } else {
    379                         /*
    380                          * Instance object. Currently we don't support
    381                          * true inner classes, thus we know the symbol is
    382                          * in the active object (there is no dynamic parent).
    383                          */
    384                         sobj = proc_ar->obj;
    385                         aobj = sobj->u.object_v;;
     367                        aobj = obj;
    386368                }
    387369
    388                 if (sym->sc == sc_var) {
    389                         /* Find member variable in object. */
    390                         member_var = intmap_get(&aobj->fields,
    391                             nameref->name->sid);
    392                         assert(member_var != NULL);
    393 
    394                         /* Return address of the variable. */
    395                         item = rdata_item_new(ic_address);
    396                         address = rdata_address_new(ac_var);
    397                         addr_var = rdata_addr_var_new();
    398 
    399                         item->u.address = address;
    400                         address->u.var_a = addr_var;
    401                         addr_var->vref = member_var;
    402 
    403                         *res = item;
    404                 } else {
    405                         /* Construct named property address. */
    406                         item = rdata_item_new(ic_address);
    407                         address = rdata_address_new(ac_prop);
    408                         addr_prop = rdata_addr_prop_new(apc_named);
    409                         aprop_named = rdata_aprop_named_new();
    410                         item->u.address = address;
    411                         address->u.prop_a = addr_prop;
    412                         addr_prop->u.named = aprop_named;
    413 
    414                         deleg_p = rdata_deleg_new();
    415                         deleg_p->obj = sobj;
    416                         deleg_p->sym = sym;
    417                         addr_prop->u.named->prop_d = deleg_p;
    418 
    419                         *res = item;
    420                 }
     370                /* Find member variable in object. */
     371                member_var = intmap_get(&aobj->fields, nameref->name->sid);
     372                assert(member_var != NULL);
     373
     374                /* Return address of the variable. */
     375                item = rdata_item_new(ic_address);
     376                address = rdata_address_new(ac_var);
     377                addr_var = rdata_addr_var_new();
     378
     379                item->u.address = address;
     380                address->u.var_a = addr_var;
     381                addr_var->vref = member_var;
     382
     383                *res = item;
     384                break;
     385        case sc_prop:
     386                /* XXX TODO */
     387                printf("Unimplemented: Property name reference.\n");
     388                abort();
    421389                break;
    422390        }
    … …  
    643611        rdata_value_t *v1, *v2;
    644612
    645         rarg1_i = NULL;
    646         rarg2_i = NULL;
    647         rarg1_vi = NULL;
    648         rarg2_vi = NULL;
    649 
    650613#ifdef DEBUG_RUN_TRACE
    651614        printf("Run binary operation.\n");
    … …  
    653616        run_expr(run, binop->arg1, &rarg1_i);
    654617        if (run_is_bo(run)) {
    655                 *res = run_recovery_item(run);
    656                 goto cleanup;
    657         }
    658 
    659 #ifdef DEBUG_RUN_TRACE
    660         printf("Check binop argument result.\n");
    661 #endif
    662         run_cvt_value_item(run, rarg1_i, &rarg1_vi);
    663         if (run_is_bo(run)) {
    664                 *res = run_recovery_item(run);
    665                 goto cleanup;
     618                *res = NULL;
     619                return;
    666620        }
    667621
    668622        run_expr(run, binop->arg2, &rarg2_i);
    669623        if (run_is_bo(run)) {
    670                 *res = run_recovery_item(run);
    671                 goto cleanup;
    672         }
    673 
    674 #ifdef DEBUG_RUN_TRACE
    675         printf("Check binop argument result.\n");
    676 #endif
     624                *res = NULL;
     625                return;
     626        }
     627
     628#ifdef DEBUG_RUN_TRACE
     629        printf("Check binop argument results.\n");
     630#endif
     631
     632        run_cvt_value_item(run, rarg1_i, &rarg1_vi);
    677633        run_cvt_value_item(run, rarg2_i, &rarg2_vi);
    678         if (run_is_bo(run)) {
    679                 *res = run_recovery_item(run);
    680                 goto cleanup;
    681         }
    682634
    683635        v1 = rarg1_vi->u.value;
    … …  
    716668                assert(b_false);
    717669        }
    718 
    719 cleanup:
    720         if (rarg1_i != NULL)
    721                 rdata_item_destroy(rarg1_i);
    722         if (rarg2_i != NULL)
    723                 rdata_item_destroy(rarg2_i);
    724         if (rarg1_vi != NULL)
    725                 rdata_item_destroy(rarg1_vi);
    726         if (rarg2_vi != NULL)
    727                 rdata_item_destroy(rarg2_vi);
    728670}
    729671
    … …  
    11121054        rdata_bool_t *bool_v;
    11131055
    1114         stree_embr_t *e1, *e2;
     1056        rdata_var_t *ref1, *ref2;
    11151057
    11161058        (void) run;
    … …  
    11251067        var->u.bool_v = bool_v;
    11261068
    1127         e1 = v1->var->u.enum_v->value;
    1128         e2 = v2->var->u.enum_v->value;
     1069        ref1 = v1->var->u.ref_v->vref;
     1070        ref2 = v2->var->u.ref_v->vref;
    11291071
    11301072        switch (binop->bc) {
    11311073        case bo_equal:
    1132                 bool_v->value = (e1 == e2);
     1074                bool_v->value = (ref1 == ref2);
    11331075                break;
    11341076        case bo_notequal:
    1135                 bool_v->value = (e1 != e2);
     1077                bool_v->value = (ref1 != ref2);
    11361078                break;
    11371079        default:
    … …  
    11581100        printf("Run unary operation.\n");
    11591101#endif
    1160         rarg_i = NULL;
    1161         rarg_vi = NULL;
    1162 
    11631102        run_expr(run, unop->arg, &rarg_i);
    11641103        if (run_is_bo(run)) {
    1165                 *res = run_recovery_item(run);
    1166                 goto cleanup;
     1104                *res = NULL;
     1105                return;
    11671106        }
    11681107
    … …  
    11711110#endif
    11721111        run_cvt_value_item(run, rarg_i, &rarg_vi);
    1173         if (run_is_bo(run)) {
    1174                 *res = run_recovery_item(run);
    1175                 goto cleanup;
    1176         }
    11771112
    11781113        val = rarg_vi->u.value;
    … …  
    11891124                    "type %d.\n", val->var->vc);
    11901125                run_raise_error(run);
    1191                 *res = run_recovery_item(run);
    1192                 break;
    1193         }
    1194 cleanup:
    1195         if (rarg_i != NULL)
    1196                 rdata_item_destroy(rarg_i);
    1197         if (rarg_vi != NULL)
    1198                 rdata_item_destroy(rarg_vi);
     1126                *res = NULL;
     1127                break;
     1128        }
    11991129}
    12001130
    … …  
    12781208        *res = item;
    12791209}
    1280 
    1281 /** Run equality comparison of two values
    1282  *
    1283  * This should be equivalent to equality ('==') binary operation.
    1284  * XXX Duplicating code of run_binop_xxx().
    1285  *
    1286  * @param run           Runner object
    1287  * @param v1            Value of first argument
    1288  * @param v2            Value of second argument
    1289  * @param res           Place to store result (plain boolean value)
    1290  */
    1291 void run_equal(run_t *run, rdata_value_t *v1, rdata_value_t *v2, bool_t *res)
    1292 {
    1293         bool_t b1, b2;
    1294         bigint_t *c1, *c2;
    1295         bigint_t *i1, *i2;
    1296         bigint_t diff;
    1297         const char *s1, *s2;
    1298         rdata_var_t *ref1, *ref2;
    1299         stree_embr_t *e1, *e2;
    1300 
    1301         (void) run;
    1302         assert(v1->var->vc == v2->var->vc);
    1303 
    1304         switch (v1->var->vc) {
    1305         case vc_bool:
    1306                 b1 = v1->var->u.bool_v->value;
    1307                 b2 = v2->var->u.bool_v->value;
    1308 
    1309                 *res = (b1 == b2);
    1310                 break;
    1311         case vc_char:
    1312                 c1 = &v1->var->u.char_v->value;
    1313                 c2 = &v2->var->u.char_v->value;
    1314 
    1315                 bigint_sub(c1, c2, &diff);
    1316                 *res = bigint_is_zero(&diff);
    1317                 break;
    1318         case vc_int:
    1319                 i1 = &v1->var->u.int_v->value;
    1320                 i2 = &v2->var->u.int_v->value;
    1321 
    1322                 bigint_sub(i1, i2, &diff);
    1323                 *res = bigint_is_zero(&diff);
    1324                 break;
    1325         case vc_string:
    1326                 s1 = v1->var->u.string_v->value;
    1327                 s2 = v2->var->u.string_v->value;
    1328 
    1329                 *res = os_str_cmp(s1, s2) == 0;
    1330                 break;
    1331         case vc_ref:
    1332                 ref1 = v1->var->u.ref_v->vref;
    1333                 ref2 = v2->var->u.ref_v->vref;
    1334 
    1335                 *res = (ref1 == ref2);
    1336                 break;
    1337         case vc_enum:
    1338                 e1 = v1->var->u.enum_v->value;
    1339                 e2 = v2->var->u.enum_v->value;
    1340 
    1341                 *res = (e1 == e2);
    1342                 break;
    1343 
    1344         case vc_deleg:
    1345         case vc_array:
    1346         case vc_object:
    1347         case vc_resource:
    1348         case vc_symbol:
    1349                 assert(b_false);
    1350         }
    1351 }
    1352 
    13531210
    13541211/** Evaluate @c new operation.
    … …  
    14401297                run_expr(run, expr, &rexpr);
    14411298                if (run_is_bo(run)) {
    1442                         *res = run_recovery_item(run);
     1299                        *res = NULL;
    14431300                        return;
    14441301                }
    14451302
    14461303                run_cvt_value_item(run, rexpr, &rexpr_vi);
    1447                 if (run_is_bo(run)) {
    1448                         *res = run_recovery_item(run);
    1449                         return;
    1450                 }
    1451 
    14521304                assert(rexpr_vi->ic == ic_value);
    14531305                rexpr_var = rexpr_vi->u.value->var;
    … …  
    15231375        run_call_args(run, &new_op->ctor_args, &arg_vals);
    15241376        if (run_is_bo(run)) {
    1525                 *res = run_recovery_item(run);
     1377                *res = NULL;
    15261378                return;
    15271379        }
    … …  
    15351387        assert(obj_i->u.address->ac == ac_var);
    15361388        run_object_ctor(run, obj_i->u.address->u.var_a->vref, &arg_vals);
    1537         rdata_item_destroy(obj_i);
    1538 
    1539         /* Destroy argument values */
    1540         run_destroy_arg_vals(&arg_vals);
    15411389}
    15421390
    … …  
    15561404        printf("Run access operation.\n");
    15571405#endif
    1558         rarg = NULL;
    1559 
    15601406        run_expr(run, access->arg, &rarg);
    15611407        if (run_is_bo(run)) {
    1562                 *res = run_recovery_item(run);
    1563                 goto cleanup;
     1408                *res = NULL;
     1409                return;
    15641410        }
    15651411
    … …  
    15701416
    15711417        run_access_item(run, access, rarg, res);
    1572 cleanup:
    1573         if (rarg != NULL)
    1574                 rdata_item_destroy(rarg);
    15751418}
    15761419
    … …  
    16411484        /* Try again. */
    16421485        run_access_item(run, access, darg, res);
    1643 
    1644         /* Destroy temporary */
    1645         rdata_item_destroy(darg);
    16461486}
    16471487
    … …  
    19501790#endif
    19511791        run_cvt_value_item(run, arg, &arg_vi);
    1952         if (run_is_bo(run)) {
    1953                 *res = run_recovery_item(run);
    1954                 return;
    1955         }
    1956 
    19571792        arg_val = arg_vi->u.value;
    19581793        assert(arg_val->var->vc == vc_symbol);
    … …  
    19651800        embr = stree_enum_find_mbr(symbol_v->sym->u.enum_d,
    19661801            access->member_name);
    1967 
    1968         rdata_item_destroy(arg_vi);
    19691802
    19701803        /* Member existence should be ensured by static type checking. */
    … …  
    20081841        printf("Run call operation.\n");
    20091842#endif
    2010         rdeleg = NULL;
    2011         rdeleg_vi = NULL;
    2012 
    20131843        run_expr(run, call->fun, &rdeleg);
    20141844        if (run_is_bo(run)) {
     1845                *res = NULL;
     1846                return;
     1847        }
     1848
     1849        if (run->thread_ar->bo_mode != bm_none) {
    20151850                *res = run_recovery_item(run);
    2016                 goto cleanup;
     1851                return;
    20171852        }
    20181853
    20191854        run_cvt_value_item(run, rdeleg, &rdeleg_vi);
    2020         if (run_is_bo(run)) {
    2021                 *res = run_recovery_item(run);
    2022                 goto cleanup;
    2023         }
    2024 
    20251855        assert(rdeleg_vi->ic == ic_value);
    20261856
    … …  
    20471877        run_call_args(run, &call->args, &arg_vals);
    20481878        if (run_is_bo(run)) {
    2049                 *res = run_recovery_item(run);
    2050                 goto cleanup;
     1879                *res = NULL;
     1880                return;
    20511881        }
    20521882
    … …  
    20591889        /* Fill in argument values. */
    20601890        run_proc_ar_set_args(run, proc_ar, &arg_vals);
    2061 
    2062         /* Destroy arg_vals, they are no longer needed. */
    2063         run_destroy_arg_vals(&arg_vals);
    20641891
    20651892        /* Run the function. */
    … …  
    20731900        }
    20741901
    2075         /* Destroy procedure activation record. */
    2076         run_proc_ar_destroy(run, proc_ar);
    2077 
    2078 cleanup:
    2079         if (rdeleg != NULL)
    2080                 rdata_item_destroy(rdeleg);
    2081         if (rdeleg_vi != NULL)
    2082                 rdata_item_destroy(rdeleg_vi);
    2083 
    20841902#ifdef DEBUG_RUN_TRACE
    20851903        printf("Returned from function call.\n");
    … …  
    21101928                run_expr(run, arg, &rarg_i);
    21111929                if (run_is_bo(run))
    2112                         goto error;
     1930                        return;
    21131931
    21141932                run_cvt_value_item(run, rarg_i, &rarg_vi);
    2115                 rdata_item_destroy(rarg_i);
    2116                 if (run_is_bo(run))
    2117                         goto error;
    21181933
    21191934                list_append(arg_vals, rarg_vi);
    21201935                arg_n = list_next(args, arg_n);
    21211936        }
    2122         return;
    2123 
    2124 error:
    2125         /*
    2126          * An exception or error occured while evaluating one of the
    2127          * arguments. Destroy already obtained argument values and
    2128          * dismantle the list.
    2129          */
    2130         run_destroy_arg_vals(arg_vals);
    2131 }
    2132 
    2133 /** Destroy list of evaluated arguments.
    2134  *
    2135  * Provided a list of evaluated arguments, destroy them, removing them
    2136  * from the list and fini the list itself.
    2137  *
    2138  * @param arg_vals      List of evaluated arguments (value items,
    2139  *                      rdata_item_t).
    2140  */
    2141 static void run_destroy_arg_vals(list_t *arg_vals)
    2142 {
    2143         list_node_t *val_n;
    2144         rdata_item_t *val_i;
    2145 
    2146         /*
    2147          * An exception or error occured while evaluating one of the
    2148          * arguments. Destroy already obtained argument values and
    2149          * dismantle the list.
    2150          */
    2151         while (!list_is_empty(arg_vals)) {
    2152                 val_n = list_first(arg_vals);
    2153                 val_i = list_node_data(val_n, rdata_item_t *);
    2154 
    2155                 rdata_item_destroy(val_i);
    2156                 list_remove(arg_vals, val_n);
    2157         }
    2158         list_fini(arg_vals);
    21591937}
    21601938
    … …  
    21761954        var_class_t vc;
    21771955        list_t arg_vals;
    2178         list_node_t *val_n;
    2179         rdata_item_t *val_i;
    21801956
    21811957#ifdef DEBUG_RUN_TRACE
    … …  
    21841960        run_expr(run, index->base, &rbase);
    21851961        if (run_is_bo(run)) {
    2186                 *res = run_recovery_item(run);
     1962                *res = NULL;
    21871963                return;
    21881964        }
    … …  
    21931969        if (vc == vc_ref) {
    21941970                run_dereference(run, rbase, index->base->cspan, &base_i);
    2195                 rdata_item_destroy(rbase);
    21961971                if (run_is_bo(run)) {
    2197                         *res = run_recovery_item(run);
     1972                        *res = NULL;
    21981973                        return;
    21991974                }
    … …  
    22121987                run_expr(run, arg, &rarg_i);
    22131988                if (run_is_bo(run)) {
    2214                         *res = run_recovery_item(run);
    2215                         goto cleanup;
     1989                        *res = NULL;
     1990                        return;
    22161991                }
    22171992
    22181993                run_cvt_value_item(run, rarg_i, &rarg_vi);
    2219                 rdata_item_destroy(rarg_i);
    2220                 if (run_is_bo(run)) {
    2221                         *res = run_recovery_item(run);
    2222                         goto cleanup;
    2223                 }
    22241994
    22251995                list_append(&arg_vals, rarg_vi);
    … …  
    22422012                exit(1);
    22432013        }
    2244 
    2245         /* Destroy the indexing base temporary */
    2246         rdata_item_destroy(base_i);
    2247 cleanup:
    2248         /*
    2249          * An exception or error occured while evaluating one of the
    2250          * arguments. Destroy already obtained argument values and
    2251          * dismantle the list.
    2252          */
    2253         while (!list_is_empty(&arg_vals)) {
    2254                 val_n = list_first(&arg_vals);
    2255                 val_i = list_node_data(val_n, rdata_item_t *);
    2256 
    2257                 rdata_item_destroy(val_i);
    2258                 list_remove(&arg_vals, val_n);
    2259         }
    2260 
    2261         list_fini(&arg_vals);
    22622014}
    22632015
    … …  
    23842136
    23852137        list_node_t *node;
    2386         rdata_item_t *arg, *arg_copy;
     2138        rdata_item_t *arg;
    23872139
    23882140#ifdef DEBUG_RUN_TRACE
    … …  
    24342186        while (node != NULL) {
    24352187                arg = list_node_data(node, rdata_item_t *);
    2436 
    2437                 /*
    2438                  * Clone argument so that original can
    2439                  * be freed.
    2440                  */
    2441                 assert(arg->ic == ic_value);
    2442                 arg_copy = rdata_item_new(ic_value);
    2443                 rdata_value_copy(arg->u.value, &arg_copy->u.value);
    2444 
    2445                 list_append(&aprop_indexed->args, arg_copy);
     2188                list_append(&aprop_indexed->args, arg);
    24462189                node = list_next(args, node);
    24472190        }
    … …  
    24822225
    24832226        run_cvt_value_item(run, base, &base_vi);
    2484         if (run_is_bo(run)) {
    2485                 *res = run_recovery_item(run);
    2486                 return;
    2487         }
    2488 
    24892227        assert(base_vi->u.value->var->vc == vc_string);
    24902228        string = base_vi->u.value->var->u.string_v;
    … …  
    25392277                    index->expr->cspan);
    25402278                *res = run_recovery_item(run);
    2541                 goto cleanup;
     2279                return;
    25422280        }
    25432281
    … …  
    25532291
    25542292        *res = ritem;
    2555 cleanup:
    2556         rdata_item_destroy(base_vi);
    25572293}
    25582294
    … …  
    25742310        printf("Run assign operation.\n");
    25752311#endif
    2576         rdest_i = NULL;
    2577         rsrc_i = NULL;
    2578         rsrc_vi = NULL;
    2579 
    25802312        run_expr(run, assign->dest, &rdest_i);
    25812313        if (run_is_bo(run)) {
    2582                 *res = run_recovery_item(run);
    2583                 goto cleanup;
     2314                *res = NULL;
     2315                return;
    25842316        }
    25852317
    25862318        run_expr(run, assign->src, &rsrc_i);
    25872319        if (run_is_bo(run)) {
    2588                 *res = run_recovery_item(run);
    2589                 goto cleanup;
     2320                *res = NULL;
     2321                return;
    25902322        }
    25912323
    25922324        run_cvt_value_item(run, rsrc_i, &rsrc_vi);
    2593         if (run_is_bo(run)) {
    2594                 *res = run_recovery_item(run);
    2595                 goto cleanup;
    2596         }
    2597 
    25982325        assert(rsrc_vi->ic == ic_value);
    25992326
    … …  
    26072334
    26082335        *res = NULL;
    2609 cleanup:
    2610         if (rdest_i != NULL)
    2611                 rdata_item_destroy(rdest_i);
    2612         if (rsrc_i != NULL)
    2613                 rdata_item_destroy(rsrc_i);
    2614         if (rsrc_vi != NULL)
    2615                 rdata_item_destroy(rsrc_vi);
    26162336}
    26172337
    … …  
    26392359        run_expr(run, as_op->arg, &rarg_i);
    26402360        if (run_is_bo(run)) {
    2641                 *res = run_recovery_item(run);
     2361                *res = NULL;
    26422362                return;
    26432363        }
    … …  
    26492369        assert(run_item_get_vc(run, rarg_i) == vc_ref);
    26502370        run_cvt_value_item(run, rarg_i, &rarg_vi);
    2651         rdata_item_destroy(rarg_i);
    2652 
    2653         if (run_is_bo(run)) {
    2654                 *res = run_recovery_item(run);
    2655                 return;
    2656         }
    2657 
    26582371        assert(rarg_vi->ic == ic_value);
    26592372
    … …  
    26922405        }
    26932406
    2694         /* The dereferenced item is not used anymore. */
    2695         rdata_item_destroy(rarg_di);
    2696 
    26972407        *res = rarg_vi;
    26982408}
    … …  
    27252435        run_expr(run, box->arg, &rarg_i);
    27262436        if (run_is_bo(run)) {
    2727                 *res = run_recovery_item(run);
     2437                *res = NULL;
    27282438                return;
    27292439        }
    27302440
    27312441        run_cvt_value_item(run, rarg_i, &rarg_vi);
    2732         rdata_item_destroy(rarg_i);
    2733         if (run_is_bo(run)) {
    2734                 *res = run_recovery_item(run);
    2735                 return;
    2736         }
    2737 
    27382442        assert(rarg_vi->ic == ic_value);
    27392443
    … …  
    27782482
    27792483        rdata_var_write(mbr_var, rarg_vi->u.value);
    2780         rdata_item_destroy(rarg_vi);
    27812484}
    27822485
    … …  
    29542657        assert(res == NULL);
    29552658
    2956         /* Destroy procedure activation record. */
    2957         run_proc_ar_destroy(run, proc_ar);
    2958 
    29592659#ifdef DEBUG_RUN_TRACE
    29602660        printf("Returned from constructor..\n");
    … …  
    29752675        rdata_item_t *vitem;
    29762676        rdata_var_t *var;
    2977         bool_t res;
    29782677
    29792678        (void) run;
    29802679        run_cvt_value_item(run, item, &vitem);
    2981         if (run_is_bo(run))
    2982                 return b_true;
    29832680
    29842681        assert(vitem->ic == ic_value);
    … …  
    29862683
    29872684        assert(var->vc == vc_bool);
    2988         res = var->u.bool_v->value;
    2989 
    2990         /* Free value item */
    2991         rdata_item_destroy(vitem);
    2992         return res;
    2993 }
     2685        return var->u.bool_v->value;
     2686}
Note: See TracChangeset for help on using the changeset viewer.