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

Changeset 5c925ce in mainline


Ignore:
Timestamp:
2012-06-07T17:00:12Z (8 years ago)
Author:
Sean Bartell <wingedtachikoma@…>
Branches:
master
Children:
8375d0eb
Parents:
5f679702
Message:

Bithenge: make blobs a type of node

Location:
uspace/app/bithenge
Files:
10 edited

Legend:

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

    r5f679702 r5c925ce  
    4242#include <stdlib.h>
    4343#include "blob.h"
     44#include "tree.h"
    4445
    4546/** Initialize a random access blob.
     
    5960        assert(ops->size);
    6061
    61         blob->ops = ops;
     62        blob->base.type = BITHENGE_NODE_BLOB;
     63        blob->base.blob_ops = ops;
    6264        return EOK;
    6365}
     
    234236 * @param len The length of the data.
    235237 * @return EOK on success or an error code from errno.h. */
    236 int bithenge_new_blob_from_data(bithenge_blob_t **out, const void *data,
     238int bithenge_new_blob_from_data(bithenge_node_t **out, const void *data,
    237239    size_t len)
    238240{
     
    258260        blob->size = len;
    259261        blob->needs_free = true;
    260         *out = blob_from_memory(blob);
     262        *out = bithenge_blob_as_node(blob_from_memory(blob));
    261263        return EOK;
    262264}
     
    273275 * blob is destroyed.
    274276 * @return EOK on success or an error code from errno.h. */
    275 int bithenge_new_blob_from_buffer(bithenge_blob_t **out, const void *buffer,
     277int bithenge_new_blob_from_buffer(bithenge_node_t **out, const void *buffer,
    276278    size_t len, bool needs_free)
    277279{
     
    291293        blob->size = len;
    292294        blob->needs_free = needs_free;
    293         *out = blob_from_memory(blob);
     295        *out = bithenge_blob_as_node(blob_from_memory(blob));
    294296        return EOK;
    295297}
  • uspace/app/bithenge/blob.h

    r5f679702 r5c925ce  
    3939
    4040#include <sys/types.h>
     41#include "tree.h"
    4142
    4243/** A blob of raw binary data. */
    4344typedef struct {
    4445        /** @privatesection */
    45         /** Operations providing random access. */
    46         const struct bithenge_random_access_blob_ops_t *ops;
     46        struct bithenge_node_t base;
    4747} bithenge_blob_t;
    4848
     
    121121{
    122122        assert(blob);
    123         assert(blob->ops);
    124         return blob->ops->size(blob, size);
     123        assert(blob->base.blob_ops);
     124        return blob->base.blob_ops->size(blob, size);
    125125}
    126126
     
    144144{
    145145        assert(blob);
    146         assert(blob->ops);
    147         return blob->ops->read(blob, offset, buffer, size);
     146        assert(blob->base.blob_ops);
     147        return blob->base.blob_ops->read(blob, offset, buffer, size);
    148148}
    149149
    150 /** Destroy the blob.
    151  * @memberof bithenge_blob_t
    152  * @param blob The blob.
    153  * @return EOK on success or an error code from errno.h.
    154  */
    155 static inline int bithenge_blob_destroy(bithenge_blob_t *blob)
     150static inline bithenge_node_t *bithenge_blob_as_node(bithenge_blob_t *blob)
    156151{
    157         assert(blob);
    158         assert(blob->ops);
    159         return blob->ops->destroy(blob);
     152        return &blob->base;
     153}
     154
     155static inline bithenge_blob_t *bithenge_node_as_blob(bithenge_node_t *node)
     156{
     157        return (bithenge_blob_t *)node;
    160158}
    161159
     
    166164    const bithenge_sequential_blob_ops_t *ops);
    167165
    168 int bithenge_new_blob_from_data(bithenge_blob_t **out, const void *data,
     166int bithenge_new_blob_from_data(bithenge_node_t **out, const void *data,
    169167    size_t len);
    170168
    171 int bithenge_new_blob_from_buffer(bithenge_blob_t **out, const void *buffer,
     169int bithenge_new_blob_from_buffer(bithenge_node_t **out, const void *buffer,
    172170    size_t len, bool needs_free);
    173171
  • uspace/app/bithenge/block.c

    r5f679702 r5c925ce  
    9797 * @param service_id The service ID of the block device.
    9898 * @return EOK on success or an error code from errno.h. */
    99 int bithenge_new_block_blob(bithenge_blob_t **out, service_id_t service_id)
     99int bithenge_new_block_blob(bithenge_node_t **out, service_id_t service_id)
    100100{
    101101        assert(out);
     
    138138        blob->service_id = service_id;
    139139        blob->size = size;
    140         *out = blob_from_block(blob);
     140        *out = bithenge_blob_as_node(blob_from_block(blob));
    141141
    142142        return EOK;
  • uspace/app/bithenge/block.h

    r5f679702 r5c925ce  
    4141#include "blob.h"
    4242
    43 int bithenge_new_block_blob(bithenge_blob_t **, service_id_t);
     43int bithenge_new_block_blob(bithenge_node_t **, service_id_t);
    4444
    4545#endif
  • uspace/app/bithenge/file.c

    r5f679702 r5c925ce  
    9797};
    9898
    99 static int new_file_blob(bithenge_blob_t **out, int fd, bool needs_close)
     99static int new_file_blob(bithenge_node_t **out, int fd, bool needs_close)
    100100{
    101101        assert(out);
     
    127127        blob->size = stat.size;
    128128        blob->needs_close = needs_close;
    129         *out = blob_from_file(blob);
     129        *out = bithenge_blob_as_node(blob_from_file(blob));
    130130
    131131        return EOK;
     
    137137 * @param filename The name of the file.
    138138 * @return EOK on success or an error code from errno.h. */
    139 int bithenge_new_file_blob(bithenge_blob_t **out, const char *filename)
     139int bithenge_new_file_blob(bithenge_node_t **out, const char *filename)
    140140{
    141141        assert(filename);
     
    153153 * @param fd The file descriptor.
    154154 * @return EOK on success or an error code from errno.h. */
    155 int bithenge_new_file_blob_from_fd(bithenge_blob_t **out, int fd)
     155int bithenge_new_file_blob_from_fd(bithenge_node_t **out, int fd)
    156156{
    157157        return new_file_blob(out, fd, false);
     
    163163 * @param file The file pointer.
    164164 * @return EOK on success or an error code from errno.h. */
    165 int bithenge_new_file_blob_from_file(bithenge_blob_t **out, FILE *file)
     165int bithenge_new_file_blob_from_file(bithenge_node_t **out, FILE *file)
    166166{
    167167        int fd = fileno(file);
  • uspace/app/bithenge/file.h

    r5f679702 r5c925ce  
    4141#include "blob.h"
    4242
    43 int bithenge_new_file_blob(bithenge_blob_t **, const char *);
    44 int bithenge_new_file_blob_from_fd(bithenge_blob_t **, int);
    45 int bithenge_new_file_blob_from_file(bithenge_blob_t **, FILE *);
     43int bithenge_new_file_blob(bithenge_node_t **, const char *);
     44int bithenge_new_file_blob_from_fd(bithenge_node_t **, int);
     45int bithenge_new_file_blob_from_file(bithenge_node_t **, FILE *);
    4646
    4747#endif
  • uspace/app/bithenge/print.c

    r5f679702 r5c925ce  
    3737#include <errno.h>
    3838#include <stdio.h>
     39#include "blob.h"
    3940#include "print.h"
    4041#include "tree.h"
     
    120121}
    121122
     123static int print_blob(bithenge_print_type_t type, bithenge_node_t *node)
     124{
     125        bithenge_blob_t *blob = bithenge_node_as_blob(node);
     126        aoff64_t pos = 0;
     127        char buffer[1024];
     128        aoff64_t size = sizeof(buffer);
     129        int rc;
     130        printf(type == BITHENGE_PRINT_PYTHON ? "b\"" : "\"");
     131        do {
     132                rc = bithenge_blob_read(blob, pos, buffer, &size);
     133                if (rc != EOK)
     134                        return rc;
     135                for (aoff64_t i = 0; i < size; i++)
     136                        printf("\\x%02x", buffer[i]);
     137                pos += size;
     138        } while (size == sizeof(buffer));
     139        printf("\"");
     140        return EOK;
     141}
     142
    122143int bithenge_print_node(bithenge_print_type_t type, bithenge_node_t *tree)
    123144{
     
    133154        case BITHENGE_NODE_STRING:
    134155                return print_string(type, tree);
     156        case BITHENGE_NODE_BLOB:
     157                return print_blob(type, tree);
    135158        }
    136159        return ENOTSUP;
  • uspace/app/bithenge/test.c

    r5f679702 r5c925ce  
    5353
    5454static void
    55 print_blob(bithenge_blob_t *blob)
     55print_blob(bithenge_node_t *node)
    5656{
     57        bithenge_blob_t *blob = bithenge_node_as_blob(node);
    5758        aoff64_t size;
    5859        bithenge_blob_size(blob, &size);
     
    6667int main(int argc, char *argv[])
    6768{
    68         bithenge_blob_t *blob;
     69        bithenge_node_t *node;
    6970
    7071        service_id_t service_id;
    7172        loc_service_get_id("bd/initrd", &service_id, 0);
    72         bithenge_new_block_blob(&blob, service_id);
     73        bithenge_new_block_blob(&node, service_id);
    7374        printf("Data from block:bd/initrd: ");
    74         print_blob(blob);
    75         bithenge_blob_destroy(blob);
     75        print_blob(node);
     76        bithenge_node_destroy(node);
    7677
    7778        const char data[] = "'Twas brillig, and the slithy toves";
    78         bithenge_new_blob_from_data(&blob, data, sizeof(data));
     79        bithenge_new_blob_from_data(&node, data, sizeof(data));
    7980        printf("Data from memory (from_data): ");
    80         print_blob(blob);
    81         bithenge_blob_destroy(blob);
     81        print_blob(node);
     82        bithenge_node_destroy(node);
    8283
    83         bithenge_new_blob_from_buffer(&blob, data, sizeof(data), false);
     84        bithenge_new_blob_from_buffer(&node, data, sizeof(data), false);
    8485        printf("Data from memory (from_buffer): ");
    85         print_blob(blob);
    86         bithenge_blob_destroy(blob);
     86        print_blob(node);
     87        bithenge_node_destroy(node);
    8788
    88         bithenge_new_file_blob(&blob, "/textdemo");
     89        bithenge_new_file_blob(&node, "/textdemo");
    8990        printf("Data from file:/textdemo: ");
    90         print_blob(blob);
    91         bithenge_blob_destroy(blob);
     91        print_blob(node);
     92        bithenge_node_destroy(node);
    9293
    93         bithenge_new_file_blob_from_fd(&blob, 0);
     94        bithenge_new_file_blob_from_fd(&node, 0);
    9495        printf("Data from fd:0: ");
    95         print_blob(blob);
    96         bithenge_blob_destroy(blob);
     96        print_blob(node);
     97        bithenge_node_destroy(node);
    9798
    98         // {True: {}, -1351: "zero", "true": False, 0: 17}
    99         bithenge_node_t *node;
     99        // {True: {}, -1351: "\"false\"", "true": False, 0: b"..."}
    100100        bithenge_node_t *nodes[8];
    101101        bithenge_new_boolean_node(&nodes[0], true);
    102102        bithenge_new_simple_internal_node(&nodes[1], NULL, 0, false);
    103103        bithenge_new_integer_node(&nodes[2], -1351);
    104         bithenge_new_string_node(&nodes[3], "zero", false);
     104        bithenge_new_string_node(&nodes[3], "\"false\"", false);
    105105        bithenge_new_string_node(&nodes[4], "true", false);
    106106        bithenge_new_boolean_node(&nodes[5], false);
    107107        bithenge_new_integer_node(&nodes[6], 0);
    108         bithenge_new_integer_node(&nodes[7], 17);
     108        bithenge_new_blob_from_data(&nodes[7], data, sizeof(data));
    109109        bithenge_new_simple_internal_node(&node, nodes, 4, false);
    110110        bithenge_print_node(BITHENGE_PRINT_PYTHON, node);
  • uspace/app/bithenge/tree.c

    r5f679702 r5c925ce  
    3737#include <errno.h>
    3838#include <stdlib.h>
     39#include "blob.h"
    3940#include "tree.h"
     41
     42static int blob_destroy(bithenge_node_t *base)
     43{
     44        bithenge_blob_t *blob = bithenge_node_as_blob(base);
     45        assert(blob->base.blob_ops);
     46        return blob->base.blob_ops->destroy(blob);
     47}
    4048
    4149int bithenge_node_destroy(bithenge_node_t *node)
    4250{
    4351        switch (bithenge_node_type(node)) {
     52        case BITHENGE_NODE_BLOB:
     53                return blob_destroy(node);
    4454        case BITHENGE_NODE_STRING:
    4555                if (node->string_value.needs_free)
     
    4757                break;
    4858        case BITHENGE_NODE_INTERNAL:
    49                 /* TODO */
    50                 break;
     59                return node->internal_ops->destroy(node);
    5160        case BITHENGE_NODE_BOOLEAN:
    5261                return EOK; // the boolean nodes are allocated statically below
     
    8493}
    8594
     95static int simple_internal_node_destroy(bithenge_node_t *base)
     96{
     97        int rc;
     98        simple_internal_node_t *node = node_as_simple(base);
     99        for (bithenge_int_t i = 0; i < node->len; i++) {
     100                rc = bithenge_node_destroy(node->nodes[2*i+0]);
     101                if (rc != EOK)
     102                        return rc;
     103                rc = bithenge_node_destroy(node->nodes[2*i+1]);
     104                if (rc != EOK)
     105                        return rc;
     106        }
     107        if (node->needs_free)
     108                free(node->nodes);
     109        free(node);
     110        return EOK;
     111}
     112
    86113static bithenge_internal_node_ops_t simple_internal_node_ops = {
    87         .for_each = simple_internal_node_for_each
     114        .for_each = simple_internal_node_for_each,
     115        .destroy = simple_internal_node_destroy,
    88116};
    89117
  • uspace/app/bithenge/tree.h

    r5f679702 r5c925ce  
    5757        BITHENGE_NODE_INTEGER,
    5858        BITHENGE_NODE_STRING,
    59         // TODO: BITHENGE_NODE_BLOB,
     59        BITHENGE_NODE_BLOB,
    6060} bithenge_node_type_t;
    6161
     
    6363        bithenge_node_type_t type;
    6464        union {
    65                 struct bithenge_internal_node_ops_t *internal_ops;
     65                const struct bithenge_internal_node_ops_t *internal_ops;
    6666                bool boolean_value;
    6767                bithenge_int_t integer_value;
     
    7070                        bool needs_free;
    7171                } string_value;
     72                const struct bithenge_random_access_blob_ops_t *blob_ops;
    7273        };
    7374} bithenge_node_t;
     
    8283typedef struct bithenge_internal_node_ops_t {
    8384        int (*for_each)(bithenge_node_t *node, bithenge_for_each_func_t func, void *data);
     85        int (*destroy)(bithenge_node_t *node);
    8486} bithenge_internal_node_ops_t;
    8587
    8688static inline int bithenge_node_for_each(bithenge_node_t *node, bithenge_for_each_func_t func, void *data)
    8789{
     90        assert(node->type == BITHENGE_NODE_INTERNAL);
    8891        return node->internal_ops->for_each(node, func, data);
    8992}
     
    9194static inline bool bithenge_boolean_node_value(bithenge_node_t *node)
    9295{
     96        assert(node->type == BITHENGE_NODE_BOOLEAN);
    9397        return node->boolean_value;
    9498}
     
    96100static inline bithenge_int_t bithenge_integer_node_value(bithenge_node_t *node)
    97101{
     102        assert(node->type == BITHENGE_NODE_INTEGER);
    98103        return node->integer_value;
    99104}
     
    101106static inline const char *bithenge_string_node_value(bithenge_node_t *node)
    102107{
     108        assert(node->type == BITHENGE_NODE_STRING);
    103109        return node->string_value.ptr;
    104110}
Note: See TracChangeset for help on using the changeset viewer.