Index: uspace/Makefile =================================================================== --- uspace/Makefile (revision 7030bc907354a32321dca605dd600f34101d78eb) +++ uspace/Makefile (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -35,4 +35,5 @@ DIRS = \ app/bdsh \ + app/bithenge \ app/blkdump \ app/bnchmark \ Index: uspace/app/bithenge/Makefile =================================================================== --- uspace/app/bithenge/Makefile (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/Makefile (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,45 @@ +# +# Copyright (c) 2012 Sean Bartell +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../.. +LIBS = $(LIBBLOCK_PREFIX)/libblock.a +EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -D__HELENOS__ -Ihelenos +BINARY = bithenge + +SOURCES = \ + helenos/block.c \ + blob.c \ + file.c \ + print.c \ + script.c \ + source.c \ + test.c \ + transform.c \ + tree.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/app/bithenge/Makefile.linux =================================================================== --- uspace/app/bithenge/Makefile.linux (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/Makefile.linux (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,52 @@ +# +# Copyright (c) 2012 Sean Bartell +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +CFLAGS += -fexec-charset=UTF-8 -finput-charset=UTF-8 -std=gnu99 -pipe +CFLAGS += -Wall -Wextra -Werror -Wno-clobbered -Wno-unused-parameter -Wmissing-prototypes -Werror-implicit-function-declaration -Wwrite-strings +CFLAGS += -g +CFLAGS += -Ilinux + +BINARY = bithenge + +SOURCES = \ + blob.c \ + file.c \ + print.c \ + script.c \ + source.c \ + test.c \ + transform.c \ + tree.c + +OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) + +$(BINARY): $(OBJECTS) + $(CC) -o $@ $^ + +clean: + find . -name '*.o' -follow -exec rm \{\} \; Index: uspace/app/bithenge/blob.c =================================================================== --- uspace/app/bithenge/blob.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/blob.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,475 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Raw binary blobs. + */ + +#include +#include +#include +#include "blob.h" +#include "os.h" +#include "tree.h" + +/** Initialize a random access blob. + * @memberof bithenge_blob_t + * @param[out] blob The blob to initialize. + * @param[in] ops Operations providing random access support. This pointer must + * be valid until the blob is destroyed. + * @return EOK on success or an error code from errno.h. + */ +int bithenge_init_random_access_blob(bithenge_blob_t *blob, + const bithenge_random_access_blob_ops_t *ops) +{ + assert(blob); + assert(ops); + assert(ops->destroy); + assert(ops->read); + assert(ops->size); + + blob->base.type = BITHENGE_NODE_BLOB; + blob->base.refs = 1; + blob->base.blob_ops = ops; + return EOK; +} + +static int sequential_buffer(bithenge_sequential_blob_t *blob, aoff64_t end) +{ + bool need_realloc = false; + while (end > blob->buffer_size) { + blob->buffer_size = max(4096, 2 * blob->buffer_size); + need_realloc = true; + } + if (need_realloc) { + char *buffer = realloc(blob->buffer, blob->buffer_size); + if (!buffer) + return ENOMEM; + blob->buffer = buffer; + } + aoff64_t size = end - blob->data_size; + int rc = blob->ops->read(blob, blob->buffer + blob->data_size, &size); + if (rc != EOK) + return rc; + blob->data_size += size; + return EOK; +} + +static inline bithenge_sequential_blob_t *blob_as_sequential( + bithenge_blob_t *base) +{ + return (bithenge_sequential_blob_t *)base; +} + +static inline bithenge_blob_t *sequential_as_blob( + bithenge_sequential_blob_t *blob) +{ + return &blob->base; +} + +static int sequential_size(bithenge_blob_t *base, aoff64_t *size) +{ + bithenge_sequential_blob_t *blob = blob_as_sequential(base); + int rc; + if (blob->ops->size) { + rc = blob->ops->size(blob, size); + if (rc == EOK) + return EOK; + } + rc = sequential_buffer(blob, blob->buffer_size); + if (rc != EOK) + return rc; + while (blob->data_size == blob->buffer_size) { + rc = sequential_buffer(blob, 2 * blob->buffer_size); + if (rc != EOK) + return rc; + } + *size = blob->data_size; + return EOK; +} + +static int sequential_read(bithenge_blob_t *base, aoff64_t offset, + char *buffer, aoff64_t *size) +{ + bithenge_sequential_blob_t *blob = blob_as_sequential(base); + aoff64_t end = offset + *size; + if (end > blob->data_size) { + int rc = sequential_buffer(blob, end); + if (rc != EOK) + return rc; + } + if (offset > blob->data_size) + return EINVAL; + *size = min(*size, blob->data_size - end); + memcpy(buffer, blob->buffer + offset, *size); + return EOK; +} + +static void sequential_destroy(bithenge_blob_t *base) +{ + bithenge_sequential_blob_t *blob = blob_as_sequential(base); + free(blob->buffer); + blob->ops->destroy(blob); +} + +static const bithenge_random_access_blob_ops_t sequential_ops = { + .size = sequential_size, + .read = sequential_read, + .destroy = sequential_destroy, +}; + +/** Initialize a sequential blob. + * @memberof bithenge_sequential_blob_t + * @param[out] blob The blob to initialize. + * @param[in] ops Operations providing sequential access support. This pointer + * must be valid until the blob is destroyed. + * @return EOK on success or an error code from errno.h. + */ +int bithenge_init_sequential_blob(bithenge_sequential_blob_t *blob, + const bithenge_sequential_blob_ops_t *ops) +{ + assert(blob); + assert(ops); + assert(ops->destroy); + assert(ops->read); + // ops->size is optional + + int rc = bithenge_init_random_access_blob(sequential_as_blob(blob), + &sequential_ops); + if (rc != EOK) + return rc; + blob->ops = ops; + blob->buffer = NULL; // realloc(NULL, ...) works like malloc + blob->buffer_size = 0; + blob->data_size = 0; + return EOK; +} + +typedef struct { + bithenge_blob_t base; + const char *buffer; + size_t size; + bool needs_free; +} memory_blob_t; + +static inline memory_blob_t *blob_as_memory(bithenge_blob_t *base) +{ + return (memory_blob_t *)base; +} + +static inline bithenge_blob_t *memory_as_blob(memory_blob_t *blob) +{ + return &blob->base; +} + +static int memory_size(bithenge_blob_t *base, aoff64_t *size) +{ + memory_blob_t *blob = blob_as_memory(base); + *size = blob->size; + return EOK; +} + +static int memory_read(bithenge_blob_t *base, aoff64_t offset, char *buffer, + aoff64_t *size) +{ + memory_blob_t *blob = blob_as_memory(base); + if (offset > blob->size) + return ELIMIT; + *size = min(*size, blob->size - offset); + memcpy(buffer, blob->buffer + offset, *size); + return EOK; +} + +static void memory_destroy(bithenge_blob_t *base) +{ + memory_blob_t *blob = blob_as_memory(base); + if (blob->needs_free) + free((void *)blob->buffer); + free(blob); +} + +static const bithenge_random_access_blob_ops_t memory_ops = { + .size = memory_size, + .read = memory_read, + .destroy = memory_destroy, +}; + +/** Create a blob node from data. Unlike with @a + * bithenge_blob_t::bithenge_new_blob_from_buffer, the data is copied into a + * new buffer and the original data can be changed after this call. The blob + * must be freed with @a bithenge_node_t::bithenge_node_destroy after it is + * used. + * @memberof bithenge_blob_t + * @param[out] out Stores the created blob node. + * @param[in] data The data. + * @param len The length of the data. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_blob_from_data(bithenge_node_t **out, const void *data, + size_t len) +{ + int rc; + assert(data || !len); + + memory_blob_t *blob = malloc(sizeof(*blob)); + if (!blob) + return ENOMEM; + rc = bithenge_init_random_access_blob(memory_as_blob(blob), + &memory_ops); + if (rc != EOK) { + free(blob); + return rc; + } + char *buffer = malloc(len); + if (!buffer) { + free(blob); + return rc; + } + memcpy(buffer, data, len); + blob->buffer = buffer; + blob->size = len; + blob->needs_free = true; + *out = bithenge_blob_as_node(memory_as_blob(blob)); + return EOK; +} + +/** Create a blob node from a buffer. The buffer must exist as long as the blob + * does. The blob must be freed with @a bithenge_node_t::bithenge_node_destroy + * after it is used. + * @memberof bithenge_blob_t + * @param[out] out Stores the created blob node. + * @param[in] buffer The buffer, which must not be changed until the blob is + * destroyed. + * @param len The length of the data. + * @param needs_free If true, the buffer will be freed with free() if this + * function fails or the blob is destroyed. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_blob_from_buffer(bithenge_node_t **out, const void *buffer, + size_t len, bool needs_free) +{ + int rc; + assert(buffer || !len); + + memory_blob_t *blob = malloc(sizeof(*blob)); + if (!blob) + return ENOMEM; + rc = bithenge_init_random_access_blob(memory_as_blob(blob), + &memory_ops); + if (rc != EOK) { + free(blob); + return rc; + } + blob->buffer = buffer; + blob->size = len; + blob->needs_free = needs_free; + *out = bithenge_blob_as_node(memory_as_blob(blob)); + return EOK; +} + +typedef struct { + bithenge_blob_t base; + bithenge_blob_t *source; + aoff64_t offset; + aoff64_t size; + bool size_matters; +} subblob_t; + +static inline subblob_t *blob_as_subblob(bithenge_blob_t *base) +{ + return (subblob_t *)base; +} + +static inline bithenge_blob_t *subblob_as_blob(subblob_t *blob) +{ + return &blob->base; +} + +static int subblob_size(bithenge_blob_t *base, aoff64_t *size) +{ + subblob_t *blob = blob_as_subblob(base); + if (blob->size_matters) { + *size = blob->size; + return EOK; + } else { + int rc = bithenge_blob_size(blob->source, size); + *size -= blob->offset; + return rc; + } +} + +static int subblob_read(bithenge_blob_t *base, aoff64_t offset, + char *buffer, aoff64_t *size) +{ + subblob_t *blob = blob_as_subblob(base); + if (blob->size_matters) { + if (offset > blob->size) + return EINVAL; + *size = min(*size, blob->size - offset); + } + offset += blob->offset; + return bithenge_blob_read(blob->source, offset, buffer, size); +} + +static void subblob_destroy(bithenge_blob_t *base) +{ + subblob_t *blob = blob_as_subblob(base); + bithenge_blob_dec_ref(blob->source); + free(blob); +} + +static const bithenge_random_access_blob_ops_t subblob_ops = { + .size = subblob_size, + .read = subblob_read, + .destroy = subblob_destroy, +}; + +static bool is_subblob(bithenge_blob_t *blob) +{ + return blob->base.blob_ops == &subblob_ops; +} + +static int new_subblob(bithenge_node_t **out, bithenge_blob_t *source, + aoff64_t offset, aoff64_t size, bool size_matters) +{ + assert(out); + assert(source); + int rc; + subblob_t *blob = 0; + + if (is_subblob(source)) { + /* We can do some optimizations this way */ + if (!size_matters) + size = 0; + subblob_t *source_subblob = blob_as_subblob(source); + if (source_subblob->size_matters && + offset + size > source_subblob->size) { + rc = EINVAL; + goto error; + } + + if (source->base.refs == 1) { + source_subblob->offset += offset; + source_subblob->size -= offset; + if (size_matters) { + source_subblob->size_matters = true; + source_subblob->size = size; + } + *out = bithenge_blob_as_node(source); + return EOK; + } + + if (!size_matters && source_subblob->size_matters) { + size_matters = true; + size = source_subblob->size - offset; + } + offset += source_subblob->offset; + source = source_subblob->source; + bithenge_blob_inc_ref(source); + bithenge_blob_dec_ref(subblob_as_blob(source_subblob)); + } + + blob = malloc(sizeof(*blob)); + if (!blob) { + rc = ENOMEM; + goto error; + } + rc = bithenge_init_random_access_blob(subblob_as_blob(blob), + &subblob_ops); + if (rc != EOK) + goto error; + blob->source = source; + blob->offset = offset; + blob->size = size; + blob->size_matters = size_matters; + *out = bithenge_blob_as_node(subblob_as_blob(blob)); + return EOK; + +error: + bithenge_blob_dec_ref(source); + free(blob); + return rc; +} + +/** Create a blob from data offset within another blob. This function takes + * ownership of a reference to @a blob. + * @param[out] out Stores the created blob node. On error, this is unchanged. + * @param[in] source The input blob. + * @param offset The offset within the input blob at which the new blob will start. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_offset_blob(bithenge_node_t **out, bithenge_blob_t *source, + aoff64_t offset) +{ + return new_subblob(out, source, offset, 0, false); +} + +/** Create a blob from part of another blob. This function takes ownership of a + * reference to @a blob. + * @param[out] out Stores the created blob node. On error, this is unchanged. + * @param[in] source The input blob. + * @param offset The offset within the input blob at which the new blob will start. + * @param size The size of the new blob. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_subblob(bithenge_node_t **out, bithenge_blob_t *source, + aoff64_t offset, aoff64_t size) +{ + return new_subblob(out, source, offset, size, true); +} + +/** Check whether the contents of two blobs are equal. + * @memberof bithenge_blob_t + * @param a, b Blobs to compare. + * @return Whether the blobs are equal. If an error occurs, returns false. + */ +bool bithenge_blob_equal(bithenge_blob_t *a, bithenge_blob_t *b) +{ + assert(a); + assert(a->base.blob_ops); + assert(b); + assert(b->base.blob_ops); + int rc; + char buffer_a[4096], buffer_b[4096]; + aoff64_t offset = 0, size_a = sizeof(buffer_a), size_b = sizeof(buffer_b); + do { + rc = bithenge_blob_read(a, offset, buffer_a, &size_a); + if (rc != EOK) + return false; + rc = bithenge_blob_read(b, offset, buffer_b, &size_b); + if (rc != EOK) + return false; + if (size_a != size_b || bcmp(buffer_a, buffer_b, size_a)) + return false; + offset += size_a; + } while (size_a == sizeof(buffer_a)); + return true; +} + +/** @} + */ Index: uspace/app/bithenge/blob.h =================================================================== --- uspace/app/bithenge/blob.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/blob.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,200 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Raw binary blobs. + */ + +#ifndef BITHENGE_BLOB_H_ +#define BITHENGE_BLOB_H_ + +#include +#include "tree.h" + +/** A blob of raw binary data. + * @implements bithenge_node_t */ +typedef struct { + /** @privatesection */ + struct bithenge_node_t base; +} bithenge_blob_t; + +/** Operations providing random access to binary data. + * @todo Should these be thread-safe? */ +typedef struct bithenge_random_access_blob_ops_t { + /** @copydoc bithenge_blob_t::bithenge_blob_size */ + int (*size)(bithenge_blob_t *self, aoff64_t *size); + /** @copydoc bithenge_blob_t::bithenge_blob_read */ + int (*read)(bithenge_blob_t *self, aoff64_t offset, char *buffer, + aoff64_t *size); + /** Destroy the blob. + * @param blob The blob. */ + void (*destroy)(bithenge_blob_t *self); +} bithenge_random_access_blob_ops_t; + +/** A blob built from an object that supports only sequential reading. + * @implements bithenge_blob_t */ +typedef struct { + /** @privatesection */ + /** The base random-access blob. */ + bithenge_blob_t base; + /** Operations providing sequential access. */ + const struct bithenge_sequential_blob_ops_t *ops; + /** Buffer containing all data read. */ + char *buffer; + /** Size of buffer. */ + aoff64_t buffer_size; + /** Amount of data actually in buffer. */ + aoff64_t data_size; +} bithenge_sequential_blob_t; + +/** Operations providing sequential access to binary data. + * @memberof bithenge_sequential_blob_t */ +typedef struct bithenge_sequential_blob_ops_t { + + /** Get the total size of the blob. If the total size cannot be + * determined easily, this field may be null or return an error, + * forcing the entire blob to be read to determine its size. + * + * @memberof bithenge_blob_t + * @param self The blob. + * @param[out] size Total size of the blob. + * @return EOK on success or an error code from errno.h. + */ + int (*size)(bithenge_sequential_blob_t *self, aoff64_t *size); + + /** Read the next part of the blob. If the requested data extends + * beyond the end of the blob, the data up until the end of the blob + * will be read. + * + * @param self The blob. + * @param[out] buffer Buffer to read into. If an error occurs, the contents are + * undefined. + * @param[in,out] size Number of bytes to read; may be 0. If not enough + * data is left in the blob, the actual number of bytes read should be + * stored here. If an error occurs, the contents are undefined. + * @return EOK on success or an error code from errno.h. + */ + int (*read)(bithenge_sequential_blob_t *self, char *buffer, + aoff64_t *size); + + /** Destroy the blob. + * @param self The blob. */ + void (*destroy)(bithenge_sequential_blob_t *self); +} bithenge_sequential_blob_ops_t; + +/** Get the total size of the blob. + * + * @memberof bithenge_blob_t + * @param self The blob. + * @param[out] size Total size of the blob. + * @return EOK on success or an error code from errno.h. + */ +static inline int bithenge_blob_size(bithenge_blob_t *self, aoff64_t *size) +{ + assert(self); + assert(self->base.blob_ops); + return self->base.blob_ops->size(self, size); +} + +/** Read part of the blob. If the requested data extends beyond the end of the + * blob, the data up until the end of the blob will be read. If the offset is + * beyond the end of the blob, even if the size is zero, an error will be + * returned. + * + * @memberof bithenge_blob_t + * @param self The blob. + * @param offset Byte offset within the blob. + * @param[out] buffer Buffer to read into. If an error occurs, the contents are + * undefined. + * @param[in,out] size Number of bytes to read; may be 0. If the requested + * range extends beyond the end of the blob, the actual number of bytes read + * should be stored here. If an error occurs, the contents are undefined. + * @return EOK on success or an error code from errno.h. + */ +static inline int bithenge_blob_read(bithenge_blob_t *self, aoff64_t offset, + char *buffer, aoff64_t *size) +{ + assert(self); + assert(self->base.blob_ops); + return self->base.blob_ops->read(self, offset, buffer, size); +} + +/** Cast a blob node to a generic node. + * @memberof bithenge_blob_t + * @param blob The blob to cast. + * @return The blob node as a generic node. */ +static inline bithenge_node_t *bithenge_blob_as_node(bithenge_blob_t *blob) +{ + return &blob->base; +} + +/** Cast a generic node to a blob node. + * @memberof bithenge_blob_t + * @param node The node to cast, which must be a blob node. + * @return The generic node as a blob node. */ +static inline bithenge_blob_t *bithenge_node_as_blob(bithenge_node_t *node) +{ + assert(node->type == BITHENGE_NODE_BLOB); + return (bithenge_blob_t *)node; +} + +/** Increment a blob's reference count. + * @param blob The blob to reference. */ +static inline void bithenge_blob_inc_ref(bithenge_blob_t *blob) +{ + bithenge_node_inc_ref(bithenge_blob_as_node(blob)); +} + +/** Decrement a blob's reference count. + * @param blob The blob to dereference, or NULL. */ +static inline void bithenge_blob_dec_ref(bithenge_blob_t *blob) +{ + if (blob) + bithenge_node_dec_ref(bithenge_blob_as_node(blob)); +} + +int bithenge_init_random_access_blob(bithenge_blob_t *, + const bithenge_random_access_blob_ops_t *); +int bithenge_init_sequential_blob(bithenge_sequential_blob_t *, + const bithenge_sequential_blob_ops_t *); +int bithenge_new_blob_from_data(bithenge_node_t **, const void *, size_t); +int bithenge_new_blob_from_buffer(bithenge_node_t **, const void *, size_t, + bool); +int bithenge_new_offset_blob(bithenge_node_t **, bithenge_blob_t *, aoff64_t); +int bithenge_new_subblob(bithenge_node_t **, bithenge_blob_t *, aoff64_t, + aoff64_t); +bool bithenge_blob_equal(bithenge_blob_t *, bithenge_blob_t *); + +#endif + +/** @} + */ Index: uspace/app/bithenge/file.c =================================================================== --- uspace/app/bithenge/file.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/file.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Access files as blobs. + * @todo Provide more information about the file. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "blob.h" +#include "file.h" +#include "os.h" + +typedef struct { + bithenge_blob_t base; + int fd; + aoff64_t size; // needed by file_read() + bool needs_close; +} file_blob_t; + +static inline file_blob_t *blob_as_file(bithenge_blob_t *base) +{ + return (file_blob_t *)base; +} + +static inline bithenge_blob_t *file_as_blob(file_blob_t *blob) +{ + return &blob->base; +} + +static int file_size(bithenge_blob_t *base, aoff64_t *size) +{ + file_blob_t *blob = blob_as_file(base); + *size = blob->size; + return EOK; +} + +static int file_read(bithenge_blob_t *base, aoff64_t offset, char *buffer, + aoff64_t *size) +{ + file_blob_t *blob = blob_as_file(base); + if (offset > blob->size) + return ELIMIT; + if (lseek(blob->fd, offset, SEEK_SET) < 0) + return errno; + + ssize_t amount_read; + aoff64_t remaining_size = *size; + *size = 0; + do { + amount_read = read(blob->fd, buffer, remaining_size); + if (amount_read < 0) + return errno; + buffer += amount_read; + *size += amount_read; + remaining_size -= amount_read; + } while (remaining_size && amount_read); + return EOK; +} + +static void file_destroy(bithenge_blob_t *base) +{ + file_blob_t *blob = blob_as_file(base); + close(blob->fd); + free(blob); +} + +static const bithenge_random_access_blob_ops_t file_ops = { + .size = file_size, + .read = file_read, + .destroy = file_destroy, +}; + +static int new_file_blob(bithenge_node_t **out, int fd, bool needs_close) +{ + assert(out); + + struct stat stat; + int rc = fstat(fd, &stat); + if (rc != EOK) { + if (needs_close) + close(fd); + return rc; + } + + // Create blob + file_blob_t *blob = malloc(sizeof(*blob)); + if (!blob) { + if (needs_close) + close(fd); + return ENOMEM; + } + rc = bithenge_init_random_access_blob(file_as_blob(blob), &file_ops); + if (rc != EOK) { + free(blob); + if (needs_close) + close(fd); + return rc; + } + blob->fd = fd; +#ifdef __HELENOS__ + blob->size = stat.size; +#else + blob->size = stat.st_size; +#endif + blob->needs_close = needs_close; + *out = bithenge_blob_as_node(file_as_blob(blob)); + + return EOK; +} + +/** Create a blob for a file. The blob must be freed with @a + * bithenge_node_t::bithenge_node_destroy after it is used. + * @param[out] out Stores the created blob. + * @param filename The name of the file. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_file_blob(bithenge_node_t **out, const char *filename) +{ + assert(filename); + + int fd = open(filename, O_RDONLY); + if (fd < 0) + return fd; + + return new_file_blob(out, fd, true); +} + +/** Create a blob for a file descriptor. The blob must be freed with @a + * bithenge_node_t::bithenge_node_destroy after it is used. + * @param[out] out Stores the created blob. + * @param fd The file descriptor. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_file_blob_from_fd(bithenge_node_t **out, int fd) +{ + return new_file_blob(out, fd, false); +} + +/** Create a blob for a file pointer. The blob must be freed with @a + * bithenge_node_t::bithenge_node_destroy after it is used. + * @param[out] out Stores the created blob. + * @param file The file pointer. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_file_blob_from_file(bithenge_node_t **out, FILE *file) +{ + int fd = fileno(file); + if (fd < 0) + return errno; + return new_file_blob(out, fd, false); +} + +/** @} + */ Index: uspace/app/bithenge/file.h =================================================================== --- uspace/app/bithenge/file.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/file.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Access files as blobs. + */ + +#ifndef BITHENGE_FILE_H_ +#define BITHENGE_FILE_H_ + +#include +#include "blob.h" + +int bithenge_new_file_blob(bithenge_node_t **, const char *); +int bithenge_new_file_blob_from_fd(bithenge_node_t **, int); +int bithenge_new_file_blob_from_file(bithenge_node_t **, FILE *); + +#endif + +/** @} + */ Index: uspace/app/bithenge/helenos/block.c =================================================================== --- uspace/app/bithenge/helenos/block.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/helenos/block.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Access block devices as blobs. + * @todo Provide more information about the block device (block size). + */ + +#include +#include +#include +#include +#include +#include +#include "../blob.h" +#include "block.h" + +typedef struct { + bithenge_blob_t base; + service_id_t service_id; + aoff64_t size; +} block_blob_t; + +static inline block_blob_t *blob_as_block(bithenge_blob_t *base) +{ + return (block_blob_t *)base; +} + +static inline bithenge_blob_t *block_as_blob(block_blob_t *blob) +{ + return &blob->base; +} + +static int block_size(bithenge_blob_t *base, aoff64_t *size) +{ + block_blob_t *self = blob_as_block(base); + *size = self->size; + return EOK; +} + +static int block_read(bithenge_blob_t *base, aoff64_t offset, char *buffer, + aoff64_t *size) +{ + block_blob_t *self = blob_as_block(base); + if (offset > self->size) + return ELIMIT; + *size = min(*size, self->size - offset); + return block_read_bytes_direct(self->service_id, offset, *size, buffer); +} + +static void block_destroy(bithenge_blob_t *base) +{ + block_blob_t *self = blob_as_block(base); + block_fini(self->service_id); + free(self); +} + +static const bithenge_random_access_blob_ops_t block_ops = { + .size = block_size, + .read = block_read, + .destroy = block_destroy, +}; + +/** Create a blob for a block device. The blob must be freed with + * @a bithenge_node_t::bithenge_node_destroy after it is used. + * @param[out] out Stores the created blob. + * @param service_id The service ID of the block device. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_block_blob(bithenge_node_t **out, service_id_t service_id) +{ + assert(out); + + // Initialize libblock + int rc; + rc = block_init(EXCHANGE_SERIALIZE, service_id, 2048); + if (rc != EOK) + return rc; + + // Calculate total device size + size_t bsize; + aoff64_t nblocks; + aoff64_t size; + rc = block_get_bsize(service_id, &bsize); + if (rc != EOK) { + block_fini(service_id); + return rc; + } + rc = block_get_nblocks(service_id, &nblocks); + if (rc != EOK) { + block_fini(service_id); + return rc; + } + size = bsize * nblocks; + + // Create blob + block_blob_t *blob = malloc(sizeof(*blob)); + if (!blob) { + block_fini(service_id); + return ENOMEM; + } + rc = bithenge_init_random_access_blob(block_as_blob(blob), + &block_ops); + if (rc != EOK) { + free(blob); + block_fini(service_id); + return rc; + } + blob->service_id = service_id; + blob->size = size; + *out = bithenge_blob_as_node(block_as_blob(blob)); + + return EOK; +} + +/** @} + */ Index: uspace/app/bithenge/helenos/block.h =================================================================== --- uspace/app/bithenge/helenos/block.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/helenos/block.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Access block devices as blobs. + */ + +#ifndef BITHENGE_BLOCK_H_ +#define BITHENGE_BLOCK_H_ + +#include +#include "../blob.h" + +int bithenge_new_block_blob(bithenge_node_t **, service_id_t); + +#endif + +/** @} + */ Index: uspace/app/bithenge/helenos/os.h =================================================================== --- uspace/app/bithenge/helenos/os.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/helenos/os.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef BITHENGE_OS_H_ +#define BITHENGE_OS_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +typedef struct { + const char *string; + size_t offset; + wchar_t ch; +} string_iterator_t; + +static inline string_iterator_t string_iterator(const char *string) +{ + string_iterator_t i; + i.string = string; + i.offset = 0; + i.ch = str_decode(i.string, &i.offset, STR_NO_LIMIT); + return i; +} + +static inline bool string_iterator_done(const string_iterator_t *i) +{ + return i->ch == L'\0'; +} + +static inline int string_iterator_next(string_iterator_t *i, wchar_t *out) +{ + *out = i->ch; + if (*out == U_SPECIAL) + return EINVAL; + i->ch = str_decode(i->string, &i->offset, STR_NO_LIMIT); + return EOK; +} + +static inline void *memchr(const void *s, int c, size_t n) +{ + for (size_t i = 0; i < n; i++) + if (((char *)s)[i] == c) + return (void *)(s + i); + return NULL; +} + +#endif Index: uspace/app/bithenge/linux/os.h =================================================================== --- uspace/app/bithenge/linux/os.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/linux/os.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef BITHENGE_OS_H_ +#define BITHENGE_OS_H_ + +#include +#include +#include +#include +#include +#include +#include + +#define max(aleph, bet) ((aleph) > (bet) ? (aleph) : (bet)) +#define min(aleph, bet) ((aleph) < (bet) ? (aleph) : (bet)) + +#define EOK 0 +#define ELIMIT EINVAL + +typedef uint64_t aoff64_t; + +typedef const char *string_iterator_t; + +static inline string_iterator_t string_iterator(const char *string) +{ + return string; +} + +static inline int string_iterator_next(string_iterator_t *i, wchar_t *out) +{ + wint_t rc = btowc(*(*i)++); // TODO + *out = (wchar_t) rc; + return rc == WEOF ? EILSEQ : EOK; +} + +static inline bool string_iterator_done(const string_iterator_t *i) +{ + return !**i; +} + +static inline size_t str_length(const char *string) +{ + return strlen(string); +} + +static inline const char *str_chr(const char *string, wchar_t ch) +{ + return strchr(string, wctob(ch)); // TODO +} + +static inline int str_cmp(const char *s1, const char *s2) +{ + return strcmp(s1, s2); +} + +static inline int str_lcmp(const char *s1, const char *s2, size_t max_len) +{ + return strncmp(s1, s2, max_len); +} + +static inline char *str_dup(const char *s) +{ + return strdup(s); +} + +static inline char *str_ndup(const char *s, size_t max_len) +{ + return strndup(s, max_len); +} + +static inline const char *str_error(int e) +{ + return strerror(e); +} + +static inline uint32_t uint32_t_le2host(uint32_t val) +{ + return le32toh(val); +} + +static inline uint32_t uint32_t_be2host(uint32_t val) +{ + return be32toh(val); +} + +#endif Index: uspace/app/bithenge/print.c =================================================================== --- uspace/app/bithenge/print.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/print.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,170 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Write a tree as JSON or other text formats. + */ + +#include +#include +#include "blob.h" +#include "print.h" +#include "tree.h" + +typedef struct { + bithenge_print_type_t type; + bool first; +} print_internal_data_t; + +static int print_internal_func(bithenge_node_t *key, bithenge_node_t *value, void *data_) +{ + print_internal_data_t *data = (print_internal_data_t *)data_; + int rc = EOK; + if (!data->first) + printf(", "); + data->first = false; + bool add_quotes = data->type == BITHENGE_PRINT_JSON + && bithenge_node_type(key) != BITHENGE_NODE_STRING; + if (add_quotes) + printf("\""); + rc = bithenge_print_node(data->type, key); + if (rc != EOK) + goto end; + if (add_quotes) + printf("\""); + printf(": "); + rc = bithenge_print_node(data->type, value); + if (rc != EOK) + goto end; +end: + bithenge_node_dec_ref(key); + bithenge_node_dec_ref(value); + return rc; +} + +static int print_internal(bithenge_print_type_t type, bithenge_node_t *node) +{ + int rc; + print_internal_data_t data = { type, true }; + printf("{"); + rc = bithenge_node_for_each(node, print_internal_func, &data); + if (rc != EOK) + return rc; + printf("}"); + return EOK; +} + +static int print_boolean(bithenge_print_type_t type, bithenge_node_t *node) +{ + bool value = bithenge_boolean_node_value(node); + switch (type) { + case BITHENGE_PRINT_PYTHON: + printf(value ? "True" : "False"); + break; + case BITHENGE_PRINT_JSON: + printf(value ? "true" : "false"); + break; + } + return EOK; +} + +static int print_integer(bithenge_print_type_t type, bithenge_node_t *node) +{ + bithenge_int_t value = bithenge_integer_node_value(node); + printf("%" BITHENGE_PRId, value); + return EOK; +} + +static int print_string(bithenge_print_type_t type, bithenge_node_t *node) +{ + const char *value = bithenge_string_node_value(node); + printf("\""); + for (string_iterator_t i = string_iterator(value); !string_iterator_done(&i); ) { + wchar_t ch; + int rc = string_iterator_next(&i, &ch); + if (rc != EOK) + return rc; + if (ch == '"' || ch == '\\') { + printf("\\%lc", (wint_t) ch); + } else if (ch <= 0x1f) { + printf("\\u%04x", (unsigned int) ch); + } else { + printf("%lc", (wint_t) ch); + } + } + printf("\""); + return EOK; +} + +static int print_blob(bithenge_print_type_t type, bithenge_node_t *node) +{ + bithenge_blob_t *blob = bithenge_node_as_blob(node); + aoff64_t pos = 0; + char buffer[1024]; + aoff64_t size = sizeof(buffer); + int rc; + printf(type == BITHENGE_PRINT_PYTHON ? "b\"" : "\""); + do { + rc = bithenge_blob_read(blob, pos, buffer, &size); + if (rc != EOK) + return rc; + for (aoff64_t i = 0; i < size; i++) + printf("\\x%02x", (unsigned int)(uint8_t)buffer[i]); + pos += size; + } while (size == sizeof(buffer)); + printf("\""); + return EOK; +} + +/** Print a tree as text. + * @param type The format to use. + * @param tree The root node of the tree to print. + * @return EOK on success or an error code from errno.h. */ +int bithenge_print_node(bithenge_print_type_t type, bithenge_node_t *tree) +{ + switch (bithenge_node_type(tree)) { + case BITHENGE_NODE_INTERNAL: + return print_internal(type, tree); + case BITHENGE_NODE_BOOLEAN: + return print_boolean(type, tree); + case BITHENGE_NODE_INTEGER: + return print_integer(type, tree); + case BITHENGE_NODE_STRING: + return print_string(type, tree); + case BITHENGE_NODE_BLOB: + return print_blob(type, tree); + } + return ENOTSUP; +} + +/** @} + */ Index: uspace/app/bithenge/print.h =================================================================== --- uspace/app/bithenge/print.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/print.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Write a tree as JSON or other text formats. + */ + +#ifndef BITHENGE_PRINT_H_ +#define BITHENGE_PRINT_H_ + +#include "tree.h" + +/** Specifies the format to be used when printing. */ +typedef enum { + /** Print a Python value. Note that internal nodes will be represented + * as unordered dictionaries. */ + BITHENGE_PRINT_PYTHON, + /** Print JSON. Due to the limitations of JSON, type information may be + * lost. */ + BITHENGE_PRINT_JSON, +} bithenge_print_type_t; + +int bithenge_print_node(bithenge_print_type_t, bithenge_node_t *); + +#endif + +/** @} + */ Index: uspace/app/bithenge/script.c =================================================================== --- uspace/app/bithenge/script.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/script.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,475 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Script parsing. + */ + +#include +#include +#include +#include "os.h" +#include "script.h" +#include "transform.h" +#include "tree.h" + +/** Tokens with more characters than this may be read incorrectly. */ +#define MAX_TOKEN_SIZE 256 +#define BUFFER_SIZE 4096 + +/** Single-character symbols are represented by the character itself. Every + * other token uses one of these values: */ +typedef enum { + TOKEN_ERROR = -128, + TOKEN_EOF, + TOKEN_IDENTIFIER, + TOKEN_LEFT_ARROW, + + /* Keywords */ + TOKEN_STRUCT, + TOKEN_TRANSFORM, +} token_type_t; + +/** Singly-linked list of named transforms. */ +typedef struct transform_list { + char *name; + bithenge_transform_t *transform; + struct transform_list *next; +} transform_list_t; + +/** State kept by the parser. */ +typedef struct { + /** Rather than constantly checking return values, the parser uses this + * to indicate whether an error has occurred. */ + int error; + /** The list of named transforms. */ + transform_list_t *transform_list; + /** The name of the script file. */ + const char *filename; + /** The script file being read from. */ + FILE *file; + /** The buffer that holds script code. There is always a '\0' after the + * current position to prevent reading too far. */ + char buffer[BUFFER_SIZE]; + /** The start position within the buffer of the next unread token. */ + size_t buffer_pos; + /** The start position within the buffer of the current token. */ + size_t old_buffer_pos; + /** The line number of the current token. */ + int lineno; + /** Added to a buffer position to find the column number. */ + int line_offset; + /** The type of the current token. */ + token_type_t token; + union { + /** The value of a TOKEN_IDENTIFIER token. Unless changed to + * NULL, it will be freed when the next token is read. */ + char *token_string; + }; +} state_t; + +/** Free the previous token's data. This must be called before changing + * state->token. */ +static void done_with_token(state_t *state) +{ + if (state->token == TOKEN_IDENTIFIER) + free(state->token_string); + state->token = TOKEN_ERROR; +} + +/** Note that an error has occurred. */ +static void error_errno(state_t *state, int error) +{ + // Don't overwrite a previous error. + if (state->error == EOK) { + done_with_token(state); + state->token = TOKEN_ERROR; + state->error = error; + } +} + +/** Note that a syntax error has occurred and print an error message. */ +static void syntax_error(state_t *state, const char *message) +{ + // Printing multiple errors is confusing. + if (state->error == EOK) { + size_t start_char = state->old_buffer_pos + state->line_offset; + size_t end_char = state->buffer_pos + state->line_offset; + size_t size = end_char - start_char; + fprintf(stderr, "%s:%d:", state->filename, state->lineno); + if (size <= 1) + fprintf(stderr, "%zd: ", start_char); + else + fprintf(stderr, "%zd-%zd: ", start_char, end_char - 1); + fprintf(stderr, "%s: \"%.*s\"\n", message, (int)size, + state->buffer + state->old_buffer_pos); + error_errno(state, EINVAL); + } +} + +/** Ensure the buffer contains enough characters to read a token. */ +static void fill_buffer(state_t *state) +{ + if (state->buffer_pos + MAX_TOKEN_SIZE < BUFFER_SIZE) + return; + + size_t empty_size = state->buffer_pos; + size_t used_size = BUFFER_SIZE - 1 - state->buffer_pos; + memmove(state->buffer, state->buffer + state->buffer_pos, used_size); + state->line_offset += state->buffer_pos; + state->buffer_pos = 0; + + size_t read_size = fread(state->buffer + used_size, 1, empty_size, + state->file); + if (ferror(state->file)) + error_errno(state, EIO); + state->buffer[used_size + read_size] = '\0'; +} + +/** Read the next token. */ +static void next_token(state_t *state) +{ + fill_buffer(state); + done_with_token(state); + state->old_buffer_pos = state->buffer_pos; + char ch = state->buffer[state->buffer_pos]; + if (ch == '\0') { + state->token = TOKEN_EOF; + } else if (ch == '#') { + while (state->buffer[state->buffer_pos] != '\n' + && state->buffer[state->buffer_pos] != '\0') { + state->buffer_pos++; + fill_buffer(state); + } + next_token(state); + return; + } else if (isspace(ch)) { + // Will eventually reach the '\0' at the end + while (isspace(state->buffer[state->buffer_pos])) { + if (state->buffer[state->buffer_pos] == '\n') { + state->lineno++; + state->line_offset = -state->buffer_pos; + } + state->buffer_pos++; + } + next_token(state); + return; + } else if (isalpha(ch)) { + while (isalnum(state->buffer[state->buffer_pos]) + || state->buffer[state->buffer_pos] == '_') + state->buffer_pos++; + char *value = str_ndup(state->buffer + state->old_buffer_pos, + state->buffer_pos - state->old_buffer_pos); + if (!value) { + error_errno(state, ENOMEM); + } else if (!str_cmp(value, "struct")) { + state->token = TOKEN_STRUCT; + free(value); + } else if (!str_cmp(value, "transform")) { + state->token = TOKEN_TRANSFORM; + free(value); + } else { + state->token = TOKEN_IDENTIFIER; + state->token_string = value; + } + } else if (ch == '<') { + state->token = ch; + state->buffer_pos++; + if (state->buffer[state->buffer_pos] == '-') { + state->buffer_pos++; + state->token = TOKEN_LEFT_ARROW; + } + } else { + state->token = ch; + state->buffer_pos++; + } +} + +/** Allocate memory and handle failure by setting the error in the state. The + * caller must check the state for errors before using the return value of this + * function. */ +static void *state_malloc(state_t *state, size_t size) +{ + if (state->error != EOK) + return NULL; + void *result = malloc(size); + if (result == NULL) + error_errno(state, ENOMEM); + return result; +} + +/** Reallocate memory and handle failure by setting the error in the state. If + * an error occurs, the existing pointer will be returned. */ +static void *state_realloc(state_t *state, void *ptr, size_t size) +{ + if (state->error != EOK) + return ptr; + void *result = realloc(ptr, size); + if (result == NULL) { + error_errno(state, ENOMEM); + return ptr; + } + return result; +} + +/** Expect and consume a certain token. If the next token is of the wrong type, + * an error is caused. */ +static void expect(state_t *state, token_type_t type) +{ + if (state->token != type) { + syntax_error(state, "unexpected"); + return; + } + next_token(state); +} + +/** Expect and consume an identifier token. If the next token is not an + * identifier, an error is caused and this function returns null. */ +static char *expect_identifier(state_t *state) +{ + if (state->token != TOKEN_IDENTIFIER) { + syntax_error(state, "unexpected (identifier expected)"); + return NULL; + } + char *val = state->token_string; + state->token_string = NULL; + next_token(state); + return val; +} + +/** Find a transform by name. A reference will be added to the transform. + * @return The found transform, or NULL if none was found. */ +static bithenge_transform_t *get_named_transform(state_t *state, + const char *name) +{ + for (transform_list_t *e = state->transform_list; e; e = e->next) { + if (!str_cmp(e->name, name)) { + bithenge_transform_inc_ref(e->transform); + return e->transform; + } + } + for (int i = 0; bithenge_primitive_transforms[i].name; i++) { + if (!str_cmp(bithenge_primitive_transforms[i].name, name)) { + bithenge_transform_t *xform = + bithenge_primitive_transforms[i].transform; + bithenge_transform_inc_ref(xform); + return xform; + } + } + return NULL; +} + +/** Add a named transform. This function takes ownership of the name and a + * reference to the transform. If an error has occurred, either may be null. */ +static void add_named_transform(state_t *state, bithenge_transform_t *xform, char *name) +{ + transform_list_t *entry = state_malloc(state, sizeof(*entry)); + if (state->error != EOK) { + free(name); + bithenge_transform_dec_ref(xform); + free(entry); + return; + } + entry->name = name; + entry->transform = xform; + entry->next = state->transform_list; + state->transform_list = entry; +} + +static bithenge_transform_t *parse_transform(state_t *state); + +static bithenge_transform_t *parse_struct(state_t *state) +{ + size_t num = 0; + bithenge_named_transform_t *subxforms; + /* We keep an extra space for the {NULL, NULL} terminator. */ + subxforms = state_malloc(state, sizeof(*subxforms)); + expect(state, TOKEN_STRUCT); + expect(state, '{'); + while (state->error == EOK && state->token != '}') { + if (state->token == '.') { + expect(state, '.'); + subxforms[num].name = expect_identifier(state); + expect(state, TOKEN_LEFT_ARROW); + } else { + subxforms[num].name = NULL; + expect(state, TOKEN_LEFT_ARROW); + } + subxforms[num].transform = parse_transform(state); + expect(state, ';'); + num++; + subxforms = state_realloc(state, subxforms, + (num + 1)*sizeof(*subxforms)); + } + expect(state, '}'); + + if (state->error != EOK) { + while (num--) { + free((void *)subxforms[num].name); + bithenge_transform_dec_ref(subxforms[num].transform); + } + free(subxforms); + return NULL; + } + + subxforms[num].name = NULL; + subxforms[num].transform = NULL; + bithenge_transform_t *result; + int rc = bithenge_new_struct(&result, subxforms); + if (rc != EOK) { + error_errno(state, rc); + return NULL; + } + return result; +} + +/** Parse a transform without composition. + * @return The parsed transform, or NULL if an error occurred. */ +static bithenge_transform_t *parse_transform_no_compose(state_t *state) +{ + if (state->token == TOKEN_IDENTIFIER) { + bithenge_transform_t *result = get_named_transform(state, + state->token_string); + if (!result) + syntax_error(state, "transform not found"); + next_token(state); + return result; + } else if (state->token == TOKEN_STRUCT) { + return parse_struct(state); + } else { + syntax_error(state, "unexpected (transform expected)"); + return NULL; + } +} + +/** Parse a transform. + * @return The parsed transform, or NULL if an error occurred. */ +static bithenge_transform_t *parse_transform(state_t *state) +{ + bithenge_transform_t *result = parse_transform_no_compose(state); + bithenge_transform_t **xforms = NULL; + size_t num = 1; + while (state->token == TOKEN_LEFT_ARROW) { + expect(state, TOKEN_LEFT_ARROW); + xforms = state_realloc(state, xforms, + (num + 1) * sizeof(*xforms)); + if (state->error != EOK) + break; + xforms[num] = parse_transform_no_compose(state); + num++; + } + if (state->error != EOK) { + while (xforms && num--) + bithenge_transform_dec_ref(xforms[num]); + free(xforms); + bithenge_transform_dec_ref(result); + return NULL; + } + if (xforms) { + xforms[0] = result; + int rc = bithenge_new_composed_transform(&result, xforms, num); + if (rc != EOK) { + error_errno(state, rc); + return NULL; + } + } + return result; +} + +/** Parse a definition. */ +static void parse_definition(state_t *state) +{ + expect(state, TOKEN_TRANSFORM); + char *name = expect_identifier(state); + expect(state, '='); + bithenge_transform_t *xform = parse_transform(state); + expect(state, ';'); + add_named_transform(state, xform, name); +} + +/** Initialize the state. */ +static void state_init(state_t *state, const char *filename) +{ + state->error = EOK; + state->transform_list = NULL; + state->token = TOKEN_ERROR; + state->old_buffer_pos = state->buffer_pos = BUFFER_SIZE - 1; + state->lineno = 1; + state->line_offset = (int)-state->buffer_pos + 1; + state->filename = filename; + state->file = fopen(filename, "r"); + if (!state->file) { + error_errno(state, errno); + } else { + next_token(state); + } +} + +/** Destroy the state. */ +static void state_destroy(state_t *state) +{ + done_with_token(state); + state->token = TOKEN_ERROR; + fclose(state->file); + transform_list_t *entry = state->transform_list; + while (entry) { + transform_list_t *next = entry->next; + free(entry->name); + bithenge_transform_dec_ref(entry->transform); + free(entry); + entry = next; + } +} + +/** Parse a script file. + * @param filename The name of the script file. + * @param[out] out Stores the "main" transform. + * @return EOK on success, EINVAL on syntax error, or an error code from + * errno.h. */ +int bithenge_parse_script(const char *filename, bithenge_transform_t **out) +{ + state_t state; + state_init(&state, filename); + while (state.error == EOK && state.token != TOKEN_EOF) + parse_definition(&state); + *out = get_named_transform(&state, "main"); + int rc = state.error; + state_destroy(&state); + if (rc == EOK && !*out) { + fprintf(stderr, "no \"main\" transform\n"); + rc = EINVAL; + } + return rc; +} + +/** @} + */ Index: uspace/app/bithenge/script.h =================================================================== --- uspace/app/bithenge/script.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/script.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Script parsing. + */ + +#ifndef BITHENGE_SCRIPT_H_ +#define BITHENGE_SCRIPT_H_ + +#include "transform.h" + +int bithenge_parse_script(const char *, bithenge_transform_t **); + +#endif + +/** @} + */ Index: uspace/app/bithenge/source.c =================================================================== --- uspace/app/bithenge/source.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/source.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Provide various external sources of data. + */ + +#include +#include +#include "blob.h" +#include "file.h" +#include "source.h" + +#ifdef __HELENOS__ +#include +#include "helenos/block.h" +#endif + +static inline int hex_digit(char digit) +{ + if ('0' <= digit && digit <= '9') + return digit - '0' + 0x0; + if ('a' <= digit && digit <= 'f') + return digit - 'a' + 0xa; + if ('A' <= digit && digit <= 'F') + return digit - 'A' + 0xA; + return -1; +} + +static int blob_from_hex(bithenge_node_t **out, const char *hex) +{ + size_t size = str_length(hex); + if (size % 2) + return EINVAL; + size /= 2; + char *buffer = malloc(size); + if (!buffer) + return ENOMEM; + for (size_t i = 0; i < size; i++) { + int upper = hex_digit(hex[2 * i + 0]); + int lower = hex_digit(hex[2 * i + 1]); + if (upper == -1 || lower == -1) { + free(buffer); + return EINVAL; + } + buffer[i] = upper << 4 | lower; + } + return bithenge_new_blob_from_buffer(out, buffer, size, true); +} + +/** Create a node from a source described with a string. For instance, + * "hex:55aa" will result in a blob node. If there is no colon in the string, + * it is assumed to be a filename. + * @param[out] out Stores the created node. + * @param source Specifies the node to be created. + * @return EOK on success or an error code from errno.h. */ +int bithenge_node_from_source(bithenge_node_t **out, const char *source) +{ + if (str_chr(source, ':')) { + if (!str_lcmp(source, "file:", 5)) { + // Example: file:/textdemo + return bithenge_new_file_blob(out, source + 5); +#ifdef __HELENOS__ + } else if (!str_lcmp(source, "block:", 6)) { + // Example: block:bd/initrd + service_id_t service_id; + int rc = loc_service_get_id(source + 6, &service_id, 0); + if (rc != EOK) + return rc; + return bithenge_new_block_blob(out, service_id); +#endif + } else if (!str_lcmp(source, "hex:", 4)) { + // Example: hex:04000000 + return blob_from_hex(out, source + 4); + } else { + return EINVAL; + } + } + return bithenge_new_file_blob(out, source); +} + +/** @} + */ Index: uspace/app/bithenge/source.h =================================================================== --- uspace/app/bithenge/source.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/source.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Provide various external sources of data. + */ + +#ifndef BITHENGE_SOURCE_H_ +#define BITHENGE_SOURCE_H_ + +#include "tree.h" + +int bithenge_node_from_source(bithenge_node_t **, const char *); + +#endif + +/** @} + */ Index: uspace/app/bithenge/test.c =================================================================== --- uspace/app/bithenge/test.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/test.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Simple program to test Bithenge. + */ + +#include +#include +#include +#include +#include "blob.h" +#include "source.h" +#include "print.h" +#include "script.h" +#include "transform.h" +#include "tree.h" + +int main(int argc, char *argv[]) +{ + int rc; + if (argc < 3) { + // {True: {}, -1351: "\"false\"", "true": False, 0: b"..."} + const char data[] = "'Twas brillig, and the slithy toves"; + bithenge_node_t *node; + bithenge_node_t *subnodes[8]; + bithenge_new_boolean_node(&subnodes[0], true); + bithenge_new_simple_internal_node(&subnodes[1], NULL, 0, false); + bithenge_new_integer_node(&subnodes[2], -1351); + bithenge_new_string_node(&subnodes[3], "\"false\"", false); + bithenge_new_string_node(&subnodes[4], "true", false); + bithenge_new_boolean_node(&subnodes[5], false); + bithenge_new_integer_node(&subnodes[6], 0); + bithenge_new_blob_from_data(&subnodes[7], data, sizeof(data)); + bithenge_new_simple_internal_node(&node, subnodes, 4, false); + bithenge_print_node(BITHENGE_PRINT_PYTHON, node); + printf("\n"); + bithenge_print_node(BITHENGE_PRINT_JSON, node); + printf("\n"); + bithenge_node_dec_ref(node); + } else { + bithenge_transform_t *transform = NULL; + bithenge_node_t *node = NULL, *node2 = NULL; + rc = bithenge_parse_script(argv[1], &transform); + if (rc != EOK) { + printf("Error parsing script: %s\n", str_error(rc)); + goto error; + } + + int rc = bithenge_node_from_source(&node, argv[2]); + if (rc != EOK) { + printf("Error creating node from source: %s\n", str_error(rc)); + goto error; + } + + rc = bithenge_transform_apply(transform, node, &node2); + if (rc != EOK) { + printf("Error applying transform: %s\n", str_error(rc)); + goto error; + } + + bithenge_node_dec_ref(node); + node = NULL; + bithenge_transform_dec_ref(transform); + transform = NULL; + + rc = bithenge_print_node(BITHENGE_PRINT_PYTHON, node2); + if (rc != EOK) { + printf("Error printing node: %s\n", str_error(rc)); + goto error; + } + bithenge_node_dec_ref(node2); + node2 = NULL; + printf("\n"); + + return 0; + +error: + bithenge_node_dec_ref(node); + bithenge_node_dec_ref(node2); + bithenge_transform_dec_ref(transform); + return 1; + } + + return 0; +} + +/** @} + */ Index: uspace/app/bithenge/transform.c =================================================================== --- uspace/app/bithenge/transform.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/transform.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,587 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Transforms. + */ + +#include +#include +#include +#include "blob.h" +#include "transform.h" + +/** Initialize a new transform. + * @param[out] self Transform to initialize. + * @param[in] ops Operations provided by the transform. + * @return EOK or an error code from errno.h. */ +int bithenge_init_transform(bithenge_transform_t *self, + const bithenge_transform_ops_t *ops) +{ + assert(ops); + assert(ops->apply); + assert(ops->destroy); + self->ops = ops; + self->refs = 1; + return EOK; +} + +static void transform_indestructible(bithenge_transform_t *self) +{ + assert(false); +} + +static int ascii_apply(bithenge_transform_t *self, + bithenge_node_t *in, bithenge_node_t **out) +{ + int rc; + if (bithenge_node_type(in) != BITHENGE_NODE_BLOB) + return EINVAL; + bithenge_blob_t *blob = bithenge_node_as_blob(in); + aoff64_t size; + rc = bithenge_blob_size(blob, &size); + if (rc != EOK) + return rc; + + char *buffer = malloc(size + 1); + if (!buffer) + return ENOMEM; + aoff64_t size_read = size; + rc = bithenge_blob_read(blob, 0, buffer, &size_read); + if (rc != EOK) { + free(buffer); + return rc; + } + if (size_read != size) { + free(buffer); + return EINVAL; + } + buffer[size] = '\0'; + + /* TODO: what if the OS encoding is incompatible with ASCII? */ + return bithenge_new_string_node(out, buffer, true); +} + +static const bithenge_transform_ops_t ascii_ops = { + .apply = ascii_apply, + .destroy = transform_indestructible, +}; + +/** The ASCII text transform. */ +bithenge_transform_t bithenge_ascii_transform = { + &ascii_ops, 1 +}; + +static int uint32le_apply(bithenge_transform_t *self, bithenge_node_t *in, + bithenge_node_t **out) +{ + int rc; + if (bithenge_node_type(in) != BITHENGE_NODE_BLOB) + return EINVAL; + bithenge_blob_t *blob = bithenge_node_as_blob(in); + + // Try to read 5 bytes and fail if the blob is too long. + uint32_t val[2]; + aoff64_t size = sizeof(val[0]) + 1; + rc = bithenge_blob_read(blob, 0, (char *)val, &size); + if (rc != EOK) + return rc; + if (size != 4) + return EINVAL; + + return bithenge_new_integer_node(out, uint32_t_le2host(val[0])); +} + +static int uint32be_apply(bithenge_transform_t *self, bithenge_node_t *in, + bithenge_node_t **out) +{ + int rc; + if (bithenge_node_type(in) != BITHENGE_NODE_BLOB) + return EINVAL; + bithenge_blob_t *blob = bithenge_node_as_blob(in); + + // Try to read 5 bytes and fail if the blob is too long. + uint32_t val[2]; + aoff64_t size = sizeof(val[0]) + 1; + rc = bithenge_blob_read(blob, 0, (char *)val, &size); + if (rc != EOK) + return rc; + if (size != 4) + return EINVAL; + + return bithenge_new_integer_node(out, uint32_t_be2host(val[0])); +} + +static int prefix_length_4(bithenge_transform_t *self, bithenge_blob_t *blob, + aoff64_t *out) +{ + *out = 4; + return EOK; +} + +static const bithenge_transform_ops_t uint32le_ops = { + .apply = uint32le_apply, + .prefix_length = prefix_length_4, + .destroy = transform_indestructible, +}; + +static const bithenge_transform_ops_t uint32be_ops = { + .apply = uint32be_apply, + .prefix_length = prefix_length_4, + .destroy = transform_indestructible, +}; + +/** The little-endian 32-bit unsigned integer transform. */ +bithenge_transform_t bithenge_uint32le_transform = { + &uint32le_ops, 1 +}; + +/** The big-endian 32-bit unsigned integer transform. */ +bithenge_transform_t bithenge_uint32be_transform = { + &uint32be_ops, 1 +}; + +static int zero_terminated_apply(bithenge_transform_t *self, + bithenge_node_t *in, bithenge_node_t **out) +{ + int rc; + if (bithenge_node_type(in) != BITHENGE_NODE_BLOB) + return EINVAL; + bithenge_blob_t *blob = bithenge_node_as_blob(in); + aoff64_t size; + rc = bithenge_blob_size(blob, &size); + if (rc != EOK) + return rc; + if (size < 1) + return EINVAL; + char ch; + aoff64_t size_read = 1; + rc = bithenge_blob_read(blob, size - 1, &ch, &size_read); + if (rc != EOK) + return rc; + if (size_read != 1 || ch != '\0') + return EINVAL; + bithenge_blob_inc_ref(blob); + return bithenge_new_subblob(out, blob, 0, size - 1); +} + +static int zero_terminated_prefix_length(bithenge_transform_t *self, + bithenge_blob_t *blob, aoff64_t *out) +{ + int rc; + char buffer[4096]; + aoff64_t offset = 0, size_read = sizeof(buffer); + do { + rc = bithenge_blob_read(blob, offset, buffer, &size_read); + if (rc != EOK) + return rc; + char *found = memchr(buffer, '\0', size_read); + if (found) { + *out = found - buffer + offset + 1; + return EOK; + } + offset += size_read; + } while (size_read == sizeof(buffer)); + return EINVAL; +} + +static const bithenge_transform_ops_t zero_terminated_ops = { + .apply = zero_terminated_apply, + .prefix_length = zero_terminated_prefix_length, + .destroy = transform_indestructible, +}; + +/** The zero-terminated data transform. */ +bithenge_transform_t bithenge_zero_terminated_transform = { + &zero_terminated_ops, 1 +}; + +static bithenge_named_transform_t primitive_transforms[] = { + {"ascii", &bithenge_ascii_transform}, + {"uint32le", &bithenge_uint32le_transform}, + {"uint32be", &bithenge_uint32be_transform}, + {"zero_terminated", &bithenge_zero_terminated_transform}, + {NULL, NULL} +}; + +/** An array of named built-in transforms. */ +bithenge_named_transform_t *bithenge_primitive_transforms = primitive_transforms; + +typedef struct { + bithenge_node_t base; + struct struct_transform *transform; + bithenge_blob_t *blob; +} struct_node_t; + +typedef struct struct_transform { + bithenge_transform_t base; + bithenge_named_transform_t *subtransforms; +} struct_transform_t; + +static bithenge_node_t *struct_as_node(struct_node_t *node) +{ + return &node->base; +} + +static struct_node_t *node_as_struct(bithenge_node_t *node) +{ + return (struct_node_t *)node; +} + +static bithenge_transform_t *struct_as_transform(struct_transform_t *xform) +{ + return &xform->base; +} + +static struct_transform_t *transform_as_struct(bithenge_transform_t *xform) +{ + return (struct_transform_t *)xform; +} + +static int struct_node_for_one(const char *name, + bithenge_transform_t *subxform, bithenge_blob_t **blob, + bithenge_for_each_func_t func, void *data) +{ + int rc; + bithenge_node_t *subxform_result = NULL; + + aoff64_t sub_size; + rc = bithenge_transform_prefix_length(subxform, *blob, &sub_size); + if (rc != EOK) + goto error; + + bithenge_node_t *subblob_node; + bithenge_blob_inc_ref(*blob); + rc = bithenge_new_subblob(&subblob_node, *blob, 0, sub_size); + if (rc != EOK) + goto error; + + rc = bithenge_transform_apply(subxform, subblob_node, + &subxform_result); + bithenge_node_dec_ref(subblob_node); + if (rc != EOK) + goto error; + + if (name) { + bithenge_node_t *name_node; + rc = bithenge_new_string_node(&name_node, name, false); + if (rc != EOK) + goto error; + rc = func(name_node, subxform_result, data); + subxform_result = NULL; + if (rc != EOK) + goto error; + } else { + if (bithenge_node_type(subxform_result) != + BITHENGE_NODE_INTERNAL) { + rc = EINVAL; + goto error; + } + rc = bithenge_node_for_each(subxform_result, func, data); + if (rc != EOK) + goto error; + } + + bithenge_node_t *blob_node; + rc = bithenge_new_offset_blob(&blob_node, *blob, sub_size); + *blob = NULL; + if (rc != EOK) + goto error; + *blob = bithenge_node_as_blob(blob_node); + +error: + bithenge_node_dec_ref(subxform_result); + return rc; +} + +static int struct_node_for_each(bithenge_node_t *base, + bithenge_for_each_func_t func, void *data) +{ + int rc = EOK; + struct_node_t *struct_node = node_as_struct(base); + bithenge_named_transform_t *subxforms = + struct_node->transform->subtransforms; + + bithenge_node_t *blob_node = NULL; + bithenge_blob_t *blob = NULL; + bithenge_blob_inc_ref(struct_node->blob); + rc = bithenge_new_offset_blob(&blob_node, struct_node->blob, 0); + if (rc != EOK) { + blob = NULL; + goto error; + } + blob = bithenge_node_as_blob(blob_node); + + for (size_t i = 0; subxforms[i].transform; i++) { + rc = struct_node_for_one(subxforms[i].name, + subxforms[i].transform, &blob, func, data); + if (rc != EOK) + goto error; + } + + aoff64_t remaining; + rc = bithenge_blob_size(blob, &remaining); + if (rc != EOK) + goto error; + if (remaining != 0) { + rc = EINVAL; + goto error; + } + +error: + bithenge_blob_dec_ref(blob); + return rc; +} + +static void struct_node_destroy(bithenge_node_t *base) +{ + struct_node_t *node = node_as_struct(base); + bithenge_transform_dec_ref(struct_as_transform(node->transform)); + bithenge_blob_dec_ref(node->blob); + free(node); +} + +static const bithenge_internal_node_ops_t struct_node_ops = { + .for_each = struct_node_for_each, + .destroy = struct_node_destroy, +}; + +static int struct_transform_apply(bithenge_transform_t *base, + bithenge_node_t *in, bithenge_node_t **out) +{ + struct_transform_t *self = transform_as_struct(base); + if (bithenge_node_type(in) != BITHENGE_NODE_BLOB) + return EINVAL; + struct_node_t *node = malloc(sizeof(*node)); + if (!node) + return ENOMEM; + int rc = bithenge_init_internal_node(struct_as_node(node), + &struct_node_ops); + if (rc != EOK) { + free(node); + return rc; + } + bithenge_transform_inc_ref(base); + node->transform = self; + bithenge_node_inc_ref(in); + node->blob = bithenge_node_as_blob(in); + *out = struct_as_node(node); + return EOK; +} + +static int struct_transform_prefix_length(bithenge_transform_t *base, + bithenge_blob_t *blob, aoff64_t *out) +{ + struct_transform_t *self = transform_as_struct(base); + int rc = EOK; + bithenge_node_t *node; + bithenge_blob_inc_ref(blob); + rc = bithenge_new_offset_blob(&node, blob, 0); + blob = NULL; + if (rc != EOK) + goto error; + blob = bithenge_node_as_blob(node); + *out = 0; + for (size_t i = 0; self->subtransforms[i].transform; i++) { + bithenge_transform_t *subxform = + self->subtransforms[i].transform; + aoff64_t sub_size; + rc = bithenge_transform_prefix_length(subxform, blob, &sub_size); + if (rc != EOK) + goto error; + *out += sub_size; + rc = bithenge_new_offset_blob(&node, blob, sub_size); + blob = NULL; + if (rc != EOK) + goto error; + blob = bithenge_node_as_blob(node); + } +error: + bithenge_blob_dec_ref(blob); + return EOK; +} + +static void free_subtransforms(bithenge_named_transform_t *subtransforms) +{ + for (size_t i = 0; subtransforms[i].transform; i++) { + free((void *)subtransforms[i].name); + bithenge_transform_dec_ref(subtransforms[i].transform); + } + free(subtransforms); +} + +static void struct_transform_destroy(bithenge_transform_t *base) +{ + struct_transform_t *self = transform_as_struct(base); + free_subtransforms(self->subtransforms); + free(self); +} + +static bithenge_transform_ops_t struct_transform_ops = { + .apply = struct_transform_apply, + .prefix_length = struct_transform_prefix_length, + .destroy = struct_transform_destroy, +}; + +/** Create a struct transform. The transform will apply its subtransforms + * sequentially to a blob to create an internal node. Each result is either + * given a key from @a subtransforms or, if the name is NULL, the result's keys + * and values are merged into the struct transform's result. This function + * takes ownership of @a subtransforms and the names and references therein. + * @param[out] out Stores the created transform. + * @param subtransforms The subtransforms and field names. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_struct(bithenge_transform_t **out, + bithenge_named_transform_t *subtransforms) +{ + int rc; + struct_transform_t *self = malloc(sizeof(*self)); + if (!self) { + rc = ENOMEM; + goto error; + } + rc = bithenge_init_transform(struct_as_transform(self), + &struct_transform_ops); + if (rc != EOK) + goto error; + self->subtransforms = subtransforms; + *out = struct_as_transform(self); + return EOK; +error: + free_subtransforms(subtransforms); + free(self); + return rc; +} + +typedef struct { + bithenge_transform_t base; + bithenge_transform_t **xforms; + size_t num; +} compose_transform_t; + +static bithenge_transform_t *compose_as_transform(compose_transform_t *xform) +{ + return &xform->base; +} + +static compose_transform_t *transform_as_compose(bithenge_transform_t *xform) +{ + return (compose_transform_t *)xform; +} + +static int compose_apply(bithenge_transform_t *base, bithenge_node_t *in, + bithenge_node_t **out) +{ + int rc; + compose_transform_t *self = transform_as_compose(base); + bithenge_node_inc_ref(in); + + /* i ranges from (self->num - 1) to 0 inside the loop. */ + for (size_t i = self->num; i--; ) { + bithenge_node_t *tmp; + rc = bithenge_transform_apply(self->xforms[i], in, &tmp); + bithenge_node_dec_ref(in); + if (rc != EOK) + return rc; + in = tmp; + } + + *out = in; + return rc; +} + +static int compose_prefix_length(bithenge_transform_t *base, + bithenge_blob_t *blob, aoff64_t *out) +{ + compose_transform_t *self = transform_as_compose(base); + return bithenge_transform_prefix_length(self->xforms[self->num - 1], + blob, out); +} + +static void compose_destroy(bithenge_transform_t *base) +{ + compose_transform_t *self = transform_as_compose(base); + for (size_t i = 0; i < self->num; i++) + bithenge_transform_dec_ref(self->xforms[i]); + free(self->xforms); + free(self); +} + +static const bithenge_transform_ops_t compose_transform_ops = { + .apply = compose_apply, + .prefix_length = compose_prefix_length, + .destroy = compose_destroy, +}; + +/** Create a composition of multiple transforms. When the result is applied to a + * node, each transform is applied in turn, with the last transform applied + * first. @a xforms may contain any number of transforms or no transforms at + * all. This function takes ownership of @a xforms and the references therein. + * @param[out] out Holds the result. + * @param[in] xforms The transforms to apply. + * @param num The number of transforms. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_composed_transform(bithenge_transform_t **out, + bithenge_transform_t **xforms, size_t num) +{ + if (num == 0) { + /* TODO: optimize */ + } else if (num == 1) { + *out = xforms[0]; + free(xforms); + return EOK; + } + + int rc; + compose_transform_t *self = malloc(sizeof(*self)); + if (!self) { + rc = ENOMEM; + goto error; + } + rc = bithenge_init_transform(compose_as_transform(self), + &compose_transform_ops); + if (rc != EOK) + goto error; + self->xforms = xforms; + self->num = num; + *out = compose_as_transform(self); + return EOK; +error: + for (size_t i = 0; i < num; i++) + bithenge_transform_dec_ref(xforms[i]); + free(xforms); + free(self); + return rc; +} + +/** @} + */ Index: uspace/app/bithenge/transform.h =================================================================== --- uspace/app/bithenge/transform.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/transform.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Transforms. + */ + +#ifndef BITHENGE_TRANSFORM_H_ +#define BITHENGE_TRANSFORM_H_ + +#include "blob.h" +#include "tree.h" + +/** A transform that creates a new tree from an old tree. */ +typedef struct { + /** @privatesection */ + const struct bithenge_transform_ops *ops; + unsigned int refs; +} bithenge_transform_t; + +/** Operations that may be provided by a transform. */ +typedef struct bithenge_transform_ops { + /** @copydoc bithenge_transform_t::bithenge_transform_apply */ + int (*apply)(bithenge_transform_t *self, bithenge_node_t *in, bithenge_node_t **out); + /** @copydoc bithenge_transform_t::bithenge_transform_prefix_length */ + int (*prefix_length)(bithenge_transform_t *self, bithenge_blob_t *blob, aoff64_t *out); + /** Destroy the transform. + * @param self The transform. */ + void (*destroy)(bithenge_transform_t *self); +} bithenge_transform_ops_t; + +/** Apply a transform. + * @memberof bithenge_transform_t + * @param self The transform. + * @param in The input tree. + * @param[out] out Where the output tree will be stored. + * @return EOK on success or an error code from errno.h. */ +static inline int bithenge_transform_apply(bithenge_transform_t *self, + bithenge_node_t *in, bithenge_node_t **out) +{ + assert(self); + assert(self->ops); + return self->ops->apply(self, in, out); +} + +/** Find the length of the prefix of a blob this transform can use as input. In + * other words, figure out how many bytes this transform will use up. This + * method is optional and can return an error, but it must succeed for struct + * subtransforms. + * @memberof bithenge_transform_t + * @param self The transform. + * @param blob The blob. + * @param[out] out Where the prefix length will be stored. + * @return EOK on success, ENOTSUP if not supported, or another error code from + * errno.h. */ +static inline int bithenge_transform_prefix_length(bithenge_transform_t *self, + bithenge_blob_t *blob, aoff64_t *out) +{ + assert(self); + assert(self->ops); + if (!self->ops->prefix_length) + return ENOTSUP; + return self->ops->prefix_length(self, blob, out); +} + +/** Increment a transform's reference count. + * @param self The transform to reference. */ +static inline void bithenge_transform_inc_ref(bithenge_transform_t *self) +{ + assert(self); + self->refs++; +} + +/** Decrement a transform's reference count and free it if appropriate. + * @param self The transform to dereference, or NULL. */ +static inline void bithenge_transform_dec_ref(bithenge_transform_t *self) +{ + if (!self) + return; + assert(self->ops); + if (--self->refs == 0) + self->ops->destroy(self); +} + +/** A transform with a name. */ +typedef struct { + const char *name; + bithenge_transform_t *transform; +} bithenge_named_transform_t; + +extern bithenge_transform_t bithenge_ascii_transform; +extern bithenge_transform_t bithenge_uint32le_transform; +extern bithenge_transform_t bithenge_uint32be_transform; +extern bithenge_transform_t bithenge_zero_terminated_transform; +extern bithenge_named_transform_t *bithenge_primitive_transforms; + +int bithenge_init_transform(bithenge_transform_t *self, + const bithenge_transform_ops_t *ops); +int bithenge_new_struct(bithenge_transform_t **out, + bithenge_named_transform_t *subtransforms); +int bithenge_new_composed_transform(bithenge_transform_t **, + bithenge_transform_t **, size_t); + +#endif + +/** @} + */ Index: uspace/app/bithenge/tree.c =================================================================== --- uspace/app/bithenge/tree.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/tree.c (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,269 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Trees and nodes. + */ + +#include +#include +#include "blob.h" +#include "os.h" +#include "tree.h" + +static void blob_destroy(bithenge_node_t *base) +{ + bithenge_blob_t *self = bithenge_node_as_blob(base); + assert(self->base.blob_ops); + self->base.blob_ops->destroy(self); +} + +static void node_destroy(bithenge_node_t *self) +{ + switch (bithenge_node_type(self)) { + case BITHENGE_NODE_BLOB: + blob_destroy(self); + return; + case BITHENGE_NODE_STRING: + if (self->string_value.needs_free) + free((void *)self->string_value.ptr); + break; + case BITHENGE_NODE_INTERNAL: + self->internal_ops->destroy(self); + return; + case BITHENGE_NODE_BOOLEAN: + return; /* The boolean nodes are allocated statically below. */ + case BITHENGE_NODE_INTEGER: /* pass-through */ + break; + } + free(self); +} + +/** Decrement a node's reference count and free it if appropriate. + * @memberof bithenge_node_t + * @param node The node to dereference, or NULL. */ +void bithenge_node_dec_ref(bithenge_node_t *node) +{ + if (!node) + return; + if (--node->refs == 0) + node_destroy(node); +} + +typedef struct +{ + bithenge_node_t base; + bithenge_node_t **nodes; + bithenge_int_t len; + bool needs_free; +} simple_internal_node_t; + +static simple_internal_node_t *node_as_simple(bithenge_node_t *node) +{ + return (simple_internal_node_t *)node; +} + +static bithenge_node_t *simple_as_node(simple_internal_node_t *node) +{ + return &node->base; +} + +static int simple_internal_node_for_each(bithenge_node_t *base, + bithenge_for_each_func_t func, void *data) +{ + int rc; + simple_internal_node_t *self = node_as_simple(base); + for (bithenge_int_t i = 0; i < self->len; i++) { + bithenge_node_inc_ref(self->nodes[2*i+0]); + bithenge_node_inc_ref(self->nodes[2*i+1]); + rc = func(self->nodes[2*i+0], self->nodes[2*i+1], data); + if (rc != EOK) + return rc; + } + return EOK; +} + +static void simple_internal_node_destroy(bithenge_node_t *base) +{ + simple_internal_node_t *self = node_as_simple(base); + for (bithenge_int_t i = 0; i < 2 * self->len; i++) + bithenge_node_dec_ref(self->nodes[i]); + if (self->needs_free) + free(self->nodes); + free(self); +} + +static bithenge_internal_node_ops_t simple_internal_node_ops = { + .for_each = simple_internal_node_for_each, + .destroy = simple_internal_node_destroy, +}; + +/** Initialize an internal node. + * @memberof bithenge_node_t + * @param[out] self The node. + * @param[in] ops The operations provided. + * @return EOK on success or an error code from errno.h. */ +int bithenge_init_internal_node(bithenge_node_t *self, + const bithenge_internal_node_ops_t *ops) +{ + self->type = BITHENGE_NODE_INTERNAL; + self->refs = 1; + self->internal_ops = ops; + return EOK; +} + +/** Create an internal node from a set of keys and values. This function takes + * ownership of a reference to the key and value nodes, and optionally the + * array @a nodes. + * @memberof bithenge_node_t + * @param[out] out Stores the created internal node. + * @param nodes The array of key-value pairs. Keys are stored at even indices + * and values are stored at odd indices. + * @param len The number of key-value pairs in the node array. + * @param needs_free If true, when the internal node is destroyed it will free + * the nodes array rather than just dereferencing each node inside it. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_simple_internal_node(bithenge_node_t **out, + bithenge_node_t **nodes, bithenge_int_t len, bool needs_free) +{ + int rc; + assert(out); + simple_internal_node_t *self = malloc(sizeof(*self)); + if (!self) { + rc = ENOMEM; + goto error; + } + rc = bithenge_init_internal_node(simple_as_node(self), + &simple_internal_node_ops); + if (rc != EOK) + goto error; + self->nodes = nodes; + self->len = len; + self->needs_free = needs_free; + *out = simple_as_node(self); + return EOK; +error: + for (bithenge_int_t i = 0; i < 2 * len; i++) + bithenge_node_dec_ref(nodes[i]); + if (needs_free) + free(nodes); + free(self); + return rc; +} + +static bithenge_node_t false_node = { BITHENGE_NODE_BOOLEAN, 1, .boolean_value = false }; +static bithenge_node_t true_node = { BITHENGE_NODE_BOOLEAN, 1, .boolean_value = true }; + +/** Create a boolean node. + * @memberof bithenge_node_t + * @param[out] out Stores the created boolean node. + * @param value The value for the node to hold. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_boolean_node(bithenge_node_t **out, bool value) +{ + assert(out); + *out = value ? &true_node : &false_node; + (*out)->refs++; + return EOK; +} + +/** Create an integer node. + * @memberof bithenge_node_t + * @param[out] out Stores the created integer node. + * @param value The value for the node to hold. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_integer_node(bithenge_node_t **out, bithenge_int_t value) +{ + assert(out); + bithenge_node_t *self = malloc(sizeof(*self)); + if (!self) + return ENOMEM; + self->type = BITHENGE_NODE_INTEGER; + self->refs = 1; + self->integer_value = value; + *out = self; + return EOK; +} + +/** Create a string node. + * @memberof bithenge_node_t + * @param[out] out Stores the created string node. On error, this is unchanged. + * @param value The value for the node to hold. + * @param needs_free Whether the string should be freed when the node is + * destroyed. + * @return EOK on success or an error code from errno.h. */ +int bithenge_new_string_node(bithenge_node_t **out, const char *value, bool needs_free) +{ + assert(out); + bithenge_node_t *self = malloc(sizeof(*self)); + if (!self) { + if (needs_free) + free((void *)value); + return ENOMEM; + } + self->type = BITHENGE_NODE_STRING; + self->refs = 1; + self->string_value.ptr = value; + self->string_value.needs_free = needs_free; + *out = self; + return EOK; +} + +/** Check whether the contents of two nodes are equal. Does not yet work for + * internal nodes. + * @memberof bithenge_node_t + * @param a, b Nodes to compare. + * @return Whether the nodes are equal. If an error occurs, returns false. + * @todo Add support for internal nodes. + */ +bool bithenge_node_equal(bithenge_node_t *a, bithenge_node_t *b) +{ + if (a->type != b->type) + return false; + switch (a->type) { + case BITHENGE_NODE_INTERNAL: + return false; + case BITHENGE_NODE_BOOLEAN: + return a->boolean_value == b->boolean_value; + case BITHENGE_NODE_INTEGER: + return a->integer_value == b->integer_value; + case BITHENGE_NODE_STRING: + return !str_cmp(a->string_value.ptr, b->string_value.ptr); + case BITHENGE_NODE_BLOB: + return bithenge_blob_equal(bithenge_node_as_blob(a), + bithenge_node_as_blob(b)); + } + return false; +} + +/** @} + */ Index: uspace/app/bithenge/tree.h =================================================================== --- uspace/app/bithenge/tree.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/app/bithenge/tree.h (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2012 Sean Bartell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bithenge + * @{ + */ +/** + * @file + * Trees and nodes. + */ + +#ifndef BITHENGE_TREE_H_ +#define BITHENGE_TREE_H_ + +#include +#include +#include +#include "os.h" + +#ifdef INTMAX_MAX +typedef intmax_t bithenge_int_t; +#define BITHENGE_PRId PRIdMAX +#else +typedef int64_t bithenge_int_t; +#define BITHENGE_PRId PRId64 +#endif + +/** Indicates the type of a tree node. */ +typedef enum { + /** An internal node with labelled edges to other nodes. */ + BITHENGE_NODE_INTERNAL = 1, + /** A leaf node holding a boolean value. */ + BITHENGE_NODE_BOOLEAN, + /** A leaf node holding an integer. */ + BITHENGE_NODE_INTEGER, + /** A leaf node holding a string. */ + BITHENGE_NODE_STRING, + /** A leaf node holding a binary blob. */ + BITHENGE_NODE_BLOB, +} bithenge_node_type_t; + +typedef struct bithenge_node_t { + /** @privatesection */ + bithenge_node_type_t type; + unsigned int refs; + union { + const struct bithenge_internal_node_ops_t *internal_ops; + bool boolean_value; + bithenge_int_t integer_value; + struct { + const char *ptr; + bool needs_free; + } string_value; + const struct bithenge_random_access_blob_ops_t *blob_ops; + }; +} bithenge_node_t; + +/** A callback function used to iterate over a node's children. It takes + * ownership of a reference to both the key and the value. + * @memberof bithenge_node_t + * @param key The key. + * @param value The value. + * @param data Data provided to @a bithenge_node_t::bithenge_node_for_each. + * @return EOK on success or an error code from errno.h. */ +typedef int (*bithenge_for_each_func_t)(bithenge_node_t *key, bithenge_node_t *value, void *data); + +/** Operations providing access to an internal node. */ +typedef struct bithenge_internal_node_ops_t { + /** @copydoc bithenge_node_t::bithenge_node_for_each */ + int (*for_each)(bithenge_node_t *self, bithenge_for_each_func_t func, void *data); + /** Destroys the internal node. + * @param self The node to destroy. */ + void (*destroy)(bithenge_node_t *self); +} bithenge_internal_node_ops_t; + +/** Find the type of a node. + * @memberof bithenge_node_t + * @param node The node. + * @return The type of the node. */ +static inline bithenge_node_type_t bithenge_node_type(const bithenge_node_t *node) +{ + return node->type; +} + +/** Increment a node's reference count. + * @memberof bithenge_node_t + * @param node The node to reference. */ +static inline void bithenge_node_inc_ref(bithenge_node_t *node) +{ + assert(node); + node->refs++; +} + +void bithenge_node_dec_ref(bithenge_node_t *node); + +/** Iterate over a node's children. + * @memberof bithenge_node_t + * @param self The internal node to iterate over. + * @param func The callback function. + * @param data Data to provide to the callback function. + * @return EOK on success or an error code from errno.h. */ +static inline int bithenge_node_for_each(bithenge_node_t *self, + bithenge_for_each_func_t func, void *data) +{ + assert(self->type == BITHENGE_NODE_INTERNAL); + return self->internal_ops->for_each(self, func, data); +} + +/** Get the value of a boolean node. + * @memberof bithenge_node_t + * @param self The boolean node. + * @return The node's value. */ +static inline bool bithenge_boolean_node_value(bithenge_node_t *self) +{ + assert(self->type == BITHENGE_NODE_BOOLEAN); + return self->boolean_value; +} + +/** Get the value of an integer node. + * @memberof bithenge_node_t + * @param self The integer node. + * @return The node's value. */ +static inline bithenge_int_t bithenge_integer_node_value(bithenge_node_t *self) +{ + assert(self->type == BITHENGE_NODE_INTEGER); + return self->integer_value; +} + +/** Get the value of an string node. + * @memberof bithenge_node_t + * @param self The string node. + * @return The node's value. */ +static inline const char *bithenge_string_node_value(bithenge_node_t *self) +{ + assert(self->type == BITHENGE_NODE_STRING); + return self->string_value.ptr; +} + +int bithenge_init_internal_node(bithenge_node_t *, + const bithenge_internal_node_ops_t *); +int bithenge_new_simple_internal_node(bithenge_node_t **, bithenge_node_t **, + bithenge_int_t, bool needs_free); +int bithenge_new_boolean_node(bithenge_node_t **, bool); +int bithenge_new_integer_node(bithenge_node_t **, bithenge_int_t); +int bithenge_new_string_node(bithenge_node_t **, const char *, bool); +bool bithenge_node_equal(bithenge_node_t *, bithenge_node_t *); + +#endif + +/** @} + */ Index: uspace/dist/src/bithenge/trip.bh =================================================================== --- uspace/dist/src/bithenge/trip.bh (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) +++ uspace/dist/src/bithenge/trip.bh (revision ae49252801c1a0f674c37b842fb549ad0c6f5f8d) @@ -0,0 +1,15 @@ +transform point = struct { + .lat <- uint32le; + .lon <- uint32le; +}; + +transform named_point = struct { + .name <- ascii <- zero_terminated; + <- point; +}; + +transform main = struct { + .from <- named_point; + .to <- named_point; + .distance <- uint32le; # in kilometers +};