// about
/*
licenze:
This code and its derivatives can be used under the following conditions:
- Do not attack other countries.
- Jerk off on public at least 1 time per day.
- Observe hygiene.
- check my other projects https://chiselapp.com/user/sergey6661313
about:
ScalpiEditor - ansi-only text editor for terminals.
killer features: no. its just editor.
Compile:
this file is just part of zig version (for now)
current version used zig compiller for compile zig file. (unstructions inside zig file)
in future you can use any C compiller, but not now.
nevest C compillers is DUMB!
they insert thousands of checks of what I did not ask them to insert. Here is how you can avoid it:
-fno-stack-protector -fno-sanitize=undefined
also for debug use:
-Og -g
todo. alse try next keys for optimize size
-ffunction-sections -fdata-sections -Wl,--gc-sections
-nostdlib -Oz -Qn -m32 -static -s -N -Wl,--build-id=none -fno-asynchronous-unwind-tables
to support me
with boosty:
https://boosty.to/cutloosedev
with monero:
87T7 qGbA TrM3 a6Br
DyeC jQQf NWtU u3iZ
bHVB MC6W mEbN NE13
Qrrt KhBb e4vF 58NR
8PTF dYk2 Sozc HexX
4Q69 jbdQ Asrs P7B
why i cancel use zig:
gabarages in output code.
zig perfecly crash without printing stack trace in non standart situations. (main feature of zig)
Zig does not try fix console flags before print stack trace.
zig can crash to segfault like c.
tagged enum does not sense.
c: tagged_enum.tag = ANOTHER_TAG;
zig: tagged_enum = .{.ANOTHER_TAG = tagged_enum.LAST_USED_TAG.data};
operator ".?" does not sense:
c: while(link) { i++; link = link->next; }
zig: while(link) |_| { i += 1; link = link.?.next; }
zig idiomatic: while(link) |unwrapped_link|{ i += 1; link = unwrapped_link.next; }
nullable types are inconvenient.
c: if (link) i++;
zig idiomatic: if (link) |_| i += 1;
zig but C pointer: if (@intFromPtr(link) != @intFromPtr(c.NULL)) i += 1;
*/
// TODO
/*
remove name buffer_len. use buffer_max_size and buffer_used instead.
*/
// desctiptions
// __NetworkTcpHttpWebSocketHeader__
// 2 bytes header for sizes 1 ... 125
#define __NetworkTcpHttpWebSocketHeaderSmall__ 0
#define __NetworkTcpHttpWebSocketHeaderSmall_size__ 2
#define __NetworkTcpHttpWebSocketHeaderSmallExtendedPayloadLen_size__ 0
// 4 bytes header for sizes 126 ... 65535
#define __NetworkTcpHttpWebSocketHeaderMedium__ 1
#define __NetworkTcpHttpWebSocketHeaderMedium_flag__ 126
#define __NetworkTcpHttpWebSocketHeaderMediumExtendedPayloadLen_size__ 2
#define __NetworkTcpHttpWebSocketHeaderMedium_size__ (__NetworkTcpHttpWebSocketHeaderSmall_size__ + __NetworkTcpHttpWebSocketHeaderMediumExtendedPayloadLen_size__)
// 10 bytes header for sizes more than 65535
#define __NetworkTcpHttpWebSocketHeaderLong__ 2
#define __NetworkTcpHttpWebSocketHeaderLong_flag__ 127
#define __NetworkTcpHttpWebSocketHeaderLongExtendedPayloadLen_size__ 8
#define __NetworkTcpHttpWebSocketHeaderLong_size__ (__NetworkTcpHttpWebSocketHeaderSmall_size__ + __NetworkTcpHttpWebSocketHeaderLongExtendedPayloadLen_size__)
// enums
// # __LoggerWriter__
#define __LoggerWriter_toFallback__ 0
#define __LoggerWriter_toFile__ 1
#define __LoggerWriter_toConsole__ 2
#define __LoggerWriter_toTerminal__ 3
// # __MemTree_fix_counts_Action__
#define __MemTree_fix_counts_Action_plus__ 'p'
#define __MemTree_fix_counts_Action_minus__ 'm'
// # __MemTree_fix_nested_Action__
#define __MemTree_fix_nested_Action_plus__ 'p'
#define __MemTree_fix_nested_Action_minus__ 'm'
// # __OsNetworkTcpSocketConnectResult__ (char)
#define __OsNetworkTcpSocketConnectResult_error__ -1
#define __OsNetworkTcpSocketConnectResult_inProgress__ 0
#define __OsNetworkTcpSocketConnectResult_success__ 1
// # __TargetOs__
#define __TargetOs_windows__ 1
#define __TargetOs_linux__ 2
// # __TargetMemoryType__
#define __TargetMemoryType_endiansLittle__ 1
#define __TargetMemoryType_endiansBig__ 2
// settings
// # __target_os__
//#define __target_os__ __TargetOs_linux__
#ifndef __target_os__
#ifdef _WIN32
#define __target_os__ __TargetOs_windows__
#elif defined(__linux__)
#define __target_os__ __TargetOs_linux__
#endif
#endif
#define __target_memoryType__ __TargetMemoryType_endiansLittle__
#define __OsFilePathLen_max__ 1024
#define __with_network__ 0
#define __OsNetworkTcp_maxClientCount__ 8
#define __OsNetworkTcpHttp_maxHeaders__ 48
#define __TerminalInput_size__ 32
#define __AppEditorViewsEasyMotionHorizontal_step__ 3
#define __AppEditorViewsEasyMotionVertical_step__ 2
#define __App_expectedFps__ 30
#define __AppEditorLineLen_max__ (1024 * 8)
#define __AppEditorTheme_folded__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bold__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_zero__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_folded_arrows__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bold__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_bg_color_gray__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_yellow__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_current_folded__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bold__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_light_green__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_notification__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_red__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_headers__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bold__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_cyan__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_easy_motion__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_yellow__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_disabled__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_magenta__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_commentary__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_yellow__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_current_disabled__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_light_green__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_current_commentary__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_yellow__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_current__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_light_green__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_current_rune__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_magenta__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_reset__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_reset__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_zero__ \
__ConsoleAnsiOutputFontStyle_end__
#define __AppEditorTheme_arrows__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_unbold__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_bg_color_zero__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_yellow__ \
__ConsoleAnsiOutputFontStyle_end__
// macro
// Os specific
#if __target_os__ == __TargetOs_windows__
#define WSA_SUCCESS 0
#elif __target_os__ == __TargetOs_linux__
#else
#error "__target_os__ not implemented"
#endif
// breakpoint
#if __target_os__ == __TargetOs_windows__
#define breakpoint() DebugBreak()
#elif __target_os__ == __TargetOs_linux__
#define breakpoint() raise(SIGTRAP)
#else
#error "__target_os__ not implemented"
#endif
#define or ||
#define and &&
#define __arrayLen__( array) (sizeof((array)) / sizeof((array[0])))
#define __Addr_fromPtr__( ptr) ((uintptr_t)(ptr))
#define __Instance_fromPtr__( ptr) (*(ptr))
#define __Struct_getFieldOffset__( type, field) (__Addr_fromPtr__(__TypedPtr_getFieldPtr__(__TypedPtr_virtual__(type), field)))
#define __TypedPtr_fromAddr__( type, addr) ((type*)(addr))
#define __TypedPtr_virtual__( type) (__TypedPtr_fromAddr__(type, 0))
#define __TypedPtr_getFieldPtr__( ptr, field_name) (&(ptr)->field_name)
#define __TypedPtr_getParentPtrFromFieldPtr__( type, field_name, field_ptr) (__TypedPtr_fromAddr__(type, __Addr_fromPtr__((field_ptr)) - __Struct_getFieldOffset__(type, field_name)))
#define __Type_getSize__( type) (__Struct_getFieldOffset__(struct {type t; char c;}, c))
#define __Type_getAlign__( type) (__Struct_getFieldOffset__(struct {char c; type t;}, t))
#define __CText_len__( str) (__arrayLen__(str) - 1)
#define __CText_write__( buffer, text) (__Mem_copy__(buffer, text, __CText_len__(text)), __CText_len__(text))
#define __CTextPtr_fromCText__( text) ((char(*)[__CText_len__(text)]) text)
#define __CTextPtr_lvalue__( name, text) (char(*name)[__CText_len__(text)])
#define __CTextPtr_declare__( name, text) __CTextPtr_lvalue__(name, text) = __CTextPtr_fromCText__(text)
#define __len_and_text__( str) __CText_len__(str), str
#define __text_and_len__( str) str, __CText_len__(str)
#define __Slice_fromCText__( text) {.ptr=text, .len=__CText_len__(text)}
#define KB_size 1024
#define MB_size (1024 * KB_size)
#define GB_size (1024 * MB_size)
// # __Mem_nativeToBig__
#if __target_memoryType__ == __TargetMemoryType_endiansBig__
#define __Mem_nativeToBig__(dest, src, size) __Mem_copy__(dest, src, size)
#elif __target_memoryType__ == __TargetMemoryType_endiansLittle__
#define __Mem_nativeToBig__(dest, src, size) __Mem_reverse__(dest, src, size)
#else
#error "please define __target_memoryType__ with __TargetMemoryType_ (you can test endings with cpu_checkNumberFormat function)"
#endif
// # __Mem_nativeToLittle__
#if __target_memoryType__ == __TargetMemoryType_endiansBig__
#define __Mem_nativeToLittle__(dest, src, size) __Mem_reverse__(dest, src, size)
#elif __target_memoryType__ == __TargetMemoryType_endiansLittle__
#define __Mem_nativeToLittle__(dest, src, size) __Mem_copy__(dest, src, size)
#else
#error "please define __target_memoryType__ with __TargetMemoryType_ (you can test endings with cpu_checkNumberFormat function)"
#endif
#define __ConsoleAnsiInputKey_ascii_ctrl__ (-'a' + 1) /* do not use externally */
#define __ConsoleAnsiInputKey_ctrl_bs__ 8 /* also ctrl_h */
#define __ConsoleAnsiInputKey_tab__ 9 /* also ctrl_i */
#define __ConsoleAnsiInputKey_enter__ 13 /* also ctrl_m */
#define __ConsoleAnsiInputKey_escape__ 27
#define __ConsoleAnsiInputKey_back_space__ 127 /* sometime delete */
// # 1 start_of_heading __ConsoleAnsiInputKey_ctrl_a__
#define __ConsoleAnsiInputKey_ctrl_a__ ('a' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 2 __ConsoleAnsiInputKey_ctrl_b__
#define __ConsoleAnsiInputKey_ctrl_b__ ('b' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 3 __ConsoleAnsiInputKey_ctrl_c__
#define __ConsoleAnsiInputKey_ctrl_c__ ('c' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 4 __ConsoleAnsiInputKey_ctrl_d__
#define __ConsoleAnsiInputKey_ctrl_d__ ('d' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 5 __ConsoleAnsiInputKey_ctrl_e__
#define __ConsoleAnsiInputKey_ctrl_e__ ('e' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 6 __ConsoleAnsiInputKey_ctrl_f__
#define __ConsoleAnsiInputKey_ctrl_f__ ('f' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 7 __ConsoleAnsiInputKey_ctrl_g__
#define __ConsoleAnsiInputKey_ctrl_g__ ('g' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 8 also ctrl_bs __ConsoleAnsiInputKey_ctrl_h__
#define __ConsoleAnsiInputKey_ctrl_h__ ('h' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 9 also tab __ConsoleAnsiInputKey_ctrl_i__
#define __ConsoleAnsiInputKey_ctrl_i__ ('i' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 10 __ConsoleAnsiInputKey_ctrl_j__
#define __ConsoleAnsiInputKey_ctrl_j__ ('j' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 11 vertical_tab__ConsoleAnsiInputKey_ctrl_k__
#define __ConsoleAnsiInputKey_ctrl_k__ ('k' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 12 formFeed__ConsoleAnsiInputKey_ctrl_l__
#define __ConsoleAnsiInputKey_ctrl_l__ ('l' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 13 also enter __ConsoleAnsiInputKey_ctrl_m__
#define __ConsoleAnsiInputKey_ctrl_m__ ('m' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 14 __ConsoleAnsiInputKey_ctrl_n__
#define __ConsoleAnsiInputKey_ctrl_n__ ('n' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 15 __ConsoleAnsiInputKey_ctrl_o__
#define __ConsoleAnsiInputKey_ctrl_o__ ('o' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 16 __ConsoleAnsiInputKey_ctrl_p__
#define __ConsoleAnsiInputKey_ctrl_p__ ('p' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 17 __ConsoleAnsiInputKey_ctrl_q__
#define __ConsoleAnsiInputKey_ctrl_q__ ('q' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 18 __ConsoleAnsiInputKey_ctrl_r__
#define __ConsoleAnsiInputKey_ctrl_r__ ('r' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 19 __ConsoleAnsiInputKey_ctrl_s__
#define __ConsoleAnsiInputKey_ctrl_s__ ('s' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 20 __ConsoleAnsiInputKey_ctrl_t__
#define __ConsoleAnsiInputKey_ctrl_t__ ('t' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 21 __ConsoleAnsiInputKey_ctrl_u__
#define __ConsoleAnsiInputKey_ctrl_u__ ('u' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 22 __ConsoleAnsiInputKey_ctrl_v__
#define __ConsoleAnsiInputKey_ctrl_v__ ('v' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 23 __ConsoleAnsiInputKey_ctrl_w__
#define __ConsoleAnsiInputKey_ctrl_w__ ('w' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 24 __ConsoleAnsiInputKey_ctrl_x__
#define __ConsoleAnsiInputKey_ctrl_x__ ('x' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 25 __ConsoleAnsiInputKey_ctrl_y__
#define __ConsoleAnsiInputKey_ctrl_y__ ('y' + __ConsoleAnsiInputKey_ascii_ctrl__)
// # 26 __ConsoleAnsiInputKey_ctrl_z__
#define __ConsoleAnsiInputKey_ctrl_z__ ('z' + __ConsoleAnsiInputKey_ascii_ctrl__)
#define __ConsoleAnsiInputKey_special__ (1 << 8)
#define __ConsoleAnsiInputKey_functional__ (1 << 9)
#define __ConsoleAnsiInputKey_ctrl__ (1 << 10)
#define __ConsoleAnsiInputKey_alt__ (1 << 11)
#define __ConsoleAnsiInputKey_shift__ (1 << 12)
#define __ConsoleAnsiInputKey_mouse__ (1 << 13)
#define __ConsoleAnsiInputKey_f1__ (1 + __ConsoleAnsiInputKey_functional__)
#define __ConsoleAnsiInputKey_f2__ (2 + __ConsoleAnsiInputKey_functional__)
#define __ConsoleAnsiInputKey_f3__ (3 + __ConsoleAnsiInputKey_functional__)
#define __ConsoleAnsiInputKey_f4__ (4 + __ConsoleAnsiInputKey_functional__)
#define __ConsoleAnsiInputKey_f5__ (5 + __ConsoleAnsiInputKey_functional__)
#define __ConsoleAnsiInputKey_f6__ (6 + __ConsoleAnsiInputKey_functional__)
#define __ConsoleAnsiInputKey_f7__ (7 + __ConsoleAnsiInputKey_functional__)
#define __ConsoleAnsiInputKey_f8__ (8 + __ConsoleAnsiInputKey_functional__)
#define __ConsoleAnsiInputKey_f9__ (9 + __ConsoleAnsiInputKey_functional__)
#define __ConsoleAnsiInputKey_f10__ (10 + __ConsoleAnsiInputKey_functional__)
#define __ConsoleAnsiInputKey_f11__ (11 + __ConsoleAnsiInputKey_functional__)
#define __ConsoleAnsiInputKey_f12__ (12 + __ConsoleAnsiInputKey_functional__)
// left
#define __ConsoleAnsiInputKey_left__ (1 + __ConsoleAnsiInputKey_special__)
#define __ConsoleAnsiInputKey_ctrl_left__ (__ConsoleAnsiInputKey_left__ + __ConsoleAnsiInputKey_ctrl__)
#define __ConsoleAnsiInputKey_alt_left__ (__ConsoleAnsiInputKey_left__ + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_shift_left__ (__ConsoleAnsiInputKey_left__ + __ConsoleAnsiInputKey_shift__)
#define __ConsoleAnsiInputKey_ctrl_shift_left__ (__ConsoleAnsiInputKey_left__ + __ConsoleAnsiInputKey_ctrl__ + __ConsoleAnsiInputKey_shift__)
// right
#define __ConsoleAnsiInputKey_right__ (2 + __ConsoleAnsiInputKey_special__)
#define __ConsoleAnsiInputKey_ctrl_right__ (__ConsoleAnsiInputKey_right__ + __ConsoleAnsiInputKey_ctrl__)
#define __ConsoleAnsiInputKey_alt_right__ (__ConsoleAnsiInputKey_right__ + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_shift_right__ (__ConsoleAnsiInputKey_right__ + __ConsoleAnsiInputKey_shift__)
#define __ConsoleAnsiInputKey_ctrl_shift_right__ (__ConsoleAnsiInputKey_right__ + __ConsoleAnsiInputKey_ctrl__ + __ConsoleAnsiInputKey_shift__)
// up
#define __ConsoleAnsiInputKey_up__ (3 + __ConsoleAnsiInputKey_special__)
#define __ConsoleAnsiInputKey_ctrl_up__ (__ConsoleAnsiInputKey_up__ + __ConsoleAnsiInputKey_ctrl__)
#define __ConsoleAnsiInputKey_alt_up__ (__ConsoleAnsiInputKey_up__ + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_shift_up__ (__ConsoleAnsiInputKey_up__ + __ConsoleAnsiInputKey_shift__)
// down
#define __ConsoleAnsiInputKey_down__ (4 + __ConsoleAnsiInputKey_special__)
#define __ConsoleAnsiInputKey_ctrl_down__ (__ConsoleAnsiInputKey_down__ + __ConsoleAnsiInputKey_ctrl__)
#define __ConsoleAnsiInputKey_alt_down__ (__ConsoleAnsiInputKey_down__ + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_shift_down__ (__ConsoleAnsiInputKey_down__ + __ConsoleAnsiInputKey_shift__)
#define __ConsoleAnsiInputKey_delete__ (5 + __ConsoleAnsiInputKey_special__)
#define __ConsoleAnsiInputKey_shift_delete__ (__ConsoleAnsiInputKey_delete__ + __ConsoleAnsiInputKey_shift__)
#define __ConsoleAnsiInputKey_page_up__ (6 + __ConsoleAnsiInputKey_special__)
#define __ConsoleAnsiInputKey_page_down__ (7 + __ConsoleAnsiInputKey_special__)
#define __ConsoleAnsiInputKey_end__ (8 + __ConsoleAnsiInputKey_special__)
#define __ConsoleAnsiInputKey_home__ (9 + __ConsoleAnsiInputKey_special__)
#define __ConsoleAnsiInputKey_ctrl_enter__ (__ConsoleAnsiInputKey_enter__ + __ConsoleAnsiInputKey_special__ + __ConsoleAnsiInputKey_ctrl__)
#define __ConsoleAnsiInputKey_ctrl_triangular_open_quotation_mark__ ('<' + __ConsoleAnsiInputKey_special__ + __ConsoleAnsiInputKey_ctrl__)
#define __ConsoleAnsiInputKey_ctrl_triangular_close_quotation_mark__ ('>' + __ConsoleAnsiInputKey_special__ + __ConsoleAnsiInputKey_ctrl__)
#define __ConsoleAnsiInputKey_ctrl_alt_v__ ('v' + __ConsoleAnsiInputKey_alt__ + __ConsoleAnsiInputKey_ctrl__)
#define __ConsoleAnsiInputKey_alt_a__ ('a' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_b__ ('b' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_c__ ('c' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_d__ ('d' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_e__ ('e' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_f__ ('f' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_g__ ('g' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_h__ ('h' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_i__ ('i' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_j__ ('j' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_k__ ('k' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_l__ ('l' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_m__ ('m' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_n__ ('n' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_o__ ('o' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_p__ ('p' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_q__ ('q' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_r__ ('r' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_s__ ('s' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_t__ ('t' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_u__ ('u' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_v__ ('v' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_w__ ('w' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_x__ ('x' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_y__ ('y' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_z__ ('z' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_M__ ('M' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_N__ ('N' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_0__ ('0' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_1__ ('1' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_2__ ('2' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_3__ ('3' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_4__ ('4' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_5__ ('5' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_6__ ('6' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_7__ ('7' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_8__ ('8' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_9__ ('9' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_comma__ (',' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_dot__ ('.' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_open_bracket__ ('[' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_close_bracket__ (']' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_semicolon__ (';' + __ConsoleAnsiInputKey_alt__)
#define __ConsoleAnsiInputKey_alt_apostrophe__ ('`' + __ConsoleAnsiInputKey_alt__)
#define __Sha1Block_size__ 64
#define Sha1_digest_length 20
#define __NetworkTcpHttpWebSocketHeaderMask_size__ 4
#define __NetworkTcpHttpWebSocketHandShake_encoded_len__ 28
#define __NetworkTcpHttpWebSocketHeaderOpcode_continuation__ 0
#define __NetworkTcpHttpWebSocketHeaderOpcode_text__ 1
#define __NetworkTcpHttpWebSocketHeaderOpcode_binary__ 2
#define __NetworkTcpHttpWebSocketHeaderOpcode_close__ 8
#define __NetworkTcpHttpWebSocketHeaderOpcode_ping__ 9
#define __NetworkTcpHttpWebSocketHeaderOpcode_pong__ 10
// # __TimeStamp_len__
// for write time stamp like "00:00:00" as "HH:MM:SS" where HH - hours, MM - minuts, SS - seconds
#define __TimeStamp_len__ 8
#define __Time_nsPerFsec__ 0.000_000_001
#define __Time_usPerFsec__ 0.000_001
#define __Time_msPerFsec__ 0.001
#define __Time_msPerSec__ 1000
#define __Time_msPerS__ 1000
#define __Time_secPerMin__ 60
#define __Time_minPerHour__ 60
#define __Time_hourPerDay__ 24
#define __Time_daysPerWeek__ 7
#define __Hex_lenFromBytesLen__(len) (len * 2)
#define __Hex_bytesLenFromHex__(len) (len >> 1)
// # __u64FromTextDec_maxLen__
//#define __u64FromTextDec_maxLen__ __CText_len__("18446744073709551615")
#define __u64FromTextDec_maxLen__ 20
// # __TextCharsDecFromU64_lenMax__
//#define __TextCharsDecFromU64_lenMax__ __CText_len__("18446744073709551615")
#define __TextCharsDecFromU64_lenMax__ 20
#define __OsNetworkTcp_maxAllowedListenPort__ 49151
// # __OsConsoleOutput_writeCText__
#define __OsConsoleOutput_writeCText__( ctx, text) \
__OsConsoleOutput_write__( ctx, text, __CText_len__(text))
// # __Terminal_setFontStyleCText__
#define __Terminal_setFontStyleCText__( ctx, text) \
__Terminal_setFontStyle__( ctx, text, __CText_len__(text))
// # __Mem_fillAny__
#define __Mem_fillAny__( dest, symbol, len) \
__Mem_fill__( (char*)dest, symbol, len)
// # __OsFile_readToAny__
#define __OsFile_readToAny__( file, buffer, buffer_len, offset ) \
__OsFile_readToBuffer__( file, (char*) (buffer), buffer_len, offset )
// # __OsMem_allocAny__
#define __OsMem_allocAny__( ret_data_addr, size) \
__OsMem_alloc__( (uintptr_t*) (ret_data_addr), size)
// # __OsMem_freeAny__
#define __OsMem_freeAny__( ret_data_addr) \
__OsMem_free__( (uintptr_t) (ret_data_addr))
// # __AlignedPtr_allocAny__
#define __AlignedPtr_allocAny__( ret_data_addr, mem_align, size) \
__AlignedPtr_alloc__( (uintptr_t*) (ret_data_addr), mem_align, size)
// # __AlignedPtr_freeAny__
#define __AlignedPtr_freeAny__( ret_data_addr, size) \
__AlignedPtr_free__( (uintptr_t) (ret_data_addr), size)
// # __FileComplete_readToAny__
#define __FileComplete_readToAny__( ret_data_ptr, ret_file_data_size, file_name, file_name_len, align ) \
__FileComplete_read__( (uintptr_t*)ret_data_ptr, ret_file_data_size, file_name, file_name_len, align )
// imports
// libC
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fenv.h>
#include <float.h>
#include <inttypes.h>
#include <iso646.h>
#include <limits.h>
#include <locale.h>
#include <math.h>
#include <setjmp.h>
#include <signal.h>
#include <string.h>
#include <tgmath.h>
#include <time.h>
#include <uchar.h>
#include <wchar.h>
#include <wctype.h>
#if __target_os__ == __TargetOs_windows__
// posix
#include <fcntl.h>
// Windows
#if __with_network__
#include <ws2tcpip.h> // include before windows.h
#include <winsock2.h>
#endif
#include <windef.h>
#include <windows.h>
#include <winuser.h>
#include <commctrl.h>
#include <io.h>
#include <conio.h>
#ifdef __COMPILED_FROM_ZIG_FILE__
#define INVALID_HANDLE_VALUE (HANDLE)0xFFFFFFFF
#endif
#elif __target_os__ == __TargetOs_linux__
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <termios.h>
#include <unistd.h>
#include <time.h>
#if __with_network__
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <sys/socket.h>
#endif
#endif
// strings
// __ConsoleAnsi__
#define __ConsoleAnsi_esc__ "\x1B"
#define __ConsoleAnsi_control__ __ConsoleAnsi_esc__ "["
// clear_output
#define __ConsoleAnsi_output_clear_to_end_line__ __ConsoleAnsi_control__ "0K"
#define __ConsoleAnsi_output_clear_to_start_line__ __ConsoleAnsi_control__ "1K"
#define __ConsoleAnsi_output_clear_line__ __ConsoleAnsi_control__ "2K"
// cursor
#define __ConsoleAnsi_output_cursor_hide__ __ConsoleAnsi_control__ "?25l"
#define __ConsoleAnsi_output_cursor_show__ __ConsoleAnsi_control__ "?25h"
#define __ConsoleAnsiOutputCursorStyle_reset__ __ConsoleAnsi_control__ "0 q"
#define __ConsoleAnsi_output_cursor_style_blinking_block__ __ConsoleAnsi_control__ "1 q"
#define __ConsoleAnsi_output_cursor_style_steady_block__ __ConsoleAnsi_control__ "2 q"
#define __ConsoleAnsi_output_cursor_style_blinking_underline__ __ConsoleAnsi_control__ "3 q"
#define __ConsoleAnsi_output_cursor_style_steady_underline__ __ConsoleAnsi_control__ "4 q"
#define __ConsoleAnsi_output_cursor_style_blinking_I_beam__ __ConsoleAnsi_control__ "5 q"
#define __ConsoleAnsi_output_cursor_style_steady_I_beam__ __ConsoleAnsi_control__ "6 q"
// color
#define __ConsoleAnsiOutputFontStyle_color_zero__ "39"
#define __ConsoleAnsiOutputFontStyle_color_black__ "30"
#define __ConsoleAnsiOutputFontStyle_color_red__ "31"
#define __ConsoleAnsiOutputFontStyle_color_green__ "32"
#define __ConsoleAnsiOutputFontStyle_color_gold__ "33"
#define __ConsoleAnsiOutputFontStyle_color_blue__ "34"
#define __ConsoleAnsiOutputFontStyle_color_magenta__ "35"
#define __ConsoleAnsiOutputFontStyle_color_cyan__ "36"
#define __ConsoleAnsiOutputFontStyle_color_light_gray__ "37"
#define __ConsoleAnsiOutputFontStyle_color_gray__ "90"
#define __ConsoleAnsiOutputFontStyle_color_pink__ "91"
#define __ConsoleAnsiOutputFontStyle_color_light_green__ "92"
#define __ConsoleAnsiOutputFontStyle_color_yellow__ "93"
#define __ConsoleAnsiOutputFontStyle_color_light_blue__ "94"
#define __ConsoleAnsiOutputFontStyle_color_light_magenta__ "95"
#define __ConsoleAnsiOutputFontStyle_color_light_cyan__ "96"
#define __ConsoleAnsiOutputFontStyle_color_white__ "97"
#define __ConsoleAnsiOutputFontStyle_bg_color_zero__ "49"
#define __ConsoleAnsiOutputFontStyle_bg_color_black__ "40"
#define __ConsoleAnsiOutputFontStyle_bg_color_red__ "41"
#define __ConsoleAnsiOutputFontStyle_bg_color_green__ "42"
#define __ConsoleAnsiOutputFontStyle_bg_color_gold__ "43"
#define __ConsoleAnsiOutputFontStyle_bg_color_blue__ "44"
#define __ConsoleAnsiOutputFontStyle_bg_color_magenta__ "45"
#define __ConsoleAnsiOutputFontStyle_bg_color_cyan__ "46"
#define __ConsoleAnsiOutputFontStyle_bg_color_light_gray__ "47"
#define __ConsoleAnsiOutputFontStyle_bg_color_gray__ "100"
#define __ConsoleAnsiOutputFontStyle_bg_color_pink__ "101"
#define __ConsoleAnsiOutputFontStyle_bg_color_light_green__ "102"
#define __ConsoleAnsiOutputFontStyle_bg_color_yellow__ "103"
#define __ConsoleAnsiOutputFontStyle_bg_color_light_blue__ "104"
#define __ConsoleAnsiOutputFontStyle_bg_color_light_magenta__ "105"
#define __ConsoleAnsiOutputFontStyle_bg_color_light_cyan__ "106"
#define __ConsoleAnsiOutputFontStyle_bg_color_white__ "107"
#define __ConsoleAnsiOutputFontStyle_sep__ ";"
#define __ConsoleAnsiOutputFontStyle_end__ "m"
#define __ConsoleAnsiOutputFontStyle_reset__ "0"
#define __ConsoleAnsiOutputFontStyle_bold__ "1"
#define __ConsoleAnsiOutputFontStyle_dim__ "2"
#define __ConsoleAnsiOutputFontStyle_italic__ "3"
#define __ConsoleAnsiOutputFontStyle_underline__ "4"
#define __ConsoleAnsiOutputFontStyle_conceal__ "8"
#define __ConsoleAnsiOutputFontStyle_fraktur__ "20"
#define __ConsoleAnsiOutputFontStyle_unbold__ "21;24"
#define __ConsoleAnsiOutputFontStyle_set_color__ "38"
#define __ConsoleAnsiOutputFontStyle_set_bg_color__ "48"
#define __ConsoleAnsiOutputFontStyle_start__ __ConsoleAnsi_control__
#define __ConsoleAnsiOutputFontStyle_command_reset__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_reset__ \
__ConsoleAnsiOutputFontStyle_end__ \
// mouse
#define ansi_input_mouse_release __ConsoleAnsi_control__ "?1000l"
#define ansi_input_mouse_grab __ConsoleAnsi_control__ "?1000h"
// settings
#define __ConsoleAnsiOutputSettings_enableLineWrap__ __ConsoleAnsi_control__ "?7h"
#define __ConsoleAnsiOutputSettings_disableLineWrap__ __ConsoleAnsi_control__ "?7l"
#define __Base64StandardAlphabet_chars__ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
// # __OsFilePath_separator__
#if __target_os__ == __TargetOs_windows__
#define __OsFilePath_separator__ "\\"
#elif __target_os__ == __TargetOs_linux__
#define __OsFilePath_separator__ "/"
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
// basic types
// lib
// C
typedef float __Float32__;
typedef double __Float64__;
typedef long double __FloatExtraSize__;
// time
typedef __Float64__ __FSec__;
// # __ConsoleAnsiInputKey__
typedef
uint64_t
__ConsoleAnsiInputKey__
;
// # __WriteFnPtr__
typedef
size_t
(*__WriteFnPtr__)
(void* context, const char* bytes, size_t bytes_len)
;
// # __WriteFnPtrVoid__
typedef
void
(*__WriteFnPtrVoid__)
(void* context, const char* bytes, size_t bytes_len)
;
// OS
// # __OsFileHandle__
#if __target_os__ == __TargetOs_windows__
typedef HANDLE __OsFileHandle__;
#elif __target_os__ == __TargetOs_linux__
typedef int __OsFileHandle__;
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
// # __OsConsoleInputHandle__
#if __target_os__ == __TargetOs_windows__
typedef void* __OsConsoleInputHandle__;
#elif __target_os__ == __TargetOs_linux__
typedef FILE* __OsConsoleInputHandle__;
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
// # __OsConsoleOutputHandle__
#if __target_os__ == __TargetOs_windows__
typedef HANDLE __OsConsoleOutputHandle__;
#elif __target_os__ == __TargetOs_linux__
typedef int __OsConsoleOutputHandle__;
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
// # __OsNetworkTcpHandle__
#if __target_os__ == __TargetOs_windows__
typedef SOCKET __OsNetworkTcpHandle__;
#elif __target_os__ == __TargetOs_linux__
typedef int __OsNetworkTcpHandle__;
#else
#error "__target_os__ not implemented"
#endif
// struct prototypes
struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_parser__;
// structs
// lib
// core
// # __Trace__
struct __Trace__ {
struct __Trace__ *__Trace_prevTrace__;
size_t __Trace_line__;
};
// 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
}
*/
// # __MemListLink__
struct __MemListLink__ {
struct __MemListLink__* prev;
struct __MemListLink__* next;
struct __MemList__* list;
};
// # __MemList__
struct __MemList__ {
struct __MemListLink__* first;
struct __MemListLink__* 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
#if __target_os__ == __TargetOs_windows__
#elif __target_os__ == __TargetOs_linux__
// # __OsLinux_timespec__
struct __OsLinux_timespec__ {
time_t tv_sec; /* seconds */
long tv_nsec; /* nanoseconds */
};
#else
#error "__target_os__ not implemented"
#endif
// OsConsole
// # __OsConsoleFlags__
struct __OsConsoleFlags__ {
bool inited;
#if __target_os__ == __TargetOs_windows__
DWORD input_mode;
DWORD output_mode;
#elif __target_os__ == __TargetOs_linux__
struct termios termios;
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
};
// # __OsConsoleInput__
struct __OsConsoleInput__ {
__OsConsoleInputHandle__ handle;
#if __target_os__ == __TargetOs_windows__
#elif __target_os__ == __TargetOs_linux__
int fileno;
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
};
// # __OsConsoleOutput__
struct __OsConsoleOutput__ {
__OsConsoleOutputHandle__ __OsConsoleOutput_handle__;
#if __target_os__ == __TargetOs_windows__
#elif __target_os__ == __TargetOs_linux__
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
};
// # __OsHelper__
struct __OsHelper__ {
#if __target_os__ == __TargetOs_windows__
HINSTANCE instance;
void* console_input_handle;
__OsConsoleOutputHandle__ console_output_handle;
#if __with_network__
bool network_inited;
WSADATA wsdata;
#endif
#elif __target_os__ == __TargetOs_linux__
FILE* console_input_handle;
__OsConsoleOutputHandle__ console_output_handle;
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
};
// crypto
// # __CryptoRandom__
struct __CryptoRandom__ {
size_t seed;
};
// # __CryptoScalpiHash__
struct __CryptoScalpiHash__ {
uint8_t mask; // value with 4 ones and 4 zeros like: 0b00001111
uint8_t a;
uint8_t b;
};
// mem
// # __Writer__
struct __Writer__ {
void* context;
__WriteFnPtr__ write;
};
// # __MemTree__
struct __MemTree__ {
struct __MemList__ childs;
struct __MemListLink__ link;
size_t count; // recurse. for get non recurse use childs.count
size_t nested;
};
// math
// # __Math2dPosU__
struct __Math2dPosU__ {
size_t x;
size_t y;
};
// # __Math2dAreaU__
struct __Math2dAreaU__ {
struct __Math2dPosU__ from;
struct __Math2dPosU__ to;
};
// text
// # __TextFormatU64__
struct __TextFormatU64__ {
char buffer [__TextCharsDecFromU64_lenMax__];
char *ptr;
size_t len;
};
// # __Text_Splitter__
struct __Text_Splitter__ {
struct Finder finder;
bool stop;
size_t last_pos;
};
// # __Logger__
struct __Logger__ {
// write to terminal, console, file or to all together, but no real check "bytes is writen"
struct __Writer__ writers[4]; // __LoggerWriters__
};
// Console
// __ConsoleAnsiInputKey_SequenceParser__
// # __ConsoleAnsiInputKey_SequenceParser__
struct __ConsoleAnsiInputKey_SequenceParser__ {
__ConsoleAnsiInputKey__ sequence;
size_t used;
};
// # __ConsoleAnsi_input_Key_SequenceParser_fromBytes_parser__
struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_parser__ {
size_t text_len;
size_t len;
const struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo__ *ptr;
};
// # __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo__
struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo__ {
const char* __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__;
__ConsoleAnsiInputKey__ key;
};
struct __Console__ {
struct __OsConsoleInput__ input;
struct __OsConsoleOutput__ output;
};
// Terminal
struct __TerminalOutput__ {
struct __Math2dPosU__ cursor_pos;
const char* font_style;
size_t __TerminalOutput_fontStyleLen__;
struct __Math2dPosU__ size;
bool convert_n_to_rn;
bool apply_r;
bool apply_n;
};
struct __TerminalInput__ {
// usage:
// call __TerminalInput_updateBuffer__ for update unreaded
// use __TerminalInput_grab__ in loop for get keys
size_t ungrabed;
char buffer[__TerminalInput_size__];
};
struct __Terminal__ {
struct __Console__ *console;
struct __OsConsoleFlags__ system_flags;
struct __TerminalInput__ input;
struct __TerminalOutput__ output;
};
// crypto
// Sha1_Streaming
struct Sha1_Streaming {
uint32_t state[5];
char block[__Sha1Block_size__];
size_t buf_len; // current? filling level of block
uint64_t total_len;
};
struct RoundParam {uint32_t a; uint32_t b; uint32_t c; uint32_t d; uint32_t e; uint32_t i;};
// Time
// # __TimeClock__
struct __TimeClock__ {
uint64_t ms;
uint64_t sec;
uint64_t min;
uint64_t hour;
};
// # __TimeTotal__
struct __TimeTotal__ {
int64_t ms;
int64_t sec;
int64_t min;
int64_t hour;
int64_t day;
};
// network
// network_tcp_Ip
// ip
struct network_tcp_Ip {
uint8_t address[4];
uint16_t port;
};
struct __NetworkTcpIpToText__ {
/// 255.255.255.255:65535
/// 127. 0. 0. 1:27015
/// 0. 0. 0. 1: 0
char buffer[25];
size_t len;
};
#if __with_network__
struct __NetworkTcpVisitor__ {
__OsNetworkTcpHandle__ socket_handle;
struct network_tcp_Ip ip;
struct sockaddr_in addr;
};
#endif
// # __NetworkTcpServer__
struct __NetworkTcpServer__ {
bool __NetworkTcpServer_ready__;
__OsNetworkTcpHandle__ __NetworkTcpServer_socketHandle__;
size_t __NetworkTcpServer_maxWaitingClients__;
uint16_t port;
};
// network_tcp_http_WebSocket
// real struct of web socket header:
// fin_flag: u1 = 1,
// rsv: [3]u1 = .{0,0,0},
// opcode: Opcode = .binary, // may be text
// mask_flag: u1 = 0,
// payload_len: u7 = 0,
// extended_payload_len: u16 or u64 or void (optional)
// masking_key: u64 or void (optional)
struct network_tcp_http_WebSocket_Parser {
char* message; // no null
size_t frame_len;
size_t header_len;
size_t message_len;
};
// __App__
// # __AppEditorLine__
struct __AppEditorLine__ {
struct __MemListLink__ link; // used in Views.Flat.lines for iterating
struct __MemTree__ tree; // used in Views.Fold.lines
char text[__AppEditorLineLen_max__]; // todo use ptr to allocated data
size_t text_len;
};
// # __AppEditorHistoryNote__
struct __AppEditorHistoryNote__ {
__ConsoleAnsiInputKey__ key;
struct __MemListLink__ link;
};
// # __AppEditorViewsVTable__
struct __AppEditorViewsVTable__ {
size_t (*getOffsetX) (void *t);
size_t (*getOffsetY) (void *t);
size_t (*getSymbolPosX) (void *t);
size_t (*countLineNum) (void *t);
void (*setAsView) (void *t);
void (*goToPrevLine) (void *t);
void (*goToNextLine) (void *t);
void (*goToSymbolPosX) (void *t, size_t pos);
void (*goToLineFromNumber) (void *t, size_t num);
};
// # __AppEditorViewsFlat__
struct __AppEditorViewsFlat__ {
struct __AppEditorLine__ *line; // current working line - is setted by outside.
struct __AppEditorLine__ *marked_line; // can be null
struct __MemList__ lines;
struct __MemList__ cutted;
struct __AppEditorLine__ bakup_line;
struct __Math2dPosU__ offset;
size_t symbol;
bool __AppEditorViewsFlat_autoSpace__;
bool need_redraw;
bool need_draw_line_num;
};
// # __AppEditorViewsFolded__
struct __AppEditorViewsFolded__ {
struct __AppEditorLine__ *line;
struct __AppEditorLine__ *marked_line;
struct __MemTree__ lines;
struct __MemTree__ cutted;
struct __AppEditorLine__ bakup_line;
struct __Math2dPosU__ offset;
size_t symbol;
bool need_redraw;
bool need_draw_line_num;
};
// # __AppEditorViewsGoToLine__
struct __AppEditorViewsGoToLine__ {
struct __AppEditorLine__ line;
const struct __AppEditorViewsVTable__ *context_vtable;
void *context;
size_t symbol;
struct __Math2dPosU__ offset;
bool need_redraw;
};
// # __AppEditorViewsFind__
struct __AppEditorViewsFind__ {
struct __Math2dPosU__ offset;
struct __AppEditorLine__ line;
const struct __AppEditorViewsVTable__ *context_vtable;
void *context;
size_t symbol;
bool need_redraw;
};
// # __AppEditorViewsReplace__
struct __AppEditorViewsReplace__ {
struct __AppEditorLine__ line;
struct __Math2dPosU__ offset;
const struct __AppEditorViewsVTable__ *context_vtable;
void *context;
size_t symbol;
bool need_redraw;
};
// # __AppEditorViews__
struct __AppEditorViews__ {
struct __AppEditorViewsReplace__ replace;
struct __AppEditorViewsFind__ find;
struct __AppEditorViewsGoToLine__ go_to_line;
struct __AppEditorViewsFlat__ flat;
struct __AppEditorViewsFolded__ folded;
};
// # __AppEditor__
struct __AppEditor__ {
struct __MemList__ history;
struct __AppEditorViews__ views;
const char *__AppEditor_endLine__;
struct __MemListLink__ *stop_record_link;
struct __MemListLink__ *start_record_link;
void (*do_ptr) (void *ctx); // can be null
void (*onKey_ptr) (void *ctx, __ConsoleAnsiInputKey__ key); // can be null
void *current_ctx; // can be null
const struct __AppEditorViewsVTable__ *current_vtable; // can be null
size_t __AppEditor_fileName_len__;
size_t __AppEditor_pathToClipboard_len__;
size_t __AppEditor_endLine_len__;
size_t lines_drawing;
char __AppEditor_fileName__ [__OsFilePathLen_max__];
char __AppEditor_pathToClipboard__ [__OsFilePathLen_max__];
bool working;
bool recording_macro;
bool inited;
};
// # __App__
struct __App__ {
struct __OsHelper__ __App_osHelper__;
struct __Logger__ __App_logger__;
struct __Console__ console;
struct __Terminal__ terminal;
struct __AppEditor__ editor;
int64_t tick; // time ms
bool working;
};
// typedef to fn_ptrs
// function prototypes
uint8_t __crypto_sumBytes__ ( const char *data, size_t data_len);
uint8_t __crypto_xorBytes__ ( const char *data, size_t data_len);
void __crypto_xorCyclic__ ( char *dest, const char *a, size_t dest_len, const char *b, size_t b_len);
void __CryptoScalpiHash_do__ ( struct __CryptoScalpiHash__ *t, const char *src, size_t src_size, char *dest, size_t dest_size);
void __CryptoScalpiHash_reset__ ( struct __CryptoScalpiHash__ *t);
bool __Mem_isEql__ ( const char a[], const char b[], size_t len);
void __MemTree_fix_counts__ ( struct __MemTree__ *t, size_t delta_count, char action);
void __MemTree_fix_nested__ ( struct __MemTree__ *t, size_t nested_delta, char action);
void __MemTree_getParent__ ( struct __MemTree__ **ret, struct __MemTree__ *tree);
struct __MemTree__* __MemTree_getParentOrNull__ ( struct __MemTree__ *tree);
void __MemTree_pushNext__ ( struct __MemTree__ *t, struct __MemTree__ *item);
struct __MemTree__* __MemTree_traverse__ ( struct __MemTree__ *tree);
void __MemList_init__ ( struct __MemList__* list);
bool __OsConsoleOutput_write__ ( struct __OsConsoleOutput__* os_console_output, const char* data, size_t _len);
size_t __OsFallbackConsole_write__ ( void* unused_ctx, char* data, size_t len);
bool __OsFile_exist__ ( const char* file_name, size_t file_name_len);
void __OsFile_truncate__ ( __OsFileHandle__ file);
void __OsFile_setPos__ ( __OsFileHandle__ file, size_t pos);
bool __OsMem_alloc__ ( uintptr_t *ret_data_addr, size_t size);
void __OsMem_free__ ( uintptr_t ret_data_addr);
void __Terminal_cursorMove__ ( struct __Terminal__ *terminal, size_t pos_x, size_t pos_y);
void __Terminal_moveCursorToStartOfLine__ ( struct __Terminal__ *terminal);
void __TerminalInput_shift__ ( struct __TerminalInput__ *t, size_t val);
size_t __Text_countIndent__ ( char* text, size_t text_len, size_t tab_size);
size_t __TextAscii_countIndent__ ( const char *text, size_t text_len, size_t tabsize);
bool __TextAsciiSymbol_isBreakWord__ ( char symbol);
size_t __ZText_countLen__ ( const char text[]);
// globals
// ansi
// # __ConsoleAnsi_input_Key_SequenceParser_sequences_9__
struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo__ __ConsoleAnsi_input_Key_SequenceParser_sequences_9__[] = {
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x32\x37\x3B\x35\x3B\x31\x33\x7E", .key = __ConsoleAnsiInputKey_ctrl_enter__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "[27;5;44~", .key = __ConsoleAnsiInputKey_ctrl_triangular_open_quotation_mark__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "[27;5;46~", .key = __ConsoleAnsiInputKey_ctrl_triangular_close_quotation_mark__ },
};
// # __ConsoleAnsi_input_Key_SequenceParser_sequences_5__
struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo__ __ConsoleAnsi_input_Key_SequenceParser_sequences_5__[] = {
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x32\x41", .key = __ConsoleAnsiInputKey_shift_up__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x33\x41", .key = __ConsoleAnsiInputKey_alt_up__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x35\x41", .key = __ConsoleAnsiInputKey_ctrl_up__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x32\x42", .key = __ConsoleAnsiInputKey_shift_down__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x33\x42", .key = __ConsoleAnsiInputKey_alt_down__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x35\x42", .key = __ConsoleAnsiInputKey_ctrl_down__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x32\x43", .key = __ConsoleAnsiInputKey_shift_right__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x33\x43", .key = __ConsoleAnsiInputKey_alt_right__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x35\x43", .key = __ConsoleAnsiInputKey_ctrl_right__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x36\x43", .key = __ConsoleAnsiInputKey_ctrl_shift_right__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x35\x44", .key = __ConsoleAnsiInputKey_ctrl_left__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x36\x44", .key = __ConsoleAnsiInputKey_ctrl_shift_left__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x32\x44", .key = __ConsoleAnsiInputKey_shift_left__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x3B\x33\x44", .key = __ConsoleAnsiInputKey_alt_left__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x33\x3B\x32\x7E", .key = __ConsoleAnsiInputKey_shift_delete__ },
};
// # __ConsoleAnsi_input_Key_SequenceParser_sequences_4__
struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo__ __ConsoleAnsi_input_Key_SequenceParser_sequences_4__[] = {
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x31\x7E", .key = __ConsoleAnsiInputKey_f1__ }, // rxvt
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x32\x7E", .key = __ConsoleAnsiInputKey_f2__ }, // rxvt
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x35\x7E", .key = __ConsoleAnsiInputKey_f5__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x37\x7E", .key = __ConsoleAnsiInputKey_f6__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x38\x7E", .key = __ConsoleAnsiInputKey_f7__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x31\x39\x7E", .key = __ConsoleAnsiInputKey_f8__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x32\x30\x7E", .key = __ConsoleAnsiInputKey_f9__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x32\x31\x7E", .key = __ConsoleAnsiInputKey_f10__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x32\x33\x7E", .key = __ConsoleAnsiInputKey_f11__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x32\x34\x7E", .key = __ConsoleAnsiInputKey_f12__ },
};
// # __ConsoleAnsi_input_Key_SequenceParser_sequences_3__
struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo__ __ConsoleAnsi_input_Key_SequenceParser_sequences_3__[] = {
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x5B\x41", .key = __ConsoleAnsiInputKey_f1__ }, // tty
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x5B\x42", .key = __ConsoleAnsiInputKey_f2__ }, // tty
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x5B\x43", .key = __ConsoleAnsiInputKey_f3__ }, // tty
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x5B\x44", .key = __ConsoleAnsiInputKey_f4__ }, // tty
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x33\x7E", .key = __ConsoleAnsiInputKey_delete__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x35\x7E", .key = __ConsoleAnsiInputKey_page_up__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x36\x7E", .key = __ConsoleAnsiInputKey_page_down__ },
};
// # __ConsoleAnsi_input_Key_SequenceParser_sequences_2__
struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo__ __ConsoleAnsi_input_Key_SequenceParser_sequences_2__[] = {
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x4F\x50", .key = __ConsoleAnsiInputKey_f1__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x4F\x51", .key = __ConsoleAnsiInputKey_f2__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x4F\x52", .key = __ConsoleAnsiInputKey_f3__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x4F\x53", .key = __ConsoleAnsiInputKey_f4__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x4F\x64", .key = __ConsoleAnsiInputKey_ctrl_left__ }, // rxvt
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x4F\x63", .key = __ConsoleAnsiInputKey_ctrl_right__ }, // rxvt
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x41", .key = __ConsoleAnsiInputKey_up__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x42", .key = __ConsoleAnsiInputKey_down__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x43", .key = __ConsoleAnsiInputKey_right__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x44", .key = __ConsoleAnsiInputKey_left__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x46", .key = __ConsoleAnsiInputKey_end__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B\x48", .key = __ConsoleAnsiInputKey_home__ },
};
// # __ConsoleAnsi_input_Key_SequenceParser_sequences_1__
struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo__ __ConsoleAnsi_input_Key_SequenceParser_sequences_1__[] = {
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x16", .key = __ConsoleAnsiInputKey_ctrl_alt_v__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x27", .key = __ConsoleAnsiInputKey_alt_apostrophe__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x2C", .key = __ConsoleAnsiInputKey_alt_comma__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x2E", .key = __ConsoleAnsiInputKey_alt_dot__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x30", .key = __ConsoleAnsiInputKey_alt_0__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x31", .key = __ConsoleAnsiInputKey_alt_1__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x32", .key = __ConsoleAnsiInputKey_alt_2__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x33", .key = __ConsoleAnsiInputKey_alt_3__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x34", .key = __ConsoleAnsiInputKey_alt_4__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x35", .key = __ConsoleAnsiInputKey_alt_5__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x36", .key = __ConsoleAnsiInputKey_alt_6__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x37", .key = __ConsoleAnsiInputKey_alt_7__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x38", .key = __ConsoleAnsiInputKey_alt_8__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x39", .key = __ConsoleAnsiInputKey_alt_9__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x3B", .key = __ConsoleAnsiInputKey_alt_semicolon__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x4D", .key = __ConsoleAnsiInputKey_alt_M__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x61", .key = __ConsoleAnsiInputKey_alt_a__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x62", .key = __ConsoleAnsiInputKey_alt_b__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x63", .key = __ConsoleAnsiInputKey_alt_c__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x64", .key = __ConsoleAnsiInputKey_alt_d__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x65", .key = __ConsoleAnsiInputKey_alt_e__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x66", .key = __ConsoleAnsiInputKey_alt_f__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x67", .key = __ConsoleAnsiInputKey_alt_g__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x68", .key = __ConsoleAnsiInputKey_alt_h__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x69", .key = __ConsoleAnsiInputKey_alt_i__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x6A", .key = __ConsoleAnsiInputKey_alt_j__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x6B", .key = __ConsoleAnsiInputKey_alt_k__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x6C", .key = __ConsoleAnsiInputKey_alt_l__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x6E", .key = __ConsoleAnsiInputKey_alt_n__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x6F", .key = __ConsoleAnsiInputKey_alt_o__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x6D", .key = __ConsoleAnsiInputKey_alt_m__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x70", .key = __ConsoleAnsiInputKey_alt_p__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x71", .key = __ConsoleAnsiInputKey_alt_q__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x72", .key = __ConsoleAnsiInputKey_alt_r__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x73", .key = __ConsoleAnsiInputKey_alt_s__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x74", .key = __ConsoleAnsiInputKey_alt_t__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x75", .key = __ConsoleAnsiInputKey_alt_u__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x76", .key = __ConsoleAnsiInputKey_alt_v__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x77", .key = __ConsoleAnsiInputKey_alt_w__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x78", .key = __ConsoleAnsiInputKey_alt_x__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x79", .key = __ConsoleAnsiInputKey_alt_y__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x7A", .key = __ConsoleAnsiInputKey_alt_z__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5B", .key = __ConsoleAnsiInputKey_alt_open_bracket__ },
{ .__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__ = "\x5D", .key = __ConsoleAnsiInputKey_alt_close_bracket__ },
};
// # __ConsoleAnsi_input_Key_SequenceParser_fromBytes_parsers__
struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_parser__ __ConsoleAnsi_input_Key_SequenceParser_fromBytes_parsers__[] = {
{ .text_len = 9, .len = __arrayLen__(__ConsoleAnsi_input_Key_SequenceParser_sequences_9__), .ptr = &__ConsoleAnsi_input_Key_SequenceParser_sequences_9__ },
{ .text_len = 5, .len = __arrayLen__(__ConsoleAnsi_input_Key_SequenceParser_sequences_5__), .ptr = &__ConsoleAnsi_input_Key_SequenceParser_sequences_5__ },
{ .text_len = 4, .len = __arrayLen__(__ConsoleAnsi_input_Key_SequenceParser_sequences_4__), .ptr = &__ConsoleAnsi_input_Key_SequenceParser_sequences_4__ },
{ .text_len = 3, .len = __arrayLen__(__ConsoleAnsi_input_Key_SequenceParser_sequences_3__), .ptr = &__ConsoleAnsi_input_Key_SequenceParser_sequences_3__ },
{ .text_len = 2, .len = __arrayLen__(__ConsoleAnsi_input_Key_SequenceParser_sequences_2__), .ptr = &__ConsoleAnsi_input_Key_SequenceParser_sequences_2__ },
{ .text_len = 1, .len = __arrayLen__(__ConsoleAnsi_input_Key_SequenceParser_sequences_1__), .ptr = &__ConsoleAnsi_input_Key_SequenceParser_sequences_1__ },
};
// # __ConsoleAnsi_input_Key_SequenceParser_fromBytes__
bool __ConsoleAnsi_input_Key_SequenceParser_fromBytes__(
struct __ConsoleAnsiInputKey_SequenceParser__ *out,
const char *data,
size_t data_len
) {
if (data[0] == '\x1B') {
const char* user_sequence = &data[1];
size_t user_sequence_len = data_len - 1;
if (user_sequence_len >= 5 and __Mem_isEql__(user_sequence, "\x5B\x4D", 2)) { // mouse
out->sequence = __ConsoleAnsiInputKey_mouse__;
out->used = 6;
return true;
}
// reverse iterating about __ConsoleAnsi_input_Key_SequenceParser_fromBytes_parsers__
for (size_t parser_id = 0; parser_id < __arrayLen__(__ConsoleAnsi_input_Key_SequenceParser_fromBytes_parsers__); parser_id++) {
struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_parser__ *parser = &__ConsoleAnsi_input_Key_SequenceParser_fromBytes_parsers__[parser_id];
size_t check_len = parser->text_len;
if (user_sequence_len >= check_len) {
size_t seq_count = parser->len;
const struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo__ *seq_list = parser->ptr;
for (size_t seq_id = 0; seq_id < seq_count; seq_id++) {
const struct __ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo__* seq = &seq_list[seq_id];
if (__Mem_isEql__(user_sequence, &seq->__ConsoleAnsi_input_Key_SequenceParser_fromBytes_SequenceInfo_text__[0], check_len)) {
out->sequence = seq->key;
out->used = check_len + 1;
return true;
}
}
}
}
}
return false;
}
// __App__
struct __App__ __app__;
struct __AppEditorViewsVTable__ __AppEditorViewsVtable_flat__;
struct __AppEditorViewsVTable__ __AppEditorViewsVtable_folded__;
void* __AppEditorViewsEasyMotionHorizontal_context__;
const struct __AppEditorViewsVTable__* __AppEditorViewsEasyMotionHorizontalContext_vtable__;
void* __AppEditorViewsEasyMotionVertical_context__;
const struct __AppEditorViewsVTable__* __AppEditorViewsEasyMotionVertical_context_vtable__;
// functions
// lib
// TRACE
// # __Trace_init__
void __Trace_init__(
struct __Trace__ *trace,
struct __Trace__ *prev_trace, // can be null
size_t line
) {
trace->__Trace_prevTrace__ = prev_trace;
trace->__Trace_line__ = line;
}
// # __Trace_print__
void __Trace_print__(
struct __Trace__ *trace
) {
if (trace) {
printf("%zu", trace->__Trace_line__);
trace = trace->__Trace_prevTrace__;
while (trace) {
printf("|%zu", trace->__Trace_line__);
trace = trace->__Trace_prevTrace__;
}
} else {
printf("nil");
}
}
// # print_trace_example
void print_trace_example(
int anyarg,
struct __Trace__* prev_trace
) {
struct __Trace__ trace; __Trace_init__(&trace, prev_trace, __LINE__);
trace.__Trace_line__ = __LINE__; __Trace_print__(&trace);
}
// # call_other_trace_example
void call_other_trace_example(
struct __Trace__* prev_trace // can be null
) {
struct __Trace__ trace; __Trace_init__(&trace, prev_trace, __LINE__);
trace.__Trace_line__ = __LINE__; print_trace_example(0, &trace);
}
// mem
// bits
uint8_t bits_rotl8(uint8_t value, unsigned int shift) {
shift %= 8;
return (value << shift) | (value >> (8 - shift));
}
uint16_t bits_rotl16(uint16_t value, unsigned int shift) {
shift %= 16;
return (value << shift) | (value >> (16 - shift));
}
uint32_t bits_rotl32(uint32_t value, unsigned int shift) {
shift %= 32;
return (value << shift) | (value >> (32 - shift));
}
uint64_t bits_rotl64(uint64_t value, unsigned int shift) {
shift %= 64;
return (value << shift) | (value >> (64 - shift));
}
// bytes
// # __Mem_fill__
void __Mem_fill__(
char *dest,
char symbol,
size_t len
) {
for (size_t pos = 0; pos < len; pos++) {
dest[pos] = symbol;
}
}
// # __Mem_copy__
void __Mem_copy__( // todo create macros __Mem_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++;
}
}
// # __Mem_copyBackward__
void __Mem_copyBackward__(char* dest, const char* src, size_t size) {
size_t pos = size;
while(pos > 0) {
pos-=1;
dest[pos] = src[pos];
}
}
// # __Mem_reverse__
void __Mem_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;
}
}
// # __Mem_find__
bool __Mem_find__(
size_t *ret_pos, // this value increment by this func
const char *data,
size_t data_len, // expected >= desired_len
const char *desired,
size_t desired_len // expected >= 1
) {
bool finded = false;
size_t last_pos = data_len - desired_len;
for (uintptr_t pos = 0; pos <= last_pos; pos++) {
size_t slice_len = data_len - pos;
if (slice_len >= desired_len) {
if (__Mem_isEql__(&data[pos], desired, desired_len)) {
*ret_pos = pos;
finded = true;
break;
}
} else {
break;
}
}
return finded;
}
// # __Mem_findFast__
bool __Mem_findFast__(
size_t *ret_pos, // expected value 0
const char *data,
size_t data_len, // expected > 0
const char *desired,
size_t desired_len // expected > 0 // expected <= data_len // optimal > 4
) {
bool finded = false;
if (desired_len <= 4) {
if (data_len >= desired_len and __Mem_find__(ret_pos, data, data_len, desired, desired_len)) {
finded = true;
}
} else {
size_t final_check_pos = data_len - desired_len;
uint8_t target_sum = __crypto_sumBytes__(desired, desired_len);
uint8_t target_xor = __crypto_xorBytes__(desired, desired_len);
uint8_t hash_sum = __crypto_sumBytes__(data, desired_len);
uint8_t hash_xor = __crypto_xorBytes__(data, desired_len);
for (size_t pos = 0; pos <= final_check_pos; pos++) {
if (true
and hash_xor == target_xor
and hash_sum == target_sum
) {
if (__Mem_isEql__(&data[pos], desired, desired_len)) {
finded = true;
*ret_pos += pos;
break;
}
}
uint8_t last_start_byte = data[pos];
hash_xor ^= last_start_byte;
hash_sum -= last_start_byte;
uint8_t new_byte_end = data[pos + desired_len];
hash_xor ^= new_byte_end;
hash_sum += new_byte_end;
}
}
return finded;
}
// # __mem_findFastReverse__
bool __mem_findFastReverse__(
size_t *ret_pos, // func increment this
const char *data,
size_t data_len, // expected >= 1
const char *desired,
size_t desired_len // expected <= data_len
) {
bool finded = false;
size_t final_check_pos = data_len - desired_len;
if (desired_len <= 4) {
for (size_t pos = 0; pos <= final_check_pos + 1; pos++) {
size_t rpos = final_check_pos - pos;
if (__Mem_isEql__(&data[rpos], desired, desired_len)) {
*ret_pos += rpos;
finded = true;
break;
}
}
} else {
const char* final_check_ptr = &data[final_check_pos];
if (__Mem_isEql__(final_check_ptr, desired, desired_len)) {
finded = true;
*ret_pos += final_check_pos;
} else {
uint8_t target_sum = __crypto_sumBytes__(desired, desired_len);
uint8_t target_xor = __crypto_xorBytes__(desired, desired_len);
uint8_t hash_sum = __crypto_sumBytes__(final_check_ptr, desired_len);
uint8_t hash_xor = __crypto_xorBytes__(final_check_ptr, desired_len);
for (size_t pos = 1; pos <= final_check_pos + 1; pos++) {
size_t rpos = final_check_pos - pos;
uint8_t last_final_byte = data[rpos + desired_len];
hash_xor ^= last_final_byte;
hash_sum -= last_final_byte;
uint8_t new_byte = data[rpos];
hash_xor ^= new_byte;
hash_sum += new_byte;
if (
(hash_xor == target_xor)
and (hash_sum == target_sum)
and (__Mem_isEql__(&data[rpos], desired, desired_len))
) {
*ret_pos += rpos;
finded = true;
break;
}
}
}
}
return finded;
}
// # __Mem_findDiffOrLen__
size_t __Mem_findDiffOrLen__(const char a[], const char b[], size_t len) {
size_t pos = 0;
while(pos < len) {
if (a[pos] != b[pos]) break;
pos++;
}
return pos;
}
// # __Mem_isEql__
bool __Mem_isEql__(const char a[], const char b[], size_t len) {
return __Mem_findDiffOrLen__(a, b, len) == len;
}
// # __Mem_isEql_test__
bool __Mem_isEql_test__() {
return true
and (__Mem_isEql__("abcd", "abcd", 4))
and (__Mem_isEql__("abcd", "abce", 4) == false)
and (__Mem_isEql__("abcdasdasd", "asd", 3) == false)
;
}
// # writeWithOffset
void writeWithOffset(
char *dest,
size_t *writed,
char *data,
size_t data_len // increment by fn
) {
__Mem_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_memoryType__ == current_endians) {
return true;
} else {
printf("%d wrong MEMORY_TYPE !\r\n", __LINE__);
}
return false;
}
// read unaligned memory
// big
uint16_t readBig16(char* src) {
uint16_t ret;
__Mem_nativeToBig__( (char*) &ret, src, 2);
return ret;
}
uint32_t readBig32(char* src) {
uint32_t ret;
__Mem_nativeToBig__( (char*) &ret, src, 4);
return ret;
}
uint64_t readBig64(char* src) {
uint64_t ret;
__Mem_nativeToBig__( (char*) &ret, src, 8);
return ret;
}
// little
uint16_t readLittle16(char* src) {
uint16_t ret;
__Mem_nativeToLittle__( (char*) &ret, src, 2);
return ret;
}
uint32_t readLittle32(char* src) {
uint32_t ret;
__Mem_nativeToLittle__( (char*) &ret, src, 4);
return ret;
}
uint64_t readLittle64(char* src) {
uint64_t ret;
__Mem_nativeToLittle__( (char*) &ret, src, 8);
return ret;
}
// write unaligned memory
// big
// # writeBig16
void writeBig16(
char *dest,
uint16_t value
) {
__Mem_nativeToBig__( dest, (char*)&value, 2);
}
// # writeBig32
void writeBig32(
char *dest,
uint32_t value
) {
__Mem_nativeToBig__(dest, (char*)&value, 4);
}
// # writeBig64
void writeBig64(
char *dest,
uint64_t value
) {
__Mem_nativeToBig__(dest, (char*)&value, 8);
}
// little
// # writeLittle16
void writeLittle16(
char *dest,
uint16_t value
) {
__Mem_nativeToLittle__(dest, (char*)&value, 2);
}
// # writeLittle32
void writeLittle32(
char *dest,
uint32_t value
) {
__Mem_nativeToLittle__(dest, (char*)&value, 4);
}
// # writeLittle64
void writeLittle64(
char *dest,
uint64_t value
) {
__Mem_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 {
printf("%zu: %s (%zu): \"%.*s", line, name, slice->len, (int)slice->len, slice->ptr);
}
}
// # isStartWith
bool isStartWith(struct Slice* a, struct Slice* b) {
return (a->len >= b->len) && __Mem_isEql__(a->ptr, b->ptr, b->len);
}
// Buffer
// # __Buffer_push__
void __Buffer_push__(
char *buffer,
size_t *buffer_used, // expected < allocated
size_t pos, // expected < allocated
char item
) {
if (pos < *buffer_used) { // shiftSymbolsToRight
__Mem_copyBackward__(&buffer[pos + 1], &buffer[pos], *buffer_used - pos);
}
buffer[pos] = item;
(*buffer_used)++;
}
// # __Buffer_pop_check__
bool __Buffer_pop_check__(
size_t buffer_used,
size_t pos
) {
return ((buffer_used > 0) and (pos < buffer_used));
}
// # __Buffer_pop__
char __Buffer_pop__(
char *buffer,
size_t *buffer_used, // expected (*) > 0
size_t pos // expected <= buffer_used
) {
char ret = buffer[pos];
(*buffer_used)--;
if (pos < *buffer_used) {
__Mem_copy__(&buffer[pos], &buffer[pos + 1], *buffer_used - pos);
}
return ret;
}
// # __Buffer_addIndent_check__
bool
__Buffer_addIndent_check__(
char *buffer,
size_t *buffer_used,
size_t buffer_max,
size_t count
) {
size_t space = buffer_max - *buffer_used;
return space > count;
}
// # __Buffer_addIndent__
void __Buffer_addIndent__(
char *buffer,
size_t *buffer_used,
size_t count // expected < (buffer_max - *buffer_used)
) {
size_t pos = 0;
while (pos < count) {
__Buffer_push__(buffer, buffer_used, 0, ' ');
pos = pos + 1;
}
}
// # __Buffer_removeIndent__
void
__Buffer_removeIndent__(
char *buffer,
size_t *buffer_used, // expected >= count
size_t count // expected <= buffer_used
) {
size_t pos = 0;
while (pos < count) {
__Buffer_pop__(
buffer,
buffer_used, // (*) > 0 becouse expected *buffer_used >= loop_count
0
);
pos += 1;
}
}
// # __Buffer_setIndent__
bool
__Buffer_setIndent__(
char *buffer,
size_t *buffer_used,
size_t buffer_max,
size_t new_indent // expected < buffer_max
) {
bool ok = true;
size_t indent = __Text_countIndent__(buffer, *buffer_used, 1);
if (new_indent != indent) {
if (new_indent > indent) {
size_t delta = new_indent - indent;
if (__Buffer_addIndent_check__(buffer, buffer_used, buffer_max, delta)) {
__Buffer_addIndent__(buffer, buffer_used, delta);
} else {
ok = false;
}
} else { // new_indent < indent
size_t delta = indent - new_indent;
__Buffer_removeIndent__(buffer, buffer_used, delta);
}
}
return ok;
}
// Finder
// # __Finder_init__
void __Finder_init__(
struct Finder* t,
char* text,
size_t text_len,
char* desired,
size_t desired_len
) {
t->pos = 0;
t->text.ptr = text;
t->text.len = text_len;
t->desired.ptr = desired;
t->desired.len = desired_len;
}
// # __Finder_next__
bool __Finder_next__(
struct Finder* t,
size_t* out_pos
) {
if (t->pos != t->text.len) {
char *data = &t->text.ptr[t->pos];
size_t data_len = t->text.len - t->pos;
size_t finded = 0;
if ( true
and t->desired.len > 0
and data_len >= t->desired.len
and __Mem_find__(
&finded,
data,
data_len,
t->desired.ptr,
t->desired.len
)
) {
size_t new_pos = t->pos + finded;
t->pos = new_pos + t->desired.len;
*out_pos = new_pos;
return true;
}
}
return false;
}
// List
// __MemListLink__
// # __MemListLink_isFirst__
bool
__MemListLink_isFirst__(
struct __MemListLink__* link
) {
struct __MemListLink__* prev = link->prev;
bool prev_is_null = (link->prev) == NULL;
return prev_is_null;
}
// # __MemListLink_resetLinks__
void __MemListLink_resetLinks__(struct __MemListLink__* link) {
link->prev = NULL;
link->next = NULL;
link->list = NULL;
}
// # __MemListLink_init__
void __MemListLink_init__(
struct __MemListLink__* link
) {
__MemListLink_resetLinks__(link);
}
// # __MemList_pushFirst__
void __MemList_pushFirst__(
struct __MemList__ *list,
struct __MemListLink__ *item // expected freed item
) {
struct __MemListLink__* first = list->first;
if (first) { // list not empty
first->prev = item;
item->next = first;
} else { // list is empty
list->last = item;
}
list->first = item;
item->list = list;
list->count += 1;
}
// # __MemList_pushLast__
void __MemList_pushLast__(
struct __MemList__ *list,
struct __MemListLink__ *item
) {
struct __MemListLink__* last = list->last;
if (last) {
last->next = item;
item->prev = last;
} else { // list empty
list->first = item;
}
list->last = item;
item->list = list;
list->count += 1;
}
// # __MemList_pushBefore__
void __MemList_pushBefore__(
struct __MemList__* list,
struct __MemListLink__* before,
struct __MemListLink__* item
) {
struct __MemListLink__* prev = before->prev;
if (prev) { // non firts
prev->next = item;
} else { // is first
list->first = item;
}
item->prev = prev;
before->prev = item;
item->next = before;
item->list = list;
list->count += 1;
}
// # __MemList_pushAfter__
void __MemList_pushAfter__(
struct __MemList__* list,
struct __MemListLink__* after,
struct __MemListLink__* item
) {
struct __MemListLink__* next = after->next;
if (next) {
next->prev = item;
} else { // after is last
list->last = item;
}
item->next = next;
after->next = item;
item->prev = after;
item->list = list;
list->count += 1;
}
// # __MemList_pop__
void __MemList_pop__(
struct __MemList__ *list,
struct __MemListLink__ *item // expected item linked to list
) {
if (list->count == 1) {
list->first = NULL;
list->last = NULL;
__MemListLink_resetLinks__(item);
} else { // count > 1 becouse != 1 and item is linked to list
if (item == list->first) {
struct __MemListLink__ *next = item->next; // not null becouse item is first and count > 1
list->first = next;
next->prev = NULL;
if (list->count == 2) {
list->last = next;
}
} else if (item == list->last) {
struct __MemListLink__ *prev = item->prev; // cannot be null becouse item is last and count > 1
list->last = prev;
prev->next = NULL;
if (list->count == 2) {
list->first = prev;
}
} else { // non first or last
// flatten prev and next
struct __MemListLink__ *next = item->next; // item is not last
struct __MemListLink__ *prev = item->prev; // item is not first
next->prev = prev;
prev->next = next;
}
__MemListLink_resetLinks__(item);
}
list->count -= 1;
}
// # __MemList_init__
void __MemList_init__(
struct __MemList__* list
) {
list->first = NULL;
list->last = NULL;
list->count = 0;
}
// tree
// # __MemTree_init__
void __MemTree_init__(
struct __MemTree__ *t
) {
t->count = 0;
t->nested = 0;
__MemList_init__ (&t->childs);
__MemListLink_init__ (&t->link);
}
// # __MemTree_pushNext__
void __MemTree_pushNext__(
struct __MemTree__ *t, // expected as child of another tree
struct __MemTree__ *item
) {
struct __MemTree__ *parent;
__MemTree_getParent__(&parent, t);
__MemTree_fix_nested__(item, t->nested, __MemTree_fix_nested_Action_plus__);
__MemList_pushAfter__(&parent->childs, &t->link, &item->link);
__MemTree_fix_counts__(parent, item->count + 1, __MemTree_fix_counts_Action_plus__);
}
// # __MemTree_pushPrev__
void __MemTree_pushPrev__(
struct __MemTree__ *t, // expected t is child
struct __MemTree__ *item
) {
struct __MemTree__ *parent;
__MemTree_getParent__(&parent, t); // expected true by right argument
__MemTree_fix_nested__(item, t->nested, __MemTree_fix_nested_Action_plus__);
__MemList_pushBefore__(&parent->childs, &t->link, &item->link);
__MemTree_fix_counts__(parent, item->count + 1, __MemTree_fix_counts_Action_plus__);
}
// # __MemTree_pushChild__
void __MemTree_pushChild__(
struct __MemTree__ *t,
struct __MemTree__ *item
) {
__MemTree_fix_nested__(item, t->nested + 1, __MemTree_fix_nested_Action_plus__);
__MemList_pushLast__(&t->childs, &item->link);
__MemTree_fix_counts__(t, item->count + 1, __MemTree_fix_counts_Action_plus__);
}
// # __MemTree_fix_nested__
void __MemTree_fix_nested__(
struct __MemTree__ *t,
size_t nested_delta,
char action // __MemTree_fix_nested_Action__
) {
struct __MemTree__ *tree = t;
if (action == __MemTree_fix_nested_Action_plus__) {
while (tree) {
tree->nested += nested_delta;
tree = __MemTree_traverse__(tree);
}
} else { // minus
while (tree) {
tree->nested -= nested_delta;
tree = __MemTree_traverse__(tree);
}
}
}
// # __MemTree_fix_counts__
void __MemTree_fix_counts__(
struct __MemTree__ *t,
size_t delta_count,
char action // __MemTree_fix_counts_Action__
) {
struct __MemTree__ *tree = t;
if (action == __MemTree_fix_counts_Action_plus__) {
while (tree) {
tree->count += delta_count;
tree = __MemTree_getParentOrNull__(tree);
}
} else { // minus
while (tree) {
tree->count -= delta_count;
tree = __MemTree_getParentOrNull__(tree);
}
}
}
// # __MemTree_pop__
// pop self from parent
void __MemTree_pop__(
struct __MemTree__ *t // expected __MemTree_isChild__(tree) == true
) {
struct __MemTree__ *parent;
__MemTree_getParent__(&parent, t);
__MemList_pop__(&parent->childs, &t->link);
__MemTree_fix_counts__(parent, t->count + 1, __MemTree_fix_counts_Action_minus__);
__MemTree_fix_nested__(t, t->nested, __MemTree_fix_nested_Action_minus__);
}
// # __MemTree_popFirstChild__
struct __MemTree__*
__MemTree_popFirstChild__(
struct __MemTree__ *tree // expected tree.childs.count > 0
) {
struct __MemListLink__ *child_link = tree->childs.first;
__MemList_pop__(&tree->childs, child_link);
return __TypedPtr_getParentPtrFromFieldPtr__(struct __MemTree__, link, child_link);
}
// # __MemTree_getPrev__
struct __MemTree__*
__MemTree_getPrev__(
struct __MemTree__ *tree // expected __MemTree_isFirst__(tree) = false;
) {
struct __MemListLink__ *prev_link = tree->link.prev;
return __TypedPtr_getParentPtrFromFieldPtr__(struct __MemTree__, link, prev_link);
}
// # __MemTree_getParent__
void __MemTree_getParent__ (
struct __MemTree__ **ret,
struct __MemTree__ *tree // expected child
) {
struct __MemList__ *list = tree->link.list;
*ret = __TypedPtr_getParentPtrFromFieldPtr__(struct __MemTree__, childs, list);
};
// # __MemTree_getParentOrNull__
struct __MemTree__* // can be null
__MemTree_getParentOrNull__ (
struct __MemTree__ *tree
) {
struct __MemList__ *list = tree->link.list;
if (list) {
struct __MemTree__ *parent = __TypedPtr_getParentPtrFromFieldPtr__(struct __MemTree__, childs, list);
return parent;
}
return NULL;
};
// # __MemTree_isFirst__
bool __MemTree_isFirst__(
struct __MemTree__ *tree
) {
return tree->link.prev == NULL;
}
// # __MemTree_isChild__
bool __MemTree_isChild__ (
struct __MemTree__ *tree
) {
return tree->link.list != NULL;
};
// # __MemTree_growChilds__
// convert childs to siblings
void __MemTree_growChilds__(
struct __MemTree__ *tree // expected tree with tree.childs.count > 0 and __MemTree_isChild__(tree) == true
) {
struct __MemList__ *childs = &tree->childs;
size_t *childs_count = &childs->count;
while(*childs_count > 0) {
struct __MemTree__ *child = __MemTree_popFirstChild__(tree);
__MemTree_pushNext__(tree, child);
}
}
// # __MemTree_traverse__
struct __MemTree__* // return first_child or next or find next_parental or null
__MemTree_traverse__(
struct __MemTree__ *tree
) {
if (tree->childs.first) {
struct __MemListLink__ *first = tree->childs.first;
return __TypedPtr_getParentPtrFromFieldPtr__(struct __MemTree__, link, first);
} else {
struct __MemListLink__ *next = tree->link.next;
if (next) {
return __TypedPtr_getParentPtrFromFieldPtr__(struct __MemTree__, link, next);
} else {
struct __MemTree__ *parent = __MemTree_getParentOrNull__(tree);
while (parent) {
struct __MemListLink__ *next_of_parent = parent->link.next;
if (next_of_parent) {
return __TypedPtr_getParentPtrFromFieldPtr__(struct __MemTree__, link, next_of_parent);
}
parent = __MemTree_getParentOrNull__(parent);
}
}
}
return NULL;
}
// math
// # __Math_linearInterpolationWithCoef__
__Float32__ __Math_linearInterpolationWithCoef__(
__Float32__ r1,
__Float32__ r2,
__Float32__ coef
) {
return r1 + coef * (r2 - r1);
}
// # __Math_linearInterpolation__
__Float32__ __Math_linearInterpolation__(
__Float32__ v1,
__Float32__ v2,
__Float32__ r1,
__Float32__ r2,
__Float32__ vx
) {
return r1 + (vx - v1) / (v2 - v1) * (r2 - r1);
}
// # __Math_ceilDiv32__
uint32_t __Math_ceilDiv32__(uint32_t a, uint32_t b) {
return (a + b - 1) / b;
}
// 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");
len += __ZText_countLen__(home_drive);
char* home_path = getenv("HOMEPATH");
len += __ZText_countLen__(home_path);
#elif __target_os__ == __TargetOs_linux__
char* home = getenv("HOME");
len += __ZText_countLen__(home);
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
return len;
}
// # __OsEnvHome_write__
void __OsEnvHome_write__(
char* buffer // expected len >= __OsEnvHome_getLen__()
) {
#if __target_os__ == __TargetOs_windows__
size_t writed = 0;
// write HOMEDRIVE
char* home_drive = getenv("HOMEDRIVE");
size_t home_drive_len = __ZText_countLen__(home_drive);
__Mem_copy__(&buffer[writed], home_drive, home_drive_len);
writed += home_drive_len;
// write HOMEPATH
char* home_path = getenv("HOMEPATH");
size_t home_path_len = __ZText_countLen__(home_path);
__Mem_copy__(&buffer[writed], home_path, home_path_len);
writed += home_path_len;
#elif __target_os__ == __TargetOs_linux__
char* home = getenv("HOME");
size_t len = __ZText_countLen__(home);
__Mem_copy__(buffer, home, len);
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
}
// file
// # __OsFile_clear__
void __OsFile_clear__(
__OsFileHandle__ file
) {
__OsFile_setPos__(file, 0);
__OsFile_truncate__(file);
}
// # __OsFile_exist__
bool __OsFile_exist__(
const char* file_name,
size_t file_name_len // expected < __OsFilePathLen_max__
) {
bool ok = true;
#if __target_os__ == __TargetOs_windows__
char file_name_z[__OsFilePathLen_max__ + 1]; // create null terminated string
__Mem_copy__(file_name_z, file_name, file_name_len);
file_name_z[file_name_len] = 0;
DWORD attrs = GetFileAttributesA(file_name_z);
if (true
and (attrs != INVALID_FILE_ATTRIBUTES)
and (!(attrs & FILE_ATTRIBUTE_DIRECTORY))
) {
} else {
ok = false;
}
#elif __target_os__ == __TargetOs_linux__
char file_name_z[__OsFilePathLen_max__ + 1]; // create null terminated string
__Mem_copy__(file_name_z, file_name, file_name_len);
file_name_z[file_name_len] = 0;
struct stat buffer;
if (stat(file_name_z, &buffer) == 0) {
} else {
ok = false;
}
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
return ok;
}
// # __OsFile_create__
bool __OsFile_create__(
__OsFileHandle__ *ret,
const char file_name[],
size_t file_name_len // expected < __OsFilePathLen_max__
) {
bool ok = true;
#if __target_os__ == __TargetOs_windows__
char file_name_z[__OsFilePathLen_max__ + 1]; // null terminated string
__Mem_copy__(file_name_z, file_name, file_name_len);
file_name_z[file_name_len] = 0;
HANDLE file = CreateFile( // open
file_name_z, // [in] LPCSTR lpFileName,
GENERIC_WRITE | GENERIC_READ, // [in] DWORD dwDesiredAccess,
0, // [in] DWORD dwShareMode, // TODO also try FILE_SHARE_WRITE
NULL, // [in, optional] LPSECURITY_ATTRIBUTES lpSecurityAttributes,
OPEN_ALWAYS, // [in] DWORD dwCreationDisposition,
FILE_ATTRIBUTE_NORMAL, // [in] DWORD dwFlagsAndAttributes,
NULL // [in, optional] HANDLE hTemplateFile
);
if (file != INVALID_HANDLE_VALUE) {
*ret = file;
} else {
ok = false;
}
#elif __target_os__ == __TargetOs_linux__
char file_name_z[__OsFilePathLen_max__ + 1]; // create null terminated string
__Mem_copy__(file_name_z, file_name, file_name_len);
file_name_z[file_name_len] = 0;
int file = creat(file_name_z, 0777);
if (file != -1) {
*ret = file;
} else {
ok = false;
}
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
return ok;
}
// # __OsFile_open__
bool __OsFile_open__(
__OsFileHandle__ *ret,
const char file_name[],
size_t file_name_len // expected < __OsFilePathLen_max__
) {
bool ok = true;
#if __target_os__ == __TargetOs_windows__
char file_name_z[__OsFilePathLen_max__ + 1]; // null terminated string
__Mem_copy__(file_name_z, file_name, file_name_len);
file_name_z[file_name_len] = 0;
HANDLE file = CreateFile( // open
file_name_z, // [in] LPCSTR lpFileName,
GENERIC_WRITE | GENERIC_READ, // [in] DWORD dwDesiredAccess,
0, // [in] DWORD dwShareMode, // TODO also try FILE_SHARE_WRITE
NULL, // [in, optional] LPSECURITY_ATTRIBUTES lpSecurityAttributes,
OPEN_EXISTING, // [in] DWORD dwCreationDisposition,
FILE_ATTRIBUTE_NORMAL, // [in] DWORD dwFlagsAndAttributes,
NULL // [in, optional] HANDLE hTemplateFile
);
if (file != INVALID_HANDLE_VALUE) {
*ret = file;
} else {
ok = false;
}
#elif __target_os__ == __TargetOs_linux__
char file_name_z[__OsFilePathLen_max__ + 1]; // null terminated string
__Mem_copy__(file_name_z, file_name, file_name_len);
file_name_z[file_name_len] = 0;
// open
int file = open(file_name_z, O_RDWR);
if (file != -1) {
*ret = file;
} else {
ok = false;
}
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
return ok;
}
// # __OsFile_openOrCreate__
bool __OsFile_openOrCreate__(
__OsFileHandle__ *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__(
__OsFileHandle__ file
) {
#if __target_os__ == __TargetOs_windows__
CloseHandle(file);
#elif __target_os__ == __TargetOs_linux__
close(file);
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
}
// # __OsFile_getPos__
size_t __OsFile_getPos__(
__OsFileHandle__ file
) {
#if __target_os__ == __TargetOs_windows__
LARGE_INTEGER liPosition = {0};
LARGE_INTEGER liNewPosition = {0};
BOOL sfp_result = SetFilePointerEx (
file,
liPosition,
&liNewPosition,
FILE_CURRENT
);
if (sfp_result == FALSE) {
// unexpected
int err = GetLastError();
printf("%d SetFilePointerEx error: %d", __LINE__, err);
}
return liNewPosition.QuadPart;
#elif __target_os__ == __TargetOs_linux__
return lseek(file, 0, SEEK_CUR);
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
}
// # __OsFile_setPos__
void __OsFile_setPos__(
__OsFileHandle__ file,
size_t pos
) {
#if __target_os__ == __TargetOs_windows__
LARGE_INTEGER liPosition = {0};
liPosition.QuadPart = pos;
BOOL sfp_result = SetFilePointerEx(file, liPosition, NULL, FILE_BEGIN);
if (sfp_result == FALSE) {
// unexpeced
printf("%d, unexpected SetFilePointer result", __LINE__);
}
#elif __target_os__ == __TargetOs_linux__
lseek(file, pos, SEEK_SET);
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
}
// # __OsFile_readToBuffer__
bool __OsFile_readToBuffer__(
__OsFileHandle__ file,
char *buffer,
size_t buffer_len,
size_t offset
) {
bool ok = true;
size_t readed = 0;
while (ok and (readed < buffer_len)) {
__OsFile_setPos__(file, offset + readed);
#if __target_os__ == __TargetOs_windows__
__OsFile_setPos__(file, offset + readed);
size_t readed_atom = 0;
if (ReadFile(file, &buffer[readed], buffer_len - readed, &readed_atom, NULL)) {
readed += readed_atom;
} else {
ok = false;
}
#elif __target_os__ == __TargetOs_linux__
__OsFile_setPos__(file, offset + readed);
ssize_t read_result = read(file, &buffer[readed], buffer_len - readed);
if (read_result >= 0) {
readed += read_result;
} else {
ok = false;
}
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
}
return ok;
}
// # __OsFile_write__
bool __OsFile_write__(
__OsFileHandle__ file,
const char* data,
size_t data_len,
size_t offset
) {
bool ok = true;
size_t writed = 0;
while (ok and (writed < data_len)) {
__OsFile_setPos__(file, offset + writed);
#if __target_os__ == __TargetOs_windows__
DWORD atom_writed = 0;
if ( WriteFile(file, &data[writed], data_len - writed, &atom_writed, NULL) ) {
writed += atom_writed;
ok = FlushFileBuffers(file);
} else {
ok = false;
}
#elif __target_os__ == __TargetOs_linux__
ssize_t atom_write = write(file, &data[writed], data_len - writed);
if (atom_write != -1) {
writed += atom_write;
} else {
ok = false;
}
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
}
return ok;
}
// # __OsFile_getSize__
size_t __OsFile_getSize__(
__OsFileHandle__ file
) {
#if __target_os__ == __TargetOs_windows__
LARGE_INTEGER size;
if (GetFileSizeEx(file, &size)) {
return size.QuadPart;
} else {
// unexpected
return 0;
}
#elif __target_os__ == __TargetOs_linux__
struct stat st;
fstat(file, &st);
return st.st_size;
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
}
// # __OsFile_truncate__
void __OsFile_truncate__(
__OsFileHandle__ file
) {
#if __target_os__ == __TargetOs_windows__
bool ok = true;
if (FlushFileBuffers(file)) {
if (SetEndOfFile(file)) {
if (FlushFileBuffers(file)) {
} else { // unexpected
ok = false;
printf("%d unexpected retusult of FlushFileBuffers", __LINE__);
}
} else { // unexpected
ok = false;
printf("%d unexpected retusult of SetEndOfFile", __LINE__);
}
} else { // unexpected
ok = false;
printf("%d unexpected retusult of FlushFileBuffers", __LINE__);
}
if (!ok) printf("%d failue", __LINE__);
// return ok; not needed to real return ok state becouse expected posibly truncate any file without errors.
#elif __target_os__ == __TargetOs_linux__
size_t current_pos = __OsFile_getPos__(file);
ftruncate(file, current_pos);
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
}
// time
// # __os_getTick__
uint64_t __os_getTick__() {
#if __target_os__ == __TargetOs_windows__
FILETIME ft;
GetSystemTimeAsFileTime(&ft);
uint64_t ft64;
__Mem_copy__((char*) &ft64, (char*) &ft, 8);
return ft64 / 10000; // in ft is intervals * 100 ns. to ms need * 100 / 1000000
#elif __target_os__ == __TargetOs_linux__
// NOT TESTED
struct timespec ts;
clock_gettime(CLOCK_REALTIME, (void*)&ts);
uint64_t ms = ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
return ms;
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
}
// # __Os_sleep__
void __Os_sleep__(uint64_t ms) {
#if __target_os__ == __TargetOs_windows__
Sleep(ms);
#elif __target_os__ == __TargetOs_linux__
struct timespec delay;
delay.tv_sec = ms / 1000;
delay.tv_nsec = (ms % 1000) * 1000000;
nanosleep(&delay, NULL);
#elif __target_os__ == __TargetOs_linuxOld__
if (milliseconds >= 1000) {
sleep(milliseconds / 1000);
}
usleep((milliseconds % 1000) * 1000);
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
}
// Console
// ConsoleOutput
// # __OsConsoleOutput_getSize__
void __OsConsoleOutput_getSize__ (
struct __OsConsoleOutput__ *t,
struct __Math2dPosU__ *ret_pos
) {
#if __target_os__ == __TargetOs_windows__
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(t->__OsConsoleOutput_handle__, &csbi);
int x = csbi.srWindow.Right - csbi.srWindow.Left + 1;
int y = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
ret_pos->x = x;
ret_pos->y = y;
// printf("%d, %d x %d\n", __LINE__, x, y);
#elif __target_os__ == __TargetOs_linux__
struct winsize w;
ioctl(t->__OsConsoleOutput_handle__, TIOCGWINSZ, &w);
ret_pos->x = w.ws_col;
ret_pos->y = w.ws_row;
#else
#error "__target_os__ not implemented"
#endif
}
// # __OsConsoleOutput_init__
void __OsConsoleOutput_init__(struct __OsConsoleOutput__* output, __OsConsoleOutputHandle__ handle) {
output->__OsConsoleOutput_handle__ = handle;
#if __target_os__ == __TargetOs_windows__
#elif __target_os__ == __TargetOs_linux__
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
}
// # __OsConsoleOutput_write__
bool __OsConsoleOutput_write__(
struct __OsConsoleOutput__* os_console_output,
const char* data,
size_t _len
) {
bool ok = true;
// support null-string // todo remove me
size_t len = _len;
if (len == 0) {
while(data[len] != 0) len += 1;
}
#if __target_os__ == __TargetOs_windows__
unsigned long writed = 0;
WriteConsoleA(os_console_output->__OsConsoleOutput_handle__, data, len, &writed, NULL);
len = writed;
#elif __target_os__ == __TargetOs_linux__
// stdin = 0
// stdout = 1
// stderr = 2
if (write(1, data, len) == len) {
} else {
ok = false;
}
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
return ok;
}
// ConsoleInput
// # __OsConsoleInput_readByte__
bool __OsConsoleInput_readByte__(
char *ret_byte,
struct __OsConsoleInput__ *t
) {
bool ok = true;
#if __target_os__ == __TargetOs_windows__
INPUT_RECORD key;
DWORD picked = 0;
if ( ReadConsoleInputA(t->handle, &key, 1, &picked) ) {
if (picked != 0) {
if (key.EventType == KEY_EVENT) {
KEY_EVENT_RECORD *event = &key.Event.KeyEvent;
if (event->bKeyDown != 0) {
if (event->uChar.AsciiChar != 0) {
*ret_byte = event->uChar.AsciiChar;
} else {ok = false;}
} else {ok = false;}
} else {ok = false;}
} else {ok = false;}
} else {ok = false;}
#elif __target_os__ == __TargetOs_linux__
ssize_t result = read(t->fileno, ret_byte, 1);
if (result != 1) {ok = false;}
#else
#error "__target_os__ not implemented"
#endif
return ok;
}
// # __OsConsoleInput_getCountOfUnreaded__
bool __OsConsoleInput_getCountOfUnreaded__(struct __OsConsoleInput__* t, size_t *ret_unreaded) {
bool ok = true;
#if __target_os__ == __TargetOs_windows__
DWORD unreaded = 0;
if ( GetNumberOfConsoleInputEvents(t->handle, &unreaded) ) {
*ret_unreaded += unreaded;
} else {
ok = false;
}
#elif __target_os__ == __TargetOs_linux__
int unreaded = 0;
int result = ioctl(t->fileno, FIONREAD, &unreaded);
*ret_unreaded += unreaded;
#else
#error "__target_os__ not implemented"
#endif
return ok;
}
// # __OsConsoleInput_init__
void __OsConsoleInput_init__(
struct __OsConsoleInput__* t,
__OsConsoleInputHandle__ input_hanle
) {
#if __target_os__ == __TargetOs_windows__
t->handle = input_hanle;
#elif __target_os__ == __TargetOs_linux__
t->handle = input_hanle;
t->fileno = fileno(t->handle);
#else
#error "__target_os__ not implemented"
#endif
}
// Flags
// # __BitsU32_enable__
uint32_t __BitsU32_enable__(uint32_t value, uint32_t mask) {
return value | mask;
}
// # __BitsU32_disable__
uint32_t __BitsU32_disable__(uint32_t value, uint32_t mask) {
return value & (~mask);
}
// # __BitsU32_toggle__
uint32_t __BitsU32_toggle__(uint32_t value, uint32_t mask, bool new_state) {
if (new_state) {
return __BitsU32_enable__(value, mask);
} else {
return __BitsU32_disable__(value, mask);
}
}
// # __OsConsoleFlags_setNonCanonicalMode__
bool __OsConsoleFlags_setNonCanonicalMode__(struct __OsConsoleFlags__ *t) {
bool ok = true;
#if __target_os__ == __TargetOs_windows__
uint32_t input = t->input_mode;
input = __BitsU32_toggle__(input, ENABLE_EXTENDED_FLAGS, true);
input = __BitsU32_toggle__(input, ENABLE_ECHO_INPUT, false); // print pressed keys
input = __BitsU32_toggle__(input, ENABLE_LINE_INPUT, false); // wait '\n' (buffering on enter)
input = __BitsU32_toggle__(input, ENABLE_VIRTUAL_TERMINAL_INPUT, true);
input = __BitsU32_toggle__(input, ENABLE_PROCESSED_INPUT, false); // CTRL+C
input = __BitsU32_toggle__(input, ENABLE_MOUSE_INPUT, false);
input = __BitsU32_toggle__(input, ENABLE_QUICK_EDIT_MODE, true); // enable mouse select and copy
input = __BitsU32_toggle__(input, ENABLE_WINDOW_INPUT, false); // reported of change size of the console screen buffer
input = __BitsU32_toggle__(input, ENABLE_INSERT_MODE, true); // When enabled, text entered in a console window will be inserted at the current cursor location and all text following that location will not be overwritten. When disabled, all following text will be overwritten.
t->input_mode = input;
uint32_t output = t->output_mode;
output = __BitsU32_toggle__(output, ENABLE_LVB_GRID_WORLDWIDE, true); // enable colors
output = __BitsU32_toggle__(output, ENABLE_VIRTUAL_TERMINAL_PROCESSING, true); // emulate VT100
output = __BitsU32_toggle__(output, ENABLE_PROCESSED_OUTPUT, true); // Backspace, tab, bell, carriage return, and line feed characters are processed
output = __BitsU32_toggle__(output, ENABLE_WRAP_AT_EOL_OUTPUT, false); // disable line wrap
output = __BitsU32_toggle__(output, DISABLE_NEWLINE_AUTO_RETURN, true);
t->output_mode = output;
#elif __target_os__ == __TargetOs_linux__
// clear c_cc
cc_t* cc = &t->termios.c_cc[0]; // cc_t c_cc[NCCS]
for (int i = 0; i < NCCS ; i++) {
cc[i] = 0;
}
// timers off
cc = &t->termios.c_cc[0];
cc[VTIME] = 0;
cc[VMIN] = 1;
uint32_t cflag = t->termios.c_cflag;
cflag = __BitsU32_toggle__(cflag, CS8, true); // use 8 bit
cflag = __BitsU32_toggle__(cflag, CSTOPB, false); // two stops bits
cflag = __BitsU32_toggle__(cflag, PARENB, false); // parity check
cflag = __BitsU32_toggle__(cflag, PARODD, false); // parity check
t->termios.c_cflag = cflag;
uint32_t lflag = t->termios.c_lflag;
lflag = __BitsU32_toggle__(lflag, ISIG, false); // disable react to Ctrl+C
lflag = __BitsU32_toggle__(lflag, ICANON, false); // no wait '\n'
lflag = __BitsU32_toggle__(lflag, ECHO, false); // print pressed keys
lflag = __BitsU32_toggle__(lflag, ECHOE, false); // mashing
lflag = __BitsU32_toggle__(lflag, ECHONL, false); // print NL
lflag = __BitsU32_toggle__(lflag, ECHOK, false); // nl after clear line
lflag = __BitsU32_toggle__(lflag, ECHOKE, false); // print NL after BS
lflag = __BitsU32_toggle__(lflag, ECHOPRT, false); // print BS (BS SP BS)
lflag = __BitsU32_toggle__(lflag, IEXTEN, false); // special funcs
t->termios.c_lflag = lflag;
uint32_t iflag = t->termios.c_iflag;
iflag = __BitsU32_toggle__(iflag, IGNBRK, true); // ignore break control
iflag = __BitsU32_toggle__(iflag, BRKINT, true); // do not delete all data after break control
iflag = __BitsU32_toggle__(iflag, IXON, false); // disable react to Ctrl+S Ctlr+Q
iflag = __BitsU32_toggle__(iflag, ISTRIP, false); // strip
iflag = __BitsU32_toggle__(iflag, INLCR, false); // convert NL to CR
iflag = __BitsU32_toggle__(iflag, ICRNL, false); // convert CR to NL
iflag = __BitsU32_toggle__(iflag, XCASE, false); // convert register to UP
iflag = __BitsU32_toggle__(iflag, IUCLC, false); // convert register to down
iflag = __BitsU32_toggle__(iflag, IGNPAR, true); // ignore framing or parity errors
iflag = __BitsU32_toggle__(iflag, IMAXBEL, false); // no bell
t->termios.c_iflag = iflag;
uint32_t oflag = t->termios.c_oflag;
oflag = __BitsU32_toggle__(oflag, ONOCR, false); // on start line // Auto CR
oflag = __BitsU32_toggle__(oflag, ONLRET, false); // on end line // Auto CR
oflag = __BitsU32_toggle__(oflag, OPOST, true); // \_(O_o)_/
oflag = __BitsU32_toggle__(oflag, ONLCR, true); // NL to CR
oflag = __BitsU32_toggle__(oflag, OCRNL, false); // CR to NL
oflag = __BitsU32_toggle__(oflag, OLCUC, false); // convert to CAPS
oflag = __BitsU32_toggle__(oflag, XTABS, false); // convert tab
oflag = __BitsU32_toggle__(oflag, TAB3, false); // convert tab
oflag = __BitsU32_toggle__(oflag, OFDEL, false); // use null for deleted symbol
t->termios.c_oflag = oflag;
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
return ok;
}
// # __OsConsoleFlags_apply__
bool __OsConsoleFlags_apply__(
struct __OsConsoleFlags__ *t,
struct __OsConsoleInput__ *input,
struct __OsConsoleOutput__ *output
) {
// expected inited
bool ok = true;
#if __target_os__ == __TargetOs_windows__
int result1 = SetConsoleMode(input->handle, t->input_mode);
if (result1 == 0) {
ok = false;
// todo GetLastError();
}
int result2 = SetConsoleMode(output->__OsConsoleOutput_handle__, t->output_mode);
if (result2 == 0) {
ok = false;
// todo GetLastError();
}
#elif __target_os__ == __TargetOs_linux__
tcsetattr(input->fileno, TCSANOW, &t->termios);
tcsetattr(output->__OsConsoleOutput_handle__, TCSANOW, &t->termios);
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
return ok;
}
// # __OsConsoleFlags_init__
bool __OsConsoleFlags_init__(struct __OsConsoleFlags__ *t, struct __OsConsoleInput__* input, struct __OsConsoleOutput__ *output) {
bool ok = true;
#if __target_os__ == __TargetOs_windows__
bool result1 = GetConsoleMode(input->handle, &t->input_mode);
if (result1 != 0) {
bool result2 = GetConsoleMode(output->__OsConsoleOutput_handle__, &t->output_mode);
if (result2 != 0) {
t->inited = true;
} else {
ok = false;
}
} else {
ok = false;
}
#elif __target_os__ == __TargetOs_linux__
int result = tcgetattr(input->fileno, &t->termios);
if (result == 0) {
t->inited = true;
} else {
ok = false;
}
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
return ok;
}
// # __OsFallbackConsole_write__
size_t
__OsFallbackConsole_write__ (
void* unused_ctx,
char* data,
size_t len
) {
#if __target_os__ == __TargetOs_windows__
struct __OsConsoleOutput__ console_output;
__OsConsoleOutput_init__(&console_output, GetStdHandle(STD_OUTPUT_HANDLE));
__OsConsoleOutput_write__(&console_output, data, len);
#elif __target_os__ == __TargetOs_linux__
__OsConsoleOutput_write__ (NULL, data, len);
#else
#error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
#endif
return len;
}
// Helper
// # __OsHelper_init__
bool __OsHelper_init__(struct __OsHelper__* t) {
bool ok = true;
#if __target_os__ == __TargetOs_windows__
HMODULE instance = GetModuleHandleA(NULL);
if (instance != NULL) {
t->instance = instance;
HANDLE console_input_handle = GetStdHandle(STD_INPUT_HANDLE);
if (console_input_handle != INVALID_HANDLE_VALUE) {
t->console_input_handle = console_input_handle;
HANDLE console_output_handle = GetStdHandle(STD_OUTPUT_HANDLE);
if (console_output_handle != INVALID_HANDLE_VALUE) {
t->console_output_handle = console_output_handle;
#if __with_network__
if (
WSAStartup(
514, // wVersionRequested ver 2.2
&t->wsdata
) == 0
) { } else {
ok = false;
}
#endif
} else {
ok = false;
}
} else {
ok = false;
}
} else {
ok = false;
}
#elif __target_os__ == __TargetOs_linux__
t->console_input_handle = stdin;
t->console_output_handle = 1; // standart output
#else
#error "__target_os__ not implemented"
#endif
return ok;
}
// # __OsHelper_deinit__
void __OsHelper_deinit__(struct __OsHelper__*t) {
#if __target_os__ == __TargetOs_windows__
#if __with_network__
WSACleanup();
#endif
FreeLibrary(t->instance);
#elif __target_os__ == __TargetOs_linux__
// nothing to do
#else
#error "__target_os__ not implemented"
#endif
}
// # __OsHelper_process__
void __OsHelper_process__(struct __OsHelper__* t) {
#if __target_os__ == __TargetOs_windows__
MSG msg;
if (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessageA(&msg);
}
#elif __target_os__ == __TargetOs_linux__
// nothing to do
#else
#error "__target_os__ not implemented"
#endif
}
// text
// Ascii
// indent
// # __TextAscii_countIndentReverse__
size_t __TextAscii_countIndentReverse__(
const char *text,
size_t text_len,
size_t tabsize
) {
size_t count = 0;
if (text_len > 0) {
size_t pos = text_len - 1;
while(true) {
char r = text[pos];
if (r == 0 ) {
count += 1;
} else if (r == ' ') {
count += 1;
} else if (r == '\t') {
count += tabsize;
} else if (r == '\r') {
count += 1;
} else break;
if (pos == 0) break;
pos -= 1;
}
}
return count;
}
// # __TextAscii_getNonIndent__
bool
__TextAscii_getNonIndent__(
const char **ret_ptr,
size_t *ret_size,
const char *text,
size_t text_len
) {
size_t indent = __TextAscii_countIndent__(text, text_len, 1);
if (indent == text_len) return false;
*ret_ptr = &text[indent];
*ret_size = text_len - indent;
return true;
}
// # __TextAscii_getStartOfText__
bool __TextAscii_getStartOfText__(
size_t *ret_pos, // increment by fn
const char *text,
size_t text_len
) {
bool ok = true;
bool finded = false;
size_t pos = 0;
for (; pos < text_len; pos++) {
char symbol = text[pos];
if (true
and symbol != ' '
and symbol != '\t'
) {
finded = true;
break;
}
}
*ret_pos += pos;
ok = ok and finded;
return ok;
}
// # __TextAscii_countNonIndent__
size_t __TextAscii_countNonIndent__(
const char *text,
size_t text_len
) {
size_t indent = __TextAscii_countIndent__(text, text_len, 1);
return text_len - indent;
}
// # __TextAscii_cutIndents__
bool __TextAscii_cutIndents__(
size_t *ret_pos, // incremented by fn
size_t *ret_len, // incremented by fn
const char *bytes,
size_t bytes_len
) {
bool ok = true;
if (bytes_len > 0) { // cut from left
size_t start = 0;
while (true) {
if (start < bytes_len) {
if (bytes[start] != ' ') {
break;
}
start += 1;
} else { // TextIsEmpty
ok = false;
break;
}
}
if (ok) { // cut from right
size_t end = bytes_len - 1;
while (true) {
if (bytes[end] != ' ') {
break;
}
end -= 1;
}
*ret_pos += start;
*ret_len += end+1 - start;
}
} else {
ok = false;
}
return ok;
}
// # __TextAscii_countIndent__
size_t __TextAscii_countIndent__(
const char *text,
size_t text_len,
size_t tabsize
) {
size_t count = 0;
for (size_t pos = 0; pos < text_len; pos++) {
char r = text[pos];
if ( r == 0) { count += 1;
} else if ( r == ' ') { count += 1;
} else if ( r == '\t') { count += tabsize;
} else if ( r == '\r') { count += 1;
} else break;
}
return count;
}
// # __TextAscii_findBreakOfWord__
size_t __TextAscii_findBreakOfWord__(
const char* text,
size_t text_len
) {
if (text_len == 1) return 1;
for (size_t pos = 1; pos <= text_len; pos++) {
char symbol = text[pos];
if (__TextAsciiSymbol_isBreakWord__(symbol)) return pos - 1;
}
return text_len - 1;
}
// # __TextAscii_findBreakOfWordReverse__
size_t __TextAscii_findBreakOfWordReverse__(
const char *text,
size_t text_len // expected text_len > 0
) {
if (text_len == 1) return 0;
for (size_t pos = text_len - 1; pos > 0; pos--) {
char symbol = text[pos];
if (__TextAsciiSymbol_isBreakWord__(symbol)) return pos;
}
return 0;
}
// # __TextAsciiSymbol_isWord__
bool __TextAsciiSymbol_isWord__(char symbol) {
return false
or (symbol == '_')
or (symbol >= '0' and symbol <= '9')
or (symbol >= 'a' and symbol <= 'z')
or (symbol >= 'A' and symbol <= 'Z')
;
}
// # __TextAscii_isLetter__
bool __TextAscii_isLetter__(char rune) {
return false
or rune < ' '
or __TextAsciiSymbol_isWord__(rune)
or rune >= 127
;
}
// # __TextAsciiSymbol_isBreakWord__
bool __TextAsciiSymbol_isBreakWord__(char symbol) {
return __TextAsciiSymbol_isWord__(symbol) == false;
}
// # __TextAscii_isVisible__
bool __TextAscii_isVisible__(char byte) {
return (byte >= 33) and (byte <= 126);
}
// # __Ascii_getFirstVisibleCharOrEnd__
size_t __Ascii_getFirstVisibleCharOrEnd__(
const char *ptr,
size_t len // expected > 0
) {
size_t pos = 0;
for (;pos < len; pos++) {
char byte = ptr[pos];
if (__TextAscii_isVisible__(byte)) break;
}
return pos;
}
// # __Ascii_isEmpty__
bool __Ascii_isEmpty__(
const char *ptr,
size_t len // expected > 0
) {
return __Ascii_getFirstVisibleCharOrEnd__(ptr, len) < len;
}
// Splitter
// # __TextSplitter_init__
void __TextSplitter_init__(struct __Text_Splitter__* t, char* text, size_t text_len, char* delim, size_t delim_len) {
t->stop = false;
t->last_pos = 0;
__Finder_init__(&t->finder, text, text_len, delim, delim_len);
}
// # __TextSplitter_next__
bool __TextSplitter_next__(struct __Text_Splitter__* t, struct Slice* out_slice) {
if (t->stop == false) {
size_t finded;
if (__Finder_next__(&t->finder, &finded)) {
out_slice->ptr = &t->finder.text.ptr[t->last_pos]; // slice = t->finder.text[t->last_pos..finded];
out_slice->len = finded - t->last_pos;
t->last_pos = t->finder.pos;
return true;
} else {
t->stop = true;
out_slice->ptr = &t->finder.text.ptr[t->last_pos]; // slice = t->finder.text[t->last_pos..];
out_slice->len = t->finder.text.len - t->last_pos;
t->last_pos = t->finder.pos;
return true;
}
}
return false;
}
// ZText - zero ended text
// # __ZText_fromBytes__
void __ZText_fromBytes__(char* buffer, const char bytes[], size_t bytes_len) {
// expected buffer_len >= bytes_len + 1
__Mem_copy__(buffer, bytes, bytes_len);
buffer[bytes_len] = 0;
}
// # __ZText_countLen__
size_t __ZText_countLen__(const char text[]) {
size_t len = 0;
while(text[len] != 0) len++;
return len;
}
// # __ZText_writeToBuffer__
size_t __ZText_writeToBuffer__(char buffer[], const char data[]) {
const size_t len = __ZText_countLen__(data);
__Mem_copy__(buffer, data, len);
return len;
}
// # __ZText_writeToWriteFn__
size_t __ZText_writeToWriteFn__(__WriteFnPtr__ fn_write, void* context, const char text[]) {
const size_t len = __ZText_countLen__(text);
fn_write(context, text, len);
return len;
}
// # __Text_countIndent__
size_t
__Text_countIndent__(
char* text,
size_t text_len, // can be 0
size_t tab_size
) {
size_t counted = 0;
size_t pos = 0;
while (pos < text_len) {
char symbol = text[pos];
if (symbol == ' ') {
counted = counted + 1;
} else if (symbol == '\t') {
counted = counted + tab_size;
} else {
break;
}
pos = pos + 1;
}
return counted;
}
// File
// # __File_clear__
void __File_clear__(
__OsFileHandle__ file
) {
__OsFile_setPos__(file, 0);
__OsFile_truncate__(file);
}
// FileComplete
// # __FileComplete_clear__
bool __FileComplete_clear__(
const char* file_name,
size_t file_name_len
) {
bool ok = true;
__OsFileHandle__ file;
if (__OsFile_open__(&file, file_name, file_name_len)) {
__OsFile_clear__(file);
__OsFile_close__(file);
} else {
ok = false;
}
return ok;
}
// # __FileComplete_write__
bool __FileComplete_write__(
const char* file_name,
size_t file_name_len,
const char* bytes,
size_t bytes_len
) {
bool ok = true;
__OsFileHandle__ file;
if(__OsFile_exist__(file_name, file_name_len)) {
ok = __OsFile_open__(&file, file_name, file_name_len);
} else {
ok = __OsFile_create__(&file, file_name, file_name_len);
}
if (ok) {
if (__OsFile_write__(file, bytes, bytes_len, 0)) {
__OsFile_truncate__(file);
} else {
ok = false;
}
__OsFile_close__(file);
}
return ok;
}
// # __FileComplete_read__
bool __FileComplete_read__(
uintptr_t *ret_data_ptr,
size_t *ret_file_data_size, // not zeroed by this func. increment instead.
const char* file_name,
size_t file_name_len,
uint8_t align
) {
bool ok = true;
__OsFileHandle__ file;
if(__OsFile_exist__(file_name, file_name_len)) {
ok = __OsFile_open__(&file, file_name, file_name_len);
} else {
ok = __OsFile_create__(&file, file_name, file_name_len);
}
if (ok) {
size_t file_size = __OsFile_getSize__(file);
*ret_file_data_size += file_size;
char* file_data;
if (__AlignedPtr_allocAny__(ret_data_ptr, align, file_size)) {
if ( __OsFile_readToAny__( file, ret_data_ptr, file_size, 0 )) {
} else {
ok = false;
}
} else {
ok = false;
}
__OsFile_close__(file);
}
return ok;
}
// formats
// __TextFormatU64__ (utoa utos)
// # __TextFormatU64_do__
void __TextFormatU64_do__(
struct __TextFormatU64__ *t,
uint64_t number,
size_t min_width
) {
size_t len = 0;
uintptr_t buffer_start = (uintptr_t) &t->buffer[0];
uintptr_t buffer_end = buffer_start + __TextCharsDecFromU64_lenMax__;
// write utoa
uintptr_t addr = buffer_end;
for (uint64_t num = number; num > 0; num = num / 10) {
uint8_t remainder = num % 10;
addr = addr - 1;
*(char*) addr = '0' + (char) remainder;
}
len = buffer_end - addr;
// fill zeroes to min_width
if (min_width > len) {
size_t fill_len = min_width - len;
addr = addr - fill_len;
__Mem_fillAny__(addr, '0', fill_len);
len = len + fill_len;
}
t->ptr = (char*) addr;
t->len = len;
}
// # __Text_formatU64ToBuffer__
size_t __Text_formatU64ToBuffer__(
char *buffer, // expected len >= __TextCharsDecFromU64_lenMax__
uint64_t number,
size_t min_width
) {
struct __TextFormatU64__ format;
__TextFormatU64_do__(&format, number, min_width);
if (format.len > 0) {
__Mem_copy__(buffer, format.ptr, format.len);
}
return format.len;
}
// # __Text_formatU64__
size_t __Text_formatU64__(__WriteFnPtrVoid__ fn_write, void* context, uint64_t number, size_t min_width) {
struct __TextFormatU64__ format;
__TextFormatU64_do__(&format, number, min_width);
fn_write(context, format.ptr, format.len);
return format.len;
}
// Base64
// # Base64_getEncodeSize
uint32_t Base64_getEncodeSize(uint32_t src_len) {
int blocks = __Math_ceilDiv32__(src_len, 3);
return blocks * 4;
}
// # __Base64_encode3Bytes__
void __Base64_encode3Bytes__(unsigned char in[3], char out[4]) {
out[0] = __Base64StandardAlphabet_chars__[(in[0] & 0b11111100) >> 2];
out[1] = __Base64StandardAlphabet_chars__[((in[0] & 0b00000011) << 4) | ((in[1] & 0b11110000) >> 4)];
out[2] = __Base64StandardAlphabet_chars__[((in[1] & 0b00001111) << 2) | ((in[2] & 0b11000000) >> 6)];
out[3] = __Base64StandardAlphabet_chars__[(in[2] & 0b00111111)];
}
// # test_rot
bool test_rot() {
char a = 0b11111100 >> 2;
if (a == 0b00111111) {
return true;
} else {
printf("%d: failed test_rot.", __LINE__);
}
return false;
}
// # __Base64_encode__
void __Base64_encode__(char* src, size_t src_len, char* out) {
// EXAMPLE
// Source ASCII text: "Ma"
// Character M a
// Octets 77 (0x4d) 97 (0x61)
// Bits 0 1 0 0 1 1 0 1|0 1 1 0 0 0 0 1|0 0 _ _ _ _ _ _|
// Base64 0 1 0 0 1 1|0 1 0 1 1 0|0 0 0 1 0 0|_ _ _ _ _ _|
// Sextets 19 22 4 Padding
// Character T W E =
// Octets 84 (0x54) 87 (0x57) 69 (0x45) 61 (0x3D)
// parse normal octets
char* end_of_src = src + src_len;
while(true) {
if (src + 3 > end_of_src) break;
__Base64_encode3Bytes__((void*) src, out);
src += 3;
out += 4;
}
// parse extra_bytes
size_t extra_bytes = end_of_src - src;
if (extra_bytes > 0 ) {
char b[3] = {0};
__Mem_copy__(b, src, extra_bytes);
__Base64_encode3Bytes__((void*)b, out);
out += 4;
// add padding
size_t pads = 3 - extra_bytes;
for (char* pad = out - pads ;pad < out; pad++) {*pad = '=';}
}
}
// HEX
// # printHex
void printHex(char* buffer_ptr, uintptr_t buffer_len) {
for (int i = 0; i < buffer_len; i++) {
printf(" %02X ", buffer_ptr[i]);
}
}
// # __Nibble_fromHexNibble__
char __Nibble_fromHexNibble__(char nibble) {
if (nibble >= 'a') return 10 + nibble - 'a';
if (nibble >= 'A') return 10 + nibble - 'A';
return nibble - '0';
}
// # __Byte_fromHex__
char __Byte_fromHex__(char* hex_byte) {
char b_F0 = __Nibble_fromHexNibble__(hex_byte[0]);
char b_0F = __Nibble_fromHexNibble__(hex_byte[1]);
return (b_F0 << 4) | b_0F;
}
// # __Bytes_fromHex__ // REPLACED ARG ORDER!
void __Bytes_fromHex__(
char* buffer_ptr, // expected len >= hex_len >> 2
char* hex,
size_t hex_len
) {
size_t end_pos = hex_len >> 1;
for(size_t pos = 0; pos < end_pos; pos++) {
buffer_ptr[pos] = __Byte_fromHex__(&hex[pos*2]);
}
}
// # __HexCapital_fromNibble__
char __HexCapital_fromNibble__(char data) {
if (data <= 9) return '0' + data;
if (data <= 15) return 'A' + data - 10;
return 0;
}
// # __HexCapital_fromByte__
void Hex_packByte_H(char data, char* hex_byte) {
hex_byte[0] = __HexCapital_fromNibble__((data & 0xF0) >> 4);
hex_byte[1] = __HexCapital_fromNibble__(data & 0x0F);
}
// # __HexCapital_fromBytes__
void Hex_pack_H(char* hex, char* data, size_t data_len) {
// expected hex.len is __Hex_lenFromBytesLen__(len)
for(size_t pos = 0; pos < data_len; pos++) {
Hex_packByte_H(data[pos], &hex[pos * 2]);
}
}
// # __Hex_fromNibble__
char __Hex_fromNibble__(uint8_t data) {
if (data <= 9) return (uint8_t)'0' + data;
if (data <= 15) return (uint8_t)'a' + data - 10;
return 0;
}
// # __Hex_fromByte__
void __Hex_fromByte__(
char *buffer,
uint8_t data
) {
buffer[0] = __Hex_fromNibble__((data & 0xF0) >> 4);
buffer[1] = __Hex_fromNibble__(data & 0x0F);
}
// # __Hex_fromBytes__
void __Hex_fromBytes__(
char *hex, // expected len >= __Hex_lenFromBytesLen__(data_len)
char *data,
size_t data_len
) {
for(size_t pos = 0; pos < data_len; pos++) {
__Hex_fromByte__(&hex[pos << 1], data[pos]);
}
}
// # __FormatsHex_packBytesReverse__
void __FormatsHex_packBytesReverse__(
char *hex, // expected len >= __Hex_lenFromBytesLen__(data_len)
char *data,
size_t data_len // expected >= 1
) {
size_t hex_pos = data_len << 1;
for (size_t data_pos = 0; data_pos < data_len; data_pos++) {
hex_pos -= 2;
__Hex_fromByte__(&hex[hex_pos], data[data_pos]);
}
}
// AP
// its hex like but use from 'a' to 'p' values for symbols
// # __Ap_fromNibble__
uint8_t __Ap_fromNibble__(
char data
) {
if (data <= 16) {
return 'A' + data;
}
return 0;
}
// # __Ap_fromByte__
void __Ap_fromByte__(
char *buffer, // expected len >= 2
char byte
) {
buffer[0] = __Ap_fromNibble__((byte & 0xF0) >> 4);
buffer[1] = __Ap_fromNibble__(byte & 0x0F);
}
// # __Ap_fromBytes__
void __Ap_fromBytes__(
char *buffer, // expected len >= data_len << 1
const char *data,
size_t data_len
) {
size_t writed = 0;
for(size_t pos = 0; pos < data_len; pos++) {
__Ap_fromByte__(&buffer[writed], data[pos]);
writed += 2;
}
}
// # __Ap_fromBytesReversed__
void __Ap_fromBytesReversed__(
char *buffer, // expected len >= data_len << 1
const char *data,
size_t data_len
) {
size_t writed = data_len << 1;
for (size_t readed = 0; readed < data_len; readed++) {
writed -= 2;
__Ap_fromByte__(&buffer[writed], data[readed]);
}
}
// # __Nibble_fromAp__
uint8_t __Nibble_fromAp__(char data) {
if (data >= 'A' && data <= 'P') {
return data - 'A';
} else if (data >= 'a' && data <= 'p') {
return data - 'a';
}
return 0;
}
// # __Byte_fromAp__
uint8_t __Byte_fromAp__(
const char* data // expected len >= 2
) {
char fo = __Nibble_fromAp__(data[0]);
char of = __Nibble_fromAp__(data[1]);
return (fo << 4) | of;
}
// # __Bytes_fromAp__
void __Bytes_fromAp__(
char *buffer, // expected len >= ap_len >> 1
const char *ap,
size_t ap_len
) {
size_t readed = 0;
size_t writed = 0;
while(readed < ap_len) {
buffer[writed] = __Byte_fromAp__(&ap[readed]);
writed += 1;
readed += 2;
}
}
// # __Bytes_fromApReversed__
void __Bytes_fromApReversed__(
char *buffer, // expected len >= ap_len >> 1
const char *ap,
size_t ap_len // expected >= 2, expected odd
) {
size_t ap_pos = ap_len;
size_t writed = 0;
while (ap_pos > 0) {
ap_pos -= 2; // garanty ap_pos < ap_len
buffer[writed] = __Byte_fromAp__(&ap[ap_pos]);
writed += 1;
}
}
// # __u64FromTextDec__ atoi atou
uint64_t
__u64FromTextDec__(
const char *bytes, // expected bytes only with numbers from '0' to '9'
size_t len // expected > 0; expected <= __u64FromTextDec_maxLen__
) {
uint64_t result = 0;
size_t numerical_place = 1;
size_t pos = len - 1; // last symbol
while (true) {
char byte = bytes[pos];
uint64_t value = (uint64_t) ((uint8_t)byte - (uint8_t)'0');
result += value * numerical_place;
if (pos == 0) break;
numerical_place *= 10;
pos -= 1;
}
return result;
}
// crypto
// random
// # __CryptoRandom_do__
void __CryptoRandom_do__(
struct __CryptoRandom__ *t,
char *out_buffer,
size_t buffer_len
) {
struct __CryptoScalpiHash__ hasher;
__CryptoScalpiHash_reset__(&hasher);
__CryptoScalpiHash_do__(&hasher, &t->seed, sizeof(t->seed), out_buffer, buffer_len);
t->seed += 1;
}
// ScalpiHash
// # __CryptoScalpiHash_swapTwoBit__
void __CryptoScalpiHash_swapTwoBit__(struct __CryptoScalpiHash__ *t) {
// truncate a and b to 3 bit.
uint8_t a = t->a & 0b111;
uint8_t b = t->b & 0b111;
// save bits with swap
uint8_t tmp_a = (t->mask & 1 << a) >> a << b;
uint8_t tmp_b = (t->mask & 1 << b) >> b << a;
uint8_t tmp = tmp_a | tmp_b;
// clear bits
t->mask &= 255 - (1 << a);
t->mask &= 255 - (1 << b);
// set last bits
t->mask |= tmp;
}
// # __CryptoScalpiHash_doBit__
void __CryptoScalpiHash_doBit__(
struct __CryptoScalpiHash__* t,
uint8_t bit,
uint8_t *dest, // canbe not zeroed
size_t dest_len
) {
uint8_t bb = 2 - bit;
for (int i = 0; i < dest_len; i++) {
uint8_t *output_byte = &dest[i];
t->a += *output_byte;
t->b += bb;
__CryptoScalpiHash_swapTwoBit__(t);
*output_byte += t->mask;
}
}
// # __CryptoScalpiHash_doByte__
void __CryptoScalpiHash_doByte__(
struct __CryptoScalpiHash__ *t,
uint8_t byte,
uint8_t *dest,
size_t size
) {
uint8_t pos = 0;
while (true) {
uint8_t bit = (byte >> pos) & 1;
__CryptoScalpiHash_doBit__(t, bit, dest, size);
if (pos == 7) break;
pos += 1;
}
}
// # __CryptoScalpiHash_do__
void __CryptoScalpiHash_do__(
struct __CryptoScalpiHash__ *t,
const char *src,
size_t src_size,
char *dest,
size_t dest_size
) {
for (int i = 0; i < src_size; i++) {
__CryptoScalpiHash_doByte__(t, src[i], dest, dest_size);
}
}
// # __CryptoScalpiHash_reset__
void __CryptoScalpiHash_reset__(
struct __CryptoScalpiHash__ *t
) {
t->mask = 0b00001111;
t->a = 0;
t->b = 0;
}
// # __crypto_sumBytes__
uint8_t __crypto_sumBytes__(
const char *data,
size_t data_len
) {
char ret = 0;
for (size_t pos = 0; pos < data_len; pos++) {
ret += data[pos];
}
return ret;
}
// # __crypto_xorBytes__
uint8_t __crypto_xorBytes__(
const char *data,
size_t data_len
) {
char ret = 0;
for (size_t pos = 0; pos < data_len; pos++) {
ret ^= data[pos];
}
return ret;
}
// # __crypto_xorCyclic__
void __crypto_xorCyclic__(
char *dest,
const char *a,
size_t dest_len,
const char *b,
size_t b_len
) {
// expected dest_len == a.len
size_t ci = 0; // cyclical iterator
for (size_t pos = 0; pos < dest_len; pos++) {
dest[pos] = a[pos] ^ b[ci];
ci += 1;
if (ci == b_len) ci = 0;
}
}
// __Logger__
// # __Logger_init__
void __Logger_init__ (struct __Logger__* t) {
for (int i = 0; i < __arrayLen__(t->writers); i++) {
struct __Writer__* w = &t->writers[i];
w->context = 0;
w->write = 0;
}
}
// # __Logger_writeToSelf__
void __Logger_writeToSelf__(struct __Logger__* t, const char bytes[], size_t len) {
for (size_t i = 0; i < __arrayLen__(t->writers); i++) {
struct __Writer__* w = &t->writers[i];
if (w->write) {
size_t writed = w->write(w->context, bytes, len);
}
}
}
// console
// Output
// # __ConsoleOutput_cursorHide__
void __ConsoleOutput_cursorHide__(struct __OsConsoleOutput__* console_output) {
__OsConsoleOutput_write__(console_output, __ConsoleAnsi_output_cursor_hide__, 0);
}
// # __Console_showCursor__
void __Console_showCursor__(struct __Console__ *console) {
__OsConsoleOutput_writeCText__(&console->output, __ConsoleAnsi_output_cursor_show__);
}
// # __Console_clearLine__
void __Console_clearLine__(struct __Console__ *console) {
__OsConsoleOutput_writeCText__(&console->output, __ConsoleAnsi_output_clear_line__);
}
// # __Console_init__
void __Console_init__(
struct __Console__ *t,
__OsConsoleInputHandle__ input_handle,
__OsConsoleOutputHandle__ output_handle
) {
__OsConsoleInput_init__(&t->input, input_handle);
__OsConsoleOutput_init__(&t->output, output_handle);
}
// terminal
// input
// __TerminalInput__
// # __TerminalInput_grab__
bool __TerminalInput_grab__(
__ConsoleAnsiInputKey__ *ret_key,
struct __TerminalInput__ *t
) {
if (t->ungrabed > 0) {
char* bytes = &t->buffer[0];
size_t bytes_len = t->ungrabed;
struct __ConsoleAnsiInputKey_SequenceParser__ parsed;
if (__ConsoleAnsi_input_Key_SequenceParser_fromBytes__(&parsed, bytes, bytes_len)) {
__TerminalInput_shift__(t, parsed.used);
*ret_key = parsed.sequence;
return true;
} else {
__ConsoleAnsiInputKey__ key = bytes[0];
__TerminalInput_shift__(t, 1);
*ret_key = key;
return true;
}
}
return false;
}
// # __TerminalInput_shift__
void __TerminalInput_shift__(
struct __TerminalInput__ *t,
size_t val
) {
__Mem_copy__(&t->buffer[0], &t->buffer[val], __TerminalInput_size__ - val);
t->ungrabed -= val;
}
// # __TerminalInput_init__
void __TerminalInput_init__(
struct __TerminalInput__ *t
) {
t->ungrabed = 0;
}
// # __Terminal_updateInputBuffer__
void __Terminal_updateInputBuffer__(
struct __Terminal__ *terminal
) {
struct __Console__ *console = terminal->console;
size_t unreaded = 0;
if (__OsConsoleInput_getCountOfUnreaded__(&console->input, &unreaded)) {
while (terminal->input.ungrabed < __TerminalInput_size__ and unreaded > 0) { // get new byte
char byte;
if (__OsConsoleInput_readByte__(&byte, &console->input)) {
terminal->input.buffer[terminal->input.ungrabed] = byte;
terminal->input.ungrabed += 1;
}
unreaded -= 1;
}
} else {
// ok = false;
}
}
// output
// __TerminalOutputCursorPos__ - not use internally
// # __TerminalOutputCursorPos_init__
void __TerminalOutputCursorPos_init__(
struct __Math2dPosU__ *cursor_pos
) {
cursor_pos->x = 0;
cursor_pos->y = 0;
}
// # __Terminal_Output_Cursor_shiftDown__
void __Terminal_Output_Cursor_shiftDown__(
struct __Math2dPosU__ *cursor_pos,
size_t delta
) {
if (delta != 0){
// print_to_console(__ConsoleAnsi_control__ + delta + "B");
char buffer[1024];
size_t writed = 0;
writed += __CText_write__(&buffer[0], __ConsoleAnsi_control__);
writed += __Text_formatU64ToBuffer__(&buffer[writed], delta, 1);
writed += __CText_write__(&buffer[writed], "B");
__OsConsoleOutput_write__(&__app__.console.output, &buffer[0], writed);
cursor_pos->y += delta;
}
}
// # __Terminal_Output_Cursor_shiftUp__
void __Terminal_Output_Cursor_shiftUp__(
struct __Math2dPosU__ *cursor_pos,
size_t delta
) {
if (delta != 0) {
// print_to_console(__ConsoleAnsi_control__ + delta + "A");
char buffer[1024];
size_t writed = 0;
writed += __CText_write__(&buffer[0], __ConsoleAnsi_control__);
writed += __Text_formatU64ToBuffer__(&buffer[writed], delta, 1);
writed += __CText_write__(&buffer[writed], "A");
__OsConsoleOutput_write__(&__app__.console.output, &buffer[0], writed);
cursor_pos->y -= delta;
}
}
// # __Terminal_Output_Cursor_shiftRight__
void __Terminal_Output_Cursor_shiftRight__(
struct __Math2dPosU__ *cursor_pos,
size_t delta
) {
if (delta != 0) {
// print_to_console(__ConsoleAnsi_control__ + delta + "C");
char buffer[1024];
size_t writed = 0;
writed += __CText_write__(&buffer[0], __ConsoleAnsi_control__);
writed += __Text_formatU64ToBuffer__(&buffer[writed], delta, 1);
writed += __CText_write__(&buffer[writed], "C");
__OsConsoleOutput_write__(&__app__.console.output, &buffer[0], writed);
cursor_pos->x += delta;
}
}
// # __Terminal_Output_Cursor_shiftLeft__
void __Terminal_Output_Cursor_shiftLeft__(
struct __Math2dPosU__ *cursor_pos,
size_t delta
) {
if (delta != 0) {
// print_to_console(__ConsoleAnsi_control__ + delta + "D");
char buffer[1024];
size_t writed = 0;
writed += __CText_write__(&buffer[0], __ConsoleAnsi_control__);
writed += __Text_formatU64ToBuffer__(&buffer[writed], delta, 1);
writed += __CText_write__(&buffer[writed], "D");
__OsConsoleOutput_write__(&__app__.console.output, &buffer[0], writed);
cursor_pos->x -= delta;
}
}
// # __TerminalOutputCursorPos_move__
// not use me directly. use __Terminal_cursorMove__ instead
void __TerminalOutputCursorPos_move__(
struct __Math2dPosU__ *cursor_pos,
size_t new_pos_x,
size_t new_pos_y
) {
if (new_pos_x != cursor_pos->x) { // move_from_x
// reset x pos
__OsConsoleOutput_write__(&__app__.console.output, "\r", 0);
cursor_pos->x = 0;
if (new_pos_x != 0) {
__Terminal_Output_Cursor_shiftRight__(cursor_pos, new_pos_x - cursor_pos->x);
}
}
if (new_pos_y != cursor_pos->y) { // move_from_y
if (new_pos_y > cursor_pos->y) {
__Terminal_Output_Cursor_shiftDown__(cursor_pos, new_pos_y - cursor_pos->y);
} else {
__Terminal_Output_Cursor_shiftUp__(cursor_pos, cursor_pos->y - new_pos_y);
}
}
}
// style
// # __Terminal_setFontStyle__
void __Terminal_setFontStyle__(
struct __Terminal__ *terminal,
const char* font_style,
size_t font_style_len
) {
if (terminal->output.font_style != font_style) {
terminal->output.font_style = font_style;
terminal->output.__TerminalOutput_fontStyleLen__ = font_style_len;
__OsConsoleOutput_write__(&terminal->console->output, font_style, font_style_len);
}
}
// # __Terminal_resetColors__
void __Terminal_resetColors__(struct __Terminal__ *terminal) {
__Terminal_setFontStyleCText__(terminal, __ConsoleAnsiOutputFontStyle_command_reset__);
}
// screen
// # __Terminal_updateOutputSize__
void __Terminal_updateOutputSize__(struct __Terminal__ *terminal) {
struct __Math2dPosU__ size;
__OsConsoleOutput_getSize__(&terminal->console->output, &size);
// x
if (size.x >= 6) {
terminal->output.size.x = size.x - 3;
} else {
terminal->output.size.x = size.x;
}
// y
if (size.y >= 6) {
terminal->output.size.y = size.y - 3;
} else {
terminal->output.size.y = size.y;
}
}
// # __Terminal_initBlankLinesToOutput__
void __Terminal_initBlankLinesToOutput__(struct __Terminal__ *terminal) {
struct __Console__ *console = terminal->console;
__OsConsoleOutput_writeCText__(&console->output, "\r\n");
__Terminal_cursorMove__(terminal, 0, 0);
size_t pos_y = 0;
while (pos_y < terminal->output.size.y - 2) {
__OsConsoleOutput_writeCText__(&console->output, "\r\n");
pos_y += 1;
terminal->output.cursor_pos.y += 1;
}
}
// cursor
// # __Terminal_cursorMove__
void __Terminal_cursorMove__(
struct __Terminal__ *terminal,
size_t pos_x,
size_t pos_y
) {
if ((pos_x > terminal->output.size.x) or (pos_y > terminal->output.size.y)) {
terminal->output.cursor_pos.x = terminal->output.size.x - 1;
terminal->output.cursor_pos.y = terminal->output.size.y - 1;
__Terminal_moveCursorToStartOfLine__(terminal);
} else {
__TerminalOutputCursorPos_move__(&terminal->output.cursor_pos, pos_x, pos_y);
}
}
// # __Terminal_moveCursorToNextLine__
void __Terminal_moveCursorToNextLine__(struct __Terminal__ *terminal) {
if (terminal->output.cursor_pos.y < terminal->output.size.y) {
__TerminalOutputCursorPos_move__(&terminal->output.cursor_pos, terminal->output.cursor_pos.x, terminal->output.cursor_pos.y + 1);
} else {
__OsConsoleOutput_write__(&terminal->console->output, "\n", 0);
}
}
// # __Terminal_moveCursorToStartOfLine__
void __Terminal_moveCursorToStartOfLine__(struct __Terminal__ *terminal) {
__OsConsoleOutput_write__(&terminal->console->output, "\r", 0);
terminal->output.cursor_pos.x = 0;
}
// # __Terminal_moveCursorToStartOfNextLine__
void __Terminal_moveCursorToStartOfNextLine__(struct __Terminal__ *terminal) { // \r\n
__Terminal_moveCursorToNextLine__(terminal);
__Terminal_moveCursorToStartOfLine__(terminal);
}
// # __Terminal_clearOutput__
void __Terminal_clearOutput__(struct __Terminal__ *terminal) {
struct __Console__* console = terminal->console;
__ConsoleOutput_cursorHide__(&__app__.console.output);
size_t pos_y = 0;
while (pos_y < terminal->output.size.y) {
__Terminal_cursorMove__(terminal, 0, pos_y);
__OsConsoleOutput_writeCText__(&console->output, __ConsoleAnsi_output_clear_line__);
pos_y += 1;
}
__Console_showCursor__(console);
}
// # __Terminal_initOutput__
void __Terminal_initOutput__(struct __Terminal__ *terminal) {
struct __TerminalOutput__ *output = &terminal->output;
__TerminalOutputCursorPos_init__(&output->cursor_pos);
output->font_style = "";
output->__TerminalOutput_fontStyleLen__ = 0;
output->size.x = 1;
output->size.y = 1;
output->convert_n_to_rn = false;
output->apply_r = false;
output->apply_n = false;
__Terminal_updateOutputSize__(terminal);
__Terminal_resetColors__(terminal);
__Terminal_initBlankLinesToOutput__(terminal);
__Terminal_clearOutput__(terminal);
__Terminal_cursorMove__(terminal, 0, 0);
}
// # __Terminal_deinitOutput__
void __Terminal_deinitOutput__(struct __Terminal__ *terminal) {
__OsConsoleOutput_writeCText__(&__app__.console.output, __ConsoleAnsiOutputSettings_enableLineWrap__);
__Terminal_resetColors__(terminal);
__OsConsoleOutput_writeCText__(&__app__.console.output, __ConsoleAnsiOutputFontStyle_command_reset__);
__OsConsoleOutput_writeCText__(&__app__.console.output, "\r\n");
__Console_showCursor__(terminal->console);
}
// # __Terminal_writeColoredErrorSymbolToOutput__
void __Terminal_writeColoredErrorSymbolToOutput__(
struct __Terminal__ *t
) {
struct __Console__ *console = t->console;
#define __TerminalErrorSymbol_color__ \
__ConsoleAnsiOutputFontStyle_start__ \
__ConsoleAnsiOutputFontStyle_bg_color_yellow__ \
__ConsoleAnsiOutputFontStyle_sep__ \
__ConsoleAnsiOutputFontStyle_color_red__ \
__ConsoleAnsiOutputFontStyle_end__
__OsConsoleOutput_writeCText__(&console->output, __TerminalErrorSymbol_color__);
__OsConsoleOutput_writeCText__(&console->output, "#");
__OsConsoleOutput_write__(&console->output, t->output.font_style, t->output.__TerminalOutput_fontStyleLen__);
t->output.cursor_pos.x += 1;
}
// # __Terminal_writeToOutput__
void __Terminal_writeToOutput__(
struct __Terminal__ *terminal,
const char *bytes,
size_t bytes_len
) {
for (size_t readed = 0; readed < bytes_len; readed += 1) {
char byte = bytes[readed];
if (byte >= ' ' and byte <= '~') {
struct __Console__ * console = terminal->console;
__OsConsoleOutput_write__(&console->output, &bytes[readed], 1);
terminal->output.cursor_pos.x += 1;
} else if (byte == '\r') {
if (terminal->output.apply_r) {
__Terminal_moveCursorToStartOfLine__(terminal);
} else {
__Terminal_writeColoredErrorSymbolToOutput__(terminal);
}
} else if (byte == '\t') {
__Terminal_writeColoredErrorSymbolToOutput__(terminal);
} else if (byte == '\n') {
if (terminal->output.apply_n) {
if (terminal->output.convert_n_to_rn) __Terminal_moveCursorToStartOfLine__(terminal);
__Terminal_moveCursorToNextLine__(terminal);
} else {
__Terminal_writeColoredErrorSymbolToOutput__(terminal);
}
} else {
__Terminal_writeColoredErrorSymbolToOutput__(terminal);
}
}
}
// # __Terminal_init__
bool __Terminal_init__(
struct __Terminal__ *t,
struct __Console__ *console
) {
bool ok = true;
t->console = console;
__TerminalInput_init__(&t->input);
__Terminal_initOutput__(t);
// configure console
// save flags before change
if (__OsConsoleFlags_init__(&t->system_flags, &console->input, &console->output)) {
// go to interactive mode ("non canonical mode" or "raw mode")
struct __OsConsoleFlags__ flags;
if (__OsConsoleFlags_init__(&flags, &console->input, &console->output)) {
__OsConsoleFlags_setNonCanonicalMode__(&flags);
if (__OsConsoleFlags_apply__(&flags, &console->input, &console->output)) {
__OsConsoleOutput_writeCText__(&__app__.console.output, __ConsoleAnsiOutputSettings_disableLineWrap__);
} else {
ok = false;
}
} else {
ok = false;
}
} else {
ok = false;
}
return ok;
}
// # __Terminal_deinit__
bool __Terminal_deinit__(struct __Terminal__ *terminal) {
bool ok = true;
struct __Console__* console = terminal->console;
__Terminal_deinitOutput__(terminal);
if (__OsConsoleFlags_apply__(&terminal->system_flags, &console->input, &console->output)) {
} else {
ok = false;
}
return ok;
}
// __App__
// editor
// __AppEditorLine__
// # __AppEditorLine_setText__
void __AppEditorLine_setText__ (
struct __AppEditorLine__ *line,
char *text_ptr,
size_t text_len // expected < __AppEditorLineLen_max__
) {
line->text_len = text_len;
__Mem_copy__(&line->text[0], text_ptr, text_len);
}
// # __AppEditorLine_setIndent__
bool __AppEditorLine_setIndent__( // TODO check all uses this fn
struct __AppEditorLine__ *line,
size_t new_indent // expected < __AppEditorLineLen_max__ - line->text_len
) {
return __Buffer_setIndent__(&line->text[0], &line->text_len, __AppEditorLineLen_max__, new_indent);
}
// # __AppEditorLine_init__
void __AppEditorLine_init__(
struct __AppEditorLine__ *t
) {
__MemListLink_init__(&t->link);
__MemTree_init__(&t->tree);
t->text_len = 0;
}
// # __AppEditorLine_alloc__
bool __AppEditorLine_alloc__(struct __AppEditorLine__ **ptr) {
return __AlignedPtr_alloc__( ptr, __Type_getAlign__(struct __AppEditorLine__), __Type_getSize__(struct __AppEditorLine__) );
}
// # __AppEditorLine_free__
void __AppEditorLine_free__(struct __AppEditorLine__ *line) {
__AlignedPtr_freeAny__(line, __Type_getSize__(struct __AppEditorLine__));
}
// __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, __Type_getAlign__(struct __AppEditorHistoryNote__), sizeof(struct __AppEditorHistoryNote__) );
}
// macro
/* // use me after port fns: __AppEditor_changeStatus__ __AppEditor_onKey__
// # __AppEditor_playMacro__
bool __AppEditor_playMacro__(struct __AppEditor__ *t) {
bool ok = true;
if (t->recording_macro != true) {
struct __MemListLink__ *start = t->start_record_link;
struct __MemListLink__ *end = t->stop_record_link;
if ( start and end ) {
struct __MemListLink__ *next_link = start->next; // skipped start recording itself
while ( next_link and (next_link != stop)) {
struct __AppEditorHistoryNote__ *history_note = __TypedPtr_getParentPtrFromFieldPtr__(struct __AppEditorHistoryNote__, link, next_link));
struct __ConsoleAnsiInputKey__ key = history_note->key;
__AppEditor_onKey__(t, key);
next_link = next_link->next;
}
} else {
ok = false;
try __AppEditor_changeStatus__("macro not recorded.");
}
} else {
ok = false;
try __AppEditor_changeStatus__("not aviable while recording");
}
return ok;
}
// # __AppEditor_stopRecordMacro__
bool __AppEditor_stopRecordMacro__(struct __AppEditor__ *t) {
bool ok = true;
if (t->recording_macro == true) {
if (__AppEditor_addKeyToHistory__(t, 0)) {
t->stop_record_link = t->history.last;
t->recording_macro = false;
ok = __AppEditor_changeStatus__("stop recording macro.");
} else {
ok = false;
}
} else {
ok = false;
try __AppEditor_changeStatus__("macro not recording right now.");
}
return ok;
}
// # __AppEditor_startRecordMacro__
bool __AppEditor_startRecordMacro__(t: *c.__AppEditor__) {
var ok: bool = true;
if (t->recording_macro != true) {
if (__AppEditor_addKeyToHistory__(t, 0)) {
t->recording_macro = true;
t->start_record_link = t->history.last;
t->stop_record_link = NULL;
__AppEditor_changeStatus__("start recording macro.");
} else {
ok = false;
__AppEditor_changeStatus__("Unexpected error"); // todo add line
}
} else {
ok = false;
__AppEditor_changeStatus__("macro is recording right now"); // todo add line
}
return ok;
}
*/
// # __AppEditor_addKeyToHistory__
bool __AppEditor_addKeyToHistory__(
struct __AppEditor__ *editor,
__ConsoleAnsiInputKey__ key
) {
bool ok = true;
struct __AppEditorHistoryNote__ *hn;
if ( __AppEditorHistoryNote_alloc__(&hn)) {
hn->key = key;
struct __MemListLink__ *link = &hn->link;
__MemListLink_init__(link);
__MemList_pushLast__(&editor->history, link);
if (!ok) __AppEditorHistoryNote_free__(hn);
} else {
ok = false;
}
return ok;
}
// # __App_init__
bool __App_init__(struct __App__* t) {
bool ok = true;
__Logger_init__(&t->__App_logger__); // preinit console output for debug
if (__OsHelper_init__(&t->__App_osHelper__)) {
t->tick = __os_getTick__();
if (!ok) __OsHelper_deinit__(&t->__App_osHelper__);
} else {
ok = false;
printf("%d app.__App_osHelper__ not inited\r\n", __LINE__);
}
return ok;
}
// # __App_deinit__
void __App_deinit__(struct __App__* app) {
__OsHelper_deinit__(&app->__App_osHelper__);
}
// # __App_process__
bool __App_process__(struct __App__* t) {
bool ok = true;
__OsHelper_process__(&t->__App_osHelper__);
return ok;
}
// # __App_waitToNextFrame__
void __App_waitToNextFrame__(struct __App__* t) {
uint64_t expected_frame_end_time = t->tick + __Time_msPerS__ / __App_expectedFps__;
uint64_t resulting_frame_end_time = __os_getTick__();
if (resulting_frame_end_time > expected_frame_end_time + 120) {
uint64_t delta = resulting_frame_end_time - expected_frame_end_time;
printf("%d \t hitch detection: %zu delta: %zu ms \r\n", __LINE__, t->tick, delta);
}
uint64_t delay_sleep = 1;
if (resulting_frame_end_time < expected_frame_end_time) {
delay_sleep = expected_frame_end_time - resulting_frame_end_time;
}
__Os_sleep__(delay_sleep);
t->tick = resulting_frame_end_time + delay_sleep;
}
// main
bool tests() {
// const char* test_file_name = "scalpi_testing_file.txt";
// size_t test_file_name_len = __ZText_countLen__(test_file_name);
if ( true
and cpu_checkNumberFormat()
and __Mem_isEql_test__()
// and __FileComplete_write__(test_file_name, test_file_name_len, "abcd", 4)
// and __FileComplete_write__(test_file_name, test_file_name_len, "efgh", 4)
// and __FileComplete_write__(test_file_name, test_file_name_len, "ijkm", 4)
// and etc...
) {
return true;
} else {
printf("%d fail tests \r\n", __LINE__);
return false;
}
return true;
}
bool real_main(int args_len, char** args_ptr) {
struct __Trace__ trace; __Trace_init__(&trace, NULL, __LINE__);
bool ok = true;
trace.__Trace_line__ = __LINE__;
if (tests()) {
trace.__Trace_line__ = __LINE__;
printf("%d success tests \r\n", __LINE__);
if (false and __App_init__(&__app__)) {
trace.__Trace_line__ = __LINE__; __Trace_print__(&trace);
while(true) {
if (!__App_process__(&__app__)) break;
__App_waitToNextFrame__(&__app__);
}
__App_deinit__(&__app__);
} else {
ok = false;
printf("%d fail: __App_init__\r\n", __LINE__);
}
} else {
ok = false;
printf("%d fail tests \r\n", __LINE__);
}
return ok;
}
#ifndef __COMPILED_FROM_ZIG_FILE__
int main(int args_len, char** args_ptr) {
trace_example();
if (real_main(args_len, args_ptr)) return 0;
return 1;
}
#endif
// TODO port this zig code to C
/*
const Utf8 = struct {
const BytesIterator = struct {
const Parsed = struct {
num: u64 = 0,
bytes: []const u8 = &.{},
fn is_connector(t: *Parsed) bool {
if (t.num == 0x200D) return true;
return false;
}
};
const Iterator = struct {
bytes: []const u8,
pos: usize = 0,
fn next(t: *Iterator) ?Parsed {
// Masks:
//| 1 byte | 2 byte | 3 byte | 4 byte
//
// 0xxxxxxx
// 110xxxxx 10xxxxxx
// 1110xxxx 10xxxxxx 10xxxxxx
// 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
// example "?"
// 208 -- 110 10000
// 159 -- 10 011111
// is
// 1055 -- 000 10000011111
parse: {
var parsed: Parsed = .{};
// 1 byte
if (t.bytes.len <= t.pos) break :parse;
const b1 = t.bytes[t.pos];
const c1: u64 = @intCast(b1);
if (checkMask(b1, 0, 0b10000000)) { // 0xxxxxxx
parsed.num = b1 & 0b01111111;
parsed.bytes = t.bytes[t.pos .. t.pos + 1];
t.pos += 1;
return parsed;
}
// 2 byte
if (t.bytes.len <= t.pos + 1) break :parse;
const b2 = t.bytes[t.pos + 1];
const c2: u64 = @intCast(b2);
if (checkMask(b1, 0b11000000, 0b11100000)) { // 110xxxxx
parsed.num = ((c1 & 31) << 6) + (c2 & 63);
parsed.bytes = t.bytes[t.pos .. t.pos + 2];
t.pos += 2;
return parsed;
}
// 3 byte
if (t.bytes.len <= t.pos + 2) break :parse;
const b3 = t.bytes[t.pos + 2];
const c3: u64 = @intCast(b3);
if (checkMask(b1, 0b11100000, 0b11110000)) { // 1110xxxx
parsed.num = ((c1 & 15) << 12) + ((c2 & 63) << 6) + (c3 & 63);
parsed.bytes = t.bytes[t.pos .. t.pos + 3];
t.pos += 3;
return parsed;
}
// 4 byte
if (t.bytes.len <= t.pos + 3) break :parse;
const b4 = t.bytes[t.pos + 3];
const c4: u64 = @intCast(b4);
if (checkMask(b1, 0b11110000, 0b11111000)) { // 11110xxx
parsed.num = ((c1 & 7) << 21) + ((c2 & 63) << 12) + ((c3 & 63) << 6) + (c4 & 63);
parsed.bytes = t.bytes[t.pos .. t.pos + 4];
t.pos += 4;
return parsed;
}
}
t.pos += 1;
return null;
}
};
fn checkMask(num: u8, mask: u8, used_bits: u8) bool {
if (num & used_bits == mask) {
return true;
} else {
return false;
}
}
fn fromDo(bytes: []const u8) Iterator {
return Iterator{ .bytes = bytes };
}
};
};
*/