WebSVN – Kolibri OS – Diff – /programs/develop/ktcc/trunk/libc/include/kos32sys1.h

 #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
 //#include
 #include
 #include
 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
-// May be next section need to be added in newlibc
+#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){
-    struct file_op_t
+    file_op_t file_op;
-    {
-        uint32_t    fn;
-        uint32_t    flags;
-        char*       args;
-        uint32_t    res1, res2;
-        char        zero;
-        char*       app_name  __attribute__((packed));
-    } 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
+//////////// 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
--
 enum>
--
 enum>

Subversion Repositories Kolibri OS

(root)/programs/develop/ktcc/trunk/libc/include/kos32sys1.h – Rev 6441 → 7172