Example C parser.

.gitignore

@@ -3,3 +3,5 @@
 /.proof.out
 /.wiseguy
 /docs
+/c/*.o
+/c/example

c/Makefile

@@ -0,0 +1,3 @@
+all: example
+
+example: example.o packet.o

c/example.c

@@ -0,0 +1,53 @@
+#include <stdlib.h>
+#include "packet.h"
+#include <stdio.h>
+
+typedef struct key_value_s {
+    uint32_t key;
+    const char* value;
+} key_value_t;
+
+void serialize_key_value (pkt_serializer_t* serializer, key_value_t* key_value)
+{
+    pkt_serialize_uint32(serializer, key_value->key);
+    pkt_serialize_zero_string(serializer, key_value->value);
+}
+
+void parse_key_value (pkt_parser_t* parser, key_value_t* key_value)
+{
+    key_value->key = pkt_parse_uint32(parser);
+    key_value->value = pkt_parse_zero_string(parser);
+}
+
+int main()
+{
+    const char foo[] = { 0xaa, 0xaa, 0xaa, 0xaa, 0x61, 0x00 };
+    key_value_t key_value;
+
+    pkt_serializer_t serializer;
+    pkt_parser_t parser;
+
+    pkt_parser_initialize(&parser, foo, sizeof(foo));
+
+    parse_key_value(&parser, &key_value);
+
+    printf("%x %s\n", key_value.key, key_value.value);
+
+    pkt_serializer_initialize(&serializer);
+
+    serialize_key_value(&serializer, &key_value);
+
+    pkt_serializer_allocate(&serializer);
+
+    serialize_key_value(&serializer, &key_value);
+
+    pkt_parser_initialize(&parser, serializer.buffer, serializer.size);
+
+    parse_key_value(&parser, &key_value);
+
+    printf("%x %s\n", key_value.key, key_value.value);
+
+    pkt_serializer_free(&serializer);
+
+    return EXIT_SUCCESS;
+}

c/packet.c

@@ -0,0 +1,99 @@
+#include "packet.h"
+#include <strings.h>
+#include <stdio.h>
+
+void pkt_sizeof_uint32 (pkt_serializer_t* serializer, uint32_t value)
+{
+    serializer->size += 4;
+}
+
+void pkt_sizeof_zero_string (pkt_serializer_t* serializer, const char*  value)
+{
+    serializer->size += strlen(value) + 1;
+}
+
+static pkt_serializer_vtable_t PKT_SERIALIZER_SIZEOF =
+{
+    pkt_sizeof_uint32,
+    pkt_sizeof_zero_string
+};
+
+void pkt_write_uint32 (pkt_serializer_t* serializer, uint32_t value)
+{
+    *serializer->offset = value >> 24 & 0xff;
+    serializer->offset++;
+    *serializer->offset = value >> 16 & 0xff;
+    serializer->offset++;
+    *serializer->offset = value >> 8 & 0xff;
+    serializer->offset++;
+    *serializer->offset = value & 0xff;
+    serializer->offset++;
+}
+
+void pkt_write_zero_string (pkt_serializer_t* serializer, const char*  value)
+{
+    strcpy(serializer->offset, value);
+    serializer->offset += strlen(serializer->offset) + 1;
+}
+
+static pkt_serializer_vtable_t PKT_SERIALIZER_SERIALIZE =
+{
+    pkt_write_uint32,
+    pkt_write_zero_string
+};
+
+void pkt_serializer_initialize (pkt_serializer_t* serializer)
+{
+    serializer->size = 0;
+    serializer->buffer = NULL;
+    serializer->vtable = &PKT_SERIALIZER_SIZEOF;
+}
+
+void pkt_serializer_allocate (pkt_serializer_t* serializer)
+{
+    serializer->offset = serializer->buffer = malloc(serializer->size);
+    serializer->vtable = &PKT_SERIALIZER_SERIALIZE;
+}
+
+void pkt_serializer_free (pkt_serializer_t* serializer)
+{
+    free(serializer->buffer);
+}
+
+const char* pkt_parse_zero_string (pkt_parser_t* parser)
+{
+    const char* value = parser->buffer;
+    parser->buffer += strlen(parser->buffer) + 1;
+    return value;
+}
+
+uint32_t pkt_parse_uint32 (pkt_parser_t* parser)
+{
+    uint32_t value =
+            (parser->buffer[0] & 0xff) * 0x1000000 +
+            (parser->buffer[1] & 0xff) * 0x10000 +
+            (parser->buffer[2] & 0xff) * 0x100 +
+            (parser->buffer[3]& 0xff) ;
+    printf("%x\n", value);
+    printf("%02x\n", parser->buffer[0] & 0xff);
+    parser->buffer += 4;
+    return value;
+}
+
+void pkt_parser_initialize (pkt_parser_t* parser, const char* buffer, size_t size)
+{
+    parser->buffer = buffer;
+    parser->size = size;
+}
+
+void pkt_serialize_uint32 (pkt_serializer_t* serializer, uint32_t value)
+{
+    serializer->vtable->serialize_uint32(serializer, value);
+}
+
+void pkt_serialize_zero_string (pkt_serializer_t* serializer, const char* value)
+{
+    serializer->vtable->serialize_zero_string(serializer, value);
+}
+
+/* vim: set et */

c/packet.h

@@ -0,0 +1,38 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <memory.h>
+
+typedef struct pkt_serializer_s pkt_serializer_t;
+
+typedef void (*pkt_serializer_uint32)(pkt_serializer_t*, uint32_t);
+typedef void (*pkt_serializer_zero_string)(pkt_serializer_t*, const char*);
+
+typedef struct {
+    pkt_serializer_uint32           serialize_uint32;
+    pkt_serializer_zero_string      serialize_zero_string;
+} pkt_serializer_vtable_t;
+
+struct pkt_serializer_s {
+    size_t size;
+    char* buffer;
+    char* offset;
+    const pkt_serializer_vtable_t*  vtable;
+};
+
+typedef struct pkt_parser_s {
+    const char* buffer;
+    size_t size;
+} pkt_parser_t;
+
+const char* pkt_parse_zero_string (pkt_parser_t*);
+uint32_t pkt_parse_uint32 (pkt_parser_t*);
+
+void pkt_parser_initialize(pkt_parser_t*, const char*, size_t);
+
+void pkt_serializer_initialize (pkt_serializer_t*);
+void pkt_serializer_allocate (pkt_serializer_t*);
+void pkt_serializer_free (pkt_serializer_t*);
+void pkt_serialize_uint32 (pkt_serializer_t*, uint32_t);
+void pkt_serialize_zero_string (pkt_serializer_t*, const char*);
+
+/* vim: set et */