Возможные будущие компиляторы для Колибри

Sat Oct 01, 2011 2:55 am

Mario wrote:Если ты подразумевал mcall который не для ассемблера, то стоит это явно обозначить, иначе фигня какая-то получается - без обид.

Возможно. Для ЯВУ в ассемблерной ОС нужна специальная оговорка, -- как-то не учёл.

Я пытаюсь представить mcall как абстракцию ЯВУ, но завязанную на регистры. Например, Borland fastcall:

Code: Select all

(EAX, EDX, ECX, стек)

Номер функции нигде не передаётся, за неимением оного.

В mcall, как понимаю, стек не используется, потому что все вызовы укладываются в регистры, а где не хватает регистров, структуры передаются через память.

Мне кажется, что для языков высокого уровня нужно разделять прикладные и служебные параметры, -- к последним относится номер функции. Прикладные параметры передаются, начиная с EBX или ECX, если в подфункции. Подразумевается, что компилятор, видя конструкцию вида mcall 9 или mcall 71.1, подставит нужные значения в EAX и EBX. Ну, или это будет сделано программистом в inline-ассемблере, если компилятор никак не доработать.

По-любому, если функция получает имя, оно используется вместо номера, и в параметрах перечисляются только прикладные параметры.

SoUrcerer, ты упоминал, что где-то были kolibri.h и прочий SDK, пусть и старый. Где смотреть-то?

Sat Oct 01, 2011 7:56 am

Последний SDK на официальном сайте, я думаю, что именно он у тебя и есть.
Вот kolibri.h, которым я пользуюсь (не знаю, кто его написал, но так как он используется в Shell, то наверное Albom). Работает с gcc и msvc.

Code: Select all



#define NULL ((void*)0)



typedef struct 

{

unsigned	p00 __attribute__((packed));

unsigned	p04 __attribute__((packed));

unsigned	p08 __attribute__((packed));

unsigned	p12 __attribute__((packed));

unsigned	p16 __attribute__((packed));

char		p20 __attribute__((packed));

char		*p21 __attribute__((packed));

} kol_struct70 __attribute__((packed));





typedef struct

{

unsigned	p00 __attribute__((packed));

char		p04 __attribute__((packed));

char		p05[3] __attribute__((packed));

unsigned	p08 __attribute__((packed));

unsigned	p12 __attribute__((packed));

unsigned	p16 __attribute__((packed));

unsigned	p20 __attribute__((packed));

unsigned	p24 __attribute__((packed));

unsigned	p28 __attribute__((packed));

unsigned	p32[2] __attribute__((packed));

unsigned	p40 __attribute__((packed));

} kol_struct_BDVK __attribute__((packed));



typedef struct

{

char	*name __attribute__((packed));

void	*data __attribute__((packed));

} kol_struct_import __attribute__((packed));





void kol_exit();

void kol_sleep(unsigned d);

void kol_wnd_define(unsigned x, unsigned y, unsigned w, unsigned h, unsigned c);

void kol_wnd_move(unsigned x, unsigned y);

void kol_wnd_caption(char *s);

void kol_event_mask(unsigned e);

unsigned kol_event_wait();

unsigned kol_event_wait_time(unsigned time);

unsigned kol_event_check();

void kol_paint_start();

void kol_paint_end();

void kol_paint_pixel(unsigned x, unsigned y, unsigned c);

void kol_paint_bar(unsigned x, unsigned y, unsigned w, unsigned h, unsigned c);

void kol_paint_line(unsigned x1, unsigned y1, unsigned x2, unsigned y2, unsigned c);

void kol_paint_string(unsigned x, unsigned y, char *s, unsigned c);

void kol_paint_image(unsigned x, unsigned y, unsigned w, unsigned h, char *d);

void kol_paint_image_pal(unsigned x, unsigned y, unsigned w, unsigned h, char *d, unsigned *palette);

unsigned kol_key_get();

unsigned kol_key_control();

void kol_key_lang_set(unsigned lang);

unsigned kol_key_lang_get();

void kol_key_mode_set(unsigned mode);

unsigned kol_key_mode_get();

void kol_btn_define(unsigned x, unsigned y, unsigned w, unsigned h, unsigned d, unsigned c);

unsigned kol_btn_get();

void kol_btn_type(unsigned t);

unsigned kol_mouse_pos();

unsigned kol_mouse_posw();

unsigned kol_mouse_btn();

void kol_board_putc(char c);

void kol_board_puts(char *s);

void kol_board_puti(int n);

int kol_file_70(kol_struct70 *k);

kol_struct_import* kol_cofflib_load(char *name);

void* kol_cofflib_procload (kol_struct_import *imp, char *name);

unsigned kol_cofflib_procnum (kol_struct_import *imp);

