Changeset 640ffe6 in mainline for uspace/app/sbi/src/p_expr.c


Ignore:
Timestamp:
2010-05-08T08:15:57Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4039c77
Parents:
1317380 (diff), 051bc69a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from lp:~jsvoboda/helenos/sysel. New: cspan printing, boolean ops, enums, constructors etc.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1317380 r640ffe6  
    3232#include <stdlib.h>
    3333#include "bigint.h"
     34#include "cspan.h"
    3435#include "debug.h"
    3536#include "lex.h"
    … …  
    4344
    4445static stree_expr_t *parse_assign(parse_t *parse);
     46static stree_expr_t *parse_disjunctive(parse_t *parse);
     47static stree_expr_t *parse_conjunctive(parse_t *parse);
    4548static stree_expr_t *parse_comparative(parse_t *parse);
    4649static stree_expr_t *parse_additive(parse_t *parse);
    … …  
    9598        stree_assign_t *assign;
    9699
    97         a = parse_comparative(parse);
     100        a = parse_disjunctive(parse);
    98101
    99102        switch (lcur_lc(parse)) {
    … …  
    109112
    110113        lskip(parse);
    111         b = parse_comparative(parse);
     114        b = parse_disjunctive(parse);
    112115
    113116        assign->dest = a;
    … …  
    116119        tmp = stree_expr_new(ec_assign);
    117120        tmp->u.assign = assign;
     121        tmp->cspan = cspan_merge(a->cspan, b->cspan);
     122
     123        assign->expr = tmp;
     124
    118125        return tmp;
     126}
     127
     128/** Parse disjunctive expression.
     129 *
     130 * @param parse         Parser object.
     131 */
     132static 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 */
     168static 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;
    119198}
    120199
    … …  
    128207        stree_binop_t *binop;
    129208        binop_class_t bc;
     209        cspan_t *cs;
    130210
    131211        a = parse_additive(parse);
     212        cs = a->cspan;
    132213
    133214        while (lcur_lc(parse) == lc_equal || lcur_lc(parse) == lc_notequal ||
    … …  
    157238                tmp = stree_expr_new(ec_binop);
    158239                tmp->u.binop = binop;
     240                tmp->cspan = cspan_merge(cs, b->cspan);
     241                binop->expr = tmp;
     242
    159243                a = tmp;
     244                cs = tmp->cspan;
    160245        }
    161246
    … …  
    172257        stree_binop_t *binop;
    173258        binop_class_t bc;
     259        cspan_t *cs;
    174260
    175261        a = parse_multip(parse);
     262        cs = a->cspan;
     263
    176264        while (lcur_lc(parse) == lc_plus || lcur_lc(parse) == lc_minus) {
    177265                if (parse_is_error(parse))
    … …  
    193281                tmp = stree_expr_new(ec_binop);
    194282                tmp->u.binop = binop;
     283                tmp->cspan = cspan_merge(cs, b->cspan);
     284                binop->expr = tmp;
     285
    195286                a = tmp;
     287                cs = tmp->cspan;
    196288        }
    197289
    … …  
    208300        stree_binop_t *binop;
    209301        binop_class_t bc;
     302        cspan_t *cs;
    210303
    211304        a = parse_prefix(parse);
     305        cs = a->cspan;
     306
    212307        while (lcur_lc(parse) == lc_mult) {
    213308                if (parse_is_error(parse))
    … …  
    228323                tmp = stree_expr_new(ec_binop);
    229324                tmp->u.binop = binop;
     325                tmp->cspan = cspan_merge(cs, b->cspan);
     326                binop->expr = tmp;
     327
    230328                a = tmp;
     329                cs = tmp->cspan;
    231330        }
    232331
    … …  
    244343        stree_unop_t *unop;
    245344        unop_class_t uc;
     345        cspan_t *cs0;
    246346
    247347        switch (lcur_lc(parse)) {
    248348        case lc_plus:
    249349        case lc_minus:
     350        case lc_not:
    250351                if (parse_is_error(parse))
    251352                        return parse_recovery_expr(parse);
    … …  
    254355                case lc_plus: uc = uo_plus; break;
    255356                case lc_minus: uc = uo_minus; break;
     357                case lc_not: uc = uo_not; break;
    256358                default: assert(b_false);
    257359                }
    258360
     361                cs0 = lcur_span(parse);
    259362                lskip(parse);
    260363                a = parse_postfix(parse);
    … …  
    265368                tmp = stree_expr_new(ec_unop);
    266369                tmp->u.unop = unop;
     370                tmp->cspan = cspan_merge(cs0, a->cspan);
     371                unop->expr = tmp;
    267372                a = tmp;
    268373                break;
    … …  
    287392        stree_new_t *new_op;
    288393        stree_expr_t *expr;
    289 
     394        stree_expr_t *arg;
     395        cspan_t *cs0, *cs1;
     396
     397        cs0 = lcur_span(parse);
    290398        lmatch(parse, lc_new);
    291399        texpr = parse_texpr(parse);
    292400
    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         }
     401        /* XXX Take span from texpr */
     402        cs1 = lprev_span(parse);
    298403
    299404        new_op = stree_new_new();
    … …  
    302407        expr->u.new_op = new_op;
    303408
     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
    304435        return expr;
    305436}
    … …  
    354485        stree_expr_t *expr;
    355486        stree_access_t *access;
     487        cspan_t *cs1;
    356488
    357489        lmatch(parse, lc_period);
    358490        ident = parse_ident(parse);
     491
     492        /* XXX Take span from ident */
     493        cs1 = lprev_span(parse);
    359494
    360495        access = stree_access_new();
    … …  
    364499        expr = stree_expr_new(ec_access);
    365500        expr->u.access = access;
     501        expr->cspan = cspan_merge(a->cspan, cs1);
     502
     503        access->expr = expr;
    366504
    367505        return expr;
    … …  
    377515        stree_call_t *call;
    378516        stree_expr_t *arg;
     517        cspan_t *cs1;
    379518
    380519        lmatch(parse, lc_lparen);
    … …  
    398537
    399538        lmatch(parse, lc_rparen);
     539        cs1 = lprev_span(parse);
    400540
    401541        expr = stree_expr_new(ec_call);
    402542        expr->u.call = call;
     543        expr->cspan = cspan_merge(a->cspan, cs1);
     544        call->expr = expr;
    403545
    404546        return expr;
    … …  
    414556        stree_index_t *index;
    415557        stree_expr_t *arg;
     558        cspan_t *cs1;
    416559
    417560        lmatch(parse, lc_lsbr);
    … …  
    435578
    436579        lmatch(parse, lc_rsbr);
     580        cs1 = lprev_span(parse);
    437581
    438582        expr = stree_expr_new(ec_index);
    439583        expr->u.index = index;
     584        expr->cspan = cspan_merge(a->cspan, cs1);
     585        index->expr = expr;
    440586
    441587        return expr;
    … …  
    451597        stree_texpr_t *texpr;
    452598        stree_as_t *as_op;
     599        cspan_t *cs1;
    453600
    454601        lmatch(parse, lc_as);
    455602        texpr = parse_texpr(parse);
     603
     604        /* XXX Take span from texpr */
     605        cs1 = lprev_span(parse);
    456606
    457607        as_op = stree_as_new();
    458608        as_op->arg = a;
    459609        as_op->dtype = texpr;
     610
    460611        expr = stree_expr_new(ec_as);
    461612        expr->u.as_op = as_op;
     613        expr->cspan = cspan_merge(a->cspan, cs1);
     614
     615        as_op->expr = expr;
    462616
    463617        return expr;
    … …  
    471625{
    472626        stree_expr_t *expr;
     627        cspan_t *cs0, *cs1;
    473628
    474629        if (lcur_lc(parse) == lc_lparen) {
     630                cs0 = lcur_span(parse);
    475631                lskip(parse);
    476632                expr = parse_expr(parse);
    477633                lmatch(parse, lc_rparen);
     634                cs1 = lprev_span(parse);
     635
     636                expr->cspan = cspan_merge(cs0, cs1);
    478637        } else {
    479638                expr = parse_primitive(parse);
    … …  
    482641        return expr;
    483642}
    484 
    485643
    486644/** Parse primitive expression.
    … …  
    536694        expr = stree_expr_new(ec_nameref);
    537695        expr->u.nameref = nameref;
     696        expr->cspan = lprev_span(parse);
     697        nameref->expr = expr;
    538698
    539699        return expr;
    … …  
    563723        expr = stree_expr_new(ec_literal);
    564724        expr->u.literal = literal;
     725        expr->cspan = lprev_span(parse);
     726        literal->expr = expr;
    565727
    566728        return expr;
    … …  
    586748        expr = stree_expr_new(ec_literal);
    587749        expr->u.literal = literal;
     750        expr->cspan = lprev_span(parse);
     751        literal->expr = expr;
    588752
    589753        return expr;
    … …  
    609773        expr = stree_expr_new(ec_literal);
    610774        expr->u.literal = literal;
     775        expr->cspan = lprev_span(parse);
     776        literal->expr = expr;
    611777
    612778        return expr;
    … …  
    628794        expr = stree_expr_new(ec_literal);
    629795        expr->u.literal = literal;
     796        expr->cspan = lprev_span(parse);
     797        literal->expr = expr;
    630798
    631799        return expr;
    … …  
    650818        expr = stree_expr_new(ec_literal);
    651819        expr->u.literal = literal;
     820        expr->cspan = lprev_span(parse);
     821        literal->expr = expr;
    652822
    653823        return expr;
    … …  
    669839        expr = stree_expr_new(ec_self_ref);
    670840        expr->u.self_ref = self_ref;
     841        expr->cspan = lprev_span(parse);
     842        self_ref->expr = expr;
    671843
    672844        return expr;
    … …  
    688860        expr = stree_expr_new(ec_literal);
    689861        expr->u.literal = literal;
    690 
    691         return expr;
    692 }
     862        literal->expr = expr;
     863
     864        return expr;
     865}
Note: See TracChangeset for help on using the changeset viewer.