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

some changes in kprint

Browse Source
This commit is contained in:
timerix 2022-10-23 17:10:30 +06:00
parent e9d736e95f
commit 0e6a0f6482
14 changed files with 205 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/base/errors.c
View File

@ -12,6 +12,7 @@ char* errname(ErrorId err){
case ERR_NULLPTR: return "ERR_NULLPTR";
case ERR_ENDOFSTR: return "ERR_ENDOFSTR";
case ERR_KEYNOTFOUND: return "ERR_KEYNOTFOUND";
case ERR_FORMAT: return "ERR_FORMAT";
default: return "UNKNOWN_ERROR";
}
}

2
src/base/kprint/README.md
View File

@ -10,7 +10,7 @@ I don't really like printf function (and its variants), so i made safer and more
## how to use it:
+ **format construction:**
```
kprint_format fmt= kprint_fgColor | kprint_fbgColor | kprint_fdataFmt | flags | ktId;
kprint_format fmt= kprint_fgColor | kprint_bgColor | kprint_fdataFmt | flags | ktId;
```
[more about `kprint_format`](kprint_format.md)
+ fgColor and bgColor can be set to change console output color

119
src/base/kprint/kprint.c
View File

@ -1,29 +1,37 @@
/* #include "../base.h"
#include "../base.h"
#include "../../String/StringBuilder.h"
Maybe __next_toString(kprint_format format, void* object){
// detecting type
if(!format.typeId) switch((kprint_dataFormat)((uint32)0 | format.dataFmt)){
ktId __typeFromFormat(kprint_format f){
ktId typeId=kprint_format_ktId(f);
if(typeId)
return typeId;
switch(kprint_format_dataFormat(f)){
case kprint_fmtInt:
case kprint_fmtHex:
case kprint_fmtBin:
format.typeId=ktId_Int64; break;
return ktId_Int64;
case kprint_fmtUInt:
format.typeId=ktId_UInt64; break;
return ktId_UInt64;
case kprint_fmtFloat:
format.typeId=ktId_Float64; break;
return ktId_Float64;
case kprint_fmtChar:
format.typeId=ktId_Char; break;
return ktId_Char;
case kprint_fmtString:
format.typeId=ktId_CharPtr; break;
return ktId_CharPtr;
default:
safethrow("typeId is not set, can't autodetect type",;);
return -1;
}
ktDescriptor typeDesc=ktDescriptor_get(format.typeId);
}
Maybe __next_toString(kprint_format f, void* object){
// detecting type
ktId typeId=__typeFromFormat(f);
if(typeId==-1)
safethrow("typeId is not set, can't autodetect type",;);
ktDescriptor typeDesc=ktDescriptor_get(typeId);
if(!typeDesc.toString)
safethrow("type descriptor doesnt have toString() func",;);
try(typeDesc.toString(object, &format), mStr,;);
return SUCCESS(mStr.value);
return SUCCESS(UniHeap(ktId_CharPtr, typeDesc.toString(object, f)));
}
Maybe __ksprint(uint8 n, kprint_format* formats, void** objects){
@ -43,6 +51,7 @@ Maybe __kfprint(FILE* file, uint8 n, kprint_format* formats, void** objects){
safethrow("can't write string to file", Unitype_free(maybeStr.value));
Unitype_free(maybeStr.value);
}
fflush(file);
return MaybeNull;
}
@ -56,18 +65,88 @@ void __kprint(uint8 n, kprint_format* formats, void** objects){
//, Unitype_free(maybeStr.value)
Unitype_free(maybeStr.value);
}
fflush(stdout);
}
#if defined(_WIN32)|| defined(_WIN64)
#include <windows.h>
#define FOREGROUND_YELLOW FOREGROUND_GREEN | FOREGROUND_RED
DWORD kprint_fgColor_toWin(kprint_fgColor f){
//printf("fg: %x\n", f);
switch(f){
case kprint_fgBlack: return 0;
case kprint_fgDarkRed: return FOREGROUND_RED;
case kprint_fgDarkGreen: return FOREGROUND_GREEN;
case kprint_fgDarkYellow: return FOREGROUND_GREEN | FOREGROUND_RED;
case kprint_fgDarkBlue: return FOREGROUND_BLUE;
case kprint_fgDarkMagneta: return FOREGROUND_RED | FOREGROUND_BLUE;
case kprint_fgDarkCyan: return FOREGROUND_BLUE | FOREGROUND_GREEN;
case kprint_fgGray: return FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED;
case kprint_fgDarkGray: return FOREGROUND_INTENSITY;
case kprint_fgRed: return FOREGROUND_RED | FOREGROUND_INTENSITY;
case kprint_fgGreen: return FOREGROUND_GREEN | FOREGROUND_INTENSITY;
case kprint_fgYellow: return FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY;
case kprint_fgBlue: return FOREGROUND_BLUE | FOREGROUND_INTENSITY;
case kprint_fgMagneta: return FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_INTENSITY;
case kprint_fgCyan: return FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
case kprint_fgWhite: return FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
default: throw(ERR_FORMAT);
}
}
DWORD kprint_bgColor_toWin(kprint_bgColor f){
//printf("bg: %x\n", f);
switch(f){
case kprint_bgBlack: return 0;
case kprint_bgDarkRed: return BACKGROUND_RED;
case kprint_bgDarkGreen: return BACKGROUND_GREEN;
case kprint_bgDarkYellow: return BACKGROUND_GREEN | BACKGROUND_RED;
case kprint_bgDarkBlue: return BACKGROUND_BLUE;
case kprint_bgDarkMagneta: return BACKGROUND_RED | BACKGROUND_BLUE;
case kprint_bgDarkCyan: return BACKGROUND_BLUE | BACKGROUND_GREEN;
case kprint_bgGray: return BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED;
case kprint_bgDarkGray: return BACKGROUND_INTENSITY;
case kprint_bgRed: return BACKGROUND_RED | BACKGROUND_INTENSITY;
case kprint_bgGreen: return BACKGROUND_GREEN | BACKGROUND_INTENSITY;
case kprint_bgYellow: return BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY;
case kprint_bgBlue: return BACKGROUND_BLUE | BACKGROUND_INTENSITY;
case kprint_bgMagneta: return BACKGROUND_BLUE | BACKGROUND_RED | BACKGROUND_INTENSITY;
case kprint_bgCyan: return BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_INTENSITY;
case kprint_bgWhite: return BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_INTENSITY;
default: throw(ERR_FORMAT);
}
}
void kprint_setColor(kprint_format f){
if(!f.bgColorChanged | !f.fgColorChanged)
DWORD color=0;
if(!kprint_format_fgColorChanged(f) & !kprint_format_bgColorChanged(f))
return;
if(kprint_format_fgColorChanged(f))
color+=kprint_fgColor_toWin(kprint_format_fgColor(f));
if(kprint_format_bgColorChanged(f))
color+=kprint_bgColor_toWin(kprint_format_bgColor(f));
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hConsole, color);
}
#else
void kprint_setColor(kprint_format f){
if(kprint_format_fgColorChanged(f)){
uint8 fg=(f&0x0f000000)>>24;
if(fg<8) fg+=30;
else fg+=90-8;
printf("\e[%um", fg);
}
if(kprint_format_bgColorChanged(f)){
uint8 bg=(f&0x00f00000)>>20;
if(bg<8) bg+=40;
else bg+=100-8;
printf("\e[%um", bg);
}
}
#endif
Maybe ksprint_ar(uint32 count, kprint_format format, ktId typeId, void* array){
/* Maybe ksprint_ar(uint32 count, kprint_format format, ktId typeId, void* array){
ktDescriptor typeDesc=ktDescriptor_get(format.typeId);
if(!typeDesc.toString)
safethrow("type descriptor doesnt have toString() func",;);
@ -75,8 +154,8 @@ Maybe ksprint_ar(uint32 count, kprint_format format, ktId typeId, void* array){
StringBuilder_append_char(strb, '[');
for (uint16 e=1; e<count; e++){
StringBuilder_append_char(strb, ' ');
try(typeDesc.toString(array+typeDesc.size*e, &format), estr, StringBuilder_free(strb));
StringBuilder_append_cptr(strb, estr.value.VoidPtr);
char* elStr=typeDesc.toString(array+typeDesc.size*e, &format);
StringBuilder_append_cptr(strb, elStr);
StringBuilder_append_char(strb, ',');
}
StringBuilder_rmchar(strb);

6
src/base/kprint/kprint.h
View File

@ -48,13 +48,13 @@ extern "C" {
__kprint_argsToObjects32(ARGS))
Maybe __ksprint(uint8 n, int32* formats, void** objects);
Maybe __ksprint(uint8 n, kprint_format* formats, void** objects);
#define ksprint(ARGS...) __ksprint(count_args(ARGS), __kprint_argsToArrs(count_args(ARGS),ARGS, __32zeroes))
Maybe __kfprint(FILE* fd, uint8 n, int32* formats, void** objects);
Maybe __kfprint(FILE* fd, uint8 n, kprint_format* formats, void** objects);
#define kfprint(FD, ARGS...) __kfprint(FD, count_args(ARGS), __kprint_argsToArrs(count_args(ARGS),ARGS, __32zeroes))
void __kprint(uint8 n, int32* formats, void** objects);
void __kprint(uint8 n, kprint_format* formats, void** objects);
#define kprint(ARGS...) __kprint(count_args(ARGS), __kprint_argsToArrs(count_args(ARGS),ARGS, __32zeroes))
// can take (bgColor | fgColor)

24
src/base/kprint/kprint_format.h
View File

@ -31,19 +31,17 @@ typedef enum kprint_dataFormat{
kprint_fmtUppercase=0x10000000
} kprint_dataFormat;
typedef union {
int32 i32;
struct {
unsigned char fgColorChanged : 1;
unsigned char bgColorChanged : 1;
unsigned char withPrefix : 1;
unsigned char uppercase : 1;
unsigned char fgColor : 4;
unsigned char bgColor : 4;
unsigned char dataFmt : 4;
ktId typeId;
};
} kprint_format;
typedef uint32 kprint_format;
#define kprint_format_fgColorChanged(FMT) (FMT&0x80000000)
#define kprint_format_bgColorChanged(FMT) (FMT&0x40000000)
#define kprint_format_withPrefix(FMT) (FMT&kprint_fmtWithPrefix)
#define kprint_format_withPostfix(FMT) (FMT&kprint_fmtWithPostfix)
#define kprint_format_uppercase(FMT) (FMT&kprint_fmtUppercase)
#define kprint_format_fgColor(FMT) (kprint_fgColor)(FMT&0x8f000000)
#define kprint_format_bgColor(FMT) (kprint_bgColor)(FMT&0x40f00000)
#define kprint_format_dataFormat(FMT) (kprint_dataFormat)(FMT&0x000f0000)
#define kprint_format_ktId(FMT) (kprint_dataFormat)(FMT&0x0000ffff)
#if __cplusplus
}

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

@ -52,7 +52,7 @@ char* toString_float(float64 n, bool withPostfix, bool uppercase){
}
char* toString_bin(char* bytes, uint32 size, bool withPrefix){
char* str=malloc(size*8+1);
char* str=malloc(size*8 + (withPrefix?2:0) +1);
uint32 cn=0;
if(withPrefix){
str[cn++]='0';
@ -80,7 +80,7 @@ char _4bitsHex(uint8 u, bool uppercase){
}
char* toString_hex(char* bytes, uint32 size, bool withPrefix, bool uppercase){
char* str=malloc(size*2);
char* str=malloc(size*2 + (withPrefix?2:0) + 1);
uint32 cn=0;
if(withPrefix){
str[cn++]='0';
@ -96,18 +96,17 @@ char* toString_hex(char* bytes, uint32 size, bool withPrefix, bool uppercase){
}
#define __toString_int_def(BITS) char* __toString_int##BITS(void* _n, int32 _f){\
kprint_format f=*(kprint_format*)&_f;\
switch(f.dataFmt | (uint32)0){\
case kprint_fmtInt:\
#define __toString_int_def(BITS) char* __toString_int##BITS(void* _n, uint32 f){\
switch(kprint_format_dataFormat(f)){\
case kprint_fmtInt: ;\
int##BITS n=*(int##BITS*)_n;\
return toString_int(n);\
case kprint_fmtBin:\
return toString_bin(_n, BITS/8, f.withPrefix);\
return toString_bin(_n, BITS/8, kprint_format_withPrefix(f));\
case kprint_fmtHex:\
return toString_hex(_n, BITS/8, f.withPrefix, f.uppercase);\
return toString_hex(_n, BITS/8, kprint_format_withPrefix(f), kprint_format_uppercase(f));\
default:\
printf("\n%u\n", f.dataFmt);\
printf("\n%u\n", kprint_format_dataFormat(f));\
throw(ERR_FORMAT);\
return NULL;\
}\
@ -117,18 +116,17 @@ __toString_int_def(16)
__toString_int_def(32)
__toString_int_def(64)
#define __toString_uint_def(BITS) char* __toString_uint##BITS(void* _n, int32 _f){\
kprint_format f=*(kprint_format*)&_f;\
switch(f.dataFmt | (uint32)0){\
case kprint_fmtUInt:\
#define __toString_uint_def(BITS) char* __toString_uint##BITS(void* _n, uint32 f){\
switch(kprint_format_dataFormat(f)){\
case kprint_fmtUInt: ;\
uint##BITS n=*(uint##BITS*)_n;\
return toString_uint(n, f.withPrefix, f.uppercase);\
return toString_uint(n, kprint_format_withPostfix(f), kprint_format_uppercase(f));\
case kprint_fmtBin:\
return toString_bin(_n, BITS/8, f.withPrefix);\
return toString_bin(_n, BITS/8, kprint_format_withPrefix(f));\
case kprint_fmtHex:\
return toString_hex(_n, BITS/8, f.withPrefix, f.uppercase);\
return toString_hex(_n, BITS/8, kprint_format_withPrefix(f), kprint_format_uppercase(f));\
default:\
printf("\n%u\n", f.dataFmt);\
printf("\n%u\n", kprint_format_dataFormat(f));\
throw(ERR_FORMAT);\
return NULL;\
}\
@ -138,18 +136,17 @@ __toString_uint_def(16)
__toString_uint_def(32)
__toString_uint_def(64)
#define __toString_float_def(BITS) char* __toString_float##BITS(void* _n, int32 _f){\
kprint_format f=*(kprint_format*)&_f;\
switch(f.dataFmt | (uint32)0){\
case kprint_fmtFloat:\
#define __toString_float_def(BITS) char* __toString_float##BITS(void* _n, uint32 f){\
switch(kprint_format_dataFormat(f)){\
case kprint_fmtFloat: ;\
float##BITS n=*(float##BITS*)_n;\
return toString_float(n, f.withPrefix, f.uppercase);\
return toString_float(n, kprint_format_withPostfix(f), kprint_format_uppercase(f));\
case kprint_fmtBin:\
return toString_bin(_n, BITS/8, f.withPrefix);\
return toString_bin(_n, BITS/8, kprint_format_withPrefix(f));\
case kprint_fmtHex:\
return toString_hex(_n, BITS/8, f.withPrefix, f.uppercase);\
return toString_hex(_n, BITS/8, kprint_format_withPrefix(f), kprint_format_uppercase(f));\
default:\
printf("\n%u\n", f.dataFmt);\
printf("\n%u\n", kprint_format_dataFormat(f));\
throw(ERR_FORMAT);\
return NULL;\
}\

20
src/base/type_system/base_toString.h
View File

@ -8,20 +8,20 @@ extern "C" {
// functions for base types
char* toString_int(int64 n);
char* __toString_int8(void* n, int32 fmt);
char* __toString_int16(void* n, int32 fmt);
char* __toString_int32(void* n, int32 fmt);
char* __toString_int64(void* n, int32 fmt);
char* __toString_int8(void* n, uint32 fmt);
char* __toString_int16(void* n, uint32 fmt);
char* __toString_uint32(void* n, uint32 fmt);
char* __toString_int64(void* n, uint32 fmt);
char* toString_uint(uint64 n, bool withPostfix, bool uppercase);
char* __toString_uint8(void* n, int32 fmt);
char* __toString_uint16(void* n, int32 fmt);
char* __toString_uint32(void* n, int32 fmt);
char* __toString_uint64(void* n, int32 fmt);
char* __toString_uint8(void* n, uint32 fmt);
char* __toString_uint16(void* n, uint32 fmt);
char* __toString_uuint32(void* n, uint32 fmt);
char* __toString_uint64(void* n, uint32 fmt);
char* toString_float(float64 n, bool withPostfix, bool uppercase); // very bad implimentation
char* __toString_float32(void* n, int32 fmt);
char* __toString_float64(void* n, int32 fmt);
char* __toString_float32(void* n, uint32 fmt);
char* __toString_float64(void* n, uint32 fmt);
// universal functions
char* toString_bin(char* bytes, uint32 size, bool withPrefix);

2
src/base/type_system/ktDescriptor.h
View File

@ -12,7 +12,7 @@ typedef struct ktDescriptor{
ktId id;
uint16 size;
void (*freeMembers)(void*); // NULL or function which frees all struct members
char* (*toString)(void* obj, int32 fmt); // NULL or function which generates string representaion of object
char* (*toString)(void* obj, uint32 fmt); // NULL or function which generates string representaion of object
} ktDescriptor;
#if __cplusplus

2
src/base/type_system/kt_functions.c
View File

@ -58,7 +58,7 @@ void ktDescriptors_endInit(){
printf("\e[92minitialized %u type descriptors\n", ktId_last);
}
void __kt_register(char* name, int16 size, void (*freeMembers)(void*), char* (*toString)(void*, int32)){
void __kt_register(char* name, int16 size, void (*freeMembers)(void*), char* (*toString)(void*, uint32)){
ktDescriptor typeDesc={
.name=name,
.size=size,

3
src/base/type_system/kt_functions.h
View File

@ -8,9 +8,8 @@ extern "C" {
#include "ktId.h"
#include "ktDescriptor.h"
extern ktId ktId_last;
void __kt_register(char* name, int16 size, void (*freeMembers)(void*), char* (*toString)(void*, int32));
void __kt_register(char* name, int16 size, void (*freeMembers)(void*), char* (*toString)(void*, uint32));
#define kt_register(TYPE, ID_VAR_NAME, FREE_MEMBERS_FUNC, TO_STRING_FUNC)\
__kt_register(#ID_VAR_NAME, sizeof(TYPE), FREE_MEMBERS_FUNC, TO_STRING_FUNC);\

2
src/base/type_system/unitype.c
View File

@ -12,7 +12,7 @@ void Unitype_free(Unitype u){
}
void __UnitypePtr_free(void* u) { Unitype_free(*(Unitype*)u); }
char* toString_Unitype(void* _u, int32 fmt){
char* toString_Unitype(void* _u, uint32 fmt){
Unitype* u=_u;
ktDescriptor type=ktDescriptor_get(u->typeId);
char* valuestr=type.toString(_u, fmt);

4
tests/main.cpp
View File

@ -9,6 +9,7 @@ void test_all(){
test_hash_functions();
test_hashtable();
test_dtsod();
test_kprint_colors();
printf("\e[96m--------------------------------------\e[0m\n");
}
@ -18,7 +19,8 @@ int main(){
ktDescriptors_initKerepTypes();
ktDescriptors_endInit();
printf("\e[97mkerep tests are starting!\n");
optime("test_all",1,test_all());
// optime("test_all",1,test_all());
test_kprint_colors();
printf("\e[0m\n");
return 0;
}

4
tests/test_autoarr-vs-vector.cpp
View File

@ -4,7 +4,7 @@
int64 _autoarrVsVector(uint16 blockCount, uint16 blockLength){
uint32 count=blockLength*blockCount;
printf("\e[94mblock count: %u block length: %u count: %llu\n", blockCount, blockLength, (uint64)count);
printf("\e[94mblock count: %u block length: %u count: " IFWIN("%llu", "%lu") "\n", blockCount, blockLength, (uint64)count);
Autoarr_int64* ar=Autoarr_create(int64, blockCount, blockLength);
std::vector<int64> vec=std::vector<int64>();
optime("Autoarr_add", 1, ({
@ -15,7 +15,7 @@ int64 _autoarrVsVector(uint16 blockCount, uint16 blockLength){
for(uint32 i=0; i< count; i++)
vec.push_back(i);
}));
int64 t;
int64 t=0;
optime("Autoarr_get", 1, ({
for(uint32 i=0; i< count; i++)
t=Autoarr_get(ar, i);

47
tests/test_kprint_colors.c Normal file
View File

@ -0,0 +1,47 @@
#include "tests.h"
#if defined(_WIN32)|| defined(_WIN64)
#include <windows.h>
#endif
#define testColor(COLOR) \
kprint_setColor(kprint_bgBlack | kprint_fg##COLOR);\
printf(#COLOR " ");\
kprint_setColor(kprint_bg##COLOR | kprint_fgGray);\
printf(#COLOR);\
kprint_setColor(kprint_bgBlack | kprint_fgBlack);\
printf("\n");
void test_kprint_colors(){
IFWIN(
({
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
for(uint8 col=0; col<255; col++){
SetConsoleTextAttribute(hConsole, col);
printf("%u ",col);
}
}),
({
for(uint8 col=0; col<255; col++)
printf("\e[%um%u ", col, col);
})
);
printf("\n");
testColor(Black);
testColor(DarkRed);
testColor(DarkGreen);
testColor(DarkYellow);
testColor(DarkBlue);
testColor(DarkMagneta);
testColor(DarkCyan);
testColor(Gray);
testColor(DarkGray);
testColor(Red);
testColor(Green);
testColor(Yellow);
testColor(Blue);
testColor(Magneta);
testColor(Cyan);
testColor(White);
kprint_setColor(kprint_bgBlack | kprint_fgGray);
}