ksprintf

src/DtsodParser/DtsodV24_deserialize.c

@@ -44,16 +44,10 @@ Maybe ERROR_WRONGCHAR(const char c, char* _text, char* text_first, const char* s
         if(!_c) break;
     }
     char errmsg[1024];
-    IFMSC(
+    ksprintf(errmsg,1024, "unexpected <%c> at:\n"
-        sprintf_s(errmsg,1024, "unexpected <%c> at:\n"
                     "  \"%s\"\n"
                     "\\___[%s:%d] %s()", 
-                        c,errBuf, srcfile,line,funcname),
+                    c,errBuf, srcfile,line,funcname);
-        sprintf(errmsg, "unexpected <%c> at:\n"
-                        "  \"%s\"\n"
-                        " \\___[%s:%d] %s()", 
-                        c,errBuf, srcfile,line,funcname)
-    );
     safethrow(errmsg,;);
 }
 #define safethrow_wrongchar(C, freeMem) { freeMem; return ERROR_WRONGCHAR(C, text, shared->sh_text_first, __FILE__,__LINE__,__func__); }
@@ -192,10 +186,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
             char* _c=string_extract(str);
             if(sscanf(_c, IFWIN("%llu", "%lu"), &lu)!=1){
                 char err[64];
-                IFMSC(
+                ksprintf(err,64,"can't parse to int: <%s>",_c);
-                    sprintf_s(err,64,"can't parse to int: <%s>",_c),
-                    sprintf(err,"can't parse to int: <%s>",_c)
-                );
                 safethrow(err,free(_c));
             }
             free(_c);
