doesnt work

diff --git a/vg_kv.c b/vg_kv.c
index 09dc8d0a20bc8c4fa2e7da6c26ac98623a8f2534..aaf68a950381c94d8c5bed8eb7f9f3d19b9bd304 100644 (file)
--- a/vg_kv.c
+++ b/vg_kv.c
@@ -1,11 +1,5 @@
 #include "vg_kv.h"
 
-void vg_kvs_init( vg_kvs *kvs, vg_stack_allocator *stack )
-{
-   vg_zero_mem( kvs, sizeof(vg_kvs) );
-   kvs->stack = stack;
-}
-
 static vg_kv *vg_kvs_newkv( vg_kvs *kvs )
 {
    void *kv_page;
@@ -26,7 +20,16 @@ static vg_kv *vg_kvs_newkv( vg_kvs *kvs )
    return kv;
 }
 
-static u32 vg_kv_string_append( vg_kvs *kvs, const char *string )
+void vg_kvs_init( vg_kvs *kvs, vg_stack_allocator *stack )
+{
+   vg_zero_mem( kvs, sizeof(vg_kvs) );
+   kvs->stack = stack;
+   
+   vg_kv *root_kv = vg_kvs_newkv( kvs );
+   kvs->root_offset = vg_stack_offset( kvs->stack, root_kv );
+}
+
+static u32 vg_kv_string_append( vg_kvs *kvs, c8 *string )
 {
    if( string == NULL )
       return 0;
@@ -35,7 +38,7 @@ static u32 vg_kv_string_append( vg_kvs *kvs, const char *string )
    return vg_stack_offset( kvs->stack, buf );
 }
 
-u32 vg_kv_append( vg_kvs *kvs, u32 parent_offset, const char *key, const char *value )
+u32 vg_kv_append( vg_kvs *kvs, u32 parent_offset, c8 *key, c8 *value )
 {
    vg_kv *kv = vg_kvs_newkv( kvs );
    u32 key_offset = vg_kv_string_append( kvs, key ),
@@ -72,14 +75,14 @@ u32 vg_kv_append( vg_kvs *kvs, u32 parent_offset, const char *key, const char *v
    return kv_offset;
 }
 
-void vg_kv_parser_init( vg_kv_parser *parser, vg_kvs *out_kvs )
+void vg_kv_parser_init( vg_kv_parser *parser, vg_kvs *out_kvs, u32 root_offset )
 {
+   VG_ASSERT( out_kvs->stack );
+   VG_ASSERT( out_kvs->kv_page_count );
+
    vg_zero_mem( parser, sizeof(vg_kv_parser) );
    parser->kvs = out_kvs;
-
-   vg_kv *root_kv = vg_kvs_newkv( parser->kvs );
-   out_kvs->root_offset = vg_stack_offset( parser->kvs->stack, root_kv );
-   parser->frame_stack[0].frame_offset = out_kvs->root_offset;
+   parser->frame_stack[0].frame_offset = root_offset;
 }
 
 void vg_kv_link( vg_kv_parser *parser, u32 offset, u32 depth )
@@ -98,7 +101,7 @@ void vg_kv_link( vg_kv_parser *parser, u32 offset, u32 depth )
    parser->frame_stack[ depth ].latest_child_offset = offset;
 }
 
-void vg_kv_parse_buffer( vg_kv_parser *parser, const char *buffer, u32 buffer_length )
+void vg_kv_parse_buffer( vg_kv_parser *parser, c8 *buffer, u32 buffer_length )
 {
    if( buffer_length == 0 )
       buffer_length = 0xffffffff;
@@ -227,14 +230,14 @@ u32 vg_kv_type( vg_kvs *kvs, u32 kv_offset )
    return (kv->key_info >> 30) & 0x3;
 }
 
-const char *vg_kv_key( vg_kvs *kvs, u32 kv_offset, u32 *out_length )
+c8 *vg_kv_key( vg_kvs *kvs, u32 kv_offset, u32 *out_length )
 {
    vg_kv *kv = vg_stack_pointer( kvs->stack, kv_offset );
    *out_length = (kv->key_info >> 20) & 0x3FF;
    return (*out_length)? vg_stack_pointer( kvs->stack, kv->key_offset ): NULL;
 }
 
-const char *vg_kv_value( vg_kvs *kvs, u32 kv_offset, u32 *out_length )
+c8 *vg_kv_value( vg_kvs *kvs, u32 kv_offset, u32 *out_length )
 { 
    if( vg_kv_type( kvs, kv_offset ) == 0x0 )
       return NULL;
@@ -269,7 +272,7 @@ u32 vg_kv_child( vg_kvs *kvs, u32 root_offset, u32 index )
    else return 0;
 }
 
