Timerix/kerep
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ksprintf

Browse Source
This commit is contained in:
Timerix22 2024-03-23 01:17:46 +05:00
parent dd5788f72a
commit 9bc2a8587b
13 changed files with 183 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
src/DtsodParser/DtsodV24_deserialize.c
View File

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

4
src/Filesystem/dir.c
View File

@ -36,9 +36,7 @@ Maybe dir_create(const char* path){
#endif #endif
{ {
char err[512]; 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,;); safethrow(err,;);
} }

4
src/Filesystem/path.c
View File

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

3
src/Network/network_types.c
View File

@ -42,8 +42,7 @@ Maybe knIPV4Address_fromStr(char* addrStr, knIPV4Address* addrVal){
default: default:
u32 errmsgL=cptr_length(addrStr) + 80; u32 errmsgL=cptr_length(addrStr) + 80;
char* errmsg=malloc(errmsgL); 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,;); safethrow(errmsg,;);
break; break;
} }

5
src/String/StringBuilder.c
View File

@ -139,9 +139,6 @@ void StringBuilder_append_u64(StringBuilder* b, u64 a){
void StringBuilder_append_f64(StringBuilder* b, f64 a){ void StringBuilder_append_f64(StringBuilder* b, f64 a){
try_complete_buf(b); try_complete_buf(b);
char buf[32]; 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)}); curr_buf_add_string(b, (string){.ptr=buf, .length=cptr_length(buf)});
} }

9
src/base/cptr.c
View File

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

2
src/base/cptr.h
View File

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

17
src/base/errors.c
View File

@ -1,7 +1,4 @@
#include "std.h" #include "base.h"
#include "errors.h"
#include "cptr.h"
#include "../kprint/kprintf.h"
char* errname(ErrorId err){ char* errname(ErrorId err){
switch(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){ char* __genErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){
size_t bufsize=ERRMSG_MAXLENGTH; size_t bufsize=ERRMSG_MAXLENGTH;
char* result=malloc(bufsize); 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; return result;
} }
char* __extendErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){ char* __extendErrMsg(const char* errmsg, const char* srcfile, i32 line, const char* funcname){
size_t bufsize=cptr_length(errmsg)+ERRMSG_MAXLENGTH; size_t bufsize=cptr_length(errmsg)+ERRMSG_MAXLENGTH;
char* result=malloc(bufsize); 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); free(errmsg);
return result; return result;
} }

1
src/base/std.h
View File

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

5
src/base/type_system/base_toString.c
View File

@ -70,10 +70,7 @@ char* toString_u64(u64 n, bool withPostfix, bool uppercase){
throw("too big precision"); \ throw("too big precision"); \
if(precision==0) \ if(precision==0) \
precision=toString_float_default_precision; \ 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*/ \ /* remove trailing zeroes except .0*/ \
while(str[cn-1]=='0' && str[cn-2]!='.') \ while(str[cn-1]=='0' && str[cn-2]!='.') \
cn--; \ cn--; \

206
src/kprint/kprintf.c
View File

@ -45,111 +45,211 @@ WORD unixColorToWin(u8 c){
} }
#endif #endif
void kprintf(const char* format, ...){ i32 kprintf(const char* format, ...){
va_list vl; va_list vl;
va_start(vl, format); 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 // 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: format_escape_seq:
switch (c) { switch (c) {
case 'u': case 'u':
argstr=toString_u64( argstr = toString_u64(
l ? va_arg(vl, u64) : va_arg(vl, u32) l ? va_arg(vl, u64) : va_arg(vl, u32)
,0,0); ,0,0);
break; break;
case 'i': case 'd': case 'i': case 'd':
argstr=toString_i64( argstr = toString_i64(
l ? va_arg(vl, i64) : va_arg(vl, i32) l ? va_arg(vl, i64) : va_arg(vl, i32)
); );
break; break;
case 'f': case 'f':
// f32 is promoted to f64 when passed through '...' // 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; break;
case 'l': case 'l':
l=true; l = true;
if((c=format[i++])) if((c = format[i++]))
goto format_escape_seq; goto format_escape_seq;
break; break;
case 'p': ; 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; break;
case 'x': ; case 'x': ;
if(l){ 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 { 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; break;
case 's': ; case 's': ;
char* cptr=va_arg(vl,char*); char* cptr = va_arg(vl,char*);
if(!cptr) if(!cptr)
cptr="<nullstr>"; cptr = "<nullstr>";
if(*cptr) if(*cptr)
fputs(cptr, stdout); fputs(cptr, stdout);
break; break;
case 'c': case 'c':
argstr=malloc(2); putc((char)va_arg(vl,int), stdout);
argstr[0]=(char)va_arg(vl,int);
argstr[1]=0;
break; break;
default: 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){ if(argstr){
fputs(argstr, stdout); fputs(argstr, stdout);
free(argstr); free(argstr);
} }
} }
// escape sequences // 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){
switch (c){ case '0': case '1': case '2': case '3': case '4':
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
case '5': case '6': case '7': case '8': case '9': colorUnix = colorUnix*10+c-'0';
colorUnix=colorUnix*10+c-'0'; break;
break; case 'm': ;
case 'm': ; WORD colorWin = unixColorToWin(colorUnix);
WORD colorWin=unixColorToWin(colorUnix); HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); SetConsoleTextAttribute(hConsole, colorWin);
SetConsoleTextAttribute(hConsole, colorWin); goto end_iteration;
goto end_iteration; default:
default: goto end_iteration;
goto end_iteration;
}
} }
} }
}), }
/* UNIX */ ////////////////////// UNIX //////////////////////
#else
putc(c,stdout); putc(c,stdout);
); #endif
} }
// common characters // common characters
else { else {
putc(c,stdout); putc(c,stdout);
} }
#if defined(_WIN64) || defined(_WIN32) #if defined(_WIN64) || defined(_WIN32)
end_iteration:; end_iteration:;
#endif #endif
} }
va_end(vl); 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;
} }

13
src/kprint/kprintf.h
View File

@ -6,8 +6,17 @@ extern "C" {
#include "../base/type_system/base_toString.h" #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 // printf format terminal color sequence
#define _PRINTF_COLOR(N) "\e["#N"m" #define _PRINTF_COLOR(N) "\e["#N"m"

5
tests/test_hashtable.c
View File

@ -38,10 +38,7 @@ void printrowgraph(Hashtable* ht){
char* genkey(u32 i){ char* genkey(u32 i){
char* key=malloc(12); 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; return key;
} }