@@ -208,10 +199,7 @@ Maybe __ParseValue(DeserializeSharedData* shared, string str){
             char* _c=string_extract(str);
             if(sscanf(_c, IFWIN("%lli", "%li"), &li)!=1){
                 char err[64];
-                IFMSC(
+                ksprintf(err,64,"can't parse to int: <%s>",_c);
-                    sprintf_s(err,64,"can't parse to int: <%s>",_c),
-                    sprintf(err,"can't parse to int: <%s>",_c)
-                );
                 safethrow(err,free(_c));
             }
             free(_c);

src/Filesystem/dir.c

@@ -36,9 +36,7 @@ Maybe dir_create(const char* path){
 #endif
     {
         char err[512];
-        IFWIN(
+        ksprintf(err, 512, "can't create dicectory <%s>", path);
-            sprintf_s(err, 512, "can't create dicectory <%s>", path),
-            sprintf(err, "can't create dicectory <%s>", path));
         safethrow(err,;);
     }
 

src/Filesystem/path.c

@@ -25,12 +25,12 @@ char* __path_concat(u32 n, ...){
     // copying content of all strings to result
     u16 k=0;
     for(; k<n-1; k++){
-        memcopy(parts[k], totality, lengths[k]);
+        memcpy(totality, parts[k], lengths[k]);
         totality+=lengths[k];
         *totality=path_sep;
         totality++;
     }
-    memcopy(parts[k], totality, lengths[k]);
+    memcpy(totality, parts[k], lengths[k]);
 
     free(parts);
     free(lengths);

src/Network/network_types.c

@@ -42,8 +42,7 @@ Maybe knIPV4Address_fromStr(char* addrStr, knIPV4Address* addrVal){
             default:
                 u32 errmsgL=cptr_length(addrStr) + 80;
                 char* errmsg=malloc(errmsgL);
-                IFMSC(sprintf_s(errmsg, errmsgL, "wrong ip address string: %s\n   %s", addrStr_src, errmsg_extra), 
+                ksprintf(errmsg, errmsgL, "wrong ip address string: %s\n   %s", addrStr_src, errmsg_extra);
-                      sprintf(  errmsg,          "wrong ip address string: %s\n   %s", addrStr_src, errmsg_extra));
                 safethrow(errmsg,;);
                 break;
         }

src/String/StringBuilder.c

@@ -139,9 +139,6 @@ void StringBuilder_append_u64(StringBuilder* b, u64 a){
 void StringBuilder_append_f64(StringBuilder* b, f64 a){
     try_complete_buf(b);
     char buf[32];
-    IFMSC(
+    ksprintf(buf,32,"%lf",a);
-        sprintf_s(buf,32,"%lf",a),
-        sprintf(buf,"%lf",a)
-    );
     curr_buf_add_string(b, (string){.ptr=buf, .length=cptr_length(buf)});
 }

src/base/cptr.c

@@ -131,13 +131,6 @@ i32 cptr_seekCharReverse(const char* src, char fragment, u32 startIndex, u32 see
     return -1;
 }
 
-void memcopy(void* from, void* to, u32 size){
-    if(from==NULL || to==NULL)
-        throw(ERR_NULLPTR);
-    for(u32 i=0; i<size; i++)
-        ((char*)to)[i]=((char*)from)[i];
-}
-
 char* __cptr_concat(u32 n, ...){
     char** strs=(char**)malloc(n*sizeof(char*));
     u32* lengths=malloc(n*sizeof(u32));
@@ -162,7 +155,7 @@ char* __cptr_concat(u32 n, ...){
     
     // copying content of all strings to result
     for(u16 k=0; k<n; k++){
-        memcopy(strs[k], totality, lengths[k]);
+        memcpy(totality, strs[k], lengths[k]);
         totality+=lengths[k];
     }
     

src/base/cptr.h

@@ -66,8 +66,6 @@ static inline bool cptr_contains(const char* src, const char* fragment){
     return cptr_seek(src, fragment, 0, -1) +1;
 }
 
-void memcopy(void* from, void* to, u32 size);
-
 char* __cptr_concat(u32 n, ...);
 #define cptr_concat(STR...) __cptr_concat(count_args(STR), STR)
 

src/base/errors.c

@@ -1,7 +1,4 @@
-#include "std.h"
+#include "base.h"
-#include "errors.h"
-#include "cptr.h"
-#include "../kprint/kprintf.h"
 
 char* errname(ErrorId err){
     switch(err){
@@ -21,25 +18,19 @@ char* errname(ErrorId err){
     }
 }
 
-#define ERRMSG_MAXLENGTH 1024
+#define ERRMSG_MAXLENGTH 4096
 
 char* __genErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){
     size_t bufsize=ERRMSG_MAXLENGTH;
     char* result=malloc(bufsize);
-    IFMSC(
+    ksprintf(result,bufsize,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg);
-        sprintf_s(result,bufsize,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg),
-        sprintf(result,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg)
-    );
     return result;
 }
 
 char* __extendErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){
     size_t bufsize=cptr_length(errmsg)+ERRMSG_MAXLENGTH;
     char* result=malloc(bufsize);
-    IFMSC(
+    ksprintf(result,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname);
-        sprintf_s(result,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname),
-        sprintf(result,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname)
-    );
     free(errmsg);
     return result;
 }

src/base/std.h

@@ -14,6 +14,7 @@ extern "C" {
 #include <setjmp.h>
 #include <signal.h>
 #include <math.h>
+#include <string.h>
 
 typedef int8_t i8;
 typedef uint8_t u8;

src/base/type_system/base_toString.c

@@ -70,10 +70,7 @@ char* toString_u64(u64 n, bool withPostfix, bool uppercase){
         throw("too big precision"); \
     if(precision==0) \
         precision=toString_float_default_precision; \
-    i32 cn=IFMSC( \
+    i32 cn = sprintf_s(str, bufsize, "%.*f", precision, n); \
-        sprintf_s(str, bufsize, "%.*f", precision, n), \
-        sprintf(str, "%.*f", precision, n) \
-    ); \
     /* remove trailing zeroes except .0*/ \
     while(str[cn-1]=='0' && str[cn-2]!='.') \
         cn--; \

src/kprint/kprintf.c

@@ -45,91 +45,86 @@ WORD unixColorToWin(u8 c){
 }
 #endif
 
-void kprintf(const char* format, ...){
+i32 kprintf(const char* format, ...){
     va_list vl;
     va_start(vl, format);
-    u32 i=0;
+    i32 i = 0;
-    for(char c=format[i++]; c!=0; c=format[i++]){
+    for(char c = format[i++]; c != 0; c = format[i++]){
         // value format specifiers
-        if(c=='%'){
+        if(c == '%'){
-            char* argstr=NULL;
+            char* argstr = NULL;
-            bool l=false;
+            bool l = false;
-            c=format[i++];
+            c = format[i++];
             format_escape_seq:
             switch (c) {
                 case 'u':
-                    argstr=toString_u64(
+                    argstr = toString_u64(
                         l ? va_arg(vl, u64) : va_arg(vl, u32)
                         ,0,0);
                     break;
                 case 'i': case 'd':
-                    argstr=toString_i64(
+                    argstr = toString_i64(
                         l ? va_arg(vl, i64) : va_arg(vl, i32)
                         );
                     break;
                 case 'f':
                     // f32 is promoted to f64 when passed through '...'
-                    argstr=toString_f64(va_arg(vl, f64), toString_float_default_precision,0,0);
+                    argstr = toString_f64(va_arg(vl, f64), toString_float_default_precision,0,0);
                     break;
                case 'l':
-                    l=true;
+                    l = true;
-                    if((c=format[i++]))
+                    if((c = format[i++]))
                         goto format_escape_seq;
                     break;
                 case 'p': ;
-                    void* phex=va_arg(vl, void*);
+                    void* phex = va_arg(vl, void*);
-                    argstr=toString_hex(&phex,getEndian()==LittleEndian,sizeof(phex),1,0);
+                    argstr = toString_hex(&phex,getEndian() == LittleEndian,sizeof(phex),1,0);
                     break;
                 case 'x': ;
                     if(l){
-                        u64 xhex=va_arg(vl, u64);
+                        u64 xhex = va_arg(vl, u64);
-                        argstr=toString_hex(&xhex,getEndian()==LittleEndian,sizeof(xhex),0,1);
+                        argstr = toString_hex(&xhex,getEndian() == LittleEndian,sizeof(xhex),0,1);
                     }
                     else {
-                        u32 xhex=va_arg(vl, u32);
+                        u32 xhex = va_arg(vl, u32);
-                        argstr=toString_hex(&xhex,getEndian()==LittleEndian,sizeof(xhex),0,1);
+                        argstr = toString_hex(&xhex,getEndian() == LittleEndian,sizeof(xhex),0,1);
                     }
                     break;
                 case 's': ;
-                    char* cptr=va_arg(vl,char*);
+                    char* cptr = va_arg(vl,char*);
                     if(!cptr)
-                        cptr="<nullstr>";
+                        cptr = "<nullstr>";
                     if(*cptr)
                         fputs(cptr, stdout);
                     break;
                 case 'c':
-                    argstr=malloc(2);
+                    putc((char)va_arg(vl,int), stdout);
-                    argstr[0]=(char)va_arg(vl,int);
-                    argstr[1]=0;
                     break;
                 default:
-                    putc('\n',stdout);
+                    fputs("<INCORRECT FORMAT STRING>", stdout);
-                    putc('<',stdout);
+                    return kprintf_INVALID_FORMAT;
-                    putc(c,stdout);
-                    putc('>',stdout);
-                    throw(ERR_FORMAT);
             }
             if(argstr){
                 fputs(argstr, stdout);
                 free(argstr);
             }
         }
+        
         // escape sequences 
-        else if(c=='\e'){
+        else if(c == '\e'){
-            IFWIN(
+            //////////////////// WINDOWS ////////////////////
-                /* WINDOWS */
+            #if defined(_WIN64) || defined(_WIN32)
-                ({
+                if((c = format[i++]) == '['){
-                    if((c=format[i++])=='['){
+                    u8 colorUnix = 0;
-                        u8 colorUnix=0;
+                    for(i8 n = 0; n<6 && c != 0; n++){
-                        for(i8 n=0; n<6 && c!=0; n++){
+                        c = format[i++];
-                            c=format[i++];
                         switch (c){
                             case '0': case '1': case '2': case '3': case '4':
                             case '5': case '6': case '7': case '8': case '9':
-                                    colorUnix=colorUnix*10+c-'0';
+                                colorUnix = colorUnix*10+c-'0';
                                 break;
                             case 'm': ;
-                                    WORD colorWin=unixColorToWin(colorUnix);
+                                WORD colorWin = unixColorToWin(colorUnix);
                                 HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
                                 SetConsoleTextAttribute(hConsole, colorWin);
                                 goto end_iteration;
@@ -138,11 +133,12 @@ void kprintf(const char* format, ...){
                         }
                     }
                 }
-                }),
+            ////////////////////// UNIX //////////////////////
-                /* UNIX */
+            #else
                 putc(c,stdout);
-            );
+            #endif
         }
+        
         // common characters 
         else {
             putc(c,stdout);
@@ -152,4 +148,108 @@ void kprintf(const char* format, ...){
         #endif
     }
     va_end(vl);
+    return i;
+}
+
+
+i32 ksprintf(char* buffer, i32 buffer_size, const char* format, ...){
+    if(buffer ==  NULL)
+        return kprintf_BUFFER_IS_NULL;
+
+    va_list vl;
+    va_start(vl, format);
+    i32 i = 0;
+    i32 written = 0;
+    for(char c = format[i++]; c != 0; c = format[i++]){
+        // value format specifiers
+        if(c == '%'){
+            char* argstr = NULL;
+            bool l = false;
+            c = format[i++];
+            format_escape_seq:
+            switch (c) {
+                case 'u':
+                    argstr = toString_u64(
+                        l ? va_arg(vl, u64) : va_arg(vl, u32)
+                        ,0,0);
+                    break;
+                case 'i': case 'd':
+                    argstr = toString_i64(
+                        l ? va_arg(vl, i64) : va_arg(vl, i32)
+                        );
+                    break;
+                case 'f':
+                    // f32 is promoted to f64 when passed through '...'
+                    argstr = toString_f64(va_arg(vl, f64), toString_float_default_precision,0,0);
+                    break;
+               case 'l':
+                    l = true;
+                    if((c = format[i++]))
+                        goto format_escape_seq;
+                    break;
+                case 'p': ;
+                    void* phex = va_arg(vl, void*);
+                    argstr = toString_hex(&phex,getEndian() == LittleEndian,sizeof(phex),1,0);
+                    break;
+                case 'x': ;
+                    if(l){
+                        u64 xhex = va_arg(vl, u64);
+                        argstr = toString_hex(&xhex,getEndian() == LittleEndian,sizeof(xhex),0,1);
+                    }
+                    else {
+                        u32 xhex = va_arg(vl, u32);
+                        argstr = toString_hex(&xhex,getEndian() == LittleEndian,sizeof(xhex),0,1);
+                    }
+                    break;
+                case 's': ;
+                    char* cptr = va_arg(vl,char*);
+                    if(!cptr)
+                        cptr = "<nullstr>";
+                    if(*cptr){
+                        i32 str_length = cptr_length(cptr);
+                        if(written + str_length > buffer_size)
+                            return kprintf_BUFFER_IS_TOO_SMALL;
+                        
+                        memcpy(buffer + written, cptr, str_length);
+                        written += str_length;
+                    }
+                    break;
+                case 'c': ;
+                    char ch = (char)va_arg(vl,int);
+                    if(written > buffer_size)
+                        return kprintf_BUFFER_IS_TOO_SMALL;
+                    
+                    buffer[written++] = ch;
+                    break;
+                default:
+                    const char errformat_str[] = "<INCORRECT FORMAT STRING>";
+                    if(written + (i32)sizeof(errformat_str) <= buffer_size)
+                        memcpy(buffer + written, errformat_str, sizeof(errformat_str));
+                    return kprintf_INVALID_FORMAT;
+            }
+            if(argstr){
+                i32 str_length = cptr_length(argstr);
+                if(written + str_length > buffer_size)
+                    return kprintf_BUFFER_IS_TOO_SMALL;
+                
+                memcpy(buffer + written, argstr, str_length);
+                written += str_length;
+                free(argstr);
+            }
+        }
+        
+        // common characters 
+        else {
+            if(written > buffer_size)
+                return kprintf_BUFFER_IS_TOO_SMALL;
+            
+            buffer[written++] = c;
+        }
+    }
+    
+    va_end(vl);
+    if(written > buffer_size)
+        return kprintf_BUFFER_IS_TOO_SMALL;
+    buffer[written] = '\0';
+    return i;
 }

src/kprint/kprintf.h

@@ -6,8 +6,17 @@ extern "C" {
 
 #include "../base/type_system/base_toString.h"
 
-// cross-platform printf analog
+#define kprintf_INVALID_FORMAT -1
-void kprintf(const char* format, ...);
+#define kprintf_BUFFER_IS_NULL -2
+#define kprintf_BUFFER_IS_TOO_SMALL -3
+
+/// cross-platform printf analog
+///@return number of processed format string characters or error code
+i32 kprintf(const char* format, ...);
+
+/// @return number of processed format string characters or error code
+i32 ksprintf(char* buffer, i32 buffer_size, const char* format, ...);
+
 
 // printf format terminal color sequence
 #define _PRINTF_COLOR(N) "\e["#N"m"

tests/test_hashtable.c

@@ -38,10 +38,7 @@ void printrowgraph(Hashtable* ht){
 
 char* genkey(u32 i){
     char* key=malloc(12);
-    IFMSC(
+    ksprintf(key,12,"key_%u",i);
-        sprintf_s(key,12,"key_%u",i),
-        sprintf(key,"key_%u",i)
-    );
     return key;
 }