Changeset 2988aec7 in mainline for uspace/app/bithenge/script.c


Ignore:
Timestamp:
2012-08-14T03:17:17Z (11 years ago)
Author:
Sean Bartell <wingedtachikoma@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade
Children:
71b0d4d4
Parents:
1b6b76d
Message:

Bithenge: read FAT files/subdirs; self-recursion and more operators

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/bithenge/script.c

    r1b6b76d r2988aec7  
    5353 * other token uses one of these values: */
    5454typedef enum {
    55         TOKEN_EQUALS = -128,
    56         TOKEN_ERROR,
     55        TOKEN_ERROR = -128,
     56
     57        TOKEN_AND,
     58        TOKEN_CONCAT,
     59        TOKEN_EQUALS,
    5760        TOKEN_EOF,
    5861        TOKEN_GREATER_THAN_OR_EQUAL,
    … …  
    6366        TOKEN_LESS_THAN_OR_EQUAL,
    6467        TOKEN_NOT_EQUAL,
     68        TOKEN_OR,
    6569
    6670        /* Keywords */
    … …  
    308312                        state->buffer_pos++;
    309313                }
     314        } else if (ch == '&') {
     315                state->token = ch;
     316                state->buffer_pos++;
     317                if (state->buffer[state->buffer_pos] == '&') {
     318                        state->token = TOKEN_AND;
     319                        state->buffer_pos++;
     320                }
     321        } else if (ch == '|') {
     322                state->token = ch;
     323                state->buffer_pos++;
     324                if (state->buffer[state->buffer_pos] == '|') {
     325                        state->token = TOKEN_OR;
     326                        state->buffer_pos++;
     327                }
     328        } else if (ch == '+') {
     329                state->token = ch;
     330                state->buffer_pos++;
     331                if (state->buffer[state->buffer_pos] == '+') {
     332                        state->token = TOKEN_CONCAT;
     333                        state->buffer_pos++;
     334                }
    310335        } else {
    311336                state->token = ch;
    … …  
    415440typedef enum {
    416441        PRECEDENCE_NONE,
     442        PRECEDENCE_AND,
    417443        PRECEDENCE_EQUALS,
    418444        PRECEDENCE_COMPARE,
    … …  
    446472        case TOKEN_NOT_EQUAL:
    447473                return BITHENGE_EXPRESSION_NOT_EQUALS;
     474        case TOKEN_AND:
     475                return BITHENGE_EXPRESSION_AND;
     476        case TOKEN_OR:
     477                return BITHENGE_EXPRESSION_OR;
     478        case TOKEN_CONCAT:
     479                return BITHENGE_EXPRESSION_CONCAT;
    448480        default:
    449481                return BITHENGE_EXPRESSION_INVALID_BINARY_OP;
    … …  
    455487        switch (op) {
    456488        case BITHENGE_EXPRESSION_ADD: /* fallthrough */
    457         case BITHENGE_EXPRESSION_SUBTRACT:
     489        case BITHENGE_EXPRESSION_SUBTRACT: /* fallthrough */
     490        case BITHENGE_EXPRESSION_CONCAT:
    458491                return PRECEDENCE_ADD;
    459492        case BITHENGE_EXPRESSION_MULTIPLY: /* fallthrough */
    … …  
    469502        case BITHENGE_EXPRESSION_NOT_EQUALS:
    470503                return PRECEDENCE_EQUALS;
     504        case BITHENGE_EXPRESSION_AND: /* fallthrough */
     505        case BITHENGE_EXPRESSION_OR:
     506                return PRECEDENCE_AND;
    471507        default:
    472508                assert(false);
    … …  
    609645                        }
    610646
    611                         rc = bithenge_member_expression(&expr, expr, key);
     647                        bithenge_expression_t *key_expr;
     648                        rc = bithenge_const_expression(&key_expr, key);
     649                        if (rc != EOK) {
     650                                error_errno(state, rc);
     651                                bithenge_expression_dec_ref(expr);
     652                                return NULL;
     653                        }
     654
     655                        rc = bithenge_binary_expression(&expr,
     656                            BITHENGE_EXPRESSION_MEMBER, expr, key_expr);
    612657                        if (rc != EOK) {
    613658                                error_errno(state, rc);
    … …  
    618663                        bithenge_expression_t *start = parse_expression(state);
    619664                        bool absolute_limit = false;
    620                         if (state->token == ',') {
    621                                 absolute_limit = false;
     665                        if (state->token == ',' || state->token == ':') {
     666                                absolute_limit = state->token == ':';
    622667                                next_token(state);
    623                         } else if (state->token == ':') {
    624                                 absolute_limit = true;
     668                                bithenge_expression_t *limit = NULL;
     669                                if (!(state->token == ']' && absolute_limit))
     670                                        limit = parse_expression(state);
     671                                expect(state, ']');
     672
     673                                if (state->error != EOK) {
     674                                        bithenge_expression_dec_ref(expr);
     675                                        bithenge_expression_dec_ref(start);
     676                                        bithenge_expression_dec_ref(limit);
     677                                        return NULL;
     678                                }
     679                                rc = bithenge_subblob_expression(&expr, expr, start,
     680                                    limit, absolute_limit);
     681                                if (rc != EOK) {
     682                                        error_errno(state, rc);
     683                                        return NULL;
     684                                }
     685                        } else if (state->token == ']') {
    625686                                next_token(state);
     687
     688                                if (state->error != EOK) {
     689                                        bithenge_expression_dec_ref(expr);
     690                                        bithenge_expression_dec_ref(start);
     691                                        return NULL;
     692                                }
     693                                rc = bithenge_binary_expression(&expr,
     694                                    BITHENGE_EXPRESSION_MEMBER, expr, start);
     695                                if (rc != EOK) {
     696                                        error_errno(state, rc);
     697                                        return NULL;
     698                                }
    626699                        } else {
    627                                 syntax_error(state, "expected ',' or ':'");
    628                         }
    629                         bithenge_expression_t *limit = NULL;
    630                         if (!(state->token == ']' && absolute_limit))
    631                                 limit = parse_expression(state);
    632                         expect(state, ']');
    633 
    634                         if (state->error != EOK) {
     700                                syntax_error(state, "expected ',', ':', or ']'");
    635701                                bithenge_expression_dec_ref(expr);
    636702                                bithenge_expression_dec_ref(start);
    637                                 bithenge_expression_dec_ref(limit);
    638                                 return NULL;
    639                         }
    640                         rc = bithenge_subblob_expression(&expr, expr, start,
    641                             limit, absolute_limit);
    642                         if (rc != EOK) {
    643                                 error_errno(state, rc);
    644703                                return NULL;
    645704                        }
    … …  
    11731232        }
    11741233
     1234        bithenge_transform_t *barrier = NULL;
     1235        if (state->error == EOK) {
     1236                int rc = bithenge_new_barrier_transform(&barrier,
     1237                    state->num_params);
     1238                if (rc != EOK) {
     1239                        barrier = NULL;
     1240                        error_errno(state, rc);
     1241                }
     1242        }
     1243
     1244        add_named_transform(state, barrier, name);
     1245
    11751246        expect(state, '=');
    11761247        bithenge_transform_t *xform = parse_transform(state);
    … …  
    11781249
    11791250        if (state->error == EOK) {
    1180                 int rc = bithenge_new_barrier_transform(&xform, xform,
    1181                     state->num_params);
    1182                 if (rc != EOK) {
    1183                         xform = NULL;
    1184                         error_errno(state, rc);
    1185                 }
    1186         }
    1187 
    1188         add_named_transform(state, xform, name);
     1251                int rc = bithenge_barrier_transform_set_subtransform(barrier,
     1252                    xform);
     1253                xform = NULL;
     1254                if (rc != EOK)
     1255                        error_errno(state, rc);
     1256        }
     1257
     1258        if (state->error != EOK)
     1259                bithenge_transform_dec_ref(xform);
    11891260
    11901261        for (int i = 0; i < state->num_params; i++)
Note: See TracChangeset for help on using the changeset viewer.