Changeset da0fef6 in mainline

Timestamp:

2012-06-23T18:24:21Z (12 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

03b2b2c

Parents:

d5070ef

Message:

Bithenge: port to Linux and allow choosing a data source

Location:

uspace/app/bithenge

Files:

• Makefile (modified) (1 diff)
• Makefile.linux (added)
• blob.c (modified) (3 diffs)
• file.c (modified) (3 diffs)
• helenos/block.c (moved) (moved from uspace/app/bithenge/block.c ) (1 diff)
• helenos/block.h (moved) (moved from uspace/app/bithenge/block.h ) (1 diff)
• helenos/os.h (added)
• linux/os.h (added)
• print.c (modified) (2 diffs)
• source.c (added)
• source.h (added)
• test.c (modified) (1 diff)
• transform.c (modified) (1 diff)
• transform.h (modified) (1 diff)
• tree.c (modified) (2 diffs)
• tree.h (modified) (1 diff)

uspace/app/bithenge/Makefile

@@ -29 +29 @@
 USPACE_PREFIX = ../..
 LIBS = $(LIBBLOCK_PREFIX)/libblock.a
-EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX)
+EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -D__HELENOS__ -Ihelenos
 BINARY = bithenge
 
 SOURCES = \
+        helenos/block.c \
         blob.c \
-        block.c \
         file.c \
         print.c \
+        source.c \
         test.c \
         transform.c \

uspace/app/bithenge/blob.c

@@ -36 +36 @@
 
 #include <assert.h>
-#include <bool.h>
 #include <errno.h>
-#include <macros.h>
-#include <mem.h>
 #include <stdlib.h>
 #include "blob.h"
+#include "os.h"
 #include "tree.h"
 
@@ -215 +213 @@
         memory_blob_t *blob = memory_from_blob(base);
         if (blob->needs_free)
-                free(blob->buffer);
+                free((void *)blob->buffer);
         free(blob);
         return EOK;
@@ -272 +270 @@
  * destroyed.
  * @param len The length of the data.
- * @param needs_free Whether the buffer should be freed with free() when the
- * blob is destroyed.
+ * @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,

uspace/app/bithenge/file.c

@@ -39 +39 @@
 #include <errno.h>
 #include <fcntl.h>
-#include <macros.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
 #include "blob.h"
 #include "file.h"
+#include "os.h"
 
 typedef struct {
@@ -76 +78 @@
         if (offset > blob->size)
                 return ELIMIT;
-        *size = min(*size, blob->size - offset);
-        int rc = lseek(blob->fd, offset, SEEK_SET);
-        if (rc != EOK)
-                return rc;
-        return read(blob->fd, buffer, *size);
+        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;
 }
 
@@ -125 +137 @@
         }
         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(blob_from_file(blob));

uspace/app/bithenge/helenos/block.c

@@ -42 +42 @@
 #include <macros.h>
 #include <stdlib.h>
-#include "blob.h"
+#include "../blob.h"
 #include "block.h"
 

uspace/app/bithenge/helenos/block.h

@@ -39 +39 @@
 
 #include <loc.h>
-#include "blob.h"
+#include "../blob.h"
 
 int bithenge_new_block_blob(bithenge_node_t **, service_id_t);

uspace/app/bithenge/print.c

@@ -104 +104 @@
 static int print_string(bithenge_print_type_t type, bithenge_node_t *node)
 {
-        size_t off = 0;
         const char *value = bithenge_string_node_value(node);
-        wchar_t ch;
         printf("\"");
-        while ((ch = str_decode(value, &off, STR_NO_LIMIT)) != 0) {
+        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);
@@ -134 +136 @@
                         return rc;
                 for (aoff64_t i = 0; i < size; i++)
-                        printf("\\x%02x", buffer[i]);
+                        printf("\\x%02x", (unsigned int)(uint8_t)buffer[i]);
                 pos += size;
         } while (size == sizeof(buffer));

uspace/app/bithenge/test.c

@@ -35 +35 @@
  */
 
-#include <loc.h>
+#include <errno.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <sys/types.h>
 #include "blob.h"
-#include "block.h"
-#include "file.h"
+#include "source.h"
 #include "print.h"
 #include "tree.h"
 
