Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset f9c314a5 in mainline


Ignore:
Timestamp:
2012-08-07T04:06:14Z (9 years ago)
Author:
Sean Bartell <wingedtachikoma@…>
Branches:
lfn, master
Children:
0191bd3
Parents:
0ce0103
Message:

Bithenge: make scopes reference-counted

Location:
uspace/app/bithenge
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/bithenge/expression.c

    r0ce0103 rf9c314a5  
    424424{
    425425        param_wrapper_t *self = transform_as_param_wrapper(base);
    426         bithenge_scope_t inner;
    427         bithenge_scope_init(&inner);
    428         int rc = param_wrapper_fill_scope(self, &inner, outer);
    429         if (rc != EOK)
    430                 goto error;
    431 
    432         rc = bithenge_transform_apply(self->transform, &inner, in, out);
     426        bithenge_scope_t *inner;
     427        int rc = bithenge_scope_new(&inner);
     428        if (rc != EOK)
     429                return rc;
     430        rc = param_wrapper_fill_scope(self, inner, outer);
     431        if (rc != EOK)
     432                goto error;
     433
     434        rc = bithenge_transform_apply(self->transform, inner, in, out);
    433435        in = NULL;
    434436
    435437error:
    436         bithenge_scope_destroy(&inner);
     438        bithenge_scope_dec_ref(inner);
    437439        return rc;
    438440}
     
    442444{
    443445        param_wrapper_t *self = transform_as_param_wrapper(base);
    444         bithenge_scope_t inner;
    445         bithenge_scope_init(&inner);
    446         int rc = param_wrapper_fill_scope(self, &inner, outer);
    447         if (rc != EOK)
    448                 goto error;
    449 
    450         rc = bithenge_transform_prefix_length(self->transform, &inner, in,
    451             out);
     446        bithenge_scope_t *inner;
     447        int rc = bithenge_scope_new(&inner);
     448        if (rc != EOK)
     449                return rc;
     450        rc = param_wrapper_fill_scope(self, inner, outer);
     451        if (rc != EOK)
     452                goto error;
     453
     454        rc = bithenge_transform_prefix_length(self->transform, inner, in, out);
    452455        in = NULL;
    453456
    454457error:
    455         bithenge_scope_destroy(&inner);
     458        bithenge_scope_dec_ref(inner);
    456459        return rc;
    457460}
  • uspace/app/bithenge/sequence.c

    r0ce0103 rf9c314a5  
    5050        const struct seq_node_ops *ops;
    5151        bithenge_blob_t *blob;
    52         bithenge_scope_t scope;
     52        bithenge_scope_t *scope;
    5353        aoff64_t *ends;
    5454        size_t num_ends;
     
    114114                bithenge_blob_t *subblob = bithenge_node_as_blob(subblob_node);
    115115                aoff64_t field_size;
    116                 rc = bithenge_transform_prefix_length(subxform, &self->scope,
     116                rc = bithenge_transform_prefix_length(subxform, self->scope,
    117117                    subblob, &field_size);
    118118                bithenge_node_dec_ref(subblob_node);
     
    177177
    178178                aoff64_t size;
    179                 rc = bithenge_transform_prefix_apply(subxform, &self->scope,
     179                rc = bithenge_transform_prefix_apply(subxform, self->scope,
    180180                    bithenge_node_as_blob(blob_node), out, &size);
    181181                bithenge_node_dec_ref(blob_node);
     
    209209                }
    210210
    211                 rc = bithenge_transform_apply(subxform, &self->scope,
    212                     blob_node, out);
     211                rc = bithenge_transform_apply(subxform, self->scope, blob_node,
     212                    out);
    213213                bithenge_node_dec_ref(blob_node);
    214214                bithenge_transform_dec_ref(subxform);
     
    235235static void seq_node_destroy(seq_node_t *self)
    236236{
    237         bithenge_scope_destroy(&self->scope);
     237        bithenge_scope_dec_ref(self->scope);
    238238        bithenge_blob_dec_ref(self->blob);
    239239        free(self->ends);
     
    248248static bithenge_scope_t *seq_node_scope(seq_node_t *self)
    249249{
    250         return &self->scope;
     250        return self->scope;
    251251}
    252252
     
    267267        self->num_ends = 0;
    268268        self->end_on_empty = end_on_empty;
    269         bithenge_scope_init(&self->scope);
    270         int rc = bithenge_scope_copy(&self->scope, scope);
     269        int rc = bithenge_scope_new(&self->scope);
    271270        if (rc != EOK) {
    272                 bithenge_scope_destroy(&self->scope);
     271                free(self->ends);
     272                return rc;
     273        }
     274        rc = bithenge_scope_copy(self->scope, scope);
     275        if (rc != EOK) {
     276                bithenge_scope_dec_ref(self->scope);
     277                free(self->ends);
    273278                return rc;
    274279        }
     
    936941                }
    937942
    938                 bithenge_scope_t scope;
    939                 bithenge_scope_init(&scope);
    940                 rc = bithenge_scope_copy(&scope,
     943                bithenge_scope_t *scope;
     944                rc = bithenge_scope_new(&scope);
     945                if (rc != EOK) {
     946                        bithenge_node_dec_ref(subxform_result);
     947                        return rc;
     948                }
     949                rc = bithenge_scope_copy(scope,
    941950                    seq_node_scope(do_while_as_seq(self)));
    942                 bithenge_scope_set_current_node(&scope, subxform_result);
     951                bithenge_scope_set_current_node(scope, subxform_result);
    943952                if (rc != EOK) {
    944                         bithenge_scope_destroy(&scope);
     953                        bithenge_scope_dec_ref(scope);
    945954                        return rc;
    946955                }
    947956                bithenge_node_t *expr_result;
    948                 rc = bithenge_expression_evaluate(self->expr, &scope,
     957                rc = bithenge_expression_evaluate(self->expr, scope,
    949958                    &expr_result);
    950                 bithenge_scope_destroy(&scope);
     959                bithenge_scope_dec_ref(scope);
    951960                if (rc != EOK)
    952961                        return rc;
  • uspace/app/bithenge/test.c

    r0ce0103 rf9c314a5  
    6969                bithenge_node_dec_ref(node);
    7070        } else {
    71                 bithenge_scope_t scope;
     71                bithenge_scope_t *scope = NULL;
    7272                bithenge_transform_t *transform = NULL;
    7373                bithenge_node_t *node = NULL, *node2 = NULL;
    7474
    75                 bithenge_scope_init(&scope);
     75                rc = bithenge_scope_new(&scope);
     76                if (rc != EOK) {
     77                        printf("Error creating scope: %s\n", str_error(rc));
     78                        scope = NULL;
     79                        goto error;
     80                }
    7681
    7782                rc = bithenge_parse_script(argv[1], &transform);
    7883                if (rc != EOK) {
    7984                        printf("Error parsing script: %s\n", str_error(rc));
     85                        transform = NULL;
    8086                        goto error;
    8187                }
    8288
    83                 int rc = bithenge_node_from_source(&node, argv[2]);
     89                rc = bithenge_node_from_source(&node, argv[2]);
    8490                if (rc != EOK) {
    8591                        printf("Error creating node from source: %s\n", str_error(rc));
     92                        node = NULL;
    8693                        goto error;
    8794                }
    8895
    89                 rc = bithenge_transform_apply(transform, &scope, node, &node2);
     96                rc = bithenge_transform_apply(transform, scope, node, &node2);
    9097                if (rc != EOK) {
    9198                        printf("Error applying transform: %s\n", str_error(rc));
     99                        node2 = NULL;
    92100                        goto error;
    93101                }
     
    105113                bithenge_node_dec_ref(node2);
    106114                node2 = NULL;
     115                bithenge_scope_dec_ref(scope);
     116                scope = NULL;
    107117                printf("\n");
    108118
     
    113123                bithenge_node_dec_ref(node2);
    114124                bithenge_transform_dec_ref(transform);
    115                 bithenge_scope_destroy(&scope);
     125                bithenge_scope_dec_ref(scope);
    116126                return 1;
    117127        }
  • uspace/app/bithenge/transform.c

    r0ce0103 rf9c314a5  
    165165}
    166166
    167 /** Initialize a transform scope. It must be destroyed with @a
    168  * bithenge_scope_destroy after it is used.
    169  * @param[out] scope The scope to initialize. */
    170 void bithenge_scope_init(bithenge_scope_t *scope)
    171 {
    172         scope->num_params = 0;
    173         scope->params = NULL;
    174         scope->current_node = NULL;
    175 }
    176 
    177 /** Destroy a transform scope.
    178  * @param scope The scope to destroy.
     167/** Create a transform scope. It must be dereferenced with @a
     168 * bithenge_scope_dec_ref after it is used.
     169 * @param[out] out Holds the new scope.
    179170 * @return EOK on success or an error code from errno.h. */
    180 void bithenge_scope_destroy(bithenge_scope_t *scope)
    181 {
    182         bithenge_node_dec_ref(scope->current_node);
    183         for (int i = 0; i < scope->num_params; i++)
    184                 bithenge_node_dec_ref(scope->params[i]);
    185         free(scope->params);
     171int bithenge_scope_new(bithenge_scope_t **out)
     172{
     173        bithenge_scope_t *self = malloc(sizeof(*self));
     174        if (!self)
     175                return ENOMEM;
     176        self->refs = 1;
     177        self->num_params = 0;
     178        self->params = NULL;
     179        self->current_node = NULL;
     180        *out = self;
     181        return EOK;
     182}
     183
     184/** Dereference a transform scope.
     185 * @param self The scope to dereference. */
     186void bithenge_scope_dec_ref(bithenge_scope_t *self)
     187{
     188        if (!--self->refs) {
     189                bithenge_node_dec_ref(self->current_node);
     190                for (int i = 0; i < self->num_params; i++)
     191                        bithenge_node_dec_ref(self->params[i]);
     192                free(self->params);
     193                free(self);
     194        }
    186195}
    187196
     
    297306{
    298307        scope_transform_t *self = transform_as_param(base);
    299         bithenge_scope_t inner_scope;
    300         bithenge_scope_init(&inner_scope);
    301         int rc = bithenge_scope_copy(&inner_scope, scope);
     308        bithenge_scope_t *inner_scope;
     309        int rc = bithenge_scope_new(&inner_scope);
     310        if (rc != EOK)
     311                return rc;
     312        rc = bithenge_scope_copy(inner_scope, scope);
    302313        if (rc != EOK)
    303314                goto error;
    304         bithenge_scope_set_current_node(&inner_scope, NULL);
     315        bithenge_scope_set_current_node(inner_scope, NULL);
    305316        rc = bithenge_transform_apply(self->transform, scope, in, out);
    306317error:
    307         bithenge_scope_destroy(&inner_scope);
     318        bithenge_scope_dec_ref(inner_scope);
    308319        return rc;
    309320}
  • uspace/app/bithenge/transform.h

    r0ce0103 rf9c314a5  
    5252typedef struct {
    5353        /** @privatesection */
     54        unsigned int refs;
    5455        int num_params;
    5556        bithenge_node_t **params;
    5657        bithenge_node_t *current_node;
    5758} bithenge_scope_t;
     59
     60static inline void bithenge_scope_inc_ref(bithenge_scope_t *self) {
     61        self->refs++;
     62}
    5863
    5964/** Operations that may be provided by a transform. All transforms must provide
     
    143148    bithenge_transform_t **, size_t);
    144149
    145 void bithenge_scope_init(bithenge_scope_t *);
    146 void bithenge_scope_destroy(bithenge_scope_t *);
     150int bithenge_scope_new(bithenge_scope_t **);
     151void bithenge_scope_dec_ref(bithenge_scope_t *);
    147152int bithenge_scope_copy(bithenge_scope_t *, bithenge_scope_t *);
    148153void bithenge_scope_set_current_node(bithenge_scope_t *, bithenge_node_t *);
Note: See TracChangeset for help on using the changeset viewer.