Some more string stuff yay

diff --git a/vg_build.h b/vg_build.h
index 4063e1a2c0c95d82b9a03666674adfcf494207a6..ccf93e96fd4b56a3e8fce66756804c7258deb3d4 100644 (file)
--- a/vg_build.h
+++ b/vg_build.h
@@ -287,7 +287,7 @@ vg_compiler_run( struct vg_project *project,
    if( env->optimization )
    {
       vg_strcat( &cmd, "  -O" );
-      vg_strcati32( &cmd, env->optimization );
+      vg_strcati64( &cmd, env->optimization, 10 );
    }
    else 
    {

diff --git a/vg_msg.c b/vg_msg.c
index d50a11b47b824f923a872144d84045f5cd08d294..3edea5bf50e2c60c4a70a318dbd72c39ed541c44 100644 (file)
--- a/vg_msg.c
+++ b/vg_msg.c
@@ -549,33 +549,30 @@ void vg_kvs_append_from_legacy_msg2( vg_kvs *kvs, u32 root, void *buffer, u32 le
                 count = vg_msg_cmd_array_count( cmd.code ),
                 size = vg_msg_cmd_type_size( cmd.code );
             c8 formatted[ 1024 ];
-            formatted[0] = '\0';
+            vg_str value_str;
+            vg_strnull( &value_str, formatted, sizeof(formatted) );
+
             for( u32 i=0; i<count; i++ )
             {
-               const c8 *end = (i+1==count)?"":" ";
                const void *p = cmd.value + size*i;
                if( base == k_vg_msg_unsigned )
                {
-                  snprintf( formatted, 1024, "%s"
-#ifdef _WIN32
-                  "%llu%s"
-#else
-                  "%lu%s"
-#endif
-                  , formatted, vg_msg_cast_to_u64( p, base, size ), end );
+                  u64 val = vg_msg_cast_to_u64( p, base, size );
+                  vg_strcatu64_internal( &value_str, val, 10, 0 );
                }
                else if( base == k_vg_msg_signed )
                {
-                  snprintf( formatted, 1024, "%s"
-#ifdef _WIN32
-                  "%lld%s"
-#else
-                  "%ld%s"
-#endif
-                  , formatted, vg_msg_cast_to_i64( p, base, size ), end );
+                  i64 val = vg_msg_cast_to_i64( p, base, size );
+                  vg_strcati64( &value_str, val, 10, 0 );
                }
                else 
-                  snprintf( formatted, 1024, "%s%f%s", formatted, vg_msg_cast_to_f64( p, base, size ), end );
+               {
+                  f64 val = vg_msg_cast_to_f64( p, base, size );
+                  vg_strcatf64( &value_str, val, 10, 0 );
+               }
+
+               if( i+1!=count )
+                  vg_strcatch( &format_str, ' ' );
             }
             vg_kv_append( kvs, frame_stack[frame_depth], cmd.key, formatted );
          }

diff --git a/vg_string.c b/vg_string.c
index 518f2a6f935bae6d5e76c3d11d803a1b9bbe626e..60a82d05322696afb031d18ed3d0f20e3eda7db6 100644 (file)
--- a/vg_string.c
+++ b/vg_string.c
@@ -124,54 +124,6 @@ void vg_strcatch( vg_str *str, char c )
    str->i --;
 }
 
-/* 
- * FIXME: Negative numbers
- */
-void vg_strcati32( vg_str *str, i32 value ){ vg_strcatu64( str, (u64)value, 10 ); }
-void vg_strcatu64( vg_str *str, u64 value, u64 base )
-{
-   const char *digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-   if( value )
-   {
-      char temp[32];
-      int i=0;
-      while( value && (i<31) )
-      {
-         u32 digit = (u32)(value % base);
-         temp[ i ++ ] = digits[digit];
-         value /= base;
-      }
-
-      char reverse[32];
-      for( int j=0; j<i; j ++ )
-         reverse[j] = temp[ i-1-j ];
-      reverse[i] = '\0';
-      vg_strcat( str, reverse );
-   }
-   else
-      vg_strcat( str, "0" );
-}
-
-void vg_strcati32r( vg_str *str, i32 value, i32 n, char alt )
-{
-   char temp[32];
-   i32 i=0;
-   while( value )
-   {
-      if( i>=n ) 
-         break;
-
-      temp[ n-1 - (i ++) ] = '0' + (value % 10);
-      value /= 10;
-   }
-
-   for( ;i<n; i ++ )
-      temp[ n-1 - i ] = alt;
-
-   temp[n]='\0';
-   vg_strcat( str, temp );
-}
-
 int vg_strgood( vg_str *str )
 {
    if( str->i == -1 ) return 0;
@@ -492,32 +444,80 @@ vg_strp_info vg_strp_f64( vg_strp *p, f64 *value )
    return (got||got_decimal)? info: k_vg_strp_eof;
 }
 
-void vg_strcatu64_internal( vg_str *str, u64 value, u64 base, u32 max_numbers )
+static u32 vg_strcatu64_internal( c8 reverse_buffer[64], u64 value, u64 base, u32 max_characters )
 {
-   const char *digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+   VG_ASSERT( base >= 2 );
+
+   if( max_characters == 0 )
+      max_characters = 64;
+
+   const c8 *digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    if( value )
    {
-      char temp[32];
-      int i=0;
-      while( value && (i<max_numbers) )
+      u32 i = 0;
+      while( value && (i<max_characters) )
       {
-         u32 digit = (u32)(value % base);
-         temp[ i ++ ] = digits[digit];
+         reverse_buffer[ i ++ ] = digits[ (u32)(value % base) ];
          value /= base;
       }
-
-      char reverse[32];
-      for( int j=0; j<i; j ++ )
-         reverse[j] = temp[ i-1-j ];
-      reverse[i] = '\0';
-      vg_strcat( str, reverse );
+      return i;
    }
    else
-      vg_strcat( str, "0" );
+   {
+      reverse_buffer[0] = digits[0];
+      return 1;
+   }
+}
+
+void vg_strcati64r( vg_str *str, i64 value, u64 base, u32 width, c8 blank_character )
+{
+   VG_ASSERT( base >= 2 );
+
+   c8 temp[65];
+   u32 digits = vg_strcatu64_internal( temp, value<0? -value: value, base, 0 );
+   if( value < 0 )
+      temp[ digits ++ ] = '-';
+   
+   u32 padding = 0;
+   if( digits > width ) 
+      padding = 0;
+   else
+      padding = width - digits;
+
+   for( u32 i=0; i<padding; i ++ )
+      vg_strcatch( str, blank_character );
+
+   for( u32 i=0; i<digits; i ++ )
+      vg_strcatch( str, temp[ digits -1 -i ] );
+}
+
+void vg_strcatu64( vg_str *str, u64 value, u64 base )
+{
+   VG_ASSERT( base >= 2 );
+
+   c8 temp[64];
+   u32 digits = vg_strcatu64_internal( temp, value, base, 0 );
+   for( u32 i=0; i<digits; i ++ )
+      vg_strcatch( str, temp[ digits -1 -i ] );
+}
+
+void vg_strcati64( vg_str *str, i64 value, u64 base )
+{
+   VG_ASSERT( base >= 2 );
+
+   if( value < 0 )
+   {
+      vg_strcatch( str,'-' );
+      value = -value;
+   }
+   vg_strcatu64( str, value, base );
 }
 
 void vg_strcatf64( vg_str *str, f64 value, u64 base, u32 decimal_places )
 {
+   VG_ASSERT( decimal_places );
+   VG_ASSERT( base >= 2 );
+
    if( value < 0.0 ) 
    {
       value = -value;
@@ -531,7 +531,11 @@ void vg_strcatf64( vg_str *str, f64 value, u64 base, u32 decimal_places )
    u64 decimal_part = (u64)((f64)m * value + 0.5),
        normal_part  = (u64)value;
 
-   vg_strcatu64_internal( str, normal_part, base, 31 );
+   vg_strcatu64( str, normal_part, base );
    vg_strcat( str, "." );
-   vg_strcatu64_internal( str, decimal_part, base, decimal_places );
+
+   c8 temp[64];
+   u32 digits = vg_strcatu64_internal( temp, decimal_part, base, decimal_places );
+   for( u32 i=0; i<digits; i ++ )
+      vg_strcatch( str, temp[ digits -1 -i ] );
 }

diff --git a/vg_string.h b/vg_string.h
index 70c44078f7184fdeddf71d95197f3851bf041387..1590b985ed6ea0eb58a667bbc8411a2577dc1e94 100644 (file)
--- a/vg_string.h
+++ b/vg_string.h
@@ -40,9 +40,13 @@ void vg_strcatf( vg_str *str, const char *fmt, ... );
  * Append character to vg_str 
  */
 void vg_strcatch( vg_str *str, char c );
+
+/* Print various data types onto vg_str */
+void vg_strcati64r( vg_str *str, i64 value, u64 base, u32 width, c8 blank_character );
 void vg_strcatu64( vg_str *str, u64 value, u64 base );
-void vg_strcati32( vg_str *str, i32 value );
-void vg_strcati32r( vg_str *str, i32 value, i32 n, char alt );
+void vg_strcati64( vg_str *str, i64 value, u64 base );
+void vg_strcatf64( vg_str *str, f64 value, u64 base, u32 decimal_places );
+
 /*
  * Returns 1 if string did not overflow while building
  */