-static void
-print_data(const char *data, size_t len)
-{
-        while (len--)
-                printf("%02x ", (uint8_t)(*data++));
-        printf("\n");
-}
-
-static void
-print_blob(bithenge_node_t *node)
-{
-        bithenge_blob_t *blob = bithenge_node_as_blob(node);
-        aoff64_t size;
-        bithenge_blob_size(blob, &size);
-        printf("Size: %d; ", (int)size);
-        char buffer[64];
-        size = sizeof(buffer);
-        bithenge_blob_read(blob, 0, buffer, &size);
-        print_data(buffer, size);
-}
-
 int main(int argc, char *argv[])
 {
-        bithenge_node_t *node;
-
-        service_id_t service_id;
-        loc_service_get_id("bd/initrd", &service_id, 0);
-        bithenge_new_block_blob(&node, service_id);
-        printf("Data from block:bd/initrd: ");
-        print_blob(node);
-        bithenge_node_destroy(node);
-
-        const char data[] = "'Twas brillig, and the slithy toves";
-        bithenge_new_blob_from_data(&node, data, sizeof(data));
-        printf("Data from memory (from_data): ");
-        print_blob(node);
-        bithenge_node_destroy(node);
-
-        bithenge_new_blob_from_buffer(&node, data, sizeof(data), false);
-        printf("Data from memory (from_buffer): ");
-        print_blob(node);
-        bithenge_node_destroy(node);
-
-        bithenge_new_file_blob(&node, "/textdemo");
-        printf("Data from file:/textdemo: ");
-        print_blob(node);
-        bithenge_node_destroy(node);
-
-        bithenge_new_file_blob_from_fd(&node, 0);
-        printf("Data from fd:0: ");
-        print_blob(node);
-        bithenge_node_destroy(node);
-
-        // {True: {}, -1351: "\"false\"", "true": False, 0: b"..."}
-        bithenge_node_t *nodes[8];
-        bithenge_new_boolean_node(&nodes[0], true);
-        bithenge_new_simple_internal_node(&nodes[1], NULL, 0, false);
-        bithenge_new_integer_node(&nodes[2], -1351);
-        bithenge_new_string_node(&nodes[3], "\"false\"", false);
-        bithenge_new_string_node(&nodes[4], "true", false);
-        bithenge_new_boolean_node(&nodes[5], false);
-        bithenge_new_integer_node(&nodes[6], 0);
-        bithenge_new_blob_from_data(&nodes[7], data, sizeof(data));
-        bithenge_new_simple_internal_node(&node, nodes, 4, false);
-        bithenge_print_node(BITHENGE_PRINT_PYTHON, node);
-        printf("\n");
-        bithenge_print_node(BITHENGE_PRINT_JSON, node);
-        printf("\n");
-        bithenge_node_destroy(node);
+        if (argc < 2) {
+                // {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_destroy(node);
+        } else {
+                bithenge_node_t *node;
+                int rc = bithenge_node_from_source(&node, argv[1]);
+                if (rc != EOK) {
+                        printf("Error creating node from source: %s\n", str_error(rc));
+                        return 1;
+                }
+                rc = bithenge_print_node(BITHENGE_PRINT_PYTHON, node);
+                if (rc != EOK) {
+                        printf("Error printing node: %s\n", str_error(rc));
+                        return 1;
+                }
+                printf("\n");
+                bithenge_node_destroy(node);
+        }
 
         return 0;

uspace/app/bithenge/transform.c

@@ -35 +35 @@
  */
 
-#include <byteorder.h>
 #include <errno.h>
 #include "blob.h"

uspace/app/bithenge/transform.h

@@ -75 +75 @@
 /** 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 is required for struct
+ * method is optional and can return an error, but it must succeed for struct
  * subtransforms.
  * @memberof bithenge_transform_t

uspace/app/bithenge/tree.c

@@ -37 +37 @@
 #include <errno.h>
 #include <stdlib.h>
-#include <str.h>
 #include "blob.h"
+#include "os.h"
 #include "tree.h"
 
@@ -59 +59 @@
         case BITHENGE_NODE_STRING:
                 if (node->string_value.needs_free)
-                        free(node->string_value.ptr);
+                        free((void *)node->string_value.ptr);
                 break;
         case BITHENGE_NODE_INTERNAL:

uspace/app/bithenge/tree.h

@@ -39 +39 @@
 
 #include <assert.h>
-#include <bool.h>
 #include <inttypes.h>
 #include <sys/types.h>
+#include "os.h"
 
 #ifdef INTMAX_MAX