Changeset 978ccaf1 in mainline


Ignore:
Timestamp:
2012-06-27T03:35:43Z (12 years ago)
Author:
Sean Bartell <wingedtachikoma@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
600f5d1
Parents:
04a7435f
Message:

Bithenge: various cleanup and tweaks

Location:
uspace/app/bithenge
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/bithenge/blob.c

    r04a7435f r978ccaf1  
    4949 * @return EOK on success or an error code from errno.h.
    5050 */
    51 int bithenge_new_random_access_blob(bithenge_blob_t *blob,
     51int bithenge_init_random_access_blob(bithenge_blob_t *blob,
    5252    const bithenge_random_access_blob_ops_t *ops)
    5353{
    … …  
    8585}
    8686
    87 static inline bithenge_sequential_blob_t *sequential_from_blob(
     87static inline bithenge_sequential_blob_t *blob_as_sequential(
    8888    bithenge_blob_t *base)
    8989{
    … …  
    9191}
    9292
    93 static inline bithenge_blob_t *blob_from_sequential(
     93static inline bithenge_blob_t *sequential_as_blob(
    9494    bithenge_sequential_blob_t *blob)
    9595{
    … …  
    9999static int sequential_size(bithenge_blob_t *base, aoff64_t *size)
    100100{
    101         bithenge_sequential_blob_t *blob = sequential_from_blob(base);
     101        bithenge_sequential_blob_t *blob = blob_as_sequential(base);
    102102        int rc;
    103103        if (blob->ops->size) {
    … …  
    121121    char *buffer, aoff64_t *size)
    122122{
    123         bithenge_sequential_blob_t *blob = sequential_from_blob(base);
     123        bithenge_sequential_blob_t *blob = blob_as_sequential(base);
    124124        aoff64_t end = offset + *size;
    125125        if (end > blob->data_size) {
    … …  
    135135}
    136136
    137 static int sequential_destroy(bithenge_blob_t *base)
    138 {
    139         bithenge_sequential_blob_t *blob = sequential_from_blob(base);
     137static void sequential_destroy(bithenge_blob_t *base)
     138{
     139        bithenge_sequential_blob_t *blob = blob_as_sequential(base);
    140140        free(blob->buffer);
    141         return blob->ops->destroy(blob);
     141        blob->ops->destroy(blob);
    142142}
    143143
    … …  
    155155 * @return EOK on success or an error code from errno.h.
    156156 */
    157 int bithenge_new_sequential_blob(bithenge_sequential_blob_t *blob,
     157int bithenge_init_sequential_blob(bithenge_sequential_blob_t *blob,
    158158    const bithenge_sequential_blob_ops_t *ops)
    159159{
    … …  
    164164        // ops->size is optional
    165165
    166         int rc = bithenge_new_random_access_blob(blob_from_sequential(blob),
     166        int rc = bithenge_init_random_access_blob(sequential_as_blob(blob),
    167167            &sequential_ops);
    168168        if (rc != EOK)
    … …  
    182182} memory_blob_t;
    183183
    184 static inline memory_blob_t *memory_from_blob(bithenge_blob_t *base)
     184static inline memory_blob_t *blob_as_memory(bithenge_blob_t *base)
    185185{
    186186        return (memory_blob_t *)base;
    187187}
    188188
    189 static inline bithenge_blob_t *blob_from_memory(memory_blob_t *blob)
     189static inline bithenge_blob_t *memory_as_blob(memory_blob_t *blob)
    190190{
    191191        return &blob->base;
    … …  
    194194static int memory_size(bithenge_blob_t *base, aoff64_t *size)
    195195{
    196         memory_blob_t *blob = memory_from_blob(base);
     196        memory_blob_t *blob = blob_as_memory(base);
    197197        *size = blob->size;
    198198        return EOK;
    … …  
    202202    aoff64_t *size)
    203203{
    204         memory_blob_t *blob = memory_from_blob(base);
     204        memory_blob_t *blob = blob_as_memory(base);
    205205        if (offset > blob->size)
    206206                return ELIMIT;
    … …  
    210210}
    211211
    212 static int memory_destroy(bithenge_blob_t *base)
    213 {
    214         memory_blob_t *blob = memory_from_blob(base);
     212static void memory_destroy(bithenge_blob_t *base)
     213{
     214        memory_blob_t *blob = blob_as_memory(base);
    215215        if (blob->needs_free)
    216216                free((void *)blob->buffer);
    217217        free(blob);
    218         return EOK;
    219218}
    220219
    … …  
    244243        if (!blob)
    245244                return ENOMEM;
    246         rc = bithenge_new_random_access_blob(blob_from_memory(blob),
     245        rc = bithenge_init_random_access_blob(memory_as_blob(blob),
    247246            &memory_ops);
    248247        if (rc != EOK) {
    … …  
    259258        blob->size = len;
    260259        blob->needs_free = true;
    261         *out = bithenge_blob_as_node(blob_from_memory(blob));
     260        *out = bithenge_blob_as_node(memory_as_blob(blob));
    262261        return EOK;
    263262}
    … …  
    283282        if (!blob)
    284283                return ENOMEM;
    285         rc = bithenge_new_random_access_blob(blob_from_memory(blob),
     284        rc = bithenge_init_random_access_blob(memory_as_blob(blob),
    286285            &memory_ops);
    287286        if (rc != EOK) {
    … …  
    292291        blob->size = len;
    293292        blob->needs_free = needs_free;
    294         *out = bithenge_blob_as_node(blob_from_memory(blob));
     293        *out = bithenge_blob_as_node(memory_as_blob(blob));
    295294        return EOK;
    296295}
    … …  
    340339}
    341340
    342 static int subblob_destroy(bithenge_blob_t *base)
     341static void subblob_destroy(bithenge_blob_t *base)
    343342{
    344343        subblob_t *blob = blob_as_subblob(base);
    345344        bithenge_blob_dec_ref(blob->source);
    346345        free(blob);
    347         return EOK;
    348346}
    349347
    … …  
    404402                goto error;
    405403        }
    406         rc = bithenge_new_random_access_blob(subblob_as_blob(blob),
     404        rc = bithenge_init_random_access_blob(subblob_as_blob(blob),
    407405            &subblob_ops);
    408406        if (rc != EOK)

  • uspace/app/bithenge/blob.h

    r04a7435f r978ccaf1  
    5252typedef struct bithenge_random_access_blob_ops_t {
    5353        /** @copydoc bithenge_blob_t::bithenge_blob_size */
    54         int (*size)(bithenge_blob_t *blob, aoff64_t *size);
     54        int (*size)(bithenge_blob_t *self, aoff64_t *size);
    5555        /** @copydoc bithenge_blob_t::bithenge_blob_read */
    56         int (*read)(bithenge_blob_t *blob, aoff64_t offset, char *buffer,
     56        int (*read)(bithenge_blob_t *self, aoff64_t offset, char *buffer,
    5757            aoff64_t *size);
    5858        /** Destroy the blob.
    59          * @param blob The blob.
    60          * @return EOK on success or an error code from errno.h. */
    61         int (*destroy)(bithenge_blob_t *blob);
     59         * @param blob The blob. */
     60        void (*destroy)(bithenge_blob_t *self);
    6261} bithenge_random_access_blob_ops_t;
    6362
    … …  
    8786         *
    8887         * @memberof bithenge_blob_t
    89          * @param blob The blob.
     88         * @param self The blob.
    9089         * @param[out] size Total size of the blob.
    9190         * @return EOK on success or an error code from errno.h.
    9291         */
    93         int (*size)(bithenge_sequential_blob_t *blob, aoff64_t *size);
     92        int (*size)(bithenge_sequential_blob_t *self, aoff64_t *size);
    9493
    9594        /** Read the next part of the blob. If the requested data extends
    … …  
    9796         * will be read.
    9897         *
    99          * @param blob The blob.
     98         * @param self The blob.
    10099         * @param[out] buffer Buffer to read into. If an error occurs, the contents are
    101100         * undefined.
    … …  
    105104         * @return EOK on success or an error code from errno.h.
    106105         */
    107         int (*read)(bithenge_sequential_blob_t *blob, char *buffer,
     106        int (*read)(bithenge_sequential_blob_t *self, char *buffer,
    108107            aoff64_t *size);
    109108
    110109        /** Destroy the blob.
    111          * @param blob The blob.
    112          * @return EOK on success or an error code from errno.h. */
    113         int (*destroy)(bithenge_sequential_blob_t *blob);
     110         * @param self The blob. */
     111        void (*destroy)(bithenge_sequential_blob_t *self);
    114112} bithenge_sequential_blob_ops_t;
    115113
    … …  
    117115 *
    118116 * @memberof bithenge_blob_t
    119  * @param blob The blob.
     117 * @param self The blob.
    120118 * @param[out] size Total size of the blob.
    121119 * @return EOK on success or an error code from errno.h.
    122120 */
    123 static inline int bithenge_blob_size(bithenge_blob_t *blob, aoff64_t *size)
    124 {
    125         assert(blob);
    126         assert(blob->base.blob_ops);
    127         return blob->base.blob_ops->size(blob, size);
     121static inline int bithenge_blob_size(bithenge_blob_t *self, aoff64_t *size)
     122{
     123        assert(self);
     124        assert(self->base.blob_ops);
     125        return self->base.blob_ops->size(self, size);
    128126}
    129127
    … …  
    134132 *
    135133 * @memberof bithenge_blob_t
    136  * @param blob The blob.
     134 * @param self The blob.
    137135 * @param offset Byte offset within the blob.
    138136 * @param[out] buffer Buffer to read into. If an error occurs, the contents are
    … …  
    143141 * @return EOK on success or an error code from errno.h.
    144142 */
    145 static inline int bithenge_blob_read(bithenge_blob_t *blob, aoff64_t offset,
     143static inline int bithenge_blob_read(bithenge_blob_t *self, aoff64_t offset,
    146144    char *buffer, aoff64_t *size)
    147145{
    148         assert(blob);
    149         assert(blob->base.blob_ops);
    150         return blob->base.blob_ops->read(blob, offset, buffer, size);
     146        assert(self);
     147        assert(self->base.blob_ops);
     148        return self->base.blob_ops->read(self, offset, buffer, size);
    151149}
    152150
    … …  
    170168}
    171169
    172 static inline int bithenge_blob_inc_ref(bithenge_blob_t *blob)
    173 {
    174         return bithenge_node_inc_ref(bithenge_blob_as_node(blob));
    175 }
    176 
    177 static inline int bithenge_blob_dec_ref(bithenge_blob_t *blob)
    178 {
    179         if (!blob)
    180                 return EOK;
    181         return bithenge_node_dec_ref(bithenge_blob_as_node(blob));
    182 }
    183 
    184 int bithenge_new_random_access_blob(bithenge_blob_t *blob,
    185     const bithenge_random_access_blob_ops_t *ops);
    186 
    187 int bithenge_new_sequential_blob(bithenge_sequential_blob_t *blob,
    188     const bithenge_sequential_blob_ops_t *ops);
    189 
    190 int bithenge_new_blob_from_data(bithenge_node_t **out, const void *data,
    191     size_t len);
    192 
    193 int bithenge_new_blob_from_buffer(bithenge_node_t **out, const void *buffer,
    194     size_t len, bool needs_free);
    195 
    196 int bithenge_new_offset_blob(bithenge_node_t **out, bithenge_blob_t *blob,
    197     aoff64_t offset);
    198 
    199 int bithenge_new_subblob(bithenge_node_t **out, bithenge_blob_t *blob,
    200     aoff64_t offset, aoff64_t size);
    201 
    202 bool bithenge_blob_equal(bithenge_blob_t *a, bithenge_blob_t *b);
     170/** Increment a blob's reference count.
     171 * @param blob The blob to reference. */
     172static inline void bithenge_blob_inc_ref(bithenge_blob_t *blob)
     173{
     174        bithenge_node_inc_ref(bithenge_blob_as_node(blob));
     175}
     176
     177/** Decrement a blob's reference count.
     178 * @param blob The blob to dereference, or NULL. */
     179static inline void bithenge_blob_dec_ref(bithenge_blob_t *blob)
     180{
     181        if (blob)
     182                bithenge_node_dec_ref(bithenge_blob_as_node(blob));
     183}
     184
     185int bithenge_init_random_access_blob(bithenge_blob_t *,
     186    const bithenge_random_access_blob_ops_t *);
     187int bithenge_init_sequential_blob(bithenge_sequential_blob_t *,
     188    const bithenge_sequential_blob_ops_t *);
     189int bithenge_new_blob_from_data(bithenge_node_t **, const void *, size_t);
     190int bithenge_new_blob_from_buffer(bithenge_node_t **, const void *, size_t,
     191    bool);
     192int bithenge_new_offset_blob(bithenge_node_t **, bithenge_blob_t *, aoff64_t);
     193int bithenge_new_subblob(bithenge_node_t **, bithenge_blob_t *, aoff64_t,
     194    aoff64_t);
     195bool bithenge_blob_equal(bithenge_blob_t *, bithenge_blob_t *);
    203196
    204197#endif

  • uspace/app/bithenge/file.c

    r04a7435f r978ccaf1  
    5555} file_blob_t;
    5656
    57 static inline file_blob_t *file_from_blob(bithenge_blob_t *base)
     57static inline file_blob_t *blob_as_file(bithenge_blob_t *base)
    5858{
    5959        return (file_blob_t *)base;
    6060}
    6161
    62 static inline bithenge_blob_t *blob_from_file(file_blob_t *blob)
     62static inline bithenge_blob_t *file_as_blob(file_blob_t *blob)
    6363{
    6464        return &blob->base;
    … …  
    6767static int file_size(bithenge_blob_t *base, aoff64_t *size)
    6868{
    69         file_blob_t *blob = file_from_blob(base);
     69        file_blob_t *blob = blob_as_file(base);
    7070        *size = blob->size;
    7171        return EOK;
    … …  
    7575    aoff64_t *size)
    7676{
    77         file_blob_t *blob = file_from_blob(base);
     77        file_blob_t *blob = blob_as_file(base);
    7878        if (offset > blob->size)
    7979                return ELIMIT;
    … …  
    9595}
    9696
    97 static int file_destroy(bithenge_blob_t *base)
     97static void file_destroy(bithenge_blob_t *base)
    9898{
    99         file_blob_t *blob = file_from_blob(base);
     99        file_blob_t *blob = blob_as_file(base);
    100100        close(blob->fd);
    101101        free(blob);
    102         return EOK;
    103102}
    104103
    … …  
    128127                return ENOMEM;
    129128        }
    130         rc = bithenge_new_random_access_blob(blob_from_file(blob),
    131             &file_ops);
     129        rc = bithenge_init_random_access_blob(file_as_blob(blob), &file_ops);
    132130        if (rc != EOK) {
    133131                free(blob);
    … …  
    143141#endif
    144142        blob->needs_close = needs_close;
    145         *out = bithenge_blob_as_node(blob_from_file(blob));
     143        *out = bithenge_blob_as_node(file_as_blob(blob));
    146144
    147145        return EOK;

  • uspace/app/bithenge/helenos/block.c

    r04a7435f r978ccaf1  
    5151} block_blob_t;
    5252
    53 static inline block_blob_t *block_from_blob(bithenge_blob_t *base)
     53static inline block_blob_t *blob_as_block(bithenge_blob_t *base)
    5454{
    5555        return (block_blob_t *)base;
    5656}
    5757
    58 static inline bithenge_blob_t *blob_from_block(block_blob_t *blob)
     58static inline bithenge_blob_t *block_as_blob(block_blob_t *blob)
    5959{
    6060        return &blob->base;
    … …  
    6363static int block_size(bithenge_blob_t *base, aoff64_t *size)
    6464{
    65         block_blob_t *blob = block_from_blob(base);
    66         *size = blob->size;
     65        block_blob_t *self = blob_as_block(base);
     66        *size = self->size;
    6767        return EOK;
    6868}
    … …  
    7171    aoff64_t *size)
    7272{
    73         block_blob_t *blob = block_from_blob(base);
    74         if (offset > blob->size)
     73        block_blob_t *self = blob_as_block(base);
     74        if (offset > self->size)
    7575                return ELIMIT;
    76         *size = min(*size, blob->size - offset);
    77         return block_read_bytes_direct(blob->service_id, offset, *size, buffer);
     76        *size = min(*size, self->size - offset);
     77        return block_read_bytes_direct(self->service_id, offset, *size, buffer);
    7878}
    7979
    80 static int block_destroy(bithenge_blob_t *base)
     80static void block_destroy(bithenge_blob_t *base)
    8181{
    82         block_blob_t *blob = block_from_blob(base);
    83         block_fini(blob->service_id);
    84         free(blob);
    85         return EOK;
     82        block_blob_t *self = blob_as_block(base);
     83        block_fini(self->service_id);
     84        free(self);
    8685}
    8786
    … …  
    129128                return ENOMEM;
    130129        }
    131         rc = bithenge_new_random_access_blob(blob_from_block(blob),
     130        rc = bithenge_init_random_access_blob(block_as_blob(blob),
    132131            &block_ops);
    133132        if (rc != EOK) {
    … …  
    138137        blob->service_id = service_id;
    139138        blob->size = size;
    140         *out = bithenge_blob_as_node(blob_from_block(blob));
     139        *out = bithenge_blob_as_node(block_as_blob(blob));
    141140
    142141        return EOK;

  • uspace/app/bithenge/script.c

    r04a7435f r978ccaf1  
    121121static void syntax_error(state_t *state, const char *message)
    122122{
    123         // Multiple errors are confusing.
     123        // Printing multiple errors is confusing.
    124124        if (state->error == EOK) {
    125125                size_t start_char = state->old_buffer_pos + state->line_offset;
    … …  
    423423        return rc;
    424424}
     425
     426/** @}
     427 */

  • uspace/app/bithenge/script.h

    r04a7435f r978ccaf1  
    4040#include "transform.h"
    4141
    42 int bithenge_parse_script(const char *filename, bithenge_transform_t **out);
     42int bithenge_parse_script(const char *, bithenge_transform_t **);
    4343
    4444#endif
    4545
    46 /** @/
     46/** @}
    4747 */

  • uspace/app/bithenge/source.c

    r04a7435f r978ccaf1  
    7878}
    7979
     80/** Create a node from a source described with a string. For instance,
     81 * "hex:55aa" will result in a blob node. If there is no colon in the string,
     82 * it is assumed to be a filename.
     83 * @param[out] out Stores the created node.
     84 * @param source Specifies the node to be created.
     85 * @return EOK on success or an error code from errno.h. */
    8086int bithenge_node_from_source(bithenge_node_t **out, const char *source)
    8187{

  • uspace/app/bithenge/source.h

    r04a7435f r978ccaf1  
    4040#include "tree.h"
    4141
    42 int bithenge_node_from_source(bithenge_node_t **out, const char *source);
     42int bithenge_node_from_source(bithenge_node_t **, const char *);
    4343
    4444#endif

  • uspace/app/bithenge/transform.c

    r04a7435f r978ccaf1  
    4242
    4343/** Initialize a new transform.
    44  * @param[out] xform Transform to initialize.
     44 * @param[out] self Transform to initialize.
    4545 * @param[in] ops Operations provided by the transform.
    4646 * @return EOK or an error code from errno.h. */
    47 int bithenge_new_transform(bithenge_transform_t *xform,
     47int bithenge_init_transform(bithenge_transform_t *self,
    4848    const bithenge_transform_ops_t *ops)
    4949{
    … …  
    5151        assert(ops->apply);
    5252        assert(ops->destroy);
    53         xform->ops = ops;
    54         xform->refs = 1;
    55         return EOK;
    56 }
    57 
    58 static int transform_indestructible(bithenge_transform_t *xform)
     53        self->ops = ops;
     54        self->refs = 1;
     55        return EOK;
     56}
     57
     58static void transform_indestructible(bithenge_transform_t *self)
    5959{
    6060        assert(false);
    61         return EOK;
    62 }
    63 
    64 static int uint32le_apply(bithenge_transform_t *xform, bithenge_node_t *in,
     61}
     62
     63static int uint32le_apply(bithenge_transform_t *self, bithenge_node_t *in,
    6564    bithenge_node_t **out)
    6665{
    … …  
    8281}
    8382
    84 static int uint32be_apply(bithenge_transform_t *xform, bithenge_node_t *in,
     83static int uint32be_apply(bithenge_transform_t *self, bithenge_node_t *in,
    8584    bithenge_node_t **out)
    8685{
    … …  
    102101}
    103102
    104 static int prefix_length_4(bithenge_transform_t *xform, bithenge_blob_t *blob,
     103static int prefix_length_4(bithenge_transform_t *self, bithenge_blob_t *blob,
    105104    aoff64_t *out)
    106105{
    … …  
    266265}
    267266
    268 static int struct_node_destroy(bithenge_node_t *base)
     267static void struct_node_destroy(bithenge_node_t *base)
    269268{
    270269        struct_node_t *node = node_as_struct(base);
    … …  
    272271        bithenge_blob_dec_ref(node->blob);
    273272        free(node);
    274         return EOK;
    275273}
    276274
    … …  
    280278};
    281279
    282 static int struct_transform_apply(bithenge_transform_t *xform,
     280static int struct_transform_apply(bithenge_transform_t *base,
    283281    bithenge_node_t *in, bithenge_node_t **out)
    284282{
    285         struct_transform_t *struct_transform = transform_as_struct(xform);
     283        struct_transform_t *self = transform_as_struct(base);
    286284        if (bithenge_node_type(in) != BITHENGE_NODE_BLOB)
    287285                return EINVAL;
    … …  
    295293                return rc;
    296294        }
    297         bithenge_transform_inc_ref(xform);
    298         node->transform = struct_transform;
     295        bithenge_transform_inc_ref(base);
     296        node->transform = self;
    299297        bithenge_node_inc_ref(in);
    300298        node->blob = bithenge_node_as_blob(in);
    … …  
    303301}
    304302
    305 static int struct_transform_prefix_length(bithenge_transform_t *xform,
     303static int struct_transform_prefix_length(bithenge_transform_t *base,
    306304    bithenge_blob_t *blob, aoff64_t *out)
    307305{
    308         struct_transform_t *struct_transform = transform_as_struct(xform);
     306        struct_transform_t *self = transform_as_struct(base);
    309307        int rc = EOK;
    310308        bithenge_node_t *node;
    … …  
    316314        blob = bithenge_node_as_blob(node);
    317315        *out = 0;
    318         for (size_t i = 0; struct_transform->subtransforms[i].transform; i++) {
     316        for (size_t i = 0; self->subtransforms[i].transform; i++) {
    319317                bithenge_transform_t *subxform =
    320                     struct_transform->subtransforms[i].transform;
     318                    self->subtransforms[i].transform;
    321319                aoff64_t sub_size;
    322320                rc = bithenge_transform_prefix_length(subxform, blob, &sub_size);
    … …  
    344342}
    345343
    346 static int struct_transform_destroy(bithenge_transform_t *xform)
    347 {
    348         struct_transform_t *struct_transform = transform_as_struct(xform);
    349         free_subtransforms(struct_transform->subtransforms);
    350         free(struct_transform);
    351         return EOK;
     344static void struct_transform_destroy(bithenge_transform_t *base)
     345{
     346        struct_transform_t *self = transform_as_struct(base);
     347        free_subtransforms(self->subtransforms);
     348        free(self);
    352349}
    353350
    … …  
    370367{
    371368        int rc;
    372         struct_transform_t *struct_transform =
    373             malloc(sizeof(*struct_transform));
    374         if (!struct_transform) {
     369        struct_transform_t *self =
     370            malloc(sizeof(*self));
     371        if (!self) {
    375372                rc = ENOMEM;
    376373                goto error;
    377374        }
    378         rc = bithenge_new_transform(struct_as_transform(struct_transform),
     375        rc = bithenge_init_transform(struct_as_transform(self),
    379376            &struct_transform_ops);
    380377        if (rc != EOK)
    381378                goto error;
    382         struct_transform->subtransforms = subtransforms;
    383         *out = struct_as_transform(struct_transform);
     379        self->subtransforms = subtransforms;
     380        *out = struct_as_transform(self);
    384381        return EOK;
    385382error:
    386383        free_subtransforms(subtransforms);
    387         free(struct_transform);
     384        free(self);
    388385        return rc;
    389386}

  • uspace/app/bithenge/transform.h

    r04a7435f r978ccaf1  
    5151typedef struct bithenge_transform_ops {
    5252        /** @copydoc bithenge_transform_t::bithenge_transform_apply */
    53         int (*apply)(bithenge_transform_t *xform, bithenge_node_t *in, bithenge_node_t **out);
     53        int (*apply)(bithenge_transform_t *self, bithenge_node_t *in, bithenge_node_t **out);
    5454        /** @copydoc bithenge_transform_t::bithenge_transform_prefix_length */
    55         int (*prefix_length)(bithenge_transform_t *xform, bithenge_blob_t *blob, aoff64_t *out);
     55        int (*prefix_length)(bithenge_transform_t *self, bithenge_blob_t *blob, aoff64_t *out);
    5656        /** Destroy the transform.
    57          * @param xform The transform.
    58          * @return EOK on success or an error code from errno.h. */
    59         int (*destroy)(bithenge_transform_t *xform);
     57         * @param self The transform. */
     58        void (*destroy)(bithenge_transform_t *self);
    6059} bithenge_transform_ops_t;
    6160
    6261/** Apply a transform.
    6362 * @memberof bithenge_transform_t
    64  * @param xform The transform.
     63 * @param self The transform.
    6564 * @param in The input tree.
    6665 * @param[out] out Where the output tree will be stored.
    6766 * @return EOK on success or an error code from errno.h. */
    68 static inline int bithenge_transform_apply(bithenge_transform_t *xform,
     67static inline int bithenge_transform_apply(bithenge_transform_t *self,
    6968    bithenge_node_t *in, bithenge_node_t **out)
    7069{
    71         assert(xform);
    72         assert(xform->ops);
    73         return xform->ops->apply(xform, in, out);
     70        assert(self);
     71        assert(self->ops);
     72        return self->ops->apply(self, in, out);
    7473}
    7574
    … …  
    7978 * subtransforms.
    8079 * @memberof bithenge_transform_t
    81  * @param xform The transform.
     80 * @param self The transform.
    8281 * @param blob The blob.
    8382 * @param[out] out Where the prefix length will be stored.
    8483 * @return EOK on success, ENOTSUP if not supported, or another error code from
    8584 * errno.h. */
    86 static inline int bithenge_transform_prefix_length(bithenge_transform_t *xform,
     85static inline int bithenge_transform_prefix_length(bithenge_transform_t *self,
    8786    bithenge_blob_t *blob, aoff64_t *out)
    8887{
    89         assert(xform);
    90         assert(xform->ops);
    91         if (!xform->ops->prefix_length)
     88        assert(self);
     89        assert(self->ops);
     90        if (!self->ops->prefix_length)
    9291                return ENOTSUP;
    93         return xform->ops->prefix_length(xform, blob, out);
     92        return self->ops->prefix_length(self, blob, out);
    9493}
    9594
    9695/** Increment a transform's reference count.
    97  * @param xform The transform to reference.
    98  * @return EOK on success or an error code from errno.h. */
    99 static inline int bithenge_transform_inc_ref(bithenge_transform_t *xform)
     96 * @param self The transform to reference. */
     97static inline void bithenge_transform_inc_ref(bithenge_transform_t *self)
    10098{
    101         assert(xform);
    102         xform->refs++;
    103         return EOK;
     99        assert(self);
     100        self->refs++;
    104101}
    105102
    106103/** Decrement a transform's reference count and free it if appropriate.
    107  * @param xform The transform to dereference, or NULL.
    108  * @return EOK on success or an error code from errno.h. */
    109 static inline int bithenge_transform_dec_ref(bithenge_transform_t *xform)
     104 * @param self The transform to dereference, or NULL. */
     105static inline void bithenge_transform_dec_ref(bithenge_transform_t *self)
    110106{
    111         if (!xform)
    112                 return EOK;
    113         assert(xform->ops);
    114         if (--xform->refs == 0)
    115                 return xform->ops->destroy(xform);
    116         return EOK;
     107        if (!self)
     108                return;
     109        assert(self->ops);
     110        if (--self->refs == 0)
     111                self->ops->destroy(self);
    117112}
    118113
    … …  
    127122extern bithenge_named_transform_t *bithenge_primitive_transforms;
    128123
    129 int bithenge_new_transform(bithenge_transform_t *xform,
     124int bithenge_init_transform(bithenge_transform_t *self,
    130125    const bithenge_transform_ops_t *ops);
    131126

  • uspace/app/bithenge/tree.c

    r04a7435f r978ccaf1  
    4141#include "tree.h"
    4242
    43 static int blob_destroy(bithenge_node_t *base)
    44 {
    45         bithenge_blob_t *blob = bithenge_node_as_blob(base);
    46         assert(blob->base.blob_ops);
    47         return blob->base.blob_ops->destroy(blob);
    48 }
    49 
    50 static int node_destroy(bithenge_node_t *node)
    51 {
    52         switch (bithenge_node_type(node)) {
     43static void blob_destroy(bithenge_node_t *base)
     44{
     45        bithenge_blob_t *self = bithenge_node_as_blob(base);
     46        assert(self->base.blob_ops);
     47        self->base.blob_ops->destroy(self);
     48}
     49
     50static void node_destroy(bithenge_node_t *self)
     51{
     52        switch (bithenge_node_type(self)) {
    5353        case BITHENGE_NODE_BLOB:
    54                 return blob_destroy(node);
     54                blob_destroy(self);
     55                return;
    5556        case BITHENGE_NODE_STRING:
    56                 if (node->string_value.needs_free)
    57                         free((void *)node->string_value.ptr);
     57                if (self->string_value.needs_free)
     58                        free((void *)self->string_value.ptr);
    5859                break;
    5960        case BITHENGE_NODE_INTERNAL:
    60                 return node->internal_ops->destroy(node);
     61                self->internal_ops->destroy(self);
     62                return;
    6163        case BITHENGE_NODE_BOOLEAN:
    62                 return EOK; // the boolean nodes are allocated statically below
     64                return; /* The boolean nodes are allocated statically below. */
    6365        case BITHENGE_NODE_INTEGER: /* pass-through */
    6466                break;
    6567        }
    66         free(node);
    67         return EOK;
     68        free(self);
    6869}
    6970
    7071/** Decrement a node's reference count and free it if appropriate.
    7172 * @memberof bithenge_node_t
    72  * @param node The node to dereference, or NULL.
    73  * @return EOK on success or an error code from errno.h. */
    74 int bithenge_node_dec_ref(bithenge_node_t *node)
     73 * @param node The node to dereference, or NULL. */
     74void bithenge_node_dec_ref(bithenge_node_t *node)
    7575{
    7676        if (!node)
    77                 return EOK;
     77                return;
    7878        if (--node->refs == 0)
    79                 return node_destroy(node);
    80         return EOK;
     79                node_destroy(node);
    8180}
    8281
    … …  
    103102{
    104103        int rc;
    105         simple_internal_node_t *node = node_as_simple(base);
    106         for (bithenge_int_t i = 0; i < node->len; i++) {
    107                 bithenge_node_inc_ref(node->nodes[2*i+0]);
    108                 bithenge_node_inc_ref(node->nodes[2*i+1]);
    109                 rc = func(node->nodes[2*i+0], node->nodes[2*i+1], data);
     104        simple_internal_node_t *self = node_as_simple(base);
     105        for (bithenge_int_t i = 0; i < self->len; i++) {
     106                bithenge_node_inc_ref(self->nodes[2*i+0]);
     107                bithenge_node_inc_ref(self->nodes[2*i+1]);
     108                rc = func(self->nodes[2*i+0], self->nodes[2*i+1], data);
    110109                if (rc != EOK)
    111110                        return rc;
    … …  
    114113}
    115114
    116 static int simple_internal_node_destroy(bithenge_node_t *base)
    117 {
    118         int rc;
    119         simple_internal_node_t *node = node_as_simple(base);
    120         for (bithenge_int_t i = 0; i < 2 * node->len; i++) {
    121                 rc = bithenge_node_dec_ref(node->nodes[i]);
    122                 if (rc != EOK)
    123                         return rc;
    124         }
    125         if (node->needs_free)
    126                 free(node->nodes);
    127         free(node);
    128         return EOK;
     115static void simple_internal_node_destroy(bithenge_node_t *base)
     116{
     117        simple_internal_node_t *self = node_as_simple(base);
     118        for (bithenge_int_t i = 0; i < 2 * self->len; i++)
     119                bithenge_node_dec_ref(self->nodes[i]);
     120        if (self->needs_free)
     121                free(self->nodes);
     122        free(self);
    129123}
    130124
    … …  
    136130/** Initialize an internal node.
    137131 * @memberof bithenge_node_t
    138  * @param[out] node The node.
     132 * @param[out] self The node.
    139133 * @param[in] ops The operations provided.
    140134 * @return EOK on success or an error code from errno.h. */
    141 int bithenge_init_internal_node(bithenge_node_t *node,
     135int bithenge_init_internal_node(bithenge_node_t *self,
    142136    const bithenge_internal_node_ops_t *ops)
    143137{
    144         node->type = BITHENGE_NODE_INTERNAL;
    145         node->refs = 1;
    146         node->internal_ops = ops;
     138        self->type = BITHENGE_NODE_INTERNAL;
     139        self->refs = 1;
     140        self->internal_ops = ops;
    147141        return EOK;
    148142}
    … …  
    164158        int rc;
    165159        assert(out);
    166         simple_internal_node_t *node = malloc(sizeof(*node));
    167         if (!node) {
     160        simple_internal_node_t *self = malloc(sizeof(*self));
     161        if (!self) {
    168162                rc = ENOMEM;
    169163                goto error;
    170164        }
    171         rc = bithenge_init_internal_node(simple_as_node(node),
     165        rc = bithenge_init_internal_node(simple_as_node(self),
    172166            &simple_internal_node_ops);
    173167        if (rc != EOK)
    174168                goto error;
    175         node->nodes = nodes;
    176         node->len = len;
    177         node->needs_free = needs_free;
    178         *out = simple_as_node(node);
     169        self->nodes = nodes;
     170        self->len = len;
     171        self->needs_free = needs_free;
     172        *out = simple_as_node(self);
    179173        return EOK;
    180174error:
    … …  
    183177        if (needs_free)
    184178                free(nodes);
    185         free(node);
     179        free(self);
    186180        return rc;
    187181}
    … …  
    211205{
    212206        assert(out);
    213         bithenge_node_t *node = malloc(sizeof(*node));
    214         if (!node)
     207        bithenge_node_t *self = malloc(sizeof(*self));
     208        if (!self)
    215209                return ENOMEM;
    216         node->type = BITHENGE_NODE_INTEGER;
    217         node->refs = 1;
    218         node->integer_value = value;
    219         *out = node;
     210        self->type = BITHENGE_NODE_INTEGER;
     211        self->refs = 1;
     212        self->integer_value = value;
     213        *out = self;
    220214        return EOK;
    221215}
    … …  
    231225{
    232226        assert(out);
    233         bithenge_node_t *node = malloc(sizeof(*node));
    234         if (!node)
     227        bithenge_node_t *self = malloc(sizeof(*self));
     228        if (!self)
    235229                return ENOMEM;
    236         node->type = BITHENGE_NODE_STRING;
    237         node->refs = 1;
    238         node->string_value.ptr = value;
    239         node->string_value.needs_free = needs_free;
    240         *out = node;
     230        self->type = BITHENGE_NODE_STRING;
     231        self->refs = 1;
     232        self->string_value.ptr = value;
     233        self->string_value.needs_free = needs_free;
     234        *out = self;
    241235        return EOK;
    242236}

  • uspace/app/bithenge/tree.h

    r04a7435f r978ccaf1  
    9393typedef struct bithenge_internal_node_ops_t {
    9494        /** @copydoc bithenge_node_t::bithenge_node_for_each */
    95         int (*for_each)(bithenge_node_t *node, bithenge_for_each_func_t func, void *data);
    96         /** @copydoc bithenge_node_t::bithenge_node_destroy */
    97         int (*destroy)(bithenge_node_t *node);
     95        int (*for_each)(bithenge_node_t *self, bithenge_for_each_func_t func, void *data);
     96        /** Destroys the internal node.
     97         * @param self The node to destroy. */
     98        void (*destroy)(bithenge_node_t *self);
    9899} bithenge_internal_node_ops_t;
    99100
    … …  
    109110/** Increment a node's reference count.
    110111 * @memberof bithenge_node_t
    111  * @param node The node to reference.
    112  * @return EOK on success or an error code from errno.h. */
    113 static inline int bithenge_node_inc_ref(bithenge_node_t *node)
     112 * @param node The node to reference. */
     113static inline void bithenge_node_inc_ref(bithenge_node_t *node)
    114114{
    115115        assert(node);
    116116        node->refs++;
    117         return EOK;
    118117}
    119118
    120 int bithenge_node_dec_ref(bithenge_node_t *node);
     119void bithenge_node_dec_ref(bithenge_node_t *node);
    121120
    122121/** Iterate over a node's children.
    123122 * @memberof bithenge_node_t
    124  * @param node The internal node to iterate over.
     123 * @param self The internal node to iterate over.
    125124 * @param func The callback function.
    126125 * @param data Data to provide to the callback function.
    127126 * @return EOK on success or an error code from errno.h. */
    128 static inline int bithenge_node_for_each(bithenge_node_t *node, bithenge_for_each_func_t func, void *data)
     127static inline int bithenge_node_for_each(bithenge_node_t *self,
     128    bithenge_for_each_func_t func, void *data)
    129129{
    130         assert(node->type == BITHENGE_NODE_INTERNAL);
    131         return node->internal_ops->for_each(node, func, data);
     130        assert(self->type == BITHENGE_NODE_INTERNAL);
     131        return self->internal_ops->for_each(self, func, data);
    132132}
    133133
    134134/** Get the value of a boolean node.
    135135 * @memberof bithenge_node_t
    136  * @param node The boolean node.
     136 * @param self The boolean node.
    137137 * @return The node's value. */
    138 static inline bool bithenge_boolean_node_value(bithenge_node_t *node)
     138static inline bool bithenge_boolean_node_value(bithenge_node_t *self)
    139139{
    140         assert(node->type == BITHENGE_NODE_BOOLEAN);
    141         return node->boolean_value;
     140        assert(self->type == BITHENGE_NODE_BOOLEAN);
     141        return self->boolean_value;
    142142}
    143143
    144144/** Get the value of an integer node.
    145145 * @memberof bithenge_node_t
    146  * @param node The integer node.
     146 * @param self The integer node.
    147147 * @return The node's value. */
    148 static inline bithenge_int_t bithenge_integer_node_value(bithenge_node_t *node)
     148static inline bithenge_int_t bithenge_integer_node_value(bithenge_node_t *self)
    149149{
    150         assert(node->type == BITHENGE_NODE_INTEGER);
    151         return node->integer_value;
     150        assert(self->type == BITHENGE_NODE_INTEGER);
     151        return self->integer_value;
    152152}
    153153
    154154/** Get the value of an string node.
    155155 * @memberof bithenge_node_t
    156  * @param node The string node.
     156 * @param self The string node.
    157157 * @return The node's value. */
    158 static inline const char *bithenge_string_node_value(bithenge_node_t *node)
     158static inline const char *bithenge_string_node_value(bithenge_node_t *self)
    159159{
    160         assert(node->type == BITHENGE_NODE_STRING);
    161         return node->string_value.ptr;
     160        assert(self->type == BITHENGE_NODE_STRING);
     161        return self->string_value.ptr;
    162162}
    163163
Note: See TracChangeset for help on using the changeset viewer.