0,0 → 1,994 |
#ifndef __KOS_32_SYS_H__ |
#define __KOS_32_SYS_H__ |
|
// file header taken from newlib |
// added many sys functions, compatible with tcc |
// with gcc USE gcc -mno-ms-bitfields!!! |
|
|
//#include <newlib.h> |
//#include <stdint.h> |
#include <stddef.h> |
#include <stdarg.h> |
typedef unsigned int uint32_t; |
typedef int int32_t; |
typedef unsigned char uint8_t; |
typedef unsigned short int uint16_t; |
typedef unsigned long long uint64_t; |
|
#ifdef __cplusplus |
extern "C" { |
#endif |
|
//#ifdef CONFIG_DEBUF |
// #define DBG(format,...) printf(format,##__VA_ARGS__) |
//#else |
// #define DBG(format,...) |
//#endif |
|
#define TYPE_3_BORDER_WIDTH 5 |
#define WIN_STATE_MINIMIZED 0x02 |
#define WIN_STATE_ROLLED 0x04 |
#define POS_SCREEN 0 |
#define POS_WINDOW 1 |
|
#define IPC_NOBUFFER 1 |
#define IPC_LOCKED 2 |
#define IPC_OVERFLOW 3 |
#define IPC_NOPID 4 |
|
#define SHM_OPEN 0x00 |
#define SHM_OPEN_ALWAYS 0x04 |
#define SHM_CREATE 0x08 |
#define SHM_READ 0x00 |
#define SHM_WRITE 0x01 |
|
|
typedef unsigned int color_t; |
|
|
typedef union __attribute__((packed)) pos_t |
{ |
uint32_t val; |
struct |
{ |
short x; |
short y; |
}; |
} pos_t; |
|
|
typedef union __attribute__((packed)) oskey_t |
{ |
uint32_t val; |
struct |
{ |
uint8_t state; |
uint8_t code; |
uint16_t ctrl_key; |
}; |
} oskey_t; |
|
typedef struct |
{ |
unsigned handle; |
unsigned io_code; |
void *input; |
int inp_size; |
void *output; |
int out_size; |
}ioctl_t; |
|
typedef union |
{ |
struct |
{ |
void *data; |
size_t size; |
} x; |
unsigned long long raw; |
}ufile_t; |
|
struct kolibri_system_colors { |
color_t frame_area; |
color_t grab_bar; |
color_t grab_bar_button; |
color_t grab_button_text; |
color_t grab_text; |
color_t work_area; |
color_t work_button; |
color_t work_button_text; |
color_t work_text; |
color_t work_graph; |
}; |
|
|
struct blit_call |
{ |
int dstx; |
int dsty; |
int w; |
int h; |
|
int srcx; |
int srcy; |
int srcw; |
int srch; |
|
void *bitmap; |
int stride; |
}; |
|
struct ipc_message |
{ |
uint32_t pid; // PID of sending thread |
uint32_t datalen; // data bytes |
char data[0]; // data begin |
}; |
|
struct ipc_buffer |
{ |
uint32_t lock; // nonzero is locked |
uint32_t used; // used bytes in buffer |
struct ipc_message data[0]; // data begin |
}; |
|
|
typedef struct __attribute__((packed)) file_op_t |
{ |
uint32_t fn; |
uint32_t flags; |
char* args; |
uint32_t res1, res2; |
char zero; |
char* app_name |
#ifdef __TINYC__ |
__attribute__((packed)) |
#endif |
; |
} file_op_t; |
|
|
static inline void begin_draw(void) |
{ |
__asm__ __volatile__( |
"int $0x40" ::"a"(12),"b"(1)); |
}; |
|
static inline |
void end_draw(void) |
{ |
__asm__ __volatile__( |
"int $0x40" ::"a"(12),"b"(2)); |
}; |
|
static inline |
void sys_create_window(int x, int y, int w, int h, const char *name, |
color_t workcolor, uint32_t style) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(0), |
"b"((x << 16) | ((w-1) & 0xFFFF)), |
"c"((y << 16) | ((h-1) & 0xFFFF)), |
"d"((style << 24) | (workcolor & 0xFFFFFF)), |
"D"(name), |
"S"(0) : "memory"); |
}; |
|
static inline |
void define_button(uint32_t x_w, uint32_t y_h, uint32_t id, uint32_t color) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(8), |
"b"(x_w), |
"c"(y_h), |
"d"(id), |
"S"(color)); |
}; |
|
static inline |
void draw_line(int xs, int ys, int xe, int ye, color_t color) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(38), "d"(color), |
"b"((xs << 16) | xe), |
"c"((ys << 16) | ye)); |
} |
|
static inline |
void draw_bar(int x, int y, int w, int h, color_t color) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(13), "d"(color), |
"b"((x << 16) | w), |
"c"((y << 16) | h)); |
} |
|
static inline |
void draw_bitmap(void *bitmap, int x, int y, int w, int h) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(7), "b"(bitmap), |
"c"((w << 16) | h), |
"d"((x << 16) | y)); |
} |
|
static inline |
void draw_text_sys(const char *text, int x, int y, int len, color_t color) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(4),"d"(text), |
"b"((x << 16) | y), |
"S"(len),"c"(color) |
:"memory"); |
} |
|
static inline |
uint32_t get_skin_height(void) |
{ |
uint32_t height; |
|
__asm__ __volatile__( |
"int $0x40 \n\t" |
:"=a"(height) |
:"a"(48),"b"(4)); |
return height; |
}; |
|
static inline |
pos_t get_mouse_pos(int origin) |
{ |
pos_t val; |
|
__asm__ __volatile__( |
"int $0x40 \n\t" |
"rol $16, %%eax" |
:"=a"(val) |
:"a"(37),"b"(origin)); |
return val; |
} |
|
static inline |
uint32_t get_mouse_buttons(void) |
{ |
uint32_t val; |
|
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(37),"b"(2)); |
return val; |
}; |
|
static inline |
uint32_t get_mouse_wheels(void) |
{ |
uint32_t val; |
|
__asm__ __volatile__( |
"int $0x40 \n\t" |
:"=a"(val) |
:"a"(37),"b"(7)); |
return val; |
}; |
|
static inline uint32_t load_cursor(void *path, uint32_t flags) |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(37), "b"(4), "c"(path), "d"(flags)); |
return val; |
} |
|
static inline uint32_t set_cursor(uint32_t cursor) |
{ |
uint32_t old; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(old) |
:"a"(37), "b"(5), "c"(cursor)); |
return old; |
}; |
|
static inline int destroy_cursor(uint32_t cursor) |
{ |
int ret; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(ret) |
:"a"(37), "b"(6), "c"(cursor) |
:"memory"); |
return ret; |
}; |
|
|
static inline |
uint32_t wait_for_event(uint32_t time) |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(23), "b"(time)); |
return val; |
}; |
|
static inline uint32_t check_os_event() |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(11)); |
return val; |
}; |
|
static inline uint32_t get_os_event() |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(10)); |
return val; |
}; |
|
static inline |
uint32_t get_tick_count(void) |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(26),"b"(9)); |
return val; |
}; |
|
static inline |
uint64_t get_ns_count(void) |
{ |
uint64_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=A"(val) |
:"a"(26), "b"(10)); |
return val; |
}; |
|
static inline |
oskey_t get_key(void) |
{ |
oskey_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(2)); |
return val; |
} |
|
static inline |
uint32_t get_os_button() |
{ |
uint32_t val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(17)); |
return val>>8; |
}; |
|
static inline uint32_t get_service(char *name) |
{ |
uint32_t retval = 0; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(retval) |
:"a"(68),"b"(16),"c"(name) |
:"memory"); |
|
return retval; |
}; |
|
static inline int call_service(ioctl_t *io) |
{ |
int retval; |
|
__asm__ __volatile__( |
"int $0x40" |
:"=a"(retval) |
:"a"(68),"b"(17),"c"(io) |
:"memory","cc"); |
|
return retval; |
}; |
|
|
static inline void yield(void) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(68), "b"(1)); |
}; |
|
static inline void delay(uint32_t time) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(5), "b"(time) |
:"memory"); |
}; |
|
static inline |
void *user_alloc(size_t size) |
{ |
void *val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(68),"b"(12),"c"(size)); |
return val; |
} |
|
static inline |
int user_free(void *mem) |
{ |
int val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(68),"b"(13),"c"(mem)); |
return val; |
} |
|
static inline |
void* user_realloc(void *mem, size_t size) |
{ |
void *val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(68),"b"(20),"c"(size),"d"(mem) |
:"memory"); |
|
return val; |
}; |
|
static inline |
int *user_unmap(void *base, size_t offset, size_t size) |
{ |
int *val; |
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(68),"b"(26),"c"(base),"d"(offset),"S"(size)); |
return val; |
}; |
|
static inline ufile_t load_file(const char *path) |
{ |
ufile_t uf; |
|
__asm__ __volatile__ ( |
"int $0x40" |
:"=A"(uf.raw) |
:"a" (68), "b"(27),"c"(path)); |
|
return uf; |
}; |
|
static inline int GetScreenSize() |
{ |
int retval; |
|
__asm__ __volatile__( |
"int $0x40" |
:"=a"(retval) |
:"a"(61), "b"(1)); |
return retval; |
} |
|
|
static inline void get_proc_info(char *info) |
{ |
__asm__ __volatile__( |
"int $0x40" |
: |
:"a"(9), "b"(info), "c"(-1) |
:"memory"); |
}; |
|
static inline void Blit(void *bitmap, int dst_x, int dst_y, |
int src_x, int src_y, int w, int h, |
int src_w, int src_h, int stride) |
{ |
volatile struct blit_call bc; |
|
bc.dstx = dst_x; |
bc.dsty = dst_y; |
bc.w = w; |
bc.h = h; |
bc.srcx = src_x; |
bc.srcy = src_y; |
bc.srcw = src_w; |
bc.srch = src_h; |
bc.stride = stride; |
bc.bitmap = bitmap; |
|
__asm__ __volatile__( |
"int $0x40" |
::"a"(73),"b"(0),"c"(&bc.dstx)); |
}; |
|
|
// newlib exclusive |
#ifndef __TINYC__ |
int create_thread(int (*proc)(void *param), void *param, int stack_size); |
|
void* load_library(const char *name); |
|
void* get_proc_address(void *handle, const char *proc_name); |
|
void enumerate_libraries(int (*callback)(void *handle, const char* name, |
uint32_t base, uint32_t size, void *user_data), |
void *user_data); |
#endif |
|
/////////////////////////////////////////////////////////////////////////////// |
/// May be next section need to be added in newlibc |
// Siemargl addenium |
|
#define X_Y(x,y) (((x)<<16)|(y)) |
|
enum KOLIBRI_GUI_EVENTS { |
KOLIBRI_EVENT_NONE = 0, /* Event queue is empty */ |
KOLIBRI_EVENT_REDRAW = 1, /* Window and window elements should be redrawn */ |
KOLIBRI_EVENT_KEY = 2, /* A key on the keyboard was pressed */ |
KOLIBRI_EVENT_BUTTON = 3, /* A button was clicked with the mouse */ |
KOLIBRI_EVENT_DESKTOP = 5, /* Desktop redraw finished */ |
KOLIBRI_EVENT_MOUSE = 6, /* Mouse activity (movement, button press) was detected */ |
KOLIBRI_EVENT_IPC = 7, /* Interprocess communication notify */ |
KOLIBRI_EVENT_NETWORK = 8, /* Network event */ |
KOLIBRI_EVENT_DEBUG = 9, /* Debug subsystem event */ |
KOLIBRI_EVENT_IRQBEGIN = 16 /* 16..31 IRQ0..IRQ15 interrupt =IRQBEGIN+IRQn */ |
}; |
|
enum control_keys { |
KM_SHIFT = 0x00010000, |
KM_CTRL = 0x00020000, |
KM_ALT = 0x00040000, |
KM_NUMLOCK = 0x00080000 |
}; |
|
|
struct __attribute__ ((__packed__)) fs_dirinfo { |
uint32_t subfn; // 1 read dir |
uint32_t start; |
uint32_t flags; |
uint32_t size; |
uint32_t retval; |
union { |
struct __attribute__ ((__packed__)) { |
uint8_t zero; // 0 |
char* ppath; |
}; |
char path[5]; // up to 4096 |
} ; |
}; |
|
static inline |
uint32_t sf_file(int subfn, struct fs_dirinfo* dinfo) |
/// SysFn70 call with subfunction |
/// retval 0 if ok |
{ |
uint32_t retval; |
dinfo->subfn = subfn; |
|
__asm__ __volatile__( |
"int $0x40 " |
:"=a"(retval) |
:"a"(70),"b"(dinfo) |
:); |
|
return retval; |
}; |
|
|
struct fs_dirheader { |
uint32_t version; // 1 |
uint32_t curn_blocks; // number of read dir items (BDFE) |
uint32_t totl_blocks; // directory full size |
char other[20]; // reserved 0 |
}; |
|
enum filetype |
{ |
FS_RONLY = 1, |
FS_HIDDEN = 2, |
FS_SYSTEM = 4, |
FS_VOLID = 8, |
FS_SUBDIR = 16, |
FS_FOLDER = 16, |
FS_ARCHIV = 32 |
}; |
|
struct __attribute__ ((__packed__)) fs_filetime { |
uint8_t sec; |
uint8_t mm; |
uint8_t hour; |
uint8_t zero; |
}; |
|
struct __attribute__ ((__packed__)) fs_filedate { |
uint8_t day; |
uint8_t month; |
uint16_t year; |
}; |
|
/// directory entry cp866 |
struct fsBDFE { |
uint32_t filetype; |
uint32_t encoding; // 0 - cp866, 1 - utf16le |
struct fs_filetime tm_created; |
struct fs_filedate dt_created; |
struct fs_filetime tm_accessed; |
struct fs_filedate dt_accessed; |
struct fs_filetime tm_modified; |
struct fs_filedate dt_modified; |
uint64_t size; |
char fname[264]; |
}; // must be sized 304 |
|
/// directory entry UTF16LE |
struct fsBDFE_16 { |
uint32_t filetype; |
uint32_t encoding; // 0 - cp866, 1 - utf16le |
struct fs_filetime tm_created; |
struct fs_filedate dt_created; |
struct fs_filetime tm_accessed; |
struct fs_filedate dt_accessed; |
struct fs_filetime tm_modified; |
struct fs_filedate dt_modified; |
uint64_t size; |
wchar_t fname[260]; |
}; // must be sized 560 |
|
|
|
// copied from /programs/system/shell/system/kolibri.c |
// fn's returned -1 as syserror, 1 as error, 0 as OK |
static inline |
int kol_clip_num() |
{ |
register uint32_t val; |
asm volatile ("int $0x40":"=a"(val):"a"(54), "b"(0)); |
return val; |
} |
|
static inline |
char* kol_clip_get(int n) |
// returned buffer must be freed by user_free() |
{ |
register char* val; |
asm volatile ("int $0x40":"=a"(val):"a"(54), "b"(1), "c"(n)); |
return val; |
} |
|
static inline |
int kol_clip_set(int n, char buffer[]) |
{ |
register uint32_t val; |
asm volatile ("int $0x40":"=a"(val):"a"(54), "b"(2), "c"(n), "d"(buffer)); |
return val; |
} |
|
static inline |
int kol_clip_pop() |
{ |
register uint32_t val; |
asm volatile ("int $0x40":"=a"(val):"a"(54), "b"(3)); |
return val; |
} |
|
static inline |
int kol_clip_unlock() |
{ |
register uint32_t val; |
asm volatile ("int $0x40":"=a"(val):"a"(54), "b"(4)); |
return val; |
} |
|
static inline void get_system_colors(struct kolibri_system_colors *color_table) |
{ |
__asm__ volatile ("int $0x40" |
: |
:"a"(48),"b"(3),"c"(color_table),"d"(40) |
); |
|
/* color_table should point to the system color table */ |
} |
|
static inline void debug_board_write_byte(const char ch){ |
__asm__ __volatile__( |
"int $0x40" |
: |
:"a"(63), "b"(1), "c"(ch)); |
} |
|
|
static inline void draw_number_sys(int32_t number, int x, int y, int len, color_t color){ |
register uint32_t fmt; |
fmt = len << 16 | 0x80000000; // no leading zeros + width |
// fmt = len << 16 | 0x00000000; // leading zeros + width |
__asm__ __volatile__( |
"int $0x40" |
: |
:"a"(47), "b"(fmt), "c"(number), "d"((x << 16) | y), "S"(color)); |
} |
|
static inline |
uint32_t get_mouse_eventstate(void) |
{ |
uint32_t val; |
|
__asm__ __volatile__( |
"int $0x40" |
:"=a"(val) |
:"a"(37),"b"(3)); |
return val; |
}; |
|
static inline |
uint32_t set_event_mask(uint32_t mask) |
{ |
register uint32_t val; |
asm volatile ("int $0x40":"=a"(val):"a"(40), "b"(mask)); |
return val; |
} |
|
typedef void (*thread_proc)(void*); |
|
static inline |
int start_thread(thread_proc proc, char* stack_top) |
{ |
register int val; |
asm volatile ("int $0x40":"=a"(val):"a"(51), "b"(1), "c"(proc), "d"(stack_top)); |
return val; |
} |
|
static inline |
void kos_exit() |
{ |
asm volatile ("int $0x40"::"a"(-1)); |
} |
|
static inline void focus_window(int slot){ |
asm volatile ("int $0x40"::"a"(18), "b"(3), "c"(slot)); |
} |
|
static inline int get_thread_slot(int tid){ |
register int val; |
asm volatile ("int $0x40":"=a"(val):"a"(18), "b"(21), "c"(tid)); |
return val; |
} |
|
static inline void set_current_folder(char* dir){ |
asm volatile ("int $0x40"::"a"(30), "b"(1), "c"(dir)); |
} |
|
static inline int get_current_folder(char* buf, int bufsize){ |
register int val; |
asm volatile ("int $0x40":"=a"(val):"a"(30), "b"(2), "c"(buf), "d"(bufsize)); |
return val; |
} |
|
static inline |
void ipc_set_area(void* buf, int bufsize){ |
asm volatile ("int $0x40"::"a"(60), "b"(1), "c"(buf), "d"(bufsize)); |
} |
|
static inline |
int ipc_send_message(int pid_reciever, void *data, int datalen) { |
register int val; |
asm volatile ("int $0x40":"=a"(val):"a"(60), "b"(2), "c"(pid_reciever), "d"(data), "S"(datalen)); |
return val; |
} |
|
static inline |
void* shm_open(char *shm_name, int msize, int flags, int *retsz){ |
register int val, cod; |
asm volatile ("int $0x40":"=a"(val),"=d"(cod):"a"(68), "b"(22), "c"(shm_name), "d"(msize), "S"(flags)); |
|
if(retsz) *retsz = cod; // errcode if NULL or memsize when open |
return (void*)val; |
} |
|
static inline |
void shm_close(char *shm_name){ |
asm volatile ("int $0x40"::"a"(68), "b"(23), "c"(shm_name)); |
} |
|
static inline |
int start_app(char *app_name, char *args){ |
file_op_t file_op; |
memset(&file_op, 0, sizeof(file_op)); |
file_op.fn = 7; |
file_op.args = args; |
file_op.app_name = app_name; |
|
register int val; |
asm volatile ("int $0x40":"=a"(val):"a"(70), "b"(&file_op)); |
|
return val; |
} |
|
static inline |
uint32_t get_control_keys(void) |
{ |
uint32_t ctrl; |
|
__asm__ __volatile__( |
"int $0x40 \n\t" |
:"=a"(ctrl) |
:"a"(66),"b"(3)); |
|
return ctrl; |
}; |
|
static inline |
int get_keyboard_layout(int opt, char* buf) |
/// 128 byte buffer |
/// opt: 1 - normal, 2 - shifted, 3 - alted, or 9 - return language |
{ |
uint32_t lang; |
|
__asm__ __volatile__( |
"int $0x40 \n\t" |
:"=a"(lang) |
:"a"(26),"b"(2), "c"(opt), "d"(buf)); |
|
return lang; |
}; |
|
|
static inline |
int font_size(int color) |
/// decode font size in pixels from color as SysFn4 |
/// returns (width, hight) |
{ |
int font = color >> 24; |
int font_multipl = (font & 7) + 1; |
int width_sym, hight_sym; |
|
if (font & 0x10) // 8x16 |
{ |
width_sym = 8 * font_multipl; |
hight_sym = 16 * font_multipl; |
} else // 6x9 |
{ |
width_sym = 6 * font_multipl; |
hight_sym = 9 * font_multipl; |
} |
return hight_sym + (width_sym << 16); |
} |
|
/* |
static inline char *getcwd(char *buf, size_t size) |
{ |
int rc = get_current_folder(buf, size); |
if (rc > size) |
{ |
errno = ERANGE; |
return 0; |
} |
else |
return buf; |
} |
*/ |
/* not finished |
void staticnum_draw(staticnum *st) |
{ |
register uint32_t fmt; |
if (st->width < 0) |
fmt = (-st->width << 16); // leading zeros, decimal |
else |
fmt = (st->width << 16) | 0x80000000; // no leading zeros, decimal |
|
__asm__ __volatile__( |
"int $0x40" |
::"a"(47), |
"b"(fmt), |
"c"(st->number), |
"d"(st->start_xy), |
"S"(st->color_flags), |
"D"(st->bg_color) |
:); |
} |
|
*/ |
//////////// end section |
|
|
|
//added nonstatic inline because incomfortabre stepping in in debugger |
void __attribute__ ((noinline)) debug_board_write_str(const char* str); |
void __attribute__ ((noinline)) debug_board_printf(const char *format,...); |
|
/* copy body to only one project file |
void __attribute__ ((noinline)) debug_board_write_str(const char* str){ |
while(*str) |
debug_board_write_byte(*str++); |
} |
|
void __attribute__ ((noinline)) debug_board_printf(const char *format,...) |
{ |
va_list ap; |
char log_board[300]; |
|
va_start (ap, format); |
vsnprintf(log_board, sizeof log_board, format, ap); |
va_end(ap); |
debug_board_write_str(log_board); |
} |
|
__attribute__ ((noinline)) void trap(int n) |
{ |
// nothing todo, just see n in debugger. use "bp trap" command |
__asm__ __volatile__( |
"nop" |
: |
:"a"(n)); |
} |
|
*/ |
|
|
|
// TinyC don't support aliasing of static inline funcs |
#ifndef __TINYC__ |
static inline void BeginDraw(void) __attribute__ ((alias ("begin_draw"))); |
static inline void EndDraw(void) __attribute__ ((alias ("end_draw"))); |
static inline void DrawWindow(int x, int y, int w, int h, const char *name, |
color_t workcolor, uint32_t style) |
__attribute__ ((alias ("sys_create_window"))); |
static inline void DefineButton(void) __attribute__ ((alias ("define_button"))); |
static inline void DrawLine(int xs, int ys, int xe, int ye, color_t color) |
__attribute__ ((alias ("draw_line"))); |
static inline void DrawBar(int x, int y, int w, int h, color_t color) |
__attribute__ ((alias ("draw_bar"))); |
static inline void DrawBitmap(void *bitmap, int x, int y, int w, int h) |
__attribute__ ((alias ("draw_bitmap"))); |
static inline uint32_t GetSkinHeight(void) __attribute__ ((alias ("get_skin_height"))); |
static inline pos_t GetMousePos(int origin) __attribute__ ((alias ("get_mouse_pos"))); |
static inline uint32_t GetMouseButtons(void) __attribute__ ((alias ("get_mouse_buttons"))); |
static inline uint32_t GetMouseWheels(void) __attribute__ ((alias ("get_mouse_wheels"))); |
static inline uint32_t LoadCursor(void *path, uint32_t flags) __attribute__ ((alias ("load_cursor"))); |
static inline uint32_t SetCursor(uint32_t cursor) __attribute__ ((alias ("set_cursor"))); |
static inline int DestroyCursor(uint32_t cursor) __attribute__ ((alias ("destroy_cursor"))); |
static inline uint32_t GetOsEvent(void) __attribute__ ((alias ("get_os_event"))); |
static inline void *UserAlloc(size_t size) __attribute__ ((alias ("user_alloc"))); |
static inline int UserFree(void *mem) __attribute__ ((alias ("user_free"))); |
static inline void* UserRealloc(void *mem, size_t size) __attribute__ ((alias ("user_realloc"))); |
static inline int *UserUnmap(void *base, size_t offset, size_t size) __attribute__ ((alias ("user_unmap"))); |
static inline ufile_t LoadFile(const char *path) __attribute__ ((alias ("load_file"))); |
static inline void GetProcInfo(char *info) __attribute__ ((alias ("get_proc_info"))); |
#endif |
|
#ifdef __cplusplus |
} |
#endif |
|
|
#endif |
|
|
|
|
|