-u32 vg_kv_find( vg_kvs *kvs, u32 root_offset, const char *key )
+u32 vg_kv_find( vg_kvs *kvs, u32 root_offset, c8 *key )
 {
    u32 hash = vg_strdjb2( key );
    u32 child_offset = vg_kv_child( kvs, root_offset, 0 );
@@ -277,11 +280,11 @@ u32 vg_kv_find( vg_kvs *kvs, u32 root_offset, const char *key )
    {
       vg_kv *kv = vg_stack_pointer( kvs->stack, child_offset );
       u32 key_length;
-      const char *child_key = vg_kv_key( kvs, child_offset, &key_length );
+      c8 *child_key = vg_kv_key( kvs, child_offset, &key_length );
       if( ((kv->key_info ^ hash) & 0xFFFFF) == 0 )
       {
          u32 key_length;
-         const char *child_key = vg_kv_key( kvs, child_offset, &key_length );
+         c8 *child_key = vg_kv_key( kvs, child_offset, &key_length );
          if( child_key )
          {
             for( u32 i=0; i<key_length; i ++ )
@@ -303,7 +306,7 @@ static void vg_kv_write_indent( vg_kv_write *w )
       fputc( ' ', w->fp );
 }
 
-static void vg_kv_write_string( vg_kv_write *w, const char *string, u32 length )
+static void vg_kv_write_string( vg_kv_write *w, c8 *string, u32 length )
 {
    if( length == 0 )
       length = 0xffffffff;
@@ -338,7 +341,7 @@ static void vg_kv_write_string( vg_kv_write *w, const char *string, u32 length )
    if( delim ) fputc( delim, w->fp );
 }
 
-void vg_kv_write_block( vg_kv_write *w, const char *name, u32 name_length )
+void vg_kv_write_block( vg_kv_write *w, c8 *name, u32 name_length )
 {
    vg_kv_write_indent( w );
    if( name )
@@ -361,7 +364,7 @@ void vg_kv_end_block( vg_kv_write *w )
    fputc( '\n', w->fp );
 }
 
-void vg_kv_write_kv( vg_kv_write *w, const char *key, u32 key_len, const char *value, u32 value_len )
+void vg_kv_write_kv( vg_kv_write *w, c8 *key, u32 key_len, c8 *value, u32 value_len )
 {
    vg_kv_write_indent( w );
    vg_kv_write_string( w, key, key_len );
@@ -387,7 +390,7 @@ void vg_kv_print_tree( vg_kv_write *w, vg_kvs *kvs, u32 root_offset )
    VG_ASSERT( vg_kv_type( kvs, root_offset ) == 0x0 );
 
    u32 root_len;
-   const char *root_str = vg_kv_key( kvs, root_offset, &root_len );
+   c8 *root_str = vg_kv_key( kvs, root_offset, &root_len );
    vg_kv_write_block( w, root_str, root_len );
 
    u32 child_offset = vg_kv_child( kvs, root_offset, 0 );
@@ -398,10 +401,10 @@ void vg_kv_print_tree( vg_kv_write *w, vg_kvs *kvs, u32 root_offset )
       else
       {
          u32 key_len;
-         const char *key_str = vg_kv_key( kvs, child_offset, &key_len );
+         c8 *key_str = vg_kv_key( kvs, child_offset, &key_len );
 
          u32 value_len;
-         const char *value_str = vg_kv_value( kvs, child_offset, &value_len );
+         c8 *value_str = vg_kv_value( kvs, child_offset, &value_len );
 
          if( key_str && value_str )
             vg_kv_write_kv( w, key_str, key_len, value_str, value_len );

diff --git a/vg_kv.h b/vg_kv.h
index 2ddd5f2d46856079e94f3ac64eeb4b6bbd6dbcf4..8976caa9072bb6d27496aed1521781d605bc4e2a 100644 (file)
--- a/vg_kv.h
+++ b/vg_kv.h
@@ -4,7 +4,7 @@
 
 #define VG_KV_PAGE_COUNT 32
 
-/* define VG_KV_SUPPORT_LEGACY_MSG to automatically convert from old vg_msg stream to plain text KVs */
+/* define VG_MSG_TO_KVS to automatically convert from old vg_msg stream to plain text KVs */
 
 typedef struct vg_kv vg_kv;
 typedef struct vg_kvs vg_kvs;
@@ -19,8 +19,8 @@ void vg_kvs_init( vg_kvs *kvs, vg_stack_allocator *stack );
  * 
  * vg_kv_parse_buffer takes a text buffer, if its null terminated, buffer_length can be 0
  */
-void vg_kv_parser_init( vg_kv_parser *parser, vg_kvs *out_kvs );
-void vg_kv_parse_buffer( vg_kv_parser *parser, const char *buffer, u32 buffer_length );
+void vg_kv_parser_init( vg_kv_parser *parser, vg_kvs *out_kvs, u32 root_offset );
+void vg_kv_parse_buffer( vg_kv_parser *parser, c8 *buffer, u32 buffer_length );
 void vg_kv_link( vg_kv_parser *parser, u32 offset, u32 depth );
 
 /* returns the type of this KV.
@@ -30,13 +30,13 @@ void vg_kv_link( vg_kv_parser *parser, u32 offset, u32 depth );
 u32 vg_kv_type( vg_kvs *kvs, u32 kv_offset );
 
 /* get key / values associated with KV pair or only key for a frame. */
-const char *vg_kv_key( vg_kvs *kvs, u32 kv_offset, u32 *out_length );
-const char *vg_kv_value( vg_kvs *kvs, u32 kv_offset, u32 *out_length );
+c8 *vg_kv_key( vg_kvs *kvs, u32 kv_offset, u32 *out_length );
+c8 *vg_kv_value( vg_kvs *kvs, u32 kv_offset, u32 *out_length );
 
 /* get the child KV at index, returns 0 if out of range */
 u32 vg_kv_child( vg_kvs *kvs, u32 root_offset, u32 index );
 u32 vg_kv_next( vg_kvs *kvs, u32 kv_offset );
-u32 vg_kv_find( vg_kvs *kvs, u32 root_offset, const char *key );
+u32 vg_kv_find( vg_kvs *kvs, u32 root_offset, c8 *key );
 
 /* editing kvs
  *  if value is NULL, it appends a named frame
@@ -44,12 +44,12 @@ u32 vg_kv_find( vg_kvs *kvs, u32 root_offset, const char *key );
  *  if both key and value are set, it appends a KV pair
  *  returns the new KV offset
  */
-u32 vg_kv_append( vg_kvs *kvs, u32 parent_offset, const char *key, const char *value );
+u32 vg_kv_append( vg_kvs *kvs, u32 parent_offset, c8 *key, c8 *value );
 
 /* Writing KV files. w should be initialized with depth 0, and fp to a valid C stream pointer */
-void vg_kv_write_block( vg_kv_write *w, const char *name, u32 name_length );
+void vg_kv_write_block( vg_kv_write *w, c8 *name, u32 name_length );
 void vg_kv_end_block( vg_kv_write *w );
-void vg_kv_write_kv( vg_kv_write *w, const char *key, u32 key_len, const char *value, u32 value_len );
+void vg_kv_write_kv( vg_kv_write *w, c8 *key, u32 key_len, c8 *value, u32 value_len );
 
 /* Just for analysis */
 void vg_kv_parser_print_info( vg_kv_parser *parser );
@@ -64,8 +64,8 @@ struct vg_kv_parser
    u32 stat_memory_strings,
        stat_source_characters;
 
-   char token0_deliminator;
-   char *token0_buffer;
+   c8 token0_deliminator;
+   c8 *token0_buffer;
    u32 depth;
 
    struct

diff --git a/vg_msg.c b/vg_msg.c
index 3edea5bf50e2c60c4a70a318dbd72c39ed541c44..35a937c51b271f2c83e98c8d6bbd7f75a98a34e1 100644 (file)
--- a/vg_msg.c
+++ b/vg_msg.c
@@ -4,6 +4,7 @@
 #include <string.h>
 #include <stdio.h>
 
+#if !defined( VG_MSG_TO_KVS )
 /* write a buffer from msg, rang checked. */
 void vg_msg_wbuf( vg_msg *msg, u8 *buf, u32 len )
 {
@@ -17,6 +18,7 @@ void vg_msg_wbuf( vg_msg *msg, u8 *buf, u32 len )
       msg->buf[ msg->cur.co ++ ] = buf[i];
    }
 }
+#endif
 
 /* read a buffer from msg, rang checked. */
 void vg_msg_rbuf( vg_msg *msg, u8 *buf, u32 len )
@@ -32,6 +34,7 @@ void vg_msg_rbuf( vg_msg *msg, u8 *buf, u32 len )
    }
 }
 
+#if !defined( VG_MSG_TO_KVS )
 /* write null terminated string to stream */
 void vg_msg_wstr( vg_msg *msg, const char *str )
 {
@@ -41,6 +44,7 @@ void vg_msg_wstr( vg_msg *msg, const char *str )
       if( !str[i] ) break;
    }
 }
+#endif
 
 /* read null terminated string, range check and generate hash (djb2) */
 const char *vg_msg_rstr( vg_msg *msg, u32 *djb2 )
@@ -62,6 +66,7 @@ const char *vg_msg_rstr( vg_msg *msg, u32 *djb2 )
    return str;
 }
 
