mirror of
https://github.com/odin-lang/Odin.git
synced 2026-04-19 21:10:30 +00:00
Replace inline with #force_inline in sys/es/api.odin
This commit is contained in:
gingerBill
@@ -2329,7 +2329,7 @@ PanelBand :: struct {
|
||||
grow : i32,
|
||||
shrink : i32,
|
||||
}
|
||||
UICallbackFunction :: distinct #type proc "c" ( ^Element, ^Message, ^Response);
|
||||
UICallbackFunction :: distinct proc "c" ( ^Element, ^Message, ^Response);
|
||||
ElementProperties :: struct {
|
||||
cStyle : cstring ,
|
||||
cStyleOverride : cstring ,
|
||||
@@ -2383,7 +2383,7 @@ FormatValue :: struct {
|
||||
time : u64 ,
|
||||
},
|
||||
}
|
||||
FragmentShaderCallbackFunction :: distinct #type proc "c" ( i32, i32, ^StyledBox) -> u32 ;
|
||||
FragmentShaderCallbackFunction :: distinct proc "c" ( i32, i32, ^StyledBox) -> u32 ;
|
||||
StyledBox :: struct {
|
||||
ox : i32,
|
||||
oy : i32,
|
||||
@@ -2414,7 +2414,7 @@ CalculationValue :: struct {
|
||||
error : bool,
|
||||
number : [16]u8 ,
|
||||
}
|
||||
CommandCallbackFunction :: distinct #type proc "c" ( ^INSTANCE_TYPE, ^Element, ^Command);
|
||||
CommandCallbackFunction :: distinct proc "c" ( ^INSTANCE_TYPE, ^Element, ^Command);
|
||||
Command :: struct {
|
||||
elements : ^^Element,
|
||||
callback : CommandCallbackFunction,
|
||||
@@ -2447,326 +2447,326 @@ AudioStream :: struct {
|
||||
control : u16 ,
|
||||
clock : u64 ,
|
||||
}
|
||||
ThreadEntryFunction :: distinct #type proc "c" ( Generic);
|
||||
ComparisonCallbackFunction :: distinct #type proc "c" ( rawptr, rawptr, Generic) -> i32;
|
||||
SwapCallbackFunction :: distinct #type proc "c" ( rawptr, rawptr, Generic);
|
||||
CRTComparisonCallback :: distinct #type proc "c" ( rawptr, rawptr) -> i32;
|
||||
TimerCallbackFunction :: distinct #type proc "c" ( Generic);
|
||||
MenuCallbackFunction :: distinct #type proc "c" ( ^Menu, Generic);
|
||||
StorePullCallbackFunction :: distinct #type proc "c" ( ^Store, ^INSTANCE_TYPE, Generic, i32, Generic, ^FormatValue);
|
||||
StoreCallbackFunction :: distinct #type proc "c" ( ^Store, ^INSTANCE_TYPE, Generic, Generic);
|
||||
DirectoryMonitorCallbackFunction :: distinct #type proc "c" ( ^DirectoryMonitor, i32, ^i8 , int , ^i8 , int , Generic);
|
||||
MessageLoopCallbackFunction :: distinct #type proc "c" ( ^Message);
|
||||
Batch :: inline proc "c" (calls_ : ^BatchCall, count_ : int ){ addr := 0x1000 + 0 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^BatchCall, int )) (fp))(calls_, count_); }
|
||||
GetCreationArgument :: inline proc "c" (object_ : Handle) -> Generic{ addr := 0x1000 + 1 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> Generic) (fp))(object_); }
|
||||
GetSystemInformation :: inline proc "c" (systemInformation_ : ^SystemInformation){ addr := 0x1000 + 2 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^SystemInformation)) (fp))(systemInformation_); }
|
||||
HandleClose :: inline proc "c" (handle_ : Handle) -> Error{ addr := 0x1000 + 3 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> Error) (fp))(handle_); }
|
||||
InitialiseCStandardLibrary :: inline proc "c" (argc_ : ^i32, argv_ : ^^^i8 ){ addr := 0x1000 + 4 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^i32, ^^^i8 )) (fp))(argc_, argv_); }
|
||||
MailslotSendData :: inline proc "c" (mailslot_ : Handle, data_ : rawptr, bytes_ : int ) -> bool{ addr := 0x1000 + 5 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, rawptr, int ) -> bool) (fp))(mailslot_, data_, bytes_); }
|
||||
MakeLinuxSystemCall2 :: inline proc "c" (n_ : int , a1_ : int , a2_ : int , a3_ : int , a4_ : int , a5_ : int , a6_ : int ) -> int { addr := 0x1000 + 6 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , int , int , int , int , int , int ) -> int ) (fp))(n_, a1_, a2_, a3_, a4_, a5_, a6_); }
|
||||
SystemConfigurationRead :: inline proc "c" (cKey_ : ^i8 , bytes_ : ^int ) -> rawptr{ addr := 0x1000 + 7 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^int ) -> rawptr) (fp))(cKey_, bytes_); }
|
||||
SystemGetConstant :: inline proc "c" (index_ : uint ) -> u64 { addr := 0x1000 + 8 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( uint ) -> u64 ) (fp))(index_); }
|
||||
TakeSystemSnapshot :: inline proc "c" (type_ : i32, bufferSize_ : ^int ) -> Handle{ addr := 0x1000 + 9 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32, ^int ) -> Handle) (fp))(type_, bufferSize_); }
|
||||
UserGetHomeFolder :: inline proc "c" (buffer_ : ^i8 , bufferBytes_ : int ) -> int { addr := 0x1000 + 10 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int ) -> int ) (fp))(buffer_, bufferBytes_); }
|
||||
_EsInstanceCreate :: inline proc "c" (bytes_ : int , message_ : ^Message) -> ^Instance{ addr := 0x1000 + 11 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , ^Message) -> ^Instance) (fp))(bytes_, message_); }
|
||||
_EsSyscall :: inline proc "c" (a_ : uint , b_ : uint , c_ : uint , d_ : uint , e_ : uint , f_ : uint ) -> uint { addr := 0x1000 + 12 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( uint , uint , uint , uint , uint , uint ) -> uint ) (fp))(a_, b_, c_, d_, e_, f_); }
|
||||
CommandAddButton :: inline proc "c" (command_ : ^Command, button_ : ^Button){ addr := 0x1000 + 13 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Command, ^Button)) (fp))(command_, button_); }
|
||||
CommandByID :: inline proc "c" (instance_ : ^Instance, stableID_ : u32 ) -> ^Command{ addr := 0x1000 + 14 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Instance, u32 ) -> ^Command) (fp))(instance_, stableID_); }
|
||||
CommandRegister :: inline proc "c" (command_ : ^Command, instance_ : ^Instance, callback_ : CommandCallbackFunction, stableID_ : u32 , cDefaultKeyboardShortcut_ : cstring , enabled_ : bool) -> ^Command{ addr := 0x1000 + 15 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Command, ^Instance, CommandCallbackFunction, u32 , cstring , bool) -> ^Command) (fp))(command_, instance_, callback_, stableID_, cDefaultKeyboardShortcut_, enabled_); }
|
||||
CommandSetCallback :: inline proc "c" (command_ : ^Command, callback_ : CommandCallbackFunction){ addr := 0x1000 + 16 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Command, CommandCallbackFunction)) (fp))(command_, callback_); }
|
||||
CommandSetDisabled :: inline proc "c" (command_ : ^Command, disabled_ : bool){ addr := 0x1000 + 17 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Command, bool)) (fp))(command_, disabled_); }
|
||||
DialogClose :: inline proc "c" (window_ : ^Window){ addr := 0x1000 + 18 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Window)) (fp))(window_); }
|
||||
DialogShow :: inline proc "c" (window_ : ^Window) -> ^Element{ addr := 0x1000 + 19 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Window) -> ^Element) (fp))(window_); }
|
||||
DialogShowAlert :: inline proc "c" (window_ : ^Window, title_ : string, content_ : string, iconID_ : u32 ) -> ^Element{ addr := 0x1000 + 20 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Window, ^u8, int, ^u8, int, u32 ) -> ^Element) (fp))(window_, raw_data(title_), len(title_), raw_data(content_), len(content_), iconID_); }
|
||||
KeyboardIsAltHeld :: inline proc "c" () -> bool{ addr := 0x1000 + 21 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> bool) (fp))(); }
|
||||
KeyboardIsCtrlHeld :: inline proc "c" () -> bool{ addr := 0x1000 + 22 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> bool) (fp))(); }
|
||||
KeyboardIsShiftHeld :: inline proc "c" () -> bool{ addr := 0x1000 + 23 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> bool) (fp))(); }
|
||||
MessageGetInputText :: inline proc "c" (message_ : ^Message, buffer_ : ^i8 ) -> int { addr := 0x1000 + 24 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Message, ^i8 ) -> int ) (fp))(message_, buffer_); }
|
||||
MessageLoopEnter :: inline proc "c" (callback_ : MessageLoopCallbackFunction){ addr := 0x1000 + 25 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( MessageLoopCallbackFunction)) (fp))(callback_); }
|
||||
MessageMutexAcquire :: inline proc "c" (){ addr := 0x1000 + 26 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
MessageMutexCheck :: inline proc "c" (){ addr := 0x1000 + 27 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
MessageMutexRelease :: inline proc "c" (){ addr := 0x1000 + 28 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
MessagePost :: inline proc "c" (target_ : ^Element, message_ : ^Message) -> Error{ addr := 0x1000 + 29 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, ^Message) -> Error) (fp))(target_, message_); }
|
||||
MessagePostRemote :: inline proc "c" (process_ : Handle, message_ : ^Message) -> Error{ addr := 0x1000 + 30 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, ^Message) -> Error) (fp))(process_, message_); }
|
||||
MessageSend :: inline proc "c" (object_ : ^Element, message_ : ^Message) -> Response{ addr := 0x1000 + 31 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, ^Message) -> Response) (fp))(object_, message_); }
|
||||
MouseGetPosition :: inline proc "c" (relativeElement_ : ^Element) -> Point{ addr := 0x1000 + 32 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> Point) (fp))(relativeElement_); }
|
||||
MouseSetPosition :: inline proc "c" (relativeWindow_ : ^Window, x_ : i32, y_ : i32){ addr := 0x1000 + 33 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Window, i32, i32)) (fp))(relativeWindow_, x_, y_); }
|
||||
PaintTargetClear :: inline proc "c" (target_ : ^PaintTarget){ addr := 0x1000 + 34 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^PaintTarget)) (fp))(target_); }
|
||||
PaintTargetTake :: inline proc "c" (window_ : ^Window, target_ : ^PaintTarget, width_ : int , height_ : int ) -> bool{ addr := 0x1000 + 35 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Window, ^PaintTarget, int , int ) -> bool) (fp))(window_, target_, width_, height_); }
|
||||
PaintTargetReturn :: inline proc "c" (window_ : ^Window, target_ : ^PaintTarget){ addr := 0x1000 + 36 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Window, ^PaintTarget)) (fp))(window_, target_); }
|
||||
StyleRefreshAll :: inline proc "c" (window_ : ^Element){ addr := 0x1000 + 37 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element)) (fp))(window_); }
|
||||
UISetDPI :: inline proc "c" (dpiScale_ : i32){ addr := 0x1000 + 38 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( i32)) (fp))(dpiScale_); }
|
||||
DirectoryEnumerateChildren :: inline proc "c" (path_ : string, buffer_ : ^^DirectoryChild) -> int { addr := 0x1000 + 39 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^^DirectoryChild) -> int ) (fp))(raw_data(path_), len(path_), buffer_); }
|
||||
DirectoryEnumerateChildrenFromHandle :: inline proc "c" (directory_ : Handle, buffer_ : ^DirectoryChild, bufferCount_ : int ) -> int { addr := 0x1000 + 40 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, ^DirectoryChild, int ) -> int ) (fp))(directory_, buffer_, bufferCount_); }
|
||||
DirectoryMonitorCreate :: inline proc "c" (path_ : string, flags_ : u64 , callback_ : DirectoryMonitorCallbackFunction, _context_ : Generic) -> ^DirectoryMonitor{ addr := 0x1000 + 41 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, u64 , DirectoryMonitorCallbackFunction, Generic) -> ^DirectoryMonitor) (fp))(raw_data(path_), len(path_), flags_, callback_, _context_); }
|
||||
DirectoryMonitorCreateFromHandle :: inline proc "c" (directory_ : Handle, flags_ : u64 , callback_ : DirectoryMonitorCallbackFunction, _context_ : Generic) -> ^DirectoryMonitor{ addr := 0x1000 + 42 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, u64 , DirectoryMonitorCallbackFunction, Generic) -> ^DirectoryMonitor) (fp))(directory_, flags_, callback_, _context_); }
|
||||
DirectoryMonitorDestroy :: inline proc "c" (monitor_ : ^DirectoryMonitor){ addr := 0x1000 + 43 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^DirectoryMonitor)) (fp))(monitor_); }
|
||||
FileReadAll :: inline proc "c" (filePath_ : string, fileSize_ : ^int ) -> rawptr{ addr := 0x1000 + 44 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^int ) -> rawptr) (fp))(raw_data(filePath_), len(filePath_), fileSize_); }
|
||||
FileReadSync :: inline proc "c" (file_ : Handle, offset_ : FileOffset, size_ : int , buffer_ : rawptr) -> int { addr := 0x1000 + 45 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, FileOffset, int , rawptr) -> int ) (fp))(file_, offset_, size_, buffer_); }
|
||||
FileResize :: inline proc "c" (file_ : Handle, newSize_ : FileOffset) -> Error{ addr := 0x1000 + 46 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, FileOffset) -> Error) (fp))(file_, newSize_); }
|
||||
FileWriteAll :: inline proc "c" (filePath_ : string, data_ : rawptr, fileSize_ : int ) -> Error{ addr := 0x1000 + 47 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, rawptr, int ) -> Error) (fp))(raw_data(filePath_), len(filePath_), data_, fileSize_); }
|
||||
FileWriteAllGather :: inline proc "c" (filePath_ : string, data_ : ^rawptr, fileSize_ : ^int , gatherCount_ : int ) -> Error{ addr := 0x1000 + 48 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^rawptr, ^int , int ) -> Error) (fp))(raw_data(filePath_), len(filePath_), data_, fileSize_, gatherCount_); }
|
||||
FileWriteComplete :: inline proc "c" (file_ : Handle){ addr := 0x1000 + 49 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle)) (fp))(file_); }
|
||||
FileWriteSync :: inline proc "c" (file_ : Handle, offset_ : FileOffset, size_ : int , buffer_ : rawptr) -> int { addr := 0x1000 + 50 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, FileOffset, int , rawptr) -> int ) (fp))(file_, offset_, size_, buffer_); }
|
||||
NodeDelete :: inline proc "c" (node_ : Handle) -> Error{ addr := 0x1000 + 51 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> Error) (fp))(node_); }
|
||||
NodeDeleteByPath :: inline proc "c" (filePath_ : string) -> Error{ addr := 0x1000 + 52 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int) -> Error) (fp))(raw_data(filePath_), len(filePath_)); }
|
||||
NodeFindUniqueName :: inline proc "c" (buffer_ : ^i8 , originalBytes_ : int , bufferBytes_ : int ) -> int { addr := 0x1000 + 53 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int , int ) -> int ) (fp))(buffer_, originalBytes_, bufferBytes_); }
|
||||
NodeMove :: inline proc "c" (node_ : Handle, newDirectory_ : Handle, newName_ : string) -> Error{ addr := 0x1000 + 54 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Handle, ^u8, int) -> Error) (fp))(node_, newDirectory_, raw_data(newName_), len(newName_)); }
|
||||
NodeOpen :: inline proc "c" (path_ : string, flags_ : u64 , information_ : ^NodeInformation) -> Error{ addr := 0x1000 + 55 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, u64 , ^NodeInformation) -> Error) (fp))(raw_data(path_), len(path_), flags_, information_); }
|
||||
NodeOpenRelative :: inline proc "c" (directory_ : Handle, path_ : string, flags_ : u64 , information_ : ^NodeInformation) -> Error{ addr := 0x1000 + 56 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, ^u8, int, u64 , ^NodeInformation) -> Error) (fp))(directory_, raw_data(path_), len(path_), flags_, information_); }
|
||||
NodeRefreshInformation :: inline proc "c" (information_ : ^NodeInformation){ addr := 0x1000 + 57 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^NodeInformation)) (fp))(information_); }
|
||||
ProcessCrash :: inline proc "c" (error_ : Error, message_ : string){ addr := 0x1000 + 58 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Error, ^u8, int)) (fp))(error_, raw_data(message_), len(message_)); }
|
||||
ProcessCreate :: inline proc "c" (executablePath_ : string, information_ : ^ProcessInformation, argument_ : Generic) -> Error{ addr := 0x1000 + 59 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^ProcessInformation, Generic) -> Error) (fp))(raw_data(executablePath_), len(executablePath_), information_, argument_); }
|
||||
ProcessCreate2 :: inline proc "c" (arguments_ : ^ProcessCreationArguments, information_ : ^ProcessInformation) -> Error{ addr := 0x1000 + 60 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^ProcessCreationArguments, ^ProcessInformation) -> Error) (fp))(arguments_, information_); }
|
||||
ProcessGetExitStatus :: inline proc "c" (process_ : Handle) -> i32{ addr := 0x1000 + 61 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> i32) (fp))(process_); }
|
||||
ProcessGetID :: inline proc "c" (process_ : Handle) -> uint { addr := 0x1000 + 62 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> uint ) (fp))(process_); }
|
||||
ProcessGetState :: inline proc "c" (process_ : Handle, state_ : ^ProcessState){ addr := 0x1000 + 63 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, ^ProcessState)) (fp))(process_, state_); }
|
||||
ProcessOpen :: inline proc "c" (pid_ : u64 ) -> Handle{ addr := 0x1000 + 64 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( u64 ) -> Handle) (fp))(pid_); }
|
||||
ProcessPause :: inline proc "c" (process_ : Handle, resume_ : bool){ addr := 0x1000 + 65 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, bool)) (fp))(process_, resume_); }
|
||||
ProcessTerminate :: inline proc "c" (process_ : Handle, status_ : i32){ addr := 0x1000 + 66 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, i32)) (fp))(process_, status_); }
|
||||
ProcessTerminateCurrent :: inline proc "c" (){ addr := 0x1000 + 67 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
ThreadCreate :: inline proc "c" (entryFunction_ : ThreadEntryFunction, information_ : ^ThreadInformation, argument_ : Generic) -> Error{ addr := 0x1000 + 68 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ThreadEntryFunction, ^ThreadInformation, Generic) -> Error) (fp))(entryFunction_, information_, argument_); }
|
||||
ThreadGetID :: inline proc "c" (thread_ : Handle) -> uint { addr := 0x1000 + 69 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> uint ) (fp))(thread_); }
|
||||
ThreadLocalStorageSetAddress :: inline proc "c" (address_ : rawptr){ addr := 0x1000 + 70 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr)) (fp))(address_); }
|
||||
ThreadTerminate :: inline proc "c" (thread_ : Handle){ addr := 0x1000 + 71 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle)) (fp))(thread_); }
|
||||
ArenaAllocate :: inline proc "c" (arena_ : ^Arena, zero_ : bool) -> rawptr{ addr := 0x1000 + 72 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Arena, bool) -> rawptr) (fp))(arena_, zero_); }
|
||||
ArenaFree :: inline proc "c" (pointer_ : rawptr){ addr := 0x1000 + 73 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr)) (fp))(pointer_); }
|
||||
ArenaInitialise :: inline proc "c" (arena_ : ^Arena, slotsPerBlock_ : int , itemSize_ : int ){ addr := 0x1000 + 74 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Arena, int , int )) (fp))(arena_, slotsPerBlock_, itemSize_); }
|
||||
ConstantBufferCreate :: inline proc "c" (data_ : rawptr, dataBytes_ : int , targetProcess_ : Handle) -> Handle{ addr := 0x1000 + 75 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, int , Handle) -> Handle) (fp))(data_, dataBytes_, targetProcess_); }
|
||||
ConstantBufferRead :: inline proc "c" (constantBuffer_ : Handle, output_ : rawptr){ addr := 0x1000 + 76 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, rawptr)) (fp))(constantBuffer_, output_); }
|
||||
ConstantBufferShare :: inline proc "c" (constantBuffer_ : Handle, targetProcess_ : Handle) -> Handle{ addr := 0x1000 + 77 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Handle) -> Handle) (fp))(constantBuffer_, targetProcess_); }
|
||||
HeapAllocate :: inline proc "c" (size_ : int , zeroMemory_ : bool) -> rawptr{ addr := 0x1000 + 78 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , bool) -> rawptr) (fp))(size_, zeroMemory_); }
|
||||
HeapFree :: inline proc "c" (address_ : rawptr){ addr := 0x1000 + 79 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr)) (fp))(address_); }
|
||||
HeapReallocate :: inline proc "c" (oldAddress_ : rawptr, newAllocationSize_ : int , zeroNewSpace_ : bool) -> rawptr{ addr := 0x1000 + 80 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, int , bool) -> rawptr) (fp))(oldAddress_, newAllocationSize_, zeroNewSpace_); }
|
||||
HeapValidate :: inline proc "c" (){ addr := 0x1000 + 81 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
MemoryAllocate :: inline proc "c" (size_ : int ) -> rawptr{ addr := 0x1000 + 82 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int ) -> rawptr) (fp))(size_); }
|
||||
MemoryCompare :: inline proc "c" (a_ : rawptr, b_ : rawptr, bytes_ : int ) -> i32{ addr := 0x1000 + 83 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, rawptr, int ) -> i32) (fp))(a_, b_, bytes_); }
|
||||
MemoryCopy :: inline proc "c" (destination_ : rawptr, source_ : rawptr, bytes_ : int ){ addr := 0x1000 + 84 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, rawptr, int )) (fp))(destination_, source_, bytes_); }
|
||||
MemoryCopyReverse :: inline proc "c" (_destination_ : rawptr, _source_ : rawptr, bytes_ : int ){ addr := 0x1000 + 85 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, rawptr, int )) (fp))(_destination_, _source_, bytes_); }
|
||||
MemoryFill :: inline proc "c" (from_ : rawptr, to_ : rawptr, byte_ : u8 ){ addr := 0x1000 + 86 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, rawptr, u8 )) (fp))(from_, to_, byte_); }
|
||||
MemoryFree :: inline proc "c" (address_ : rawptr) -> Error{ addr := 0x1000 + 87 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr) -> Error) (fp))(address_); }
|
||||
MemoryMove :: inline proc "c" (_start_ : rawptr, _end_ : rawptr, amount_ : int , zeroEmptySpace_ : bool){ addr := 0x1000 + 88 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, rawptr, int , bool)) (fp))(_start_, _end_, amount_, zeroEmptySpace_); }
|
||||
MemoryOpen :: inline proc "c" (size_ : int , name_ : string, flags_ : u32 ) -> Handle{ addr := 0x1000 + 89 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , ^u8, int, u32 ) -> Handle) (fp))(size_, raw_data(name_), len(name_), flags_); }
|
||||
MemoryShare :: inline proc "c" (sharedMemoryRegion_ : Handle, targetProcess_ : Handle, readOnly_ : bool) -> Handle{ addr := 0x1000 + 90 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Handle, bool) -> Handle) (fp))(sharedMemoryRegion_, targetProcess_, readOnly_); }
|
||||
MemorySumBytes :: inline proc "c" (data_ : ^u8 , bytes_ : int ) -> u8 { addr := 0x1000 + 91 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^u8 , int ) -> u8 ) (fp))(data_, bytes_); }
|
||||
MemoryZero :: inline proc "c" (destination_ : rawptr, bytes_ : int ){ addr := 0x1000 + 92 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, int )) (fp))(destination_, bytes_); }
|
||||
ObjectMap :: inline proc "c" (object_ : Handle, offset_ : uint , size_ : int , flags_ : u32 ) -> rawptr{ addr := 0x1000 + 93 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, uint , int , u32 ) -> rawptr) (fp))(object_, offset_, size_, flags_); }
|
||||
Abort :: inline proc "c" (){ addr := 0x1000 + 94 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
Assert :: inline proc "c" (expression_ : bool, failureMessage_ : cstring ){ addr := 0x1000 + 95 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( bool, cstring )) (fp))(expression_, failureMessage_); }
|
||||
CalculateFromUserExpression :: inline proc "c" (cExpression_ : cstring ) -> CalculationValue{ addr := 0x1000 + 96 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( cstring ) -> CalculationValue) (fp))(cExpression_); }
|
||||
DoubleParse :: inline proc "c" (string_ : string, endptr_ : ^^i8 ) -> f64 { addr := 0x1000 + 97 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^^i8 ) -> f64 ) (fp))(raw_data(string_), len(string_), endptr_); }
|
||||
ExtractArguments :: inline proc "c" (string_ : ^i8 , bytes_ : int , delimiterByte_ : u8 , replacementDelimiter_ : u8 , argvAllocated_ : int , argv_ : ^^i8 , argc_ : ^int ) -> bool{ addr := 0x1000 + 98 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int , u8 , u8 , int , ^^i8 , ^int ) -> bool) (fp))(string_, bytes_, delimiterByte_, replacementDelimiter_, argvAllocated_, argv_, argc_); }
|
||||
GetRandomU8 :: inline proc "c" () -> u8 { addr := 0x1000 + 99 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> u8 ) (fp))(); }
|
||||
GetRandomU64 :: inline proc "c" () -> u64 { addr := 0x1000 + 100 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> u64 ) (fp))(); }
|
||||
IntegerParse :: inline proc "c" (text_ : string) -> i64 { addr := 0x1000 + 101 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int) -> i64 ) (fp))(raw_data(text_), len(text_)); }
|
||||
Print :: inline proc "c" (format_ : cstring , _varargs_ : ..any){ addr := 0x1000 + 102 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( cstring , ..any)) (fp))(format_, _varargs_); }
|
||||
PrintDirect :: inline proc "c" (string_ : string){ addr := 0x1000 + 103 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" (^u8, int)) (fp))(raw_data(string_), len(string_)); }
|
||||
PrintHelloWorld :: inline proc "c" (){ addr := 0x1000 + 104 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
ProcessorReadTimeStamp :: inline proc "c" () -> u64 { addr := 0x1000 + 105 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> u64 ) (fp))(); }
|
||||
RandomAddEntropy :: inline proc "c" (x_ : u64 ){ addr := 0x1000 + 106 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( u64 )) (fp))(x_); }
|
||||
RandomSeed :: inline proc "c" (x_ : u64 ){ addr := 0x1000 + 107 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( u64 )) (fp))(x_); }
|
||||
RectangleClip :: inline proc "c" (parent_ : Rectangle, rectangle_ : Rectangle, output_ : ^Rectangle) -> bool{ addr := 0x1000 + 108 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Rectangle, Rectangle, ^Rectangle) -> bool) (fp))(parent_, rectangle_, output_); }
|
||||
Sort :: inline proc "c" (_base_ : rawptr, nmemb_ : int , size_ : int , compar_ : ComparisonCallbackFunction, argument_ : Generic){ addr := 0x1000 + 109 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, int , int , ComparisonCallbackFunction, Generic)) (fp))(_base_, nmemb_, size_, compar_, argument_); }
|
||||
SortWithSwapCallback :: inline proc "c" (_base_ : rawptr, nmemb_ : int , size_ : int , compar_ : ComparisonCallbackFunction, argument_ : Generic, swap_ : SwapCallbackFunction){ addr := 0x1000 + 110 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, int , int , ComparisonCallbackFunction, Generic, SwapCallbackFunction)) (fp))(_base_, nmemb_, size_, compar_, argument_, swap_); }
|
||||
StringLoadRaw :: inline proc "c" (cRule_ : cstring , formatValues_ : ^FormatValue, formatValueCount_ : int ) -> FormatValue{ addr := 0x1000 + 111 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( cstring , ^FormatValue, int ) -> FormatValue) (fp))(cRule_, formatValues_, formatValueCount_); }
|
||||
StringZeroTerminate :: inline proc "c" (string_ : string) -> ^i8 { addr := 0x1000 + 112 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int) -> ^i8 ) (fp))(raw_data(string_), len(string_)); }
|
||||
ColorBlend :: inline proc "c" (under_ : u32 , over_ : u32 , fullAlpha_ : bool) -> u32 { addr := 0x1000 + 113 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( u32 , u32 , bool) -> u32 ) (fp))(under_, over_, fullAlpha_); }
|
||||
ColorConvertToRGB :: inline proc "c" (h_ : f32 , s_ : f32 , v_ : f32 ) -> u32 { addr := 0x1000 + 114 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 , f32 , f32 ) -> u32 ) (fp))(h_, s_, v_); }
|
||||
ColorConvertToHSV :: inline proc "c" (color_ : u32 , h_ : ^f32 , s_ : ^f32 , v_ : ^f32 ) -> bool{ addr := 0x1000 + 115 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( u32 , ^f32 , ^f32 , ^f32 ) -> bool) (fp))(color_, h_, s_, v_); }
|
||||
ColorParse :: inline proc "c" (string_ : ^i8 , bytes_ : int ) -> u32 { addr := 0x1000 + 116 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int ) -> u32 ) (fp))(string_, bytes_); }
|
||||
DrawStandardIcon :: inline proc "c" (painter_ : ^Painter, id_ : u32 , size_ : i32, region_ : Rectangle, color_ : u32 ) -> bool{ addr := 0x1000 + 117 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Painter, u32 , i32, Rectangle, u32 ) -> bool) (fp))(painter_, id_, size_, region_, color_); }
|
||||
DrawStyledBox :: inline proc "c" (painter_ : ^Painter, box_ : StyledBox){ addr := 0x1000 + 118 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Painter, StyledBox)) (fp))(painter_, box_); }
|
||||
DrawSurface :: inline proc "c" (destination_ : Handle, source_ : Handle, destinationRegion_ : Rectangle, sourceRegion_ : Rectangle, borderRegion_ : Rectangle, mode_ : DrawMode, alpha_ : u16 ) -> Error{ addr := 0x1000 + 119 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Handle, Rectangle, Rectangle, Rectangle, DrawMode, u16 ) -> Error) (fp))(destination_, source_, destinationRegion_, sourceRegion_, borderRegion_, mode_, alpha_); }
|
||||
DrawSurface2 :: inline proc "c" (painter_ : ^Painter, source_ : Handle, destinationRegion_ : Rectangle, sourceRegion_ : Rectangle, alpha_ : u16 ){ addr := 0x1000 + 120 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Painter, Handle, Rectangle, Rectangle, u16 )) (fp))(painter_, source_, destinationRegion_, sourceRegion_, alpha_); }
|
||||
DrawSurfaceClipped :: inline proc "c" (destination_ : Handle, source_ : Handle, destinationRegion_ : Rectangle, sourceRegion_ : Rectangle, borderRegion_ : Rectangle, mode_ : DrawMode, alpha_ : u16 , clipRegion_ : Rectangle) -> Error{ addr := 0x1000 + 121 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Handle, Rectangle, Rectangle, Rectangle, DrawMode, u16 , Rectangle) -> Error) (fp))(destination_, source_, destinationRegion_, sourceRegion_, borderRegion_, mode_, alpha_, clipRegion_); }
|
||||
DrawText :: inline proc "c" (painter_ : ^Painter, plan_ : ^TextPlan, bounds_ : Rectangle, clip_ : ^Rectangle, selectionProperties_ : ^TextSelection){ addr := 0x1000 + 122 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Painter, ^TextPlan, Rectangle, ^Rectangle, ^TextSelection)) (fp))(painter_, plan_, bounds_, clip_, selectionProperties_); }
|
||||
FontGetName :: inline proc "c" (family_ : u16 , buffer_ : ^i8 , bufferBytes_ : int ) -> int { addr := 0x1000 + 123 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( u16 , ^i8 , int ) -> int ) (fp))(family_, buffer_, bufferBytes_); }
|
||||
PainterBoundsClient :: inline proc "c" (painter_ : ^Painter) -> Rectangle{ addr := 0x1000 + 124 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Painter) -> Rectangle) (fp))(painter_); }
|
||||
PainterBoundsInset :: inline proc "c" (painter_ : ^Painter) -> Rectangle{ addr := 0x1000 + 125 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Painter) -> Rectangle) (fp))(painter_); }
|
||||
RedrawAll :: inline proc "c" (){ addr := 0x1000 + 126 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
SurfaceCreate :: inline proc "c" (width_ : int , height_ : int , flags_ : u32 ) -> Handle{ addr := 0x1000 + 127 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , int , u32 ) -> Handle) (fp))(width_, height_, flags_); }
|
||||
SurfaceGetLinearBuffer :: inline proc "c" (surface_ : Handle, linearBuffer_ : ^LinearBuffer){ addr := 0x1000 + 128 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, ^LinearBuffer)) (fp))(surface_, linearBuffer_); }
|
||||
SurfaceReset :: inline proc "c" (surface_ : Handle){ addr := 0x1000 + 129 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle)) (fp))(surface_); }
|
||||
AudioStreamClose :: inline proc "c" (stream_ : ^AudioStream){ addr := 0x1000 + 130 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^AudioStream)) (fp))(stream_); }
|
||||
AudioStreamOpen :: inline proc "c" (device_ : AudioDeviceID, bufferLengthUs_ : int ) -> ^AudioStream{ addr := 0x1000 + 131 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( AudioDeviceID, int ) -> ^AudioStream) (fp))(device_, bufferLengthUs_); }
|
||||
AudioStreamNotify :: inline proc "c" (stream_ : ^AudioStream){ addr := 0x1000 + 132 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^AudioStream)) (fp))(stream_); }
|
||||
AudioStreamSend :: inline proc "c" (destination_ : ^AudioStream, source_ : ^AudioStream, time_ : ^f64 ) -> Error{ addr := 0x1000 + 133 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^AudioStream, ^AudioStream, ^f64 ) -> Error) (fp))(destination_, source_, time_); }
|
||||
EventCreate :: inline proc "c" (autoReset_ : bool) -> Handle{ addr := 0x1000 + 134 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( bool) -> Handle) (fp))(autoReset_); }
|
||||
EventForward :: inline proc "c" (event_ : Handle, eventSink_ : Handle, data_ : Generic){ addr := 0x1000 + 135 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, Handle, Generic)) (fp))(event_, eventSink_, data_); }
|
||||
EventPoll :: inline proc "c" (event_ : Handle) -> Error{ addr := 0x1000 + 136 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> Error) (fp))(event_); }
|
||||
EventReset :: inline proc "c" (event_ : Handle){ addr := 0x1000 + 137 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle)) (fp))(event_); }
|
||||
EventSet :: inline proc "c" (event_ : Handle){ addr := 0x1000 + 138 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle)) (fp))(event_); }
|
||||
EventSinkCreate :: inline proc "c" (ignoreDuplicates_ : bool) -> Handle{ addr := 0x1000 + 139 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( bool) -> Handle) (fp))(ignoreDuplicates_); }
|
||||
EventSinkPop :: inline proc "c" (eventSink_ : Handle, data_ : ^Generic) -> Error{ addr := 0x1000 + 140 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, ^Generic) -> Error) (fp))(eventSink_, data_); }
|
||||
EventSinkPush :: inline proc "c" (eventSink_ : Handle, data_ : Generic) -> Error{ addr := 0x1000 + 141 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Generic) -> Error) (fp))(eventSink_, data_); }
|
||||
MutexAcquire :: inline proc "c" (mutex_ : ^Mutex){ addr := 0x1000 + 142 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Mutex)) (fp))(mutex_); }
|
||||
MutexDestroy :: inline proc "c" (mutex_ : ^Mutex){ addr := 0x1000 + 143 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Mutex)) (fp))(mutex_); }
|
||||
MutexRelease :: inline proc "c" (mutex_ : ^Mutex){ addr := 0x1000 + 144 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Mutex)) (fp))(mutex_); }
|
||||
PerformanceTimerPush :: inline proc "c" (){ addr := 0x1000 + 145 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
PerformanceTimerPop :: inline proc "c" () -> f64 { addr := 0x1000 + 146 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> f64 ) (fp))(); }
|
||||
SchedulerYield :: inline proc "c" (){ addr := 0x1000 + 147 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
Sleep :: inline proc "c" (milliseconds_ : u64 ){ addr := 0x1000 + 148 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( u64 )) (fp))(milliseconds_); }
|
||||
SpinlockAcquire :: inline proc "c" (spinlock_ : ^Spinlock){ addr := 0x1000 + 149 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Spinlock)) (fp))(spinlock_); }
|
||||
SpinlockRelease :: inline proc "c" (spinlock_ : ^Spinlock){ addr := 0x1000 + 150 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Spinlock)) (fp))(spinlock_); }
|
||||
TimerCreate :: inline proc "c" () -> Handle{ addr := 0x1000 + 151 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> Handle) (fp))(); }
|
||||
TimerSet :: inline proc "c" (handle_ : Handle, afterMs_ : u64 , callback_ : TimerCallbackFunction, argument_ : Generic){ addr := 0x1000 + 152 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, u64 , TimerCallbackFunction, Generic)) (fp))(handle_, afterMs_, callback_, argument_); }
|
||||
Wait :: inline proc "c" (objects_ : ^Handle, objectCount_ : int , timeoutMs_ : uint ) -> uint { addr := 0x1000 + 153 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Handle, int , uint ) -> uint ) (fp))(objects_, objectCount_, timeoutMs_); }
|
||||
CStringLength :: inline proc "c" (string_ : cstring ) -> int { addr := 0x1000 + 154 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( cstring ) -> int ) (fp))(string_); }
|
||||
StringAllocateAndFormat :: inline proc "c" (bytes_ : ^int , format_ : cstring , _varargs_ : ..any) -> ^i8 { addr := 0x1000 + 155 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^int , cstring , ..any) -> ^i8 ) (fp))(bytes_, format_, _varargs_); }
|
||||
StringCompare :: inline proc "c" (s1_ : string, s2_ : string) -> i32{ addr := 0x1000 + 157 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^u8, int) -> i32) (fp))(raw_data(s1_), len(s1_), raw_data(s2_), len(s2_)); }
|
||||
StringCompareRaw :: inline proc "c" (s1_ : string, s2_ : string) -> i32{ addr := 0x1000 + 158 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^u8, int) -> i32) (fp))(raw_data(s1_), len(s1_), raw_data(s2_), len(s2_)); }
|
||||
StringFormat :: inline proc "c" (buffer_ : ^i8 , bufferLength_ : int , format_ : cstring , _varargs_ : ..any) -> int { addr := 0x1000 + 159 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int , cstring , ..any) -> int ) (fp))(buffer_, bufferLength_, format_, _varargs_); }
|
||||
StringFormatTemporary :: inline proc "c" (format_ : cstring , _varargs_ : ..any) -> ^i8 { addr := 0x1000 + 160 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( cstring , ..any) -> ^i8 ) (fp))(format_, _varargs_); }
|
||||
StringFormatAppend :: inline proc "c" (buffer_ : ^i8 , bufferLength_ : int , bufferPosition_ : ^int , format_ : cstring , _varargs_ : ..any){ addr := 0x1000 + 162 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^i8 , int , ^int , cstring , ..any)) (fp))(buffer_, bufferLength_, bufferPosition_, format_, _varargs_); }
|
||||
StringLength :: inline proc "c" (string_ : ^i8 , end_ : u8 ) -> int { addr := 0x1000 + 164 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , u8 ) -> int ) (fp))(string_, end_); }
|
||||
StringLoad :: inline proc "c" (cRule_ : cstring , formatValues_ : ^FormatValue, formatValueCount_ : int , bytes_ : ^int ) -> ^i8 { addr := 0x1000 + 165 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( cstring , ^FormatValue, int , ^int ) -> ^i8 ) (fp))(cRule_, formatValues_, formatValueCount_, bytes_); }
|
||||
StringStartsWith :: inline proc "c" (string_ : string, prefix_ : string, caseInsensitive_ : bool) -> bool{ addr := 0x1000 + 166 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^u8, int, bool) -> bool) (fp))(raw_data(string_), len(string_), raw_data(prefix_), len(prefix_), caseInsensitive_); }
|
||||
CRTabs :: inline proc "c" (n_ : i32) -> i32{ addr := 0x1000 + 167 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(n_); }
|
||||
CRTacosf :: inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 168 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTasinf :: inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 169 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTassert :: inline proc "c" (test_ : bool){ addr := 0x1000 + 170 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( bool)) (fp))(test_); }
|
||||
CRTatan2f :: inline proc "c" (y_ : f32 , x_ : f32 ) -> f32 { addr := 0x1000 + 171 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 , f32 ) -> f32 ) (fp))(y_, x_); }
|
||||
CRTatanf :: inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 172 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTatoi :: inline proc "c" (string_ : ^i8 ) -> i32{ addr := 0x1000 + 173 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 ) -> i32) (fp))(string_); }
|
||||
CRTcalloc :: inline proc "c" (num_ : int , size_ : int ) -> rawptr{ addr := 0x1000 + 174 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , int ) -> rawptr) (fp))(num_, size_); }
|
||||
CRTceil :: inline proc "c" (x_ : f64 ) -> f64 { addr := 0x1000 + 175 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f64 ) -> f64 ) (fp))(x_); }
|
||||
CRTceilf :: inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 176 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTcosf :: inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 177 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTfabs :: inline proc "c" (x_ : f64 ) -> f64 { addr := 0x1000 + 178 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f64 ) -> f64 ) (fp))(x_); }
|
||||
CRTfabsl :: inline proc "c" (x_ : [16]u8 ) -> [16]u8 { addr := 0x1000 + 179 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( [16]u8 ) -> [16]u8 ) (fp))(x_); }
|
||||
CRTfloor :: inline proc "c" (x_ : f64 ) -> f64 { addr := 0x1000 + 180 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f64 ) -> f64 ) (fp))(x_); }
|
||||
CRTfloorf :: inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 181 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTfmodf :: inline proc "c" (x_ : f32 , y_ : f32 ) -> f32 { addr := 0x1000 + 182 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 , f32 ) -> f32 ) (fp))(x_, y_); }
|
||||
CRTfree :: inline proc "c" (ptr_ : rawptr){ addr := 0x1000 + 183 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr)) (fp))(ptr_); }
|
||||
CRTgetenv :: inline proc "c" (name_ : ^i8 ) -> ^i8 { addr := 0x1000 + 184 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 ) -> ^i8 ) (fp))(name_); }
|
||||
CRTisalpha :: inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 185 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
CRTisdigit :: inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 186 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
CRTisspace :: inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 187 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
CRTisupper :: inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 188 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
CRTisxdigit :: inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 189 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
CRTmalloc :: inline proc "c" (size_ : int ) -> rawptr{ addr := 0x1000 + 190 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int ) -> rawptr) (fp))(size_); }
|
||||
CRTmemchr :: inline proc "c" (_s_ : rawptr, _c_ : i32, n_ : int ) -> rawptr{ addr := 0x1000 + 191 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, i32, int ) -> rawptr) (fp))(_s_, _c_, n_); }
|
||||
CRTmemcmp :: inline proc "c" (s1_ : rawptr, s2_ : rawptr, n_ : int ) -> i32{ addr := 0x1000 + 192 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, rawptr, int ) -> i32) (fp))(s1_, s2_, n_); }
|
||||
CRTmemcpy :: inline proc "c" (dest_ : rawptr, src_ : rawptr, n_ : int ) -> rawptr{ addr := 0x1000 + 193 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, rawptr, int ) -> rawptr) (fp))(dest_, src_, n_); }
|
||||
CRTmemmove :: inline proc "c" (dest_ : rawptr, src_ : rawptr, n_ : int ) -> rawptr{ addr := 0x1000 + 194 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, rawptr, int ) -> rawptr) (fp))(dest_, src_, n_); }
|
||||
CRTmemset :: inline proc "c" (s_ : rawptr, c_ : i32, n_ : int ) -> rawptr{ addr := 0x1000 + 195 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, i32, int ) -> rawptr) (fp))(s_, c_, n_); }
|
||||
CRTqsort :: inline proc "c" (_base_ : rawptr, nmemb_ : int , size_ : int , compar_ : CRTComparisonCallback){ addr := 0x1000 + 196 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, int , int , CRTComparisonCallback)) (fp))(_base_, nmemb_, size_, compar_); }
|
||||
CRTrealloc :: inline proc "c" (ptr_ : rawptr, size_ : int ) -> rawptr{ addr := 0x1000 + 197 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, int ) -> rawptr) (fp))(ptr_, size_); }
|
||||
CRTsinf :: inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 198 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTsnprintf :: inline proc "c" (buffer_ : ^i8 , bufferSize_ : int , format_ : ^i8 , _varargs_ : ..any) -> i32{ addr := 0x1000 + 199 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int , ^i8 , ..any) -> i32) (fp))(buffer_, bufferSize_, format_, _varargs_); }
|
||||
CRTsprintf :: inline proc "c" (buffer_ : ^i8 , format_ : ^i8 , _varargs_ : ..any) -> i32{ addr := 0x1000 + 200 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 , ..any) -> i32) (fp))(buffer_, format_, _varargs_); }
|
||||
CRTsqrt :: inline proc "c" (x_ : f64 ) -> f64 { addr := 0x1000 + 201 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f64 ) -> f64 ) (fp))(x_); }
|
||||
CRTsqrtf :: inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 202 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTsqrtl :: inline proc "c" (x_ : [16]u8 ) -> [16]u8 { addr := 0x1000 + 203 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( [16]u8 ) -> [16]u8 ) (fp))(x_); }
|
||||
CRTstrcat :: inline proc "c" (dest_ : ^i8 , src_ : ^i8 ) -> ^i8 { addr := 0x1000 + 204 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 ) -> ^i8 ) (fp))(dest_, src_); }
|
||||
CRTstrchr :: inline proc "c" (s_ : ^i8 , c_ : i32) -> ^i8 { addr := 0x1000 + 205 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , i32) -> ^i8 ) (fp))(s_, c_); }
|
||||
CRTstrcmp :: inline proc "c" (s1_ : ^i8 , s2_ : ^i8 ) -> i32{ addr := 0x1000 + 206 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 ) -> i32) (fp))(s1_, s2_); }
|
||||
CRTstrcpy :: inline proc "c" (dest_ : ^i8 , src_ : ^i8 ) -> ^i8 { addr := 0x1000 + 207 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 ) -> ^i8 ) (fp))(dest_, src_); }
|
||||
CRTstrerror :: inline proc "c" (errnum_ : i32) -> ^i8 { addr := 0x1000 + 208 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> ^i8 ) (fp))(errnum_); }
|
||||
CRTstrlen :: inline proc "c" (s_ : ^i8 ) -> int { addr := 0x1000 + 209 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 ) -> int ) (fp))(s_); }
|
||||
CRTstrncmp :: inline proc "c" (s1_ : ^i8 , s2_ : ^i8 , n_ : int ) -> i32{ addr := 0x1000 + 210 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 , int ) -> i32) (fp))(s1_, s2_, n_); }
|
||||
CRTstrncpy :: inline proc "c" (dest_ : ^i8 , src_ : ^i8 , n_ : int ) -> ^i8 { addr := 0x1000 + 211 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 , int ) -> ^i8 ) (fp))(dest_, src_, n_); }
|
||||
CRTstrnlen :: inline proc "c" (s_ : ^i8 , maxlen_ : int ) -> int { addr := 0x1000 + 212 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int ) -> int ) (fp))(s_, maxlen_); }
|
||||
CRTstrstr :: inline proc "c" (haystack_ : ^i8 , needle_ : ^i8 ) -> ^i8 { addr := 0x1000 + 213 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 ) -> ^i8 ) (fp))(haystack_, needle_); }
|
||||
CRTstrtol :: inline proc "c" (nptr_ : ^i8 , endptr_ : ^^i8 , base_ : i32) -> i64 { addr := 0x1000 + 214 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^^i8 , i32) -> i64 ) (fp))(nptr_, endptr_, base_); }
|
||||
CRTstrtoul :: inline proc "c" (nptr_ : ^i8 , endptr_ : ^^i8 , base_ : i32) -> u64 { addr := 0x1000 + 215 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^^i8 , i32) -> u64 ) (fp))(nptr_, endptr_, base_); }
|
||||
CRTtolower :: inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 216 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
NewPanel :: inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^Panel{ addr := 0x1000 + 218 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^Panel) (fp))(parent_, flags_, properties_); }
|
||||
NewSplitter :: inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^Splitter{ addr := 0x1000 + 219 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^Splitter) (fp))(parent_, flags_, properties_); }
|
||||
NewButton :: inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties, label_ : string) -> ^Button{ addr := 0x1000 + 220 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties, ^u8, int) -> ^Button) (fp))(parent_, flags_, properties_, raw_data(label_), len(label_)); }
|
||||
NewChoice :: inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^Choice{ addr := 0x1000 + 221 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^Choice) (fp))(parent_, flags_, properties_); }
|
||||
NewColorWell :: inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties, colorRGB_ : u32 ) -> ^ColorWell{ addr := 0x1000 + 222 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties, u32 ) -> ^ColorWell) (fp))(parent_, flags_, properties_, colorRGB_); }
|
||||
NewTextDisplay :: inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties, label_ : string) -> ^TextDisplay{ addr := 0x1000 + 223 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties, ^u8, int) -> ^TextDisplay) (fp))(parent_, flags_, properties_, raw_data(label_), len(label_)); }
|
||||
NewIconDisplay :: inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties, iconID_ : u32 ) -> ^IconDisplay{ addr := 0x1000 + 224 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties, u32 ) -> ^IconDisplay) (fp))(parent_, flags_, properties_, iconID_); }
|
||||
NewImageDisplay :: inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^ImageDisplay{ addr := 0x1000 + 225 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^ImageDisplay) (fp))(parent_, flags_, properties_); }
|
||||
NewListView :: inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties, cItemStyle_ : cstring , cHeaderItemStyle_ : cstring , cFooterItemStyle_ : cstring ) -> ^ListView{ addr := 0x1000 + 226 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties, cstring , cstring , cstring ) -> ^ListView) (fp))(parent_, flags_, properties_, cItemStyle_, cHeaderItemStyle_, cFooterItemStyle_); }
|
||||
NewTextbox :: inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^Textbox{ addr := 0x1000 + 227 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^Textbox) (fp))(parent_, flags_, properties_); }
|
||||
NewCustomElement :: inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^Element{ addr := 0x1000 + 228 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^Element) (fp))(parent_, flags_, properties_); }
|
||||
NewWindow :: inline proc "c" (instance_ : ^INSTANCE_TYPE, style_ : WindowStyle) -> ^Window{ addr := 0x1000 + 229 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^INSTANCE_TYPE, WindowStyle) -> ^Window) (fp))(instance_, style_); }
|
||||
NewMenu :: inline proc "c" (source_ : ^Element, flags_ : u64 , userCallback_ : MenuCallbackFunction, _context_ : Generic, fixedWidth_ : i32, fixedHeight_ : i32) -> ^Menu{ addr := 0x1000 + 230 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , MenuCallbackFunction, Generic, i32, i32) -> ^Menu) (fp))(source_, flags_, userCallback_, _context_, fixedWidth_, fixedHeight_); }
|
||||
NewMenuItem :: inline proc "c" (parent_ : ^Element, flags_ : u64 , label_ : string, callback_ : MenuCallbackFunction, _context_ : Generic){ addr := 0x1000 + 231 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, u64 , ^u8, int, MenuCallbackFunction, Generic)) (fp))(parent_, flags_, raw_data(label_), len(label_), callback_, _context_); }
|
||||
NewMenuCommand :: inline proc "c" (parent_ : ^Element, flags_ : u64 , label_ : string, command_ : ^Command){ addr := 0x1000 + 232 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, u64 , ^u8, int, ^Command)) (fp))(parent_, flags_, raw_data(label_), len(label_), command_); }
|
||||
NewMenuColumn :: inline proc "c" (parent_ : ^Element, flags_ : u64 ) -> ^Element{ addr := 0x1000 + 233 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 ) -> ^Element) (fp))(parent_, flags_); }
|
||||
NewMenuSeparator :: inline proc "c" (parent_ : ^Element){ addr := 0x1000 + 234 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element)) (fp))(parent_); }
|
||||
NewSpacer :: inline proc "c" (parent_ : ^Element, flags_ : u64 ) -> ^Element{ addr := 0x1000 + 235 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 ) -> ^Element) (fp))(parent_, flags_); }
|
||||
NewElementGroup :: inline proc "c" (instance_ : ^INSTANCE_TYPE) -> ^ElementGroup{ addr := 0x1000 + 236 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^INSTANCE_TYPE) -> ^ElementGroup) (fp))(instance_); }
|
||||
NewTextPlan :: inline proc "c" (properties_ : ^TextDisplayProperties, bounds_ : Rectangle, string_ : ^i8 , textRuns_ : ^TextRun, textRunCount_ : int , singleUse_ : bool) -> ^TextPlan{ addr := 0x1000 + 237 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^TextDisplayProperties, Rectangle, ^i8 , ^TextRun, int , bool) -> ^TextPlan) (fp))(properties_, bounds_, string_, textRuns_, textRunCount_, singleUse_); }
|
||||
NewStore :: inline proc "c" (instance_ : ^INSTANCE_TYPE, pullCallback_ : StorePullCallbackFunction, pullCallbackContext_ : Generic) -> ^Store{ addr := 0x1000 + 238 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^INSTANCE_TYPE, StorePullCallbackFunction, Generic) -> ^Store) (fp))(instance_, pullCallback_, pullCallbackContext_); }
|
||||
ElementDraw :: inline proc "c" (element_ : ^Element, painter_ : ^Painter){ addr := 0x1000 + 239 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, ^Painter)) (fp))(element_, painter_); }
|
||||
ElementGetInstance :: inline proc "c" (element_ : ^Element) -> ^INSTANCE_TYPE{ addr := 0x1000 + 240 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> ^INSTANCE_TYPE) (fp))(element_); }
|
||||
ElementGetWindow :: inline proc "c" (element_ : ^Element) -> ^Window{ addr := 0x1000 + 241 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> ^Window) (fp))(element_); }
|
||||
ElementFocus :: inline proc "c" (element_ : ^Element, ensureVisible_ : bool){ addr := 0x1000 + 242 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, bool)) (fp))(element_, ensureVisible_); }
|
||||
ElementSetDisabled :: inline proc "c" (element_ : ^Element, disabled_ : bool){ addr := 0x1000 + 243 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, bool)) (fp))(element_, disabled_); }
|
||||
ElementSetHidden :: inline proc "c" (element_ : ^Element, hidden_ : bool){ addr := 0x1000 + 244 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, bool)) (fp))(element_, hidden_); }
|
||||
ElementSetCallback :: inline proc "c" (element_ : ^Element, callback_ : UICallbackFunction){ addr := 0x1000 + 245 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, UICallbackFunction)) (fp))(element_, callback_); }
|
||||
ElementGetSize :: inline proc "c" (element_ : ^Element, width_ : ^i32, height_ : ^i32){ addr := 0x1000 + 246 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, ^i32, ^i32)) (fp))(element_, width_, height_); }
|
||||
ElementRepaint :: inline proc "c" (element_ : ^Element, all_ : bool, region_ : Rectangle){ addr := 0x1000 + 247 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, bool, Rectangle)) (fp))(element_, all_, region_); }
|
||||
ElementSetData :: inline proc "c" (element_ : ^Element, data_ : Generic){ addr := 0x1000 + 248 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, Generic)) (fp))(element_, data_); }
|
||||
ElementGetData :: inline proc "c" (element_ : ^Element) -> Generic{ addr := 0x1000 + 249 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> Generic) (fp))(element_); }
|
||||
ElementSetCellRange :: inline proc "c" (element_ : ^Element, xFrom_ : i32, yFrom_ : i32, xTo_ : i32, yTo_ : i32){ addr := 0x1000 + 250 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, i32, i32, i32, i32)) (fp))(element_, xFrom_, yFrom_, xTo_, yTo_); }
|
||||
ElementAddGroup :: inline proc "c" (element_ : ^Element, group_ : ^ElementGroup){ addr := 0x1000 + 251 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, ^ElementGroup)) (fp))(element_, group_); }
|
||||
ElementGetInsets :: inline proc "c" (element_ : ^Element) -> Rectangle{ addr := 0x1000 + 252 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> Rectangle) (fp))(element_); }
|
||||
ElementGetInsetSize :: inline proc "c" (element_ : ^Element) -> Rectangle{ addr := 0x1000 + 253 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> Rectangle) (fp))(element_); }
|
||||
ElementGetPreferredSize :: inline proc "c" (element_ : ^Element) -> Rectangle{ addr := 0x1000 + 254 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> Rectangle) (fp))(element_); }
|
||||
ElementMove :: inline proc "c" (element_ : ^Element, x_ : i32, y_ : i32, width_ : i32, height_ : i32){ addr := 0x1000 + 255 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, i32, i32, i32, i32)) (fp))(element_, x_, y_, width_, height_); }
|
||||
ElementGetLayoutParent :: inline proc "c" (element_ : ^Element) -> ^Element{ addr := 0x1000 + 256 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> ^Element) (fp))(element_); }
|
||||
ElementDestroy :: inline proc "c" (element_ : ^Element){ addr := 0x1000 + 257 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element)) (fp))(element_); }
|
||||
ElementDestroyContents :: inline proc "c" (element_ : ^Element){ addr := 0x1000 + 258 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element)) (fp))(element_); }
|
||||
ElementStartAnimating :: inline proc "c" (element_ : ^Element) -> bool{ addr := 0x1000 + 259 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> bool) (fp))(element_); }
|
||||
ElementGroupSetCallback :: inline proc "c" (group_ : ^ElementGroup, callback_ : UICallbackFunction){ addr := 0x1000 + 260 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ElementGroup, UICallbackFunction)) (fp))(group_, callback_); }
|
||||
ElementGroupSetDisabled :: inline proc "c" (group_ : ^ElementGroup, disabled_ : bool){ addr := 0x1000 + 261 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ElementGroup, bool)) (fp))(group_, disabled_); }
|
||||
ElementGroupSetHidden :: inline proc "c" (group_ : ^ElementGroup, hidden_ : bool){ addr := 0x1000 + 262 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ElementGroup, bool)) (fp))(group_, hidden_); }
|
||||
ElementGroupRepaintAll :: inline proc "c" (group_ : ^ElementGroup){ addr := 0x1000 + 263 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ElementGroup)) (fp))(group_); }
|
||||
WindowGetBounds :: inline proc "c" (window_ : ^Window) -> Rectangle{ addr := 0x1000 + 264 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Window) -> Rectangle) (fp))(window_); }
|
||||
WindowGetToolbar :: inline proc "c" (window_ : ^Window) -> ^Element{ addr := 0x1000 + 265 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Window) -> ^Element) (fp))(window_); }
|
||||
WindowSetIcon :: inline proc "c" (window_ : ^Window, iconID_ : u32 ){ addr := 0x1000 + 266 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Window, u32 )) (fp))(window_, iconID_); }
|
||||
WindowSetTitle :: inline proc "c" (window_ : ^Window, title_ : string){ addr := 0x1000 + 267 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Window, ^u8, int)) (fp))(window_, raw_data(title_), len(title_)); }
|
||||
MenuGetSource :: inline proc "c" (menu_ : ^Menu) -> ^Element{ addr := 0x1000 + 268 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Menu) -> ^Element) (fp))(menu_); }
|
||||
ButtonSetIcon :: inline proc "c" (button_ : ^Button, iconID_ : u32 ){ addr := 0x1000 + 269 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Button, u32 )) (fp))(button_, iconID_); }
|
||||
ButtonSetCheck :: inline proc "c" (button_ : ^Button, checkState_ : CheckState, sendUpdatedMessage_ : bool){ addr := 0x1000 + 270 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Button, CheckState, bool)) (fp))(button_, checkState_, sendUpdatedMessage_); }
|
||||
ButtonGetCheck :: inline proc "c" (button_ : ^Button) -> CheckState{ addr := 0x1000 + 271 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Button) -> CheckState) (fp))(button_); }
|
||||
ButtonOnCommand :: inline proc "c" (button_ : ^Button, callback_ : CommandCallbackFunction, command_ : ^Command){ addr := 0x1000 + 272 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Button, CommandCallbackFunction, ^Command)) (fp))(button_, callback_, command_); }
|
||||
ButtonSetCheckBuddy :: inline proc "c" (button_ : ^Button, checkBuddy_ : ^Element){ addr := 0x1000 + 273 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Button, ^Element)) (fp))(button_, checkBuddy_); }
|
||||
ButtonGetCheckBuddy :: inline proc "c" (button_ : ^Button) -> ^Element{ addr := 0x1000 + 274 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Button) -> ^Element) (fp))(button_); }
|
||||
ButtonBindLabel :: inline proc "c" (button_ : ^Button, cRule_ : ^i8 ){ addr := 0x1000 + 275 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Button, ^i8 )) (fp))(button_, cRule_); }
|
||||
TextboxFind :: inline proc "c" (textbox_ : ^Textbox, string_ : string, line_ : ^i32 , byte_ : ^i32 , flags_ : u32 ) -> bool{ addr := 0x1000 + 276 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Textbox, ^u8, int, ^i32 , ^i32 , u32 ) -> bool) (fp))(textbox_, raw_data(string_), len(string_), line_, byte_, flags_); }
|
||||
TextboxInsert :: inline proc "c" (textbox_ : ^Textbox, string_ : string, sendUpdatedMessage_ : bool){ addr := 0x1000 + 277 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, ^u8, int, bool)) (fp))(textbox_, raw_data(string_), len(string_), sendUpdatedMessage_); }
|
||||
TextboxGetContents :: inline proc "c" (textbox_ : ^Textbox, bytes_ : ^int ) -> ^i8 { addr := 0x1000 + 278 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Textbox, ^int ) -> ^i8 ) (fp))(textbox_, bytes_); }
|
||||
TextboxGetLineLength :: inline proc "c" (textbox_ : ^Textbox, line_ : uint ) -> int { addr := 0x1000 + 279 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Textbox, uint ) -> int ) (fp))(textbox_, line_); }
|
||||
TextboxGetSelection :: inline proc "c" (textbox_ : ^Textbox, fromLine_ : ^i32 , fromByte_ : ^i32 , toLine_ : ^i32 , toByte_ : ^i32 ){ addr := 0x1000 + 280 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, ^i32 , ^i32 , ^i32 , ^i32 )) (fp))(textbox_, fromLine_, fromByte_, toLine_, toByte_); }
|
||||
TextboxMoveCaret :: inline proc "c" (textbox_ : ^Textbox, line_ : i32 , byte_ : i32 ){ addr := 0x1000 + 281 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, i32 , i32 )) (fp))(textbox_, line_, byte_); }
|
||||
TextboxSetSelection :: inline proc "c" (textbox_ : ^Textbox, fromLine_ : i32 , fromByte_ : i32 , toLine_ : i32 , toByte_ : i32 ){ addr := 0x1000 + 282 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, i32 , i32 , i32 , i32 )) (fp))(textbox_, fromLine_, fromByte_, toLine_, toByte_); }
|
||||
TextboxSelectAll :: inline proc "c" (textbox_ : ^Textbox){ addr := 0x1000 + 283 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox)) (fp))(textbox_); }
|
||||
TextboxClear :: inline proc "c" (textbox_ : ^Textbox, sendUpdatedMessage_ : bool){ addr := 0x1000 + 284 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, bool)) (fp))(textbox_, sendUpdatedMessage_); }
|
||||
TextboxUseNumberOverlay :: inline proc "c" (textbox_ : ^Textbox, defaultBehaviour_ : bool){ addr := 0x1000 + 285 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, bool)) (fp))(textbox_, defaultBehaviour_); }
|
||||
TextboxUseBreadcrumbOverlay :: inline proc "c" (textbox_ : ^Textbox){ addr := 0x1000 + 286 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox)) (fp))(textbox_); }
|
||||
PanelSetBands :: inline proc "c" (panel_ : ^Panel, columnCount_ : int , rowCount_ : int , columns_ : ^PanelBand, rows_ : ^PanelBand){ addr := 0x1000 + 287 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Panel, int , int , ^PanelBand, ^PanelBand)) (fp))(panel_, columnCount_, rowCount_, columns_, rows_); }
|
||||
PanelSwitchTo :: inline proc "c" (panel_ : ^Panel, targetChild_ : ^Element, transitionType_ : TransitionType){ addr := 0x1000 + 288 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Panel, ^Element, TransitionType)) (fp))(panel_, targetChild_, transitionType_); }
|
||||
TextPlanGetWidth :: inline proc "c" (plan_ : ^TextPlan) -> i32{ addr := 0x1000 + 289 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^TextPlan) -> i32) (fp))(plan_); }
|
||||
TextPlanGetHeight :: inline proc "c" (plan_ : ^TextPlan) -> i32{ addr := 0x1000 + 290 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^TextPlan) -> i32) (fp))(plan_); }
|
||||
TextPlanGetLineCount :: inline proc "c" (plan_ : ^TextPlan) -> int { addr := 0x1000 + 291 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^TextPlan) -> int ) (fp))(plan_); }
|
||||
TextPlanDestroy :: inline proc "c" (plan_ : ^TextPlan){ addr := 0x1000 + 292 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^TextPlan)) (fp))(plan_); }
|
||||
TextDisplaySetContents :: inline proc "c" (display_ : ^TextDisplay, contents_ : string){ addr := 0x1000 + 293 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^TextDisplay, ^u8, int)) (fp))(display_, raw_data(contents_), len(contents_)); }
|
||||
TextDisplayBindContents :: inline proc "c" (display_ : ^TextDisplay, cRule_ : ^i8 , store_ : ^Store, id_ : Generic, values_ : ^i32, valueCount_ : int ){ addr := 0x1000 + 294 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^TextDisplay, ^i8 , ^Store, Generic, ^i32, int )) (fp))(display_, cRule_, store_, id_, values_, valueCount_); }
|
||||
TextDisplayUnbindContents :: inline proc "c" (display_ : ^TextDisplay){ addr := 0x1000 + 295 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^TextDisplay)) (fp))(display_); }
|
||||
StoreDestroy :: inline proc "c" (store_ : ^Store){ addr := 0x1000 + 296 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store)) (fp))(store_); }
|
||||
StoreObserve :: inline proc "c" (store_ : ^Store, id_ : Generic, tag_ : i32, callback_ : StoreCallbackFunction, _context_ : Generic, callNow_ : bool){ addr := 0x1000 + 297 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store, Generic, i32, StoreCallbackFunction, Generic, bool)) (fp))(store_, id_, tag_, callback_, _context_, callNow_); }
|
||||
StoreUnobserve :: inline proc "c" (store_ : ^Store, id_ : Generic, callback_ : StoreCallbackFunction, _context_ : Generic){ addr := 0x1000 + 298 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store, Generic, StoreCallbackFunction, Generic)) (fp))(store_, id_, callback_, _context_); }
|
||||
StoreNotify :: inline proc "c" (store_ : ^Store, id_ : Generic, tag_ : i32){ addr := 0x1000 + 299 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store, Generic, i32)) (fp))(store_, id_, tag_); }
|
||||
StoreSet :: inline proc "c" (store_ : ^Store, id_ : Generic, tag_ : i32, value_ : FormatValue){ addr := 0x1000 + 300 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store, Generic, i32, FormatValue)) (fp))(store_, id_, tag_, value_); }
|
||||
StoreGet :: inline proc "c" (store_ : ^Store, id_ : Generic, tag_ : i32, defaultValue_ : FormatValue) -> FormatValue{ addr := 0x1000 + 301 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Store, Generic, i32, FormatValue) -> FormatValue) (fp))(store_, id_, tag_, defaultValue_); }
|
||||
StoreDispatchNotifications :: inline proc "c" (store_ : ^Store){ addr := 0x1000 + 302 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store)) (fp))(store_); }
|
||||
ColorWellGetRGB :: inline proc "c" (well_ : ^ColorWell) -> u32 { addr := 0x1000 + 303 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^ColorWell) -> u32 ) (fp))(well_); }
|
||||
ColorWellSetRGB :: inline proc "c" (well_ : ^ColorWell, colorRGB_ : u32 , sendChangedMessage_ : bool){ addr := 0x1000 + 304 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ColorWell, u32 , bool)) (fp))(well_, colorRGB_, sendChangedMessage_); }
|
||||
ColorWellSetIndeterminate :: inline proc "c" (well_ : ^ColorWell){ addr := 0x1000 + 305 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ColorWell)) (fp))(well_); }
|
||||
ChoiceAddMenuItem :: inline proc "c" (choice_ : ^Choice, item_ : Generic){ addr := 0x1000 + 306 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Choice, Generic)) (fp))(choice_, item_); }
|
||||
ChoiceSetItem :: inline proc "c" (choice_ : ^Choice, item_ : Generic, sendUpdatedMessage_ : bool){ addr := 0x1000 + 307 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Choice, Generic, bool)) (fp))(choice_, item_, sendUpdatedMessage_); }
|
||||
ChoiceGetItem :: inline proc "c" (choice_ : ^Choice) -> Generic{ addr := 0x1000 + 308 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Choice) -> Generic) (fp))(choice_); }
|
||||
ListViewInsertGroup :: inline proc "c" (view_ : ^ListView, group_ : i32 , flags_ : u32 ){ addr := 0x1000 + 309 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, i32 , u32 )) (fp))(view_, group_, flags_); }
|
||||
ListViewInsert :: inline proc "c" (view_ : ^ListView, group_ : i32 , firstIndex_ : Generic, lastIndex_ : Generic, count_ : i64 ){ addr := 0x1000 + 310 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, i32 , Generic, Generic, i64 )) (fp))(view_, group_, firstIndex_, lastIndex_, count_); }
|
||||
ListViewRemove :: inline proc "c" (view_ : ^ListView, group_ : i32 , firstIndex_ : Generic, lastIndex_ : Generic, count_ : i64 ){ addr := 0x1000 + 311 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, i32 , Generic, Generic, i64 )) (fp))(view_, group_, firstIndex_, lastIndex_, count_); }
|
||||
ListViewRemoveAll :: inline proc "c" (view_ : ^ListView, group_ : i32 ){ addr := 0x1000 + 312 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, i32 )) (fp))(view_, group_); }
|
||||
ListViewGetIndex :: inline proc "c" (view_ : ^ListView, item_ : ^Element) -> Generic{ addr := 0x1000 + 313 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^ListView, ^Element) -> Generic) (fp))(view_, item_); }
|
||||
ListViewSetColumns :: inline proc "c" (view_ : ^ListView, columns_ : ^ListViewColumn, columnCount_ : int ){ addr := 0x1000 + 314 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, ^ListViewColumn, int )) (fp))(view_, columns_, columnCount_); }
|
||||
ListViewSelect :: inline proc "c" (view_ : ^ListView, group_ : i32 , index_ : Generic){ addr := 0x1000 + 315 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, i32 , Generic)) (fp))(view_, group_, index_); }
|
||||
ListViewResetSearchBuffer :: inline proc "c" (view_ : ^ListView){ addr := 0x1000 + 316 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView)) (fp))(view_); }
|
||||
ThreadEntryFunction :: distinct proc "c" ( Generic);
|
||||
ComparisonCallbackFunction :: distinct proc "c" ( rawptr, rawptr, Generic) -> i32;
|
||||
SwapCallbackFunction :: distinct proc "c" ( rawptr, rawptr, Generic);
|
||||
CRTComparisonCallback :: distinct proc "c" ( rawptr, rawptr) -> i32;
|
||||
TimerCallbackFunction :: distinct proc "c" ( Generic);
|
||||
MenuCallbackFunction :: distinct proc "c" ( ^Menu, Generic);
|
||||
StorePullCallbackFunction :: distinct proc "c" ( ^Store, ^INSTANCE_TYPE, Generic, i32, Generic, ^FormatValue);
|
||||
StoreCallbackFunction :: distinct proc "c" ( ^Store, ^INSTANCE_TYPE, Generic, Generic);
|
||||
DirectoryMonitorCallbackFunction :: distinct proc "c" ( ^DirectoryMonitor, i32, ^i8 , int , ^i8 , int , Generic);
|
||||
MessageLoopCallbackFunction :: distinct proc "c" ( ^Message);
|
||||
Batch :: #force_inline proc "c" (calls_ : ^BatchCall, count_ : int ){ addr := 0x1000 + 0 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^BatchCall, int )) (fp))(calls_, count_); }
|
||||
GetCreationArgument :: #force_inline proc "c" (object_ : Handle) -> Generic{ addr := 0x1000 + 1 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> Generic) (fp))(object_); }
|
||||
GetSystemInformation :: #force_inline proc "c" (systemInformation_ : ^SystemInformation){ addr := 0x1000 + 2 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^SystemInformation)) (fp))(systemInformation_); }
|
||||
HandleClose :: #force_inline proc "c" (handle_ : Handle) -> Error{ addr := 0x1000 + 3 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> Error) (fp))(handle_); }
|
||||
InitialiseCStandardLibrary :: #force_inline proc "c" (argc_ : ^i32, argv_ : ^^^i8 ){ addr := 0x1000 + 4 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^i32, ^^^i8 )) (fp))(argc_, argv_); }
|
||||
MailslotSendData :: #force_inline proc "c" (mailslot_ : Handle, data_ : rawptr, bytes_ : int ) -> bool{ addr := 0x1000 + 5 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, rawptr, int ) -> bool) (fp))(mailslot_, data_, bytes_); }
|
||||
MakeLinuxSystemCall2 :: #force_inline proc "c" (n_ : int , a1_ : int , a2_ : int , a3_ : int , a4_ : int , a5_ : int , a6_ : int ) -> int { addr := 0x1000 + 6 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , int , int , int , int , int , int ) -> int ) (fp))(n_, a1_, a2_, a3_, a4_, a5_, a6_); }
|
||||
SystemConfigurationRead :: #force_inline proc "c" (cKey_ : ^i8 , bytes_ : ^int ) -> rawptr{ addr := 0x1000 + 7 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^int ) -> rawptr) (fp))(cKey_, bytes_); }
|
||||
SystemGetConstant :: #force_inline proc "c" (index_ : uint ) -> u64 { addr := 0x1000 + 8 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( uint ) -> u64 ) (fp))(index_); }
|
||||
TakeSystemSnapshot :: #force_inline proc "c" (type_ : i32, bufferSize_ : ^int ) -> Handle{ addr := 0x1000 + 9 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32, ^int ) -> Handle) (fp))(type_, bufferSize_); }
|
||||
UserGetHomeFolder :: #force_inline proc "c" (buffer_ : ^i8 , bufferBytes_ : int ) -> int { addr := 0x1000 + 10 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int ) -> int ) (fp))(buffer_, bufferBytes_); }
|
||||
_EsInstanceCreate :: #force_inline proc "c" (bytes_ : int , message_ : ^Message) -> ^Instance{ addr := 0x1000 + 11 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , ^Message) -> ^Instance) (fp))(bytes_, message_); }
|
||||
_EsSyscall :: #force_inline proc "c" (a_ : uint , b_ : uint , c_ : uint , d_ : uint , e_ : uint , f_ : uint ) -> uint { addr := 0x1000 + 12 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( uint , uint , uint , uint , uint , uint ) -> uint ) (fp))(a_, b_, c_, d_, e_, f_); }
|
||||
CommandAddButton :: #force_inline proc "c" (command_ : ^Command, button_ : ^Button){ addr := 0x1000 + 13 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Command, ^Button)) (fp))(command_, button_); }
|
||||
CommandByID :: #force_inline proc "c" (instance_ : ^Instance, stableID_ : u32 ) -> ^Command{ addr := 0x1000 + 14 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Instance, u32 ) -> ^Command) (fp))(instance_, stableID_); }
|
||||
CommandRegister :: #force_inline proc "c" (command_ : ^Command, instance_ : ^Instance, callback_ : CommandCallbackFunction, stableID_ : u32 , cDefaultKeyboardShortcut_ : cstring , enabled_ : bool) -> ^Command{ addr := 0x1000 + 15 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Command, ^Instance, CommandCallbackFunction, u32 , cstring , bool) -> ^Command) (fp))(command_, instance_, callback_, stableID_, cDefaultKeyboardShortcut_, enabled_); }
|
||||
CommandSetCallback :: #force_inline proc "c" (command_ : ^Command, callback_ : CommandCallbackFunction){ addr := 0x1000 + 16 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Command, CommandCallbackFunction)) (fp))(command_, callback_); }
|
||||
CommandSetDisabled :: #force_inline proc "c" (command_ : ^Command, disabled_ : bool){ addr := 0x1000 + 17 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Command, bool)) (fp))(command_, disabled_); }
|
||||
DialogClose :: #force_inline proc "c" (window_ : ^Window){ addr := 0x1000 + 18 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Window)) (fp))(window_); }
|
||||
DialogShow :: #force_inline proc "c" (window_ : ^Window) -> ^Element{ addr := 0x1000 + 19 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Window) -> ^Element) (fp))(window_); }
|
||||
DialogShowAlert :: #force_inline proc "c" (window_ : ^Window, title_ : string, content_ : string, iconID_ : u32 ) -> ^Element{ addr := 0x1000 + 20 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Window, ^u8, int, ^u8, int, u32 ) -> ^Element) (fp))(window_, raw_data(title_), len(title_), raw_data(content_), len(content_), iconID_); }
|
||||
KeyboardIsAltHeld :: #force_inline proc "c" () -> bool{ addr := 0x1000 + 21 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> bool) (fp))(); }
|
||||
KeyboardIsCtrlHeld :: #force_inline proc "c" () -> bool{ addr := 0x1000 + 22 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> bool) (fp))(); }
|
||||
KeyboardIsShiftHeld :: #force_inline proc "c" () -> bool{ addr := 0x1000 + 23 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> bool) (fp))(); }
|
||||
MessageGetInputText :: #force_inline proc "c" (message_ : ^Message, buffer_ : ^i8 ) -> int { addr := 0x1000 + 24 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Message, ^i8 ) -> int ) (fp))(message_, buffer_); }
|
||||
MessageLoopEnter :: #force_inline proc "c" (callback_ : MessageLoopCallbackFunction){ addr := 0x1000 + 25 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( MessageLoopCallbackFunction)) (fp))(callback_); }
|
||||
MessageMutexAcquire :: #force_inline proc "c" (){ addr := 0x1000 + 26 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
MessageMutexCheck :: #force_inline proc "c" (){ addr := 0x1000 + 27 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
MessageMutexRelease :: #force_inline proc "c" (){ addr := 0x1000 + 28 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
MessagePost :: #force_inline proc "c" (target_ : ^Element, message_ : ^Message) -> Error{ addr := 0x1000 + 29 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, ^Message) -> Error) (fp))(target_, message_); }
|
||||
MessagePostRemote :: #force_inline proc "c" (process_ : Handle, message_ : ^Message) -> Error{ addr := 0x1000 + 30 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, ^Message) -> Error) (fp))(process_, message_); }
|
||||
MessageSend :: #force_inline proc "c" (object_ : ^Element, message_ : ^Message) -> Response{ addr := 0x1000 + 31 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, ^Message) -> Response) (fp))(object_, message_); }
|
||||
MouseGetPosition :: #force_inline proc "c" (relativeElement_ : ^Element) -> Point{ addr := 0x1000 + 32 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> Point) (fp))(relativeElement_); }
|
||||
MouseSetPosition :: #force_inline proc "c" (relativeWindow_ : ^Window, x_ : i32, y_ : i32){ addr := 0x1000 + 33 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Window, i32, i32)) (fp))(relativeWindow_, x_, y_); }
|
||||
PaintTargetClear :: #force_inline proc "c" (target_ : ^PaintTarget){ addr := 0x1000 + 34 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^PaintTarget)) (fp))(target_); }
|
||||
PaintTargetTake :: #force_inline proc "c" (window_ : ^Window, target_ : ^PaintTarget, width_ : int , height_ : int ) -> bool{ addr := 0x1000 + 35 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Window, ^PaintTarget, int , int ) -> bool) (fp))(window_, target_, width_, height_); }
|
||||
PaintTargetReturn :: #force_inline proc "c" (window_ : ^Window, target_ : ^PaintTarget){ addr := 0x1000 + 36 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Window, ^PaintTarget)) (fp))(window_, target_); }
|
||||
StyleRefreshAll :: #force_inline proc "c" (window_ : ^Element){ addr := 0x1000 + 37 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element)) (fp))(window_); }
|
||||
UISetDPI :: #force_inline proc "c" (dpiScale_ : i32){ addr := 0x1000 + 38 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( i32)) (fp))(dpiScale_); }
|
||||
DirectoryEnumerateChildren :: #force_inline proc "c" (path_ : string, buffer_ : ^^DirectoryChild) -> int { addr := 0x1000 + 39 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^^DirectoryChild) -> int ) (fp))(raw_data(path_), len(path_), buffer_); }
|
||||
DirectoryEnumerateChildrenFromHandle :: #force_inline proc "c" (directory_ : Handle, buffer_ : ^DirectoryChild, bufferCount_ : int ) -> int { addr := 0x1000 + 40 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, ^DirectoryChild, int ) -> int ) (fp))(directory_, buffer_, bufferCount_); }
|
||||
DirectoryMonitorCreate :: #force_inline proc "c" (path_ : string, flags_ : u64 , callback_ : DirectoryMonitorCallbackFunction, _context_ : Generic) -> ^DirectoryMonitor{ addr := 0x1000 + 41 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, u64 , DirectoryMonitorCallbackFunction, Generic) -> ^DirectoryMonitor) (fp))(raw_data(path_), len(path_), flags_, callback_, _context_); }
|
||||
DirectoryMonitorCreateFromHandle :: #force_inline proc "c" (directory_ : Handle, flags_ : u64 , callback_ : DirectoryMonitorCallbackFunction, _context_ : Generic) -> ^DirectoryMonitor{ addr := 0x1000 + 42 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, u64 , DirectoryMonitorCallbackFunction, Generic) -> ^DirectoryMonitor) (fp))(directory_, flags_, callback_, _context_); }
|
||||
DirectoryMonitorDestroy :: #force_inline proc "c" (monitor_ : ^DirectoryMonitor){ addr := 0x1000 + 43 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^DirectoryMonitor)) (fp))(monitor_); }
|
||||
FileReadAll :: #force_inline proc "c" (filePath_ : string, fileSize_ : ^int ) -> rawptr{ addr := 0x1000 + 44 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^int ) -> rawptr) (fp))(raw_data(filePath_), len(filePath_), fileSize_); }
|
||||
FileReadSync :: #force_inline proc "c" (file_ : Handle, offset_ : FileOffset, size_ : int , buffer_ : rawptr) -> int { addr := 0x1000 + 45 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, FileOffset, int , rawptr) -> int ) (fp))(file_, offset_, size_, buffer_); }
|
||||
FileResize :: #force_inline proc "c" (file_ : Handle, newSize_ : FileOffset) -> Error{ addr := 0x1000 + 46 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, FileOffset) -> Error) (fp))(file_, newSize_); }
|
||||
FileWriteAll :: #force_inline proc "c" (filePath_ : string, data_ : rawptr, fileSize_ : int ) -> Error{ addr := 0x1000 + 47 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, rawptr, int ) -> Error) (fp))(raw_data(filePath_), len(filePath_), data_, fileSize_); }
|
||||
FileWriteAllGather :: #force_inline proc "c" (filePath_ : string, data_ : ^rawptr, fileSize_ : ^int , gatherCount_ : int ) -> Error{ addr := 0x1000 + 48 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^rawptr, ^int , int ) -> Error) (fp))(raw_data(filePath_), len(filePath_), data_, fileSize_, gatherCount_); }
|
||||
FileWriteComplete :: #force_inline proc "c" (file_ : Handle){ addr := 0x1000 + 49 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle)) (fp))(file_); }
|
||||
FileWriteSync :: #force_inline proc "c" (file_ : Handle, offset_ : FileOffset, size_ : int , buffer_ : rawptr) -> int { addr := 0x1000 + 50 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, FileOffset, int , rawptr) -> int ) (fp))(file_, offset_, size_, buffer_); }
|
||||
NodeDelete :: #force_inline proc "c" (node_ : Handle) -> Error{ addr := 0x1000 + 51 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> Error) (fp))(node_); }
|
||||
NodeDeleteByPath :: #force_inline proc "c" (filePath_ : string) -> Error{ addr := 0x1000 + 52 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int) -> Error) (fp))(raw_data(filePath_), len(filePath_)); }
|
||||
NodeFindUniqueName :: #force_inline proc "c" (buffer_ : ^i8 , originalBytes_ : int , bufferBytes_ : int ) -> int { addr := 0x1000 + 53 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int , int ) -> int ) (fp))(buffer_, originalBytes_, bufferBytes_); }
|
||||
NodeMove :: #force_inline proc "c" (node_ : Handle, newDirectory_ : Handle, newName_ : string) -> Error{ addr := 0x1000 + 54 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Handle, ^u8, int) -> Error) (fp))(node_, newDirectory_, raw_data(newName_), len(newName_)); }
|
||||
NodeOpen :: #force_inline proc "c" (path_ : string, flags_ : u64 , information_ : ^NodeInformation) -> Error{ addr := 0x1000 + 55 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, u64 , ^NodeInformation) -> Error) (fp))(raw_data(path_), len(path_), flags_, information_); }
|
||||
NodeOpenRelative :: #force_inline proc "c" (directory_ : Handle, path_ : string, flags_ : u64 , information_ : ^NodeInformation) -> Error{ addr := 0x1000 + 56 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, ^u8, int, u64 , ^NodeInformation) -> Error) (fp))(directory_, raw_data(path_), len(path_), flags_, information_); }
|
||||
NodeRefreshInformation :: #force_inline proc "c" (information_ : ^NodeInformation){ addr := 0x1000 + 57 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^NodeInformation)) (fp))(information_); }
|
||||
ProcessCrash :: #force_inline proc "c" (error_ : Error, message_ : string){ addr := 0x1000 + 58 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Error, ^u8, int)) (fp))(error_, raw_data(message_), len(message_)); }
|
||||
ProcessCreate :: #force_inline proc "c" (executablePath_ : string, information_ : ^ProcessInformation, argument_ : Generic) -> Error{ addr := 0x1000 + 59 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^ProcessInformation, Generic) -> Error) (fp))(raw_data(executablePath_), len(executablePath_), information_, argument_); }
|
||||
ProcessCreate2 :: #force_inline proc "c" (arguments_ : ^ProcessCreationArguments, information_ : ^ProcessInformation) -> Error{ addr := 0x1000 + 60 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^ProcessCreationArguments, ^ProcessInformation) -> Error) (fp))(arguments_, information_); }
|
||||
ProcessGetExitStatus :: #force_inline proc "c" (process_ : Handle) -> i32{ addr := 0x1000 + 61 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> i32) (fp))(process_); }
|
||||
ProcessGetID :: #force_inline proc "c" (process_ : Handle) -> uint { addr := 0x1000 + 62 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> uint ) (fp))(process_); }
|
||||
ProcessGetState :: #force_inline proc "c" (process_ : Handle, state_ : ^ProcessState){ addr := 0x1000 + 63 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, ^ProcessState)) (fp))(process_, state_); }
|
||||
ProcessOpen :: #force_inline proc "c" (pid_ : u64 ) -> Handle{ addr := 0x1000 + 64 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( u64 ) -> Handle) (fp))(pid_); }
|
||||
ProcessPause :: #force_inline proc "c" (process_ : Handle, resume_ : bool){ addr := 0x1000 + 65 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, bool)) (fp))(process_, resume_); }
|
||||
ProcessTerminate :: #force_inline proc "c" (process_ : Handle, status_ : i32){ addr := 0x1000 + 66 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, i32)) (fp))(process_, status_); }
|
||||
ProcessTerminateCurrent :: #force_inline proc "c" (){ addr := 0x1000 + 67 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
ThreadCreate :: #force_inline proc "c" (entryFunction_ : ThreadEntryFunction, information_ : ^ThreadInformation, argument_ : Generic) -> Error{ addr := 0x1000 + 68 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ThreadEntryFunction, ^ThreadInformation, Generic) -> Error) (fp))(entryFunction_, information_, argument_); }
|
||||
ThreadGetID :: #force_inline proc "c" (thread_ : Handle) -> uint { addr := 0x1000 + 69 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> uint ) (fp))(thread_); }
|
||||
ThreadLocalStorageSetAddress :: #force_inline proc "c" (address_ : rawptr){ addr := 0x1000 + 70 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr)) (fp))(address_); }
|
||||
ThreadTerminate :: #force_inline proc "c" (thread_ : Handle){ addr := 0x1000 + 71 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle)) (fp))(thread_); }
|
||||
ArenaAllocate :: #force_inline proc "c" (arena_ : ^Arena, zero_ : bool) -> rawptr{ addr := 0x1000 + 72 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Arena, bool) -> rawptr) (fp))(arena_, zero_); }
|
||||
ArenaFree :: #force_inline proc "c" (pointer_ : rawptr){ addr := 0x1000 + 73 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr)) (fp))(pointer_); }
|
||||
ArenaInitialise :: #force_inline proc "c" (arena_ : ^Arena, slotsPerBlock_ : int , itemSize_ : int ){ addr := 0x1000 + 74 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Arena, int , int )) (fp))(arena_, slotsPerBlock_, itemSize_); }
|
||||
ConstantBufferCreate :: #force_inline proc "c" (data_ : rawptr, dataBytes_ : int , targetProcess_ : Handle) -> Handle{ addr := 0x1000 + 75 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, int , Handle) -> Handle) (fp))(data_, dataBytes_, targetProcess_); }
|
||||
ConstantBufferRead :: #force_inline proc "c" (constantBuffer_ : Handle, output_ : rawptr){ addr := 0x1000 + 76 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, rawptr)) (fp))(constantBuffer_, output_); }
|
||||
ConstantBufferShare :: #force_inline proc "c" (constantBuffer_ : Handle, targetProcess_ : Handle) -> Handle{ addr := 0x1000 + 77 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Handle) -> Handle) (fp))(constantBuffer_, targetProcess_); }
|
||||
HeapAllocate :: #force_inline proc "c" (size_ : int , zeroMemory_ : bool) -> rawptr{ addr := 0x1000 + 78 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , bool) -> rawptr) (fp))(size_, zeroMemory_); }
|
||||
HeapFree :: #force_inline proc "c" (address_ : rawptr){ addr := 0x1000 + 79 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr)) (fp))(address_); }
|
||||
HeapReallocate :: #force_inline proc "c" (oldAddress_ : rawptr, newAllocationSize_ : int , zeroNewSpace_ : bool) -> rawptr{ addr := 0x1000 + 80 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, int , bool) -> rawptr) (fp))(oldAddress_, newAllocationSize_, zeroNewSpace_); }
|
||||
HeapValidate :: #force_inline proc "c" (){ addr := 0x1000 + 81 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
MemoryAllocate :: #force_inline proc "c" (size_ : int ) -> rawptr{ addr := 0x1000 + 82 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int ) -> rawptr) (fp))(size_); }
|
||||
MemoryCompare :: #force_inline proc "c" (a_ : rawptr, b_ : rawptr, bytes_ : int ) -> i32{ addr := 0x1000 + 83 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, rawptr, int ) -> i32) (fp))(a_, b_, bytes_); }
|
||||
MemoryCopy :: #force_inline proc "c" (destination_ : rawptr, source_ : rawptr, bytes_ : int ){ addr := 0x1000 + 84 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, rawptr, int )) (fp))(destination_, source_, bytes_); }
|
||||
MemoryCopyReverse :: #force_inline proc "c" (_destination_ : rawptr, _source_ : rawptr, bytes_ : int ){ addr := 0x1000 + 85 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, rawptr, int )) (fp))(_destination_, _source_, bytes_); }
|
||||
MemoryFill :: #force_inline proc "c" (from_ : rawptr, to_ : rawptr, byte_ : u8 ){ addr := 0x1000 + 86 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, rawptr, u8 )) (fp))(from_, to_, byte_); }
|
||||
MemoryFree :: #force_inline proc "c" (address_ : rawptr) -> Error{ addr := 0x1000 + 87 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr) -> Error) (fp))(address_); }
|
||||
MemoryMove :: #force_inline proc "c" (_start_ : rawptr, _end_ : rawptr, amount_ : int , zeroEmptySpace_ : bool){ addr := 0x1000 + 88 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, rawptr, int , bool)) (fp))(_start_, _end_, amount_, zeroEmptySpace_); }
|
||||
MemoryOpen :: #force_inline proc "c" (size_ : int , name_ : string, flags_ : u32 ) -> Handle{ addr := 0x1000 + 89 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , ^u8, int, u32 ) -> Handle) (fp))(size_, raw_data(name_), len(name_), flags_); }
|
||||
MemoryShare :: #force_inline proc "c" (sharedMemoryRegion_ : Handle, targetProcess_ : Handle, readOnly_ : bool) -> Handle{ addr := 0x1000 + 90 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Handle, bool) -> Handle) (fp))(sharedMemoryRegion_, targetProcess_, readOnly_); }
|
||||
MemorySumBytes :: #force_inline proc "c" (data_ : ^u8 , bytes_ : int ) -> u8 { addr := 0x1000 + 91 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^u8 , int ) -> u8 ) (fp))(data_, bytes_); }
|
||||
MemoryZero :: #force_inline proc "c" (destination_ : rawptr, bytes_ : int ){ addr := 0x1000 + 92 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, int )) (fp))(destination_, bytes_); }
|
||||
ObjectMap :: #force_inline proc "c" (object_ : Handle, offset_ : uint , size_ : int , flags_ : u32 ) -> rawptr{ addr := 0x1000 + 93 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, uint , int , u32 ) -> rawptr) (fp))(object_, offset_, size_, flags_); }
|
||||
Abort :: #force_inline proc "c" (){ addr := 0x1000 + 94 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
Assert :: #force_inline proc "c" (expression_ : bool, failureMessage_ : cstring ){ addr := 0x1000 + 95 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( bool, cstring )) (fp))(expression_, failureMessage_); }
|
||||
CalculateFromUserExpression :: #force_inline proc "c" (cExpression_ : cstring ) -> CalculationValue{ addr := 0x1000 + 96 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( cstring ) -> CalculationValue) (fp))(cExpression_); }
|
||||
DoubleParse :: #force_inline proc "c" (string_ : string, endptr_ : ^^i8 ) -> f64 { addr := 0x1000 + 97 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^^i8 ) -> f64 ) (fp))(raw_data(string_), len(string_), endptr_); }
|
||||
ExtractArguments :: #force_inline proc "c" (string_ : ^i8 , bytes_ : int , delimiterByte_ : u8 , replacementDelimiter_ : u8 , argvAllocated_ : int , argv_ : ^^i8 , argc_ : ^int ) -> bool{ addr := 0x1000 + 98 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int , u8 , u8 , int , ^^i8 , ^int ) -> bool) (fp))(string_, bytes_, delimiterByte_, replacementDelimiter_, argvAllocated_, argv_, argc_); }
|
||||
GetRandomU8 :: #force_inline proc "c" () -> u8 { addr := 0x1000 + 99 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> u8 ) (fp))(); }
|
||||
GetRandomU64 :: #force_inline proc "c" () -> u64 { addr := 0x1000 + 100 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> u64 ) (fp))(); }
|
||||
IntegerParse :: #force_inline proc "c" (text_ : string) -> i64 { addr := 0x1000 + 101 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int) -> i64 ) (fp))(raw_data(text_), len(text_)); }
|
||||
Print :: #force_inline proc "c" (format_ : cstring , _varargs_ : ..any){ addr := 0x1000 + 102 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( cstring , ..any)) (fp))(format_, _varargs_); }
|
||||
PrintDirect :: #force_inline proc "c" (string_ : string){ addr := 0x1000 + 103 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" (^u8, int)) (fp))(raw_data(string_), len(string_)); }
|
||||
PrintHelloWorld :: #force_inline proc "c" (){ addr := 0x1000 + 104 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
ProcessorReadTimeStamp :: #force_inline proc "c" () -> u64 { addr := 0x1000 + 105 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> u64 ) (fp))(); }
|
||||
RandomAddEntropy :: #force_inline proc "c" (x_ : u64 ){ addr := 0x1000 + 106 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( u64 )) (fp))(x_); }
|
||||
RandomSeed :: #force_inline proc "c" (x_ : u64 ){ addr := 0x1000 + 107 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( u64 )) (fp))(x_); }
|
||||
RectangleClip :: #force_inline proc "c" (parent_ : Rectangle, rectangle_ : Rectangle, output_ : ^Rectangle) -> bool{ addr := 0x1000 + 108 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Rectangle, Rectangle, ^Rectangle) -> bool) (fp))(parent_, rectangle_, output_); }
|
||||
Sort :: #force_inline proc "c" (_base_ : rawptr, nmemb_ : int , size_ : int , compar_ : ComparisonCallbackFunction, argument_ : Generic){ addr := 0x1000 + 109 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, int , int , ComparisonCallbackFunction, Generic)) (fp))(_base_, nmemb_, size_, compar_, argument_); }
|
||||
SortWithSwapCallback :: #force_inline proc "c" (_base_ : rawptr, nmemb_ : int , size_ : int , compar_ : ComparisonCallbackFunction, argument_ : Generic, swap_ : SwapCallbackFunction){ addr := 0x1000 + 110 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, int , int , ComparisonCallbackFunction, Generic, SwapCallbackFunction)) (fp))(_base_, nmemb_, size_, compar_, argument_, swap_); }
|
||||
StringLoadRaw :: #force_inline proc "c" (cRule_ : cstring , formatValues_ : ^FormatValue, formatValueCount_ : int ) -> FormatValue{ addr := 0x1000 + 111 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( cstring , ^FormatValue, int ) -> FormatValue) (fp))(cRule_, formatValues_, formatValueCount_); }
|
||||
StringZeroTerminate :: #force_inline proc "c" (string_ : string) -> ^i8 { addr := 0x1000 + 112 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int) -> ^i8 ) (fp))(raw_data(string_), len(string_)); }
|
||||
ColorBlend :: #force_inline proc "c" (under_ : u32 , over_ : u32 , fullAlpha_ : bool) -> u32 { addr := 0x1000 + 113 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( u32 , u32 , bool) -> u32 ) (fp))(under_, over_, fullAlpha_); }
|
||||
ColorConvertToRGB :: #force_inline proc "c" (h_ : f32 , s_ : f32 , v_ : f32 ) -> u32 { addr := 0x1000 + 114 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 , f32 , f32 ) -> u32 ) (fp))(h_, s_, v_); }
|
||||
ColorConvertToHSV :: #force_inline proc "c" (color_ : u32 , h_ : ^f32 , s_ : ^f32 , v_ : ^f32 ) -> bool{ addr := 0x1000 + 115 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( u32 , ^f32 , ^f32 , ^f32 ) -> bool) (fp))(color_, h_, s_, v_); }
|
||||
ColorParse :: #force_inline proc "c" (string_ : ^i8 , bytes_ : int ) -> u32 { addr := 0x1000 + 116 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int ) -> u32 ) (fp))(string_, bytes_); }
|
||||
DrawStandardIcon :: #force_inline proc "c" (painter_ : ^Painter, id_ : u32 , size_ : i32, region_ : Rectangle, color_ : u32 ) -> bool{ addr := 0x1000 + 117 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Painter, u32 , i32, Rectangle, u32 ) -> bool) (fp))(painter_, id_, size_, region_, color_); }
|
||||
DrawStyledBox :: #force_inline proc "c" (painter_ : ^Painter, box_ : StyledBox){ addr := 0x1000 + 118 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Painter, StyledBox)) (fp))(painter_, box_); }
|
||||
DrawSurface :: #force_inline proc "c" (destination_ : Handle, source_ : Handle, destinationRegion_ : Rectangle, sourceRegion_ : Rectangle, borderRegion_ : Rectangle, mode_ : DrawMode, alpha_ : u16 ) -> Error{ addr := 0x1000 + 119 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Handle, Rectangle, Rectangle, Rectangle, DrawMode, u16 ) -> Error) (fp))(destination_, source_, destinationRegion_, sourceRegion_, borderRegion_, mode_, alpha_); }
|
||||
DrawSurface2 :: #force_inline proc "c" (painter_ : ^Painter, source_ : Handle, destinationRegion_ : Rectangle, sourceRegion_ : Rectangle, alpha_ : u16 ){ addr := 0x1000 + 120 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Painter, Handle, Rectangle, Rectangle, u16 )) (fp))(painter_, source_, destinationRegion_, sourceRegion_, alpha_); }
|
||||
DrawSurfaceClipped :: #force_inline proc "c" (destination_ : Handle, source_ : Handle, destinationRegion_ : Rectangle, sourceRegion_ : Rectangle, borderRegion_ : Rectangle, mode_ : DrawMode, alpha_ : u16 , clipRegion_ : Rectangle) -> Error{ addr := 0x1000 + 121 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Handle, Rectangle, Rectangle, Rectangle, DrawMode, u16 , Rectangle) -> Error) (fp))(destination_, source_, destinationRegion_, sourceRegion_, borderRegion_, mode_, alpha_, clipRegion_); }
|
||||
DrawText :: #force_inline proc "c" (painter_ : ^Painter, plan_ : ^TextPlan, bounds_ : Rectangle, clip_ : ^Rectangle, selectionProperties_ : ^TextSelection){ addr := 0x1000 + 122 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Painter, ^TextPlan, Rectangle, ^Rectangle, ^TextSelection)) (fp))(painter_, plan_, bounds_, clip_, selectionProperties_); }
|
||||
FontGetName :: #force_inline proc "c" (family_ : u16 , buffer_ : ^i8 , bufferBytes_ : int ) -> int { addr := 0x1000 + 123 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( u16 , ^i8 , int ) -> int ) (fp))(family_, buffer_, bufferBytes_); }
|
||||
PainterBoundsClient :: #force_inline proc "c" (painter_ : ^Painter) -> Rectangle{ addr := 0x1000 + 124 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Painter) -> Rectangle) (fp))(painter_); }
|
||||
PainterBoundsInset :: #force_inline proc "c" (painter_ : ^Painter) -> Rectangle{ addr := 0x1000 + 125 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Painter) -> Rectangle) (fp))(painter_); }
|
||||
RedrawAll :: #force_inline proc "c" (){ addr := 0x1000 + 126 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
SurfaceCreate :: #force_inline proc "c" (width_ : int , height_ : int , flags_ : u32 ) -> Handle{ addr := 0x1000 + 127 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , int , u32 ) -> Handle) (fp))(width_, height_, flags_); }
|
||||
SurfaceGetLinearBuffer :: #force_inline proc "c" (surface_ : Handle, linearBuffer_ : ^LinearBuffer){ addr := 0x1000 + 128 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, ^LinearBuffer)) (fp))(surface_, linearBuffer_); }
|
||||
SurfaceReset :: #force_inline proc "c" (surface_ : Handle){ addr := 0x1000 + 129 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle)) (fp))(surface_); }
|
||||
AudioStreamClose :: #force_inline proc "c" (stream_ : ^AudioStream){ addr := 0x1000 + 130 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^AudioStream)) (fp))(stream_); }
|
||||
AudioStreamOpen :: #force_inline proc "c" (device_ : AudioDeviceID, bufferLengthUs_ : int ) -> ^AudioStream{ addr := 0x1000 + 131 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( AudioDeviceID, int ) -> ^AudioStream) (fp))(device_, bufferLengthUs_); }
|
||||
AudioStreamNotify :: #force_inline proc "c" (stream_ : ^AudioStream){ addr := 0x1000 + 132 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^AudioStream)) (fp))(stream_); }
|
||||
AudioStreamSend :: #force_inline proc "c" (destination_ : ^AudioStream, source_ : ^AudioStream, time_ : ^f64 ) -> Error{ addr := 0x1000 + 133 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^AudioStream, ^AudioStream, ^f64 ) -> Error) (fp))(destination_, source_, time_); }
|
||||
EventCreate :: #force_inline proc "c" (autoReset_ : bool) -> Handle{ addr := 0x1000 + 134 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( bool) -> Handle) (fp))(autoReset_); }
|
||||
EventForward :: #force_inline proc "c" (event_ : Handle, eventSink_ : Handle, data_ : Generic){ addr := 0x1000 + 135 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, Handle, Generic)) (fp))(event_, eventSink_, data_); }
|
||||
EventPoll :: #force_inline proc "c" (event_ : Handle) -> Error{ addr := 0x1000 + 136 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle) -> Error) (fp))(event_); }
|
||||
EventReset :: #force_inline proc "c" (event_ : Handle){ addr := 0x1000 + 137 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle)) (fp))(event_); }
|
||||
EventSet :: #force_inline proc "c" (event_ : Handle){ addr := 0x1000 + 138 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle)) (fp))(event_); }
|
||||
EventSinkCreate :: #force_inline proc "c" (ignoreDuplicates_ : bool) -> Handle{ addr := 0x1000 + 139 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( bool) -> Handle) (fp))(ignoreDuplicates_); }
|
||||
EventSinkPop :: #force_inline proc "c" (eventSink_ : Handle, data_ : ^Generic) -> Error{ addr := 0x1000 + 140 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, ^Generic) -> Error) (fp))(eventSink_, data_); }
|
||||
EventSinkPush :: #force_inline proc "c" (eventSink_ : Handle, data_ : Generic) -> Error{ addr := 0x1000 + 141 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( Handle, Generic) -> Error) (fp))(eventSink_, data_); }
|
||||
MutexAcquire :: #force_inline proc "c" (mutex_ : ^Mutex){ addr := 0x1000 + 142 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Mutex)) (fp))(mutex_); }
|
||||
MutexDestroy :: #force_inline proc "c" (mutex_ : ^Mutex){ addr := 0x1000 + 143 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Mutex)) (fp))(mutex_); }
|
||||
MutexRelease :: #force_inline proc "c" (mutex_ : ^Mutex){ addr := 0x1000 + 144 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Mutex)) (fp))(mutex_); }
|
||||
PerformanceTimerPush :: #force_inline proc "c" (){ addr := 0x1000 + 145 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
PerformanceTimerPop :: #force_inline proc "c" () -> f64 { addr := 0x1000 + 146 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> f64 ) (fp))(); }
|
||||
SchedulerYield :: #force_inline proc "c" (){ addr := 0x1000 + 147 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ()) (fp))(); }
|
||||
Sleep :: #force_inline proc "c" (milliseconds_ : u64 ){ addr := 0x1000 + 148 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( u64 )) (fp))(milliseconds_); }
|
||||
SpinlockAcquire :: #force_inline proc "c" (spinlock_ : ^Spinlock){ addr := 0x1000 + 149 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Spinlock)) (fp))(spinlock_); }
|
||||
SpinlockRelease :: #force_inline proc "c" (spinlock_ : ^Spinlock){ addr := 0x1000 + 150 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Spinlock)) (fp))(spinlock_); }
|
||||
TimerCreate :: #force_inline proc "c" () -> Handle{ addr := 0x1000 + 151 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" () -> Handle) (fp))(); }
|
||||
TimerSet :: #force_inline proc "c" (handle_ : Handle, afterMs_ : u64 , callback_ : TimerCallbackFunction, argument_ : Generic){ addr := 0x1000 + 152 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( Handle, u64 , TimerCallbackFunction, Generic)) (fp))(handle_, afterMs_, callback_, argument_); }
|
||||
Wait :: #force_inline proc "c" (objects_ : ^Handle, objectCount_ : int , timeoutMs_ : uint ) -> uint { addr := 0x1000 + 153 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Handle, int , uint ) -> uint ) (fp))(objects_, objectCount_, timeoutMs_); }
|
||||
CStringLength :: #force_inline proc "c" (string_ : cstring ) -> int { addr := 0x1000 + 154 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( cstring ) -> int ) (fp))(string_); }
|
||||
StringAllocateAndFormat :: #force_inline proc "c" (bytes_ : ^int , format_ : cstring , _varargs_ : ..any) -> ^i8 { addr := 0x1000 + 155 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^int , cstring , ..any) -> ^i8 ) (fp))(bytes_, format_, _varargs_); }
|
||||
StringCompare :: #force_inline proc "c" (s1_ : string, s2_ : string) -> i32{ addr := 0x1000 + 157 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^u8, int) -> i32) (fp))(raw_data(s1_), len(s1_), raw_data(s2_), len(s2_)); }
|
||||
StringCompareRaw :: #force_inline proc "c" (s1_ : string, s2_ : string) -> i32{ addr := 0x1000 + 158 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^u8, int) -> i32) (fp))(raw_data(s1_), len(s1_), raw_data(s2_), len(s2_)); }
|
||||
StringFormat :: #force_inline proc "c" (buffer_ : ^i8 , bufferLength_ : int , format_ : cstring , _varargs_ : ..any) -> int { addr := 0x1000 + 159 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int , cstring , ..any) -> int ) (fp))(buffer_, bufferLength_, format_, _varargs_); }
|
||||
StringFormatTemporary :: #force_inline proc "c" (format_ : cstring , _varargs_ : ..any) -> ^i8 { addr := 0x1000 + 160 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( cstring , ..any) -> ^i8 ) (fp))(format_, _varargs_); }
|
||||
StringFormatAppend :: #force_inline proc "c" (buffer_ : ^i8 , bufferLength_ : int , bufferPosition_ : ^int , format_ : cstring , _varargs_ : ..any){ addr := 0x1000 + 162 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^i8 , int , ^int , cstring , ..any)) (fp))(buffer_, bufferLength_, bufferPosition_, format_, _varargs_); }
|
||||
StringLength :: #force_inline proc "c" (string_ : ^i8 , end_ : u8 ) -> int { addr := 0x1000 + 164 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , u8 ) -> int ) (fp))(string_, end_); }
|
||||
StringLoad :: #force_inline proc "c" (cRule_ : cstring , formatValues_ : ^FormatValue, formatValueCount_ : int , bytes_ : ^int ) -> ^i8 { addr := 0x1000 + 165 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( cstring , ^FormatValue, int , ^int ) -> ^i8 ) (fp))(cRule_, formatValues_, formatValueCount_, bytes_); }
|
||||
StringStartsWith :: #force_inline proc "c" (string_ : string, prefix_ : string, caseInsensitive_ : bool) -> bool{ addr := 0x1000 + 166 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" (^u8, int, ^u8, int, bool) -> bool) (fp))(raw_data(string_), len(string_), raw_data(prefix_), len(prefix_), caseInsensitive_); }
|
||||
CRTabs :: #force_inline proc "c" (n_ : i32) -> i32{ addr := 0x1000 + 167 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(n_); }
|
||||
CRTacosf :: #force_inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 168 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTasinf :: #force_inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 169 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTassert :: #force_inline proc "c" (test_ : bool){ addr := 0x1000 + 170 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( bool)) (fp))(test_); }
|
||||
CRTatan2f :: #force_inline proc "c" (y_ : f32 , x_ : f32 ) -> f32 { addr := 0x1000 + 171 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 , f32 ) -> f32 ) (fp))(y_, x_); }
|
||||
CRTatanf :: #force_inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 172 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTatoi :: #force_inline proc "c" (string_ : ^i8 ) -> i32{ addr := 0x1000 + 173 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 ) -> i32) (fp))(string_); }
|
||||
CRTcalloc :: #force_inline proc "c" (num_ : int , size_ : int ) -> rawptr{ addr := 0x1000 + 174 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int , int ) -> rawptr) (fp))(num_, size_); }
|
||||
CRTceil :: #force_inline proc "c" (x_ : f64 ) -> f64 { addr := 0x1000 + 175 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f64 ) -> f64 ) (fp))(x_); }
|
||||
CRTceilf :: #force_inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 176 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTcosf :: #force_inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 177 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTfabs :: #force_inline proc "c" (x_ : f64 ) -> f64 { addr := 0x1000 + 178 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f64 ) -> f64 ) (fp))(x_); }
|
||||
CRTfabsl :: #force_inline proc "c" (x_ : [16]u8 ) -> [16]u8 { addr := 0x1000 + 179 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( [16]u8 ) -> [16]u8 ) (fp))(x_); }
|
||||
CRTfloor :: #force_inline proc "c" (x_ : f64 ) -> f64 { addr := 0x1000 + 180 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f64 ) -> f64 ) (fp))(x_); }
|
||||
CRTfloorf :: #force_inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 181 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTfmodf :: #force_inline proc "c" (x_ : f32 , y_ : f32 ) -> f32 { addr := 0x1000 + 182 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 , f32 ) -> f32 ) (fp))(x_, y_); }
|
||||
CRTfree :: #force_inline proc "c" (ptr_ : rawptr){ addr := 0x1000 + 183 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr)) (fp))(ptr_); }
|
||||
CRTgetenv :: #force_inline proc "c" (name_ : ^i8 ) -> ^i8 { addr := 0x1000 + 184 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 ) -> ^i8 ) (fp))(name_); }
|
||||
CRTisalpha :: #force_inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 185 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
CRTisdigit :: #force_inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 186 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
CRTisspace :: #force_inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 187 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
CRTisupper :: #force_inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 188 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
CRTisxdigit :: #force_inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 189 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
CRTmalloc :: #force_inline proc "c" (size_ : int ) -> rawptr{ addr := 0x1000 + 190 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( int ) -> rawptr) (fp))(size_); }
|
||||
CRTmemchr :: #force_inline proc "c" (_s_ : rawptr, _c_ : i32, n_ : int ) -> rawptr{ addr := 0x1000 + 191 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, i32, int ) -> rawptr) (fp))(_s_, _c_, n_); }
|
||||
CRTmemcmp :: #force_inline proc "c" (s1_ : rawptr, s2_ : rawptr, n_ : int ) -> i32{ addr := 0x1000 + 192 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, rawptr, int ) -> i32) (fp))(s1_, s2_, n_); }
|
||||
CRTmemcpy :: #force_inline proc "c" (dest_ : rawptr, src_ : rawptr, n_ : int ) -> rawptr{ addr := 0x1000 + 193 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, rawptr, int ) -> rawptr) (fp))(dest_, src_, n_); }
|
||||
CRTmemmove :: #force_inline proc "c" (dest_ : rawptr, src_ : rawptr, n_ : int ) -> rawptr{ addr := 0x1000 + 194 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, rawptr, int ) -> rawptr) (fp))(dest_, src_, n_); }
|
||||
CRTmemset :: #force_inline proc "c" (s_ : rawptr, c_ : i32, n_ : int ) -> rawptr{ addr := 0x1000 + 195 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, i32, int ) -> rawptr) (fp))(s_, c_, n_); }
|
||||
CRTqsort :: #force_inline proc "c" (_base_ : rawptr, nmemb_ : int , size_ : int , compar_ : CRTComparisonCallback){ addr := 0x1000 + 196 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( rawptr, int , int , CRTComparisonCallback)) (fp))(_base_, nmemb_, size_, compar_); }
|
||||
CRTrealloc :: #force_inline proc "c" (ptr_ : rawptr, size_ : int ) -> rawptr{ addr := 0x1000 + 197 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( rawptr, int ) -> rawptr) (fp))(ptr_, size_); }
|
||||
CRTsinf :: #force_inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 198 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTsnprintf :: #force_inline proc "c" (buffer_ : ^i8 , bufferSize_ : int , format_ : ^i8 , _varargs_ : ..any) -> i32{ addr := 0x1000 + 199 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int , ^i8 , ..any) -> i32) (fp))(buffer_, bufferSize_, format_, _varargs_); }
|
||||
CRTsprintf :: #force_inline proc "c" (buffer_ : ^i8 , format_ : ^i8 , _varargs_ : ..any) -> i32{ addr := 0x1000 + 200 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 , ..any) -> i32) (fp))(buffer_, format_, _varargs_); }
|
||||
CRTsqrt :: #force_inline proc "c" (x_ : f64 ) -> f64 { addr := 0x1000 + 201 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f64 ) -> f64 ) (fp))(x_); }
|
||||
CRTsqrtf :: #force_inline proc "c" (x_ : f32 ) -> f32 { addr := 0x1000 + 202 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( f32 ) -> f32 ) (fp))(x_); }
|
||||
CRTsqrtl :: #force_inline proc "c" (x_ : [16]u8 ) -> [16]u8 { addr := 0x1000 + 203 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( [16]u8 ) -> [16]u8 ) (fp))(x_); }
|
||||
CRTstrcat :: #force_inline proc "c" (dest_ : ^i8 , src_ : ^i8 ) -> ^i8 { addr := 0x1000 + 204 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 ) -> ^i8 ) (fp))(dest_, src_); }
|
||||
CRTstrchr :: #force_inline proc "c" (s_ : ^i8 , c_ : i32) -> ^i8 { addr := 0x1000 + 205 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , i32) -> ^i8 ) (fp))(s_, c_); }
|
||||
CRTstrcmp :: #force_inline proc "c" (s1_ : ^i8 , s2_ : ^i8 ) -> i32{ addr := 0x1000 + 206 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 ) -> i32) (fp))(s1_, s2_); }
|
||||
CRTstrcpy :: #force_inline proc "c" (dest_ : ^i8 , src_ : ^i8 ) -> ^i8 { addr := 0x1000 + 207 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 ) -> ^i8 ) (fp))(dest_, src_); }
|
||||
CRTstrerror :: #force_inline proc "c" (errnum_ : i32) -> ^i8 { addr := 0x1000 + 208 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> ^i8 ) (fp))(errnum_); }
|
||||
CRTstrlen :: #force_inline proc "c" (s_ : ^i8 ) -> int { addr := 0x1000 + 209 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 ) -> int ) (fp))(s_); }
|
||||
CRTstrncmp :: #force_inline proc "c" (s1_ : ^i8 , s2_ : ^i8 , n_ : int ) -> i32{ addr := 0x1000 + 210 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 , int ) -> i32) (fp))(s1_, s2_, n_); }
|
||||
CRTstrncpy :: #force_inline proc "c" (dest_ : ^i8 , src_ : ^i8 , n_ : int ) -> ^i8 { addr := 0x1000 + 211 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 , int ) -> ^i8 ) (fp))(dest_, src_, n_); }
|
||||
CRTstrnlen :: #force_inline proc "c" (s_ : ^i8 , maxlen_ : int ) -> int { addr := 0x1000 + 212 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , int ) -> int ) (fp))(s_, maxlen_); }
|
||||
CRTstrstr :: #force_inline proc "c" (haystack_ : ^i8 , needle_ : ^i8 ) -> ^i8 { addr := 0x1000 + 213 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^i8 ) -> ^i8 ) (fp))(haystack_, needle_); }
|
||||
CRTstrtol :: #force_inline proc "c" (nptr_ : ^i8 , endptr_ : ^^i8 , base_ : i32) -> i64 { addr := 0x1000 + 214 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^^i8 , i32) -> i64 ) (fp))(nptr_, endptr_, base_); }
|
||||
CRTstrtoul :: #force_inline proc "c" (nptr_ : ^i8 , endptr_ : ^^i8 , base_ : i32) -> u64 { addr := 0x1000 + 215 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^i8 , ^^i8 , i32) -> u64 ) (fp))(nptr_, endptr_, base_); }
|
||||
CRTtolower :: #force_inline proc "c" (c_ : i32) -> i32{ addr := 0x1000 + 216 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( i32) -> i32) (fp))(c_); }
|
||||
NewPanel :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^Panel{ addr := 0x1000 + 218 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^Panel) (fp))(parent_, flags_, properties_); }
|
||||
NewSplitter :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^Splitter{ addr := 0x1000 + 219 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^Splitter) (fp))(parent_, flags_, properties_); }
|
||||
NewButton :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties, label_ : string) -> ^Button{ addr := 0x1000 + 220 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties, ^u8, int) -> ^Button) (fp))(parent_, flags_, properties_, raw_data(label_), len(label_)); }
|
||||
NewChoice :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^Choice{ addr := 0x1000 + 221 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^Choice) (fp))(parent_, flags_, properties_); }
|
||||
NewColorWell :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties, colorRGB_ : u32 ) -> ^ColorWell{ addr := 0x1000 + 222 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties, u32 ) -> ^ColorWell) (fp))(parent_, flags_, properties_, colorRGB_); }
|
||||
NewTextDisplay :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties, label_ : string) -> ^TextDisplay{ addr := 0x1000 + 223 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties, ^u8, int) -> ^TextDisplay) (fp))(parent_, flags_, properties_, raw_data(label_), len(label_)); }
|
||||
NewIconDisplay :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties, iconID_ : u32 ) -> ^IconDisplay{ addr := 0x1000 + 224 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties, u32 ) -> ^IconDisplay) (fp))(parent_, flags_, properties_, iconID_); }
|
||||
NewImageDisplay :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^ImageDisplay{ addr := 0x1000 + 225 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^ImageDisplay) (fp))(parent_, flags_, properties_); }
|
||||
NewListView :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties, cItemStyle_ : cstring , cHeaderItemStyle_ : cstring , cFooterItemStyle_ : cstring ) -> ^ListView{ addr := 0x1000 + 226 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties, cstring , cstring , cstring ) -> ^ListView) (fp))(parent_, flags_, properties_, cItemStyle_, cHeaderItemStyle_, cFooterItemStyle_); }
|
||||
NewTextbox :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^Textbox{ addr := 0x1000 + 227 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^Textbox) (fp))(parent_, flags_, properties_); }
|
||||
NewCustomElement :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , properties_ : ElementProperties) -> ^Element{ addr := 0x1000 + 228 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , ElementProperties) -> ^Element) (fp))(parent_, flags_, properties_); }
|
||||
NewWindow :: #force_inline proc "c" (instance_ : ^INSTANCE_TYPE, style_ : WindowStyle) -> ^Window{ addr := 0x1000 + 229 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^INSTANCE_TYPE, WindowStyle) -> ^Window) (fp))(instance_, style_); }
|
||||
NewMenu :: #force_inline proc "c" (source_ : ^Element, flags_ : u64 , userCallback_ : MenuCallbackFunction, _context_ : Generic, fixedWidth_ : i32, fixedHeight_ : i32) -> ^Menu{ addr := 0x1000 + 230 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 , MenuCallbackFunction, Generic, i32, i32) -> ^Menu) (fp))(source_, flags_, userCallback_, _context_, fixedWidth_, fixedHeight_); }
|
||||
NewMenuItem :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , label_ : string, callback_ : MenuCallbackFunction, _context_ : Generic){ addr := 0x1000 + 231 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, u64 , ^u8, int, MenuCallbackFunction, Generic)) (fp))(parent_, flags_, raw_data(label_), len(label_), callback_, _context_); }
|
||||
NewMenuCommand :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 , label_ : string, command_ : ^Command){ addr := 0x1000 + 232 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, u64 , ^u8, int, ^Command)) (fp))(parent_, flags_, raw_data(label_), len(label_), command_); }
|
||||
NewMenuColumn :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 ) -> ^Element{ addr := 0x1000 + 233 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 ) -> ^Element) (fp))(parent_, flags_); }
|
||||
NewMenuSeparator :: #force_inline proc "c" (parent_ : ^Element){ addr := 0x1000 + 234 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element)) (fp))(parent_); }
|
||||
NewSpacer :: #force_inline proc "c" (parent_ : ^Element, flags_ : u64 ) -> ^Element{ addr := 0x1000 + 235 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element, u64 ) -> ^Element) (fp))(parent_, flags_); }
|
||||
NewElementGroup :: #force_inline proc "c" (instance_ : ^INSTANCE_TYPE) -> ^ElementGroup{ addr := 0x1000 + 236 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^INSTANCE_TYPE) -> ^ElementGroup) (fp))(instance_); }
|
||||
NewTextPlan :: #force_inline proc "c" (properties_ : ^TextDisplayProperties, bounds_ : Rectangle, string_ : ^i8 , textRuns_ : ^TextRun, textRunCount_ : int , singleUse_ : bool) -> ^TextPlan{ addr := 0x1000 + 237 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^TextDisplayProperties, Rectangle, ^i8 , ^TextRun, int , bool) -> ^TextPlan) (fp))(properties_, bounds_, string_, textRuns_, textRunCount_, singleUse_); }
|
||||
NewStore :: #force_inline proc "c" (instance_ : ^INSTANCE_TYPE, pullCallback_ : StorePullCallbackFunction, pullCallbackContext_ : Generic) -> ^Store{ addr := 0x1000 + 238 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^INSTANCE_TYPE, StorePullCallbackFunction, Generic) -> ^Store) (fp))(instance_, pullCallback_, pullCallbackContext_); }
|
||||
ElementDraw :: #force_inline proc "c" (element_ : ^Element, painter_ : ^Painter){ addr := 0x1000 + 239 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, ^Painter)) (fp))(element_, painter_); }
|
||||
ElementGetInstance :: #force_inline proc "c" (element_ : ^Element) -> ^INSTANCE_TYPE{ addr := 0x1000 + 240 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> ^INSTANCE_TYPE) (fp))(element_); }
|
||||
ElementGetWindow :: #force_inline proc "c" (element_ : ^Element) -> ^Window{ addr := 0x1000 + 241 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> ^Window) (fp))(element_); }
|
||||
ElementFocus :: #force_inline proc "c" (element_ : ^Element, ensureVisible_ : bool){ addr := 0x1000 + 242 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, bool)) (fp))(element_, ensureVisible_); }
|
||||
ElementSetDisabled :: #force_inline proc "c" (element_ : ^Element, disabled_ : bool){ addr := 0x1000 + 243 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, bool)) (fp))(element_, disabled_); }
|
||||
ElementSetHidden :: #force_inline proc "c" (element_ : ^Element, hidden_ : bool){ addr := 0x1000 + 244 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, bool)) (fp))(element_, hidden_); }
|
||||
ElementSetCallback :: #force_inline proc "c" (element_ : ^Element, callback_ : UICallbackFunction){ addr := 0x1000 + 245 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, UICallbackFunction)) (fp))(element_, callback_); }
|
||||
ElementGetSize :: #force_inline proc "c" (element_ : ^Element, width_ : ^i32, height_ : ^i32){ addr := 0x1000 + 246 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, ^i32, ^i32)) (fp))(element_, width_, height_); }
|
||||
ElementRepaint :: #force_inline proc "c" (element_ : ^Element, all_ : bool, region_ : Rectangle){ addr := 0x1000 + 247 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, bool, Rectangle)) (fp))(element_, all_, region_); }
|
||||
ElementSetData :: #force_inline proc "c" (element_ : ^Element, data_ : Generic){ addr := 0x1000 + 248 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, Generic)) (fp))(element_, data_); }
|
||||
ElementGetData :: #force_inline proc "c" (element_ : ^Element) -> Generic{ addr := 0x1000 + 249 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> Generic) (fp))(element_); }
|
||||
ElementSetCellRange :: #force_inline proc "c" (element_ : ^Element, xFrom_ : i32, yFrom_ : i32, xTo_ : i32, yTo_ : i32){ addr := 0x1000 + 250 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, i32, i32, i32, i32)) (fp))(element_, xFrom_, yFrom_, xTo_, yTo_); }
|
||||
ElementAddGroup :: #force_inline proc "c" (element_ : ^Element, group_ : ^ElementGroup){ addr := 0x1000 + 251 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, ^ElementGroup)) (fp))(element_, group_); }
|
||||
ElementGetInsets :: #force_inline proc "c" (element_ : ^Element) -> Rectangle{ addr := 0x1000 + 252 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> Rectangle) (fp))(element_); }
|
||||
ElementGetInsetSize :: #force_inline proc "c" (element_ : ^Element) -> Rectangle{ addr := 0x1000 + 253 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> Rectangle) (fp))(element_); }
|
||||
ElementGetPreferredSize :: #force_inline proc "c" (element_ : ^Element) -> Rectangle{ addr := 0x1000 + 254 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> Rectangle) (fp))(element_); }
|
||||
ElementMove :: #force_inline proc "c" (element_ : ^Element, x_ : i32, y_ : i32, width_ : i32, height_ : i32){ addr := 0x1000 + 255 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element, i32, i32, i32, i32)) (fp))(element_, x_, y_, width_, height_); }
|
||||
ElementGetLayoutParent :: #force_inline proc "c" (element_ : ^Element) -> ^Element{ addr := 0x1000 + 256 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> ^Element) (fp))(element_); }
|
||||
ElementDestroy :: #force_inline proc "c" (element_ : ^Element){ addr := 0x1000 + 257 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element)) (fp))(element_); }
|
||||
ElementDestroyContents :: #force_inline proc "c" (element_ : ^Element){ addr := 0x1000 + 258 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Element)) (fp))(element_); }
|
||||
ElementStartAnimating :: #force_inline proc "c" (element_ : ^Element) -> bool{ addr := 0x1000 + 259 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Element) -> bool) (fp))(element_); }
|
||||
ElementGroupSetCallback :: #force_inline proc "c" (group_ : ^ElementGroup, callback_ : UICallbackFunction){ addr := 0x1000 + 260 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ElementGroup, UICallbackFunction)) (fp))(group_, callback_); }
|
||||
ElementGroupSetDisabled :: #force_inline proc "c" (group_ : ^ElementGroup, disabled_ : bool){ addr := 0x1000 + 261 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ElementGroup, bool)) (fp))(group_, disabled_); }
|
||||
ElementGroupSetHidden :: #force_inline proc "c" (group_ : ^ElementGroup, hidden_ : bool){ addr := 0x1000 + 262 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ElementGroup, bool)) (fp))(group_, hidden_); }
|
||||
ElementGroupRepaintAll :: #force_inline proc "c" (group_ : ^ElementGroup){ addr := 0x1000 + 263 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ElementGroup)) (fp))(group_); }
|
||||
WindowGetBounds :: #force_inline proc "c" (window_ : ^Window) -> Rectangle{ addr := 0x1000 + 264 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Window) -> Rectangle) (fp))(window_); }
|
||||
WindowGetToolbar :: #force_inline proc "c" (window_ : ^Window) -> ^Element{ addr := 0x1000 + 265 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Window) -> ^Element) (fp))(window_); }
|
||||
WindowSetIcon :: #force_inline proc "c" (window_ : ^Window, iconID_ : u32 ){ addr := 0x1000 + 266 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Window, u32 )) (fp))(window_, iconID_); }
|
||||
WindowSetTitle :: #force_inline proc "c" (window_ : ^Window, title_ : string){ addr := 0x1000 + 267 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Window, ^u8, int)) (fp))(window_, raw_data(title_), len(title_)); }
|
||||
MenuGetSource :: #force_inline proc "c" (menu_ : ^Menu) -> ^Element{ addr := 0x1000 + 268 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Menu) -> ^Element) (fp))(menu_); }
|
||||
ButtonSetIcon :: #force_inline proc "c" (button_ : ^Button, iconID_ : u32 ){ addr := 0x1000 + 269 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Button, u32 )) (fp))(button_, iconID_); }
|
||||
ButtonSetCheck :: #force_inline proc "c" (button_ : ^Button, checkState_ : CheckState, sendUpdatedMessage_ : bool){ addr := 0x1000 + 270 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Button, CheckState, bool)) (fp))(button_, checkState_, sendUpdatedMessage_); }
|
||||
ButtonGetCheck :: #force_inline proc "c" (button_ : ^Button) -> CheckState{ addr := 0x1000 + 271 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Button) -> CheckState) (fp))(button_); }
|
||||
ButtonOnCommand :: #force_inline proc "c" (button_ : ^Button, callback_ : CommandCallbackFunction, command_ : ^Command){ addr := 0x1000 + 272 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Button, CommandCallbackFunction, ^Command)) (fp))(button_, callback_, command_); }
|
||||
ButtonSetCheckBuddy :: #force_inline proc "c" (button_ : ^Button, checkBuddy_ : ^Element){ addr := 0x1000 + 273 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Button, ^Element)) (fp))(button_, checkBuddy_); }
|
||||
ButtonGetCheckBuddy :: #force_inline proc "c" (button_ : ^Button) -> ^Element{ addr := 0x1000 + 274 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Button) -> ^Element) (fp))(button_); }
|
||||
ButtonBindLabel :: #force_inline proc "c" (button_ : ^Button, cRule_ : ^i8 ){ addr := 0x1000 + 275 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Button, ^i8 )) (fp))(button_, cRule_); }
|
||||
TextboxFind :: #force_inline proc "c" (textbox_ : ^Textbox, string_ : string, line_ : ^i32 , byte_ : ^i32 , flags_ : u32 ) -> bool{ addr := 0x1000 + 276 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Textbox, ^u8, int, ^i32 , ^i32 , u32 ) -> bool) (fp))(textbox_, raw_data(string_), len(string_), line_, byte_, flags_); }
|
||||
TextboxInsert :: #force_inline proc "c" (textbox_ : ^Textbox, string_ : string, sendUpdatedMessage_ : bool){ addr := 0x1000 + 277 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, ^u8, int, bool)) (fp))(textbox_, raw_data(string_), len(string_), sendUpdatedMessage_); }
|
||||
TextboxGetContents :: #force_inline proc "c" (textbox_ : ^Textbox, bytes_ : ^int ) -> ^i8 { addr := 0x1000 + 278 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Textbox, ^int ) -> ^i8 ) (fp))(textbox_, bytes_); }
|
||||
TextboxGetLineLength :: #force_inline proc "c" (textbox_ : ^Textbox, line_ : uint ) -> int { addr := 0x1000 + 279 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Textbox, uint ) -> int ) (fp))(textbox_, line_); }
|
||||
TextboxGetSelection :: #force_inline proc "c" (textbox_ : ^Textbox, fromLine_ : ^i32 , fromByte_ : ^i32 , toLine_ : ^i32 , toByte_ : ^i32 ){ addr := 0x1000 + 280 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, ^i32 , ^i32 , ^i32 , ^i32 )) (fp))(textbox_, fromLine_, fromByte_, toLine_, toByte_); }
|
||||
TextboxMoveCaret :: #force_inline proc "c" (textbox_ : ^Textbox, line_ : i32 , byte_ : i32 ){ addr := 0x1000 + 281 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, i32 , i32 )) (fp))(textbox_, line_, byte_); }
|
||||
TextboxSetSelection :: #force_inline proc "c" (textbox_ : ^Textbox, fromLine_ : i32 , fromByte_ : i32 , toLine_ : i32 , toByte_ : i32 ){ addr := 0x1000 + 282 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, i32 , i32 , i32 , i32 )) (fp))(textbox_, fromLine_, fromByte_, toLine_, toByte_); }
|
||||
TextboxSelectAll :: #force_inline proc "c" (textbox_ : ^Textbox){ addr := 0x1000 + 283 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox)) (fp))(textbox_); }
|
||||
TextboxClear :: #force_inline proc "c" (textbox_ : ^Textbox, sendUpdatedMessage_ : bool){ addr := 0x1000 + 284 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, bool)) (fp))(textbox_, sendUpdatedMessage_); }
|
||||
TextboxUseNumberOverlay :: #force_inline proc "c" (textbox_ : ^Textbox, defaultBehaviour_ : bool){ addr := 0x1000 + 285 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox, bool)) (fp))(textbox_, defaultBehaviour_); }
|
||||
TextboxUseBreadcrumbOverlay :: #force_inline proc "c" (textbox_ : ^Textbox){ addr := 0x1000 + 286 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Textbox)) (fp))(textbox_); }
|
||||
PanelSetBands :: #force_inline proc "c" (panel_ : ^Panel, columnCount_ : int , rowCount_ : int , columns_ : ^PanelBand, rows_ : ^PanelBand){ addr := 0x1000 + 287 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Panel, int , int , ^PanelBand, ^PanelBand)) (fp))(panel_, columnCount_, rowCount_, columns_, rows_); }
|
||||
PanelSwitchTo :: #force_inline proc "c" (panel_ : ^Panel, targetChild_ : ^Element, transitionType_ : TransitionType){ addr := 0x1000 + 288 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Panel, ^Element, TransitionType)) (fp))(panel_, targetChild_, transitionType_); }
|
||||
TextPlanGetWidth :: #force_inline proc "c" (plan_ : ^TextPlan) -> i32{ addr := 0x1000 + 289 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^TextPlan) -> i32) (fp))(plan_); }
|
||||
TextPlanGetHeight :: #force_inline proc "c" (plan_ : ^TextPlan) -> i32{ addr := 0x1000 + 290 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^TextPlan) -> i32) (fp))(plan_); }
|
||||
TextPlanGetLineCount :: #force_inline proc "c" (plan_ : ^TextPlan) -> int { addr := 0x1000 + 291 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^TextPlan) -> int ) (fp))(plan_); }
|
||||
TextPlanDestroy :: #force_inline proc "c" (plan_ : ^TextPlan){ addr := 0x1000 + 292 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^TextPlan)) (fp))(plan_); }
|
||||
TextDisplaySetContents :: #force_inline proc "c" (display_ : ^TextDisplay, contents_ : string){ addr := 0x1000 + 293 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^TextDisplay, ^u8, int)) (fp))(display_, raw_data(contents_), len(contents_)); }
|
||||
TextDisplayBindContents :: #force_inline proc "c" (display_ : ^TextDisplay, cRule_ : ^i8 , store_ : ^Store, id_ : Generic, values_ : ^i32, valueCount_ : int ){ addr := 0x1000 + 294 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^TextDisplay, ^i8 , ^Store, Generic, ^i32, int )) (fp))(display_, cRule_, store_, id_, values_, valueCount_); }
|
||||
TextDisplayUnbindContents :: #force_inline proc "c" (display_ : ^TextDisplay){ addr := 0x1000 + 295 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^TextDisplay)) (fp))(display_); }
|
||||
StoreDestroy :: #force_inline proc "c" (store_ : ^Store){ addr := 0x1000 + 296 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store)) (fp))(store_); }
|
||||
StoreObserve :: #force_inline proc "c" (store_ : ^Store, id_ : Generic, tag_ : i32, callback_ : StoreCallbackFunction, _context_ : Generic, callNow_ : bool){ addr := 0x1000 + 297 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store, Generic, i32, StoreCallbackFunction, Generic, bool)) (fp))(store_, id_, tag_, callback_, _context_, callNow_); }
|
||||
StoreUnobserve :: #force_inline proc "c" (store_ : ^Store, id_ : Generic, callback_ : StoreCallbackFunction, _context_ : Generic){ addr := 0x1000 + 298 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store, Generic, StoreCallbackFunction, Generic)) (fp))(store_, id_, callback_, _context_); }
|
||||
StoreNotify :: #force_inline proc "c" (store_ : ^Store, id_ : Generic, tag_ : i32){ addr := 0x1000 + 299 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store, Generic, i32)) (fp))(store_, id_, tag_); }
|
||||
StoreSet :: #force_inline proc "c" (store_ : ^Store, id_ : Generic, tag_ : i32, value_ : FormatValue){ addr := 0x1000 + 300 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store, Generic, i32, FormatValue)) (fp))(store_, id_, tag_, value_); }
|
||||
StoreGet :: #force_inline proc "c" (store_ : ^Store, id_ : Generic, tag_ : i32, defaultValue_ : FormatValue) -> FormatValue{ addr := 0x1000 + 301 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Store, Generic, i32, FormatValue) -> FormatValue) (fp))(store_, id_, tag_, defaultValue_); }
|
||||
StoreDispatchNotifications :: #force_inline proc "c" (store_ : ^Store){ addr := 0x1000 + 302 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Store)) (fp))(store_); }
|
||||
ColorWellGetRGB :: #force_inline proc "c" (well_ : ^ColorWell) -> u32 { addr := 0x1000 + 303 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^ColorWell) -> u32 ) (fp))(well_); }
|
||||
ColorWellSetRGB :: #force_inline proc "c" (well_ : ^ColorWell, colorRGB_ : u32 , sendChangedMessage_ : bool){ addr := 0x1000 + 304 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ColorWell, u32 , bool)) (fp))(well_, colorRGB_, sendChangedMessage_); }
|
||||
ColorWellSetIndeterminate :: #force_inline proc "c" (well_ : ^ColorWell){ addr := 0x1000 + 305 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ColorWell)) (fp))(well_); }
|
||||
ChoiceAddMenuItem :: #force_inline proc "c" (choice_ : ^Choice, item_ : Generic){ addr := 0x1000 + 306 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Choice, Generic)) (fp))(choice_, item_); }
|
||||
ChoiceSetItem :: #force_inline proc "c" (choice_ : ^Choice, item_ : Generic, sendUpdatedMessage_ : bool){ addr := 0x1000 + 307 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^Choice, Generic, bool)) (fp))(choice_, item_, sendUpdatedMessage_); }
|
||||
ChoiceGetItem :: #force_inline proc "c" (choice_ : ^Choice) -> Generic{ addr := 0x1000 + 308 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^Choice) -> Generic) (fp))(choice_); }
|
||||
ListViewInsertGroup :: #force_inline proc "c" (view_ : ^ListView, group_ : i32 , flags_ : u32 ){ addr := 0x1000 + 309 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, i32 , u32 )) (fp))(view_, group_, flags_); }
|
||||
ListViewInsert :: #force_inline proc "c" (view_ : ^ListView, group_ : i32 , firstIndex_ : Generic, lastIndex_ : Generic, count_ : i64 ){ addr := 0x1000 + 310 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, i32 , Generic, Generic, i64 )) (fp))(view_, group_, firstIndex_, lastIndex_, count_); }
|
||||
ListViewRemove :: #force_inline proc "c" (view_ : ^ListView, group_ : i32 , firstIndex_ : Generic, lastIndex_ : Generic, count_ : i64 ){ addr := 0x1000 + 311 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, i32 , Generic, Generic, i64 )) (fp))(view_, group_, firstIndex_, lastIndex_, count_); }
|
||||
ListViewRemoveAll :: #force_inline proc "c" (view_ : ^ListView, group_ : i32 ){ addr := 0x1000 + 312 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, i32 )) (fp))(view_, group_); }
|
||||
ListViewGetIndex :: #force_inline proc "c" (view_ : ^ListView, item_ : ^Element) -> Generic{ addr := 0x1000 + 313 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); return ((proc "c" ( ^ListView, ^Element) -> Generic) (fp))(view_, item_); }
|
||||
ListViewSetColumns :: #force_inline proc "c" (view_ : ^ListView, columns_ : ^ListViewColumn, columnCount_ : int ){ addr := 0x1000 + 314 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, ^ListViewColumn, int )) (fp))(view_, columns_, columnCount_); }
|
||||
ListViewSelect :: #force_inline proc "c" (view_ : ^ListView, group_ : i32 , index_ : Generic){ addr := 0x1000 + 315 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView, i32 , Generic)) (fp))(view_, group_, index_); }
|
||||
ListViewResetSearchBuffer :: #force_inline proc "c" (view_ : ^ListView){ addr := 0x1000 + 316 * size_of(int); fp := (rawptr(((^uintptr)(uintptr(addr)))^)); ((proc "c" ( ^ListView)) (fp))(view_); }
|
||||
|
||||
Reference in New Issue
Block a user