Subversion Repositories Kolibri OS

#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

#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