void kol_cofflib_procname (kol_struct_import *imp, char *name, unsigned n);

unsigned kol_system_end(unsigned param);

unsigned kol_system_cpufreq();

unsigned kol_system_mem();

unsigned kol_system_memfree();

unsigned kol_system_time_get();

unsigned kol_system_date_get();

void kol_path_file2dir(char *dir, char *fname);

void kol_path_full(char *full, char *fname);

void kol_screen_wait_rr();

void kol_screen_get_size(unsigned *w, unsigned *h);

unsigned kol_skin_height();

unsigned kol_thread_start(unsigned start, unsigned stack);

unsigned kol_time_tick();

unsigned kol_sound_speaker(char data[]);

unsigned kol_process_info(unsigned slot, char buf1k[]);

int kol_process_kill_pid(unsigned process);

Вот menuet/os.h (кроме os.h есть еще console.h, gui.h, net.h, sem.h, thread.h и другие):

Code: Select all

#ifndef __GLIBC__MENUET_OS_H
#define __GLIBC__MENUET_OS_H

#ifdef __cplusplus
extern "C" {
#endif

typedef unsigned char       __u8;
typedef unsigned short      __u16;
typedef unsigned long       __u32;

#pragma pack(push,1)

void __menuet__define_window(__u16 x1,__u16 y1,__u16 xsize,__u16 ysize,
     __u32 body_color,__u32 grab_color,__u32 frame_color);
void __menuet__window_redraw(int status);
void __menuet__putpixel(__u32 x,__u32 y,__u32 color);
int __menuet__getkey(void);
__u32 __menuet__getsystemclock(void);
void __menuet__write_text(__u16 x,__u16 y,__u32 color,char * text,int len);
void __menuet__delay100(int m);
__u32 __menuet__open(char * name,char * data);
void __menuet__save(char * name,char * data,__u32 count);
void __menuet__putimage(__u16 x1,__u16 y1,__u16 xsize,__u16 ysize,char * image);
void __menuet__make_button(__u16 x1,__u16 y1,__u16 xsize,__u16 ysize,
                           int id,__u32 color);
int __menuet__get_button_id(void);
int __menuet__wait_for_event(void);
int __menuet__check_for_event(void);
void __menuet__bar(__u16 x1,__u16 y1,__u16 xsize,__u16 ysize,__u32 color);
void __menuet__sys_exit(void);
void * __menuet__exec_thread(void (* func_ptr)(void),__u32 stack_size,int * retp);
void __menuet__idle(void);

void __menuet__exec_ramdisk(char * filename,char * args,...);
void __menuet__exec_hd(char * filename,char * args,...);

struct process_table_entry
{
 __u32 cpu_usage;
 __u16 pos_in_windowing_stack;
 __u16 win_stack_val_at_ecx;
 __u16 reserved1;
 char name[12];
 __u32 memstart;
 __u32 memused;
 __u32 pid;
 __u32 winx_start,winy_start;
 __u32 winx_size,winy_size;
 __u16 thread_state;
 __u16 reserved2;
 __u32 client_left,client_top,client_width,client_height;
 __u8 window_state;
 __u8 reserved3[1024-71];
};

#define PID_WHOAMI		(-1)

int __menuet__get_process_table(struct process_table_entry * proctab,int pid);
void __menuet__get_screen_max(__u16 * x,__u16 * y);

#define BTYPE_TILE                  1
#define BTYPE_STRETCH               2

void __menuet__set_background_size(__u32 xsz,__u32 ysz);
void __menuet__write_background_mem(__u32 pos,__u32 color);
void __menuet__draw_background(void);
void __menuet__set_background_draw_type(int type);
void __menuet__background_blockmove(char * src_ptr,__u32 bgr_dst,__u32 count);

void __menuet__reset_mpu401(void);
void __menuet__write_mpu401(__u8 d);

__u32 __menuet__get_date(void);

void __menuet__line(__u16 x1,__u16 y1,__u16 x2,__u16 y2,__u32 color);

void __menuet__set_bitfield_for_wanted_events(__u16 ev);

#define EVENT_REDRAW              0x00000001
#define EVENT_KEY                 0x00000002
#define EVENT_BUTTON              0x00000004
#define EVENT_END_REQUEST         0x00000008
#define EVENT_DESKTOP_BACK_DRAW   0x00000010
#define EVENT_MOUSE_CHANGE        0x00000020
#define EVENT_IPC		  0x00000040
#define EVENT_GET_IRQS_MASK       0xFFFF0000
#define EVENT_GET_IRQ(e)          (((e)>>16)&0xFFFF)

__u32 __menuet__get_irq_owner(__u32 irq);
int __menuet__get_data_read_by_irq(__u32 irq,__u32 * num_bytes_in_buf,__u8 * data);
int __menuet__send_data_to_device(__u16 port,__u8 val);
void __menuet__program_irq(void * intr_table,__u32 irq_num);
int __menuet__reserve_irq(int irqno);
int __menuet__free_irq(int irqno);
int __menuet__reserve_port_area(__u32 start,__u32 end);
int __menuet__free_port_area(__u32 start,__u32 end);


#define NAME_LEN                   512

#define STC_READ                  0
#define STC_WRITE                 1
#define STC_APPEND                2

struct systree_info
{
	__u32 command;
	__u32 file_offset_low;
	__u32 file_offset_high;
	__u32 size;
	__u32 data_pointer;
	char _zero;
	const char* nameptr;
};

struct systree_info2
{
	__u32 command;
	__u32 file_offset_low;
	__u32 file_offset_high;
	__u32 size;
	__u32 data_pointer;
	char name[NAME_LEN];
};

struct bdfe_time
{
	__u8 seconds;
	__u8 minutes;
	__u8 hours;
	__u8 reserved;
};
struct bdfe_date
{
	__u8 day;
	__u8 month;
	__u16 year;
};
struct bdfe_item
{
	__u32 attr;
	__u8 nametype;
	__u8 reserved[3];
	struct bdfe_time ctime;
	struct bdfe_date cdate;
	struct bdfe_time atime;
	struct bdfe_date adate;
	struct bdfe_time mtime;
	struct bdfe_date mdate;
	__u32 filesize_low;
	__u32 filesize_high;
};

int __kolibri__system_tree_access(struct systree_info * info);
int __kolibri__system_tree_access2(struct systree_info2 * info);

int __fslayer_open(char * name,int flags);
int __fslayer_close(int fd);
int __fslayer_lseek(int fd,int pos,int seek_type);
int __fslayer_tell(int fd);
int __fslayer_read(int fd,void * buffer,__u32 count);
int __fslayer_write(int fd,void * buffer,__u32 count);

typedef struct
{
 __u8 lock;
 __u8 resvd[3];
 __u32 ptr_to_fmsg_pos;
 /* Below is for message */
 __u32 sender_pid;
 __u32 msg_length;
} msgrcva_t /*__attribute__((packed))*/;

void send_message(int pid,void * msg_ptr,int message_size);
void define_receive_area(msgrcva_t * rcva_ptr,int size);

void __menuet__sound_load_block(char * blockptr);
void __menuet__sound_play_block(void);

void __menuet__dga_get_caps(int * xres,int * yres,int * bpp,int * bpscan);

void get_pci_version(__u8 * major,__u8 * minor);
void pci_get_last_bus(__u8 * last_bus);
void get_pci_access_mechanism(__u8 * mechanism);

void pci_write_config_byte(__u8 bus,__u8 dev,__u8 fn,__u8 reg,__u8 val);
void pci_write_config_word(__u8 bus,__u8 dev,__u8 fn,__u8 reg,__u16 val);
void pci_write_config_dword(__u8 bus,__u8 dev,__u8 fn,__u8 reg,__u32 val);
__u8 pci_read_config_byte(__u8 bus,__u8 dev,__u8 fn,__u8 reg);
__u16 pci_read_config_word(__u8 bus,__u8 dev,__u8 fn,__u8 reg);
__u32 pci_read_config_dword(__u8 bus,__u8 dev,__u8 fn,__u8 reg);

typedef struct{
	char* name;
	void* pointer;
} IMP_ENTRY;
typedef const IMP_ENTRY* IMP_TABLE;
IMP_TABLE __kolibri__cofflib_load(const char*);
__u32 __kolibri__cofflib_getproc(IMP_TABLE, const char*);
//int __kolibri__cofflib_link(FUNC*, IMP_TABLE);

static __inline__ void __menuet__debug_out_byte(const char ch){
    __asm__ __volatile__ ("int $0x40"::"a"(63L),"b"(1L),"c"((__u8)ch));
}
void __menuet__debug_out(const char* str);

#define TIME_GETH(x)	((x)&0x000000FF)
#define TIME_GETM(x)	((((x)&0x00FF00)>>8)&0xFF)
#define TIME_GETS(x)	((((x)&0xFF0000)>>16)&0xFF)

#pragma pack(pop)

#ifdef __cplusplus
}
#endif

