Differences From Artifact [a03577a0c4]:
- Executable file main.c — part of check-in [34afc47f85] at 2025-06-28 17:28:54 on branch trunk — _ (user: Scalpi size: 125696)
To Artifact [c2bae00a20]:
- Executable file main.c — part of check-in [45abd8ae4d] at 2025-06-29 21:07:41 on branch trunk — _ (user: Scalpi size: 126821)
| ︙ | ︙ | |||
516 517 518 519 520 521 522 523 524 525 526 |
#define Scalpi_network_tcp_http_WebSocket_Header_Size_medium_header (Scalpi_network_tcp_http_WebSocket_Header_Size_small_header + Scalpi_network_tcp_http_WebSocket_Header_Size_medium_extended_payload_len_size)
// 10 bytes header for sizes more than 65535
#define Scalpi_network_tcp_http_WebSocket_Header_Size_long 2
#define Scalpi_network_tcp_http_WebSocket_Header_Size_long_flag 127
#define Scalpi_network_tcp_http_WebSocket_Header_Size_long_extended_payload_len_size 8
#define Scalpi_network_tcp_http_WebSocket_Header_Size_long_header (Scalpi_network_tcp_http_WebSocket_Header_Size_small_header + Scalpi_network_tcp_http_WebSocket_Header_Size_long_extended_payload_len_size)
// structs
// core
// memory
// # __AlignedPtr__
| > > > > > > | | | | < < > > | | | | | 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 |
#define Scalpi_network_tcp_http_WebSocket_Header_Size_medium_header (Scalpi_network_tcp_http_WebSocket_Header_Size_small_header + Scalpi_network_tcp_http_WebSocket_Header_Size_medium_extended_payload_len_size)
// 10 bytes header for sizes more than 65535
#define Scalpi_network_tcp_http_WebSocket_Header_Size_long 2
#define Scalpi_network_tcp_http_WebSocket_Header_Size_long_flag 127
#define Scalpi_network_tcp_http_WebSocket_Header_Size_long_extended_payload_len_size 8
#define Scalpi_network_tcp_http_WebSocket_Header_Size_long_header (Scalpi_network_tcp_http_WebSocket_Header_Size_small_header + Scalpi_network_tcp_http_WebSocket_Header_Size_long_extended_payload_len_size)
// auto casting
#define __OsMem_allocAny__( ret_data_addr, size) __OsMem_alloc__( (uintptr_t*) (ret_data_addr), size)
#define __OsMem_freeAny__( ret_data_addr) __OsMem_free__( (uintptr_t) (ret_data_addr))
#define __AlignedPtr_allocAny__( ret_data_addr, mem_align, size) __AlignedPtr_alloc__( (uintptr_t*) (ret_data_addr), mem_align, size)
#define __AlignedPtr_freeAny__( ret_data_addr, size) __AlignedPtr_free__( (uintptr_t) (ret_data_addr), size)
// structs
// core
// memory
// # __AlignedPtr__
/* its a virtual struct becouse C not have "anytype" type.
struct __AlignedPtr__ {
char gap[gap_size] // padding for aligning data. gap_size can be 0.
anytype your_data // <- the pointer that the alloc function returns will be pointed here.
uint8_t gap_size
}
*/
// # __ScalpiMemListLink__
struct __ScalpiMemListLink__ {
struct __ScalpiMemListLink__* prev;
struct __ScalpiMemListLink__* next;
struct __ScalpiMemList__* list;
};
// # __ScalpiMemList__
struct __ScalpiMemList__ {
struct __ScalpiMemListLink__* first;
struct __ScalpiMemListLink__* last;
size_t count;
};
// # Slice
struct Slice {
char* ptr;
size_t len;
};
// # Finder
struct Finder {
struct Slice text;
struct Slice desired;
size_t pos;
};
// Os
// system specifics
|
| ︙ | ︙ | |||
636 637 638 639 640 641 642 |
};
// text
struct Scalpi_Text_Splitter {
struct Finder finder;
bool stop;
size_t last_pos;
};
| | | 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 |
};
// text
struct Scalpi_Text_Splitter {
struct Finder finder;
bool stop;
size_t last_pos;
};
// # Scalpi_Logger
struct Scalpi_Logger {
// write to terminal, console, file or to all together, but no real check "bytes is writen"
struct __Scalpi_Writer__ writers[4]; // Scalpi_Logger_writers
};
// Console
// __Scalpi_Console_ansi_input_Key_SequenceParser__
struct __Scalpi_Console_ansi_input_Key_SequenceParser__ {
|
| ︙ | ︙ | |||
762 763 764 765 766 767 768 |
// # App
struct App {
struct __OsHelper__ __App_osHelper__;
struct Scalpi_Logger logger;
uint64_t tick;
};
// function prototypes
| | | | | | 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 |
// # App
struct App {
struct __OsHelper__ __App_osHelper__;
struct Scalpi_Logger logger;
uint64_t tick;
};
// function prototypes
bool __OsFile_exist__( const char* file_name, size_t file_name_len);
bool __OsMem_alloc__( uintptr_t *ret_data_addr, size_t size); // todo rename to __OsMem_alloc__
void __OsMem_free__( uintptr_t ret_data_addr);
size_t __OsFallbackConsole_write__( void* unused_ctx, char* data, size_t len);
// globals
struct App global_app;
// functions
// core
// mem
// bits operations
uint8_t bits_rotl8(uint8_t value, unsigned int shift) {
|
| ︙ | ︙ | |||
798 799 800 801 802 803 804 |
// bytes operations
// # __ScalpiMem_fill__
void __ScalpiMem_fill__(char* dest, char symbol, size_t len) {
for (size_t pos = 0; pos < len; pos++) {
dest[pos] = symbol;
}
}
| | | < < < | < < < < | | | < < < < < > > > > > > > > > > > > > > > > > > > > > | 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 |
// bytes operations
// # __ScalpiMem_fill__
void __ScalpiMem_fill__(char* dest, char symbol, size_t len) {
for (size_t pos = 0; pos < len; pos++) {
dest[pos] = symbol;
}
}
// # __ScalpiMem_copy__
void __ScalpiMem_copy__( // todo create macros __ScalpiMem_copyAny__
char *dest,
const char *src,
size_t size
) {
// i use this instead memcpy becouse clang-in-zig just replace memcpy to crash-zig-bloated-version code
size_t pos = 0;
while(pos < size) {
dest[pos] = src[pos];
pos++;
}
}
// # __ScalpiMem_copyBackward__
void __ScalpiMem_copyBackward__(char* dest, const char* src, size_t size) {
size_t pos = size;
while(pos > 0) {
pos-=1;
dest[pos] = src[pos];
}
}
// # __ScalpiMem_reverse__
void __ScalpiMem_reverse__(
char *dest,
const char *src,
size_t len
) {
src = &src[len - 1];
size_t iter = 0;
for(; iter < len; iter++, dest++, src--) {
*dest = *src;
}
}
// # __ScalpiMem_findDiffOrLen__
size_t __ScalpiMem_findDiffOrLen__(const char a[], const char b[], size_t len) {
size_t pos = 0;
while(pos < len) {
if (a[pos] != b[pos]) break;
pos++;
}
|
| ︙ | ︙ | |||
850 851 852 853 854 855 856 |
;
}
// # writeWithOffset
void writeWithOffset(char* dest, size_t* writed, char* data, size_t data_len) {
__ScalpiMem_copy__(&dest[*writed], data, data_len);
*writed += data_len;
}
| | | | | > | | | | | | | | > | | | > | | | | | < | | < < < | < < | < < < | < < | | | | | | | | | | | | | | | | | | | | | | | | | 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 |
;
}
// # writeWithOffset
void writeWithOffset(char* dest, size_t* writed, char* data, size_t data_len) {
__ScalpiMem_copy__(&dest[*writed], data, data_len);
*writed += data_len;
}
// __AlignedPtr__
// # __AlignedPtr_alloc__
bool __AlignedPtr_alloc__(
uintptr_t *ret_data_addr,
uint8_t data_align, // expected >= 1
size_t data_size // expected >= 1
) {
bool ok = true;
uint8_t gap_size = 0;
size_t allocated_size = data_size + (data_align - 1) + sizeof(gap_size);
uintptr_t allocated_addr;
if (__OsMem_allocAny__(&allocated_addr, allocated_size)) {
// calc size of gap
uint8_t nodled = allocated_addr % data_align;
if (nodled) {
gap_size = data_align - nodled;
}
// write ret_data_addr
uintptr_t data_addr = allocated_addr + gap_size;
*ret_data_addr = data_addr;
// save gap size
* (uint8_t*) (data_addr + data_size) = gap_size;
if (!ok) __OsMem_freeAny__(allocated_addr);
} else {
ok = false;
}
return ok;
}
// # __AlignedPtr_free__
void __AlignedPtr_free__(
uintptr_t data_addr,
size_t data_size
) {
uint8_t gap_size = * (uint8_t*) (data_addr + data_size);
__OsMem_freeAny__(data_addr - gap_size);
}
// format_number
bool cpu_checkNumberFormat() {
char current_endians = 0;
int n = 1;
if (* (char *) &n == 1) {
current_endians = __TargetMemoryType_endiansLittle__;
} else {
current_endians = __TargetMemoryType_endiansBig__;
}
if (__target_memory_type__ == current_endians) {
return true;
} else {
printf("%d wrong MEMORY_TYPE !\r\n", __LINE__);
}
return false;
}
#if __target_memory_type__ == __TargetMemoryType_endiansBig__
#define nativeToBig(dest, src, size) __ScalpiMem_copy__(dest, src, size)
#define nativeToLittle(dest, src, size) __ScalpiMem_reverse__(dest, src, size)
#elif __target_memory_type__ == __TargetMemoryType_endiansLittle__
#define nativeToBig(dest, src, size) __ScalpiMem_reverse__(dest, src, size)
#define nativeToLittle(dest, src, size) __ScalpiMem_copy__(dest, src, size)
#else
#error "please define __target_memory_type__ with __TargetMemoryType_ (you can test endings with cpu_checkNumberFormat function)"
#endif
// read unaligned memory
// big
uint16_t readBig16(char* src) {
uint16_t ret;
nativeToBig( (char*) &ret, src, 2);
return ret;
}
uint32_t readBig32(char* src) {
uint32_t ret;
nativeToBig( (char*) &ret, src, 4);
return ret;
}
uint64_t readBig64(char* src) {
uint64_t ret;
nativeToBig( (char*) &ret, src, 8);
return ret;
}
// little
uint16_t readLittle16(char* src) {
uint16_t ret;
nativeToLittle( (char*) &ret, src, 2);
return ret;
}
uint32_t readLittle32(char* src) {
uint32_t ret;
nativeToLittle( (char*) &ret, src, 4);
return ret;
}
uint64_t readLittle64(char* src) {
uint64_t ret;
nativeToLittle( (char*) &ret, src, 8);
return ret;
}
// write unaligned memory
// big
// # writeBig16
void writeBig16(
char *dest,
uint16_t value
) {
nativeToBig( dest, (char*)&value, 2);
}
// # writeBig32
void writeBig32(
char *dest,
uint32_t value
) {
nativeToBig(dest, (char*)&value, 4);
}
// # writeBig64
void writeBig64(
char *dest,
uint64_t value
) {
nativeToBig(dest, (char*)&value, 8);
}
// little
// # writeLittle16
void writeLittle16(
char *dest,
uint16_t value
) {
nativeToLittle(dest, (char*)&value, 2);
}
// # writeLittle32
void writeLittle32(
char *dest,
uint32_t value
) {
nativeToLittle(dest, (char*)&value, 4);
}
// # writeLittle64
void writeLittle64(
char *dest,
uint64_t value
) {
nativeToLittle(dest, (char*)&value, 8);
}
// Slice
// # Slice_debug
void Slice_debug(struct Slice* slice, char* name, size_t line) {
if (slice->len == 0) {
printf("%zu: %s is NULL. \r\n", line, name);
} else {
|
| ︙ | ︙ | |||
1159 1160 1161 1162 1163 1164 1165 |
// # C_Text_writeToWriteFn
size_t C_Text_writeToWriteFn(__WriteFnPtr__ fn_write, void* context, const char text[]) {
const size_t len = __ZText_countLen__(text);
return fn_write(context, text, len);
}
// Os
// mem
| | | | | | | > | | | | 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 |
// # C_Text_writeToWriteFn
size_t C_Text_writeToWriteFn(__WriteFnPtr__ fn_write, void* context, const char text[]) {
const size_t len = __ZText_countLen__(text);
return fn_write(context, text, len);
}
// Os
// mem
// # __OsMem_alloc__
bool __OsMem_alloc__( // TODO use real system alloc?
uintptr_t *ret,
size_t size
) {
bool ok = true;
char* ptr = malloc(size);
if (ptr) {
*ret = (uintptr_t) ptr;
} else {
ok = false;
// TODO print debug
}
return ok;
}
// # __OsMem_free__
void __OsMem_free__(uintptr_t ptr) {
free((void*) ptr);
}
// enviroment
// # __OsEnvHome_getLen__
size_t __OsEnvHome_getLen__() {
size_t len = 0;
#if __target_os__ == __TargetOs_windows__
char* home_drive = getenv("HOMEDRIVE");
|
| ︙ | ︙ | |||
1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 |
} else {
ok = false;
}
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
return ok;
}
// # __OsFile_close__
void __OsFile_close__(
__OsFile__ file
) {
#if __target_os__ == __TargetOs_windows__
CloseHandle(file);
| > > > > > > > > > > > > | 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 |
} else {
ok = false;
}
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
return ok;
}
// # __OsFile_openOrCreate__
bool __OsFile_openOrCreate__(
__OsFile__ *ret,
const char file_name[],
size_t file_name_len // expected < __OsFilePathLen_max__
) {
if (__OsFile_exist__(file_name, file_name_len)) {
return __OsFile_open__(ret, file_name, file_name_len);
} else {
return __OsFile_create__(ret, file_name, file_name_len);
}
}
// # __OsFile_close__
void __OsFile_close__(
__OsFile__ file
) {
#if __target_os__ == __TargetOs_windows__
CloseHandle(file);
|
| ︙ | ︙ | |||
2199 2200 2201 2202 2203 2204 2205 |
}
// App
// AppEditorHistoryNote
// # __AppEditorHistoryNote_free__
void __AppEditorHistoryNote_free__(
struct __AppEditorHistoryNote__* ptr
) {
| | | < < | < < | 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 |
}
// App
// AppEditorHistoryNote
// # __AppEditorHistoryNote_free__
void __AppEditorHistoryNote_free__(
struct __AppEditorHistoryNote__* ptr
) {
__AlignedPtr_freeAny__(ptr, sizeof(struct __AppEditorHistoryNote__));
}
// # __AppEditorHistoryNote_alloc__
bool __AppEditorHistoryNote_alloc__(
struct __AppEditorHistoryNote__ **ptr
) {
return __AlignedPtr_allocAny__( ptr, __alignOf__(struct __AppEditorHistoryNote__), sizeof(struct __AppEditorHistoryNote__) );
}
// # App_init
bool App_init(struct App* t) {
bool ok = true;
Scalpi_Logger_init(&t->logger); // preinit console output for debug
if (__OsHelper_init__(&t->__App_osHelper__)) {
|
| ︙ | ︙ |