kolibrios/data/common/develop/tcc/include/kos32sys1beta.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 <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