#endif

Ссылка на kolibri.h-- проскакивала в теме Flood-it. На websvn в папке /programs/develop/ktcc есть версия kolibri.h для ktcc.

Mon Oct 03, 2011 12:10 am

Ой, а можно не сдержаться? Это же просто жесть!

То есть, получается, что каждый программист создаёт себе SDK сам, под свой компилятор? А где же ваш "комитет по стандартам"? Тогда да, разработка на ЯВУ под Колибри кагбэ не существует.

Mon Oct 03, 2011 7:45 am

Это просто обёртки системных функций. И каждый может их называть по-своему. С точки зрения кода - это всего лишь наборы меток, после которых идёт разбор параметров (в зависимости от способа передачи), выполнение определённых действий, подготовка результата (обычно в регистре eax), корректировка стека (если таковая требуется) и возвращение на адрес, следующий за командой вызова процедуры. Свой вариант обёрток я написал за выходные. Кстати, исходники библиотеки раньше не выкладывал - только заголовочные файлы. И diamond написал свой вариант (с теми же названиями функций, но ассемблерные вставки в стиле Intel, а не AT&T, как у меня).

Mon Oct 03, 2011 8:01 am

На самом деле ничего жестокого нет, мне кажется. В Windows пользователь может работать с winapi через классические подключаемые файлы или писать свои обертки. При программировании для Колибри для функций системы (исключительно функций системы, а не стандартных библиотек!!!) тоже можно использовать свои обертки (см. выше) или устоявшийся способ вызова функций (inline-ассемблер). Строго говоря, это необязательно. Большая часть моих портов не использует ни menuet/os.h, ни kolibri.h вообще. Ничего, кроме libc и console.c (для работы с console.obj - getch, printf).