+#if !defined( VG_MSG_TO_KVS )
 /* begin a new frame in message stream */
 void vg_msg_frame( vg_msg *msg, const char *name )
 {
@@ -100,6 +105,7 @@ void vg_msg_wkvbin( vg_msg *msg, const char *key, u8 *bin, u32 len )
    vg_msg_wbuf( msg, (u8 *)(&len), 4 );
    vg_msg_wbuf( msg, bin, len );
 }
+#endif
 
 u32 vg_msg_cmd_array_count( u8 code )
 {
@@ -123,6 +129,7 @@ u8 vg_msg_count_bits( u32 count )
    return ((count-1)<<2);
 }
 
+#if !defined( VG_MSG_TO_KVS )
 /* write a sized type */
 void vg_msg_wkvnum( vg_msg *msg, const char *key, u8 type, u8 count, void *data )
 {
@@ -131,6 +138,7 @@ void vg_msg_wkvnum( vg_msg *msg, const char *key, u8 type, u8 count, void *data
    vg_msg_wstr( msg, key );
    vg_msg_wbuf( msg, data, vg_msg_cmd_bytecount(code) );
 }
+#endif
 
 void vg_msg_init( vg_msg *msg, u8 *buffer, u32 len )
 {
@@ -210,6 +218,7 @@ int vg_msg_next( vg_msg *msg, vg_msg_cmd *cmd )
       return 1;
 }
 
+#if !defined( VG_MSG_TO_KVS )
 /* move through the frame(and subframes) until we fall out of it */
 int vg_msg_skip_frame( vg_msg *msg )
 {
@@ -249,6 +258,7 @@ int vg_msg_seekframe( vg_msg *msg, const char *name )
    msg->cur = orig;
    return 0;
 }
+#endif
 
 /* 
  * Convert any type integral type to u64
@@ -317,6 +327,7 @@ f64 vg_msg_cast_to_f64( const void *src, u8 src_base, u8 src_size )
       return (f64)vg_msg_cast_to_i64( src, src_base, src_size );
 }
 
+#if !defined( VG_MSG_TO_KVS )
 /*
  * Convert any full integral type code to another
  * Passing in non-integral codes is undefined
@@ -362,6 +373,7 @@ void vg_msg_cast( const void *src, u8 src_code, void *dst, u8 dst_code )
       }
    }
 }
+#endif
 
 /*
  * search in current level from cursor, to find kv cmd
@@ -391,6 +403,7 @@ int vg_msg_getkvcmd( vg_msg *msg, const char *key, vg_msg_cmd *cmd )
    return 0;
 }
 
+#if !defined( VG_MSG_TO_KVS )
 /*
  * Read a integral KV out to dst, and perform conversion if needed
  * dst is always defined, if its not found its set to 0
@@ -423,7 +436,9 @@ const char *vg_msg_getkvstr( vg_msg *msg, const char *key )
    else 
       return NULL;
 }
+#endif
 
+#if !defined( VG_MSG_TO_KVS )
 int vg_msg_getkvvecf( vg_msg *msg, const char *key, u8 type, 
                       void *v, void *default_value )
 {
@@ -508,10 +523,11 @@ void vg_msg_print( vg_msg *msg, u32 len )
       }
    }
 }
+#endif
 
-#ifdef VG_LEGACY_MSG_TO_KVS
+#if defined( VG_MSG_TO_KVS )
 #include "vg_kv.h"
-void vg_kvs_append_from_legacy_msg2( vg_kvs *kvs, u32 root, void *buffer, u32 len, vg_stack_allocator *stack )
+bool vg_kvs_append_from_legacy_msg2( vg_kvs *kvs, u32 root, void *buffer, u32 len, vg_stack_allocator *stack )
 {
    vg_msg b;
    vg_msg_init( &b, buffer, len );
@@ -574,9 +590,15 @@ void vg_kvs_append_from_legacy_msg2( vg_kvs *kvs, u32 root, void *buffer, u32 le
                if( i+1!=count )
                   vg_strcatch( &format_str, ' ' );
             }
+
+            if( !vg_strgood( &value_str ) )
+               return 0;
+
             vg_kv_append( kvs, frame_stack[frame_depth], cmd.key, formatted );
          }
       }
    }
+
+   return 1;
 }
 #endif