Tue Oct 04, 2011 12:39 am

Хорошо, задам вопрос напрямик: Колибри думает становиться полноценной платформой? Самобытной, да. Но при этом платформой -- самодостаточным основанием, на которое можно опереться.

Грубо говоря, вы воспринимаете все эти libc и прочие как данность, и механически их воспроизводите. Я же предлагаю сделать нечто вроде Kolibri API, не базирующийся ни на чём, кроме Колибри. Для большинства языков программирования от системы требуется лишь malloc/free, и всё. Процедуры API могут быть любыми.

Да, в школе и ВУЗе учат, что printf непременно должен выводить на консоль. И что? Кровь из носу, но чёрное окошко обязательно?

Tue Oct 04, 2011 12:46 am

Т.е. ты предлагаешь сделать некую kolibri.obj для программ на ЯВУ, и эту библиотеку со стандартным набором функций через стандартный набор функций чтобы могли вызывать все языки?

Tue Oct 04, 2011 2:08 am

> Kolibri API
Зачем? Ты считаешь себя умнее тех кто разработал API libc, glib, pascal rtl/crt. Зачем придумывать новый интерфейс, чем именно этот новый интерфейс будет лучше существующих (чем хуже понятно). (Я разделяю понятия интерфейса и реализации, так что под Kolibri API понимаю именно интерфейс, который придётся несколько раз реализовать.)

> чёрное окошко обязательно?
Да. (c) КО :-)

p.s. Это всё оффтопик. Может стоит выделить в тему "Kolibri API"?

..bw

Wed Oct 05, 2011 12:00 am

SoUrcerer wrote:Т.е. ты предлагаешь сделать некую kolibri.obj для программ на ЯВУ

Я не думаю, что это будет именно kolibri.obj -- всё равно ведь всё через прерывания вызывается. Скорее kolibri.h с ассемблерными макросами (как оно называется в Си?), kolibri.pas, kolibri.ctx и т. п.

bw wrote:под Kolibri API понимаю именно интерфейс, который придётся несколько раз реализовать.

Интерфейс, если за него принимать printf и WriteLn, реализуется уже поверх API, какую ОС ни возьми. API первичен.

Представьте, например, что для того, чтобы писать под Windows, пришлось бы сначала по MSDN придумывать себе kernel32.h с CreateFile, CloseHandle, самостоятельно описывать структуры, вроде WNDCLASS, и т. п. И под каждый язык и компилятор было бы что-то своё, придуманное наспех программистом имярек.

Wed Oct 05, 2011 7:25 am

Freeman Так действуй.

Spoiler:

Мне бы очень не помешал такой kolibri.h, чтобы в нём было функций 200-300 (начальный минимум) для работы с памятью (malloc, calloc, free - и чтобы можно было выделять память меньше 4 кб), окнами, шрифтами, графикой, контроллами (хотя бы для начала box_lib, а там может ещё чего захочу), аудио и видео (хочу, чтобы при запуске программы играла музыка), файлами различных типов (чтобы загружать JPEG одной командой и одной командой его отрисовывать) и чтобы HTMLv можно было в свои приложения встраивать (а что, IE в винде встраивать можно). И чтобы каждая функция была документирована, и примеры на каждую группу функций были. Сможешь сделать?

Fri Nov 18, 2011 12:18 pm

Здравствуйте.

Для переноса на Колибри есть очень хорошая система программи