include "macros.inc"

MEOS_APP_START

CODE
redraw:
        call    draw_window
wait_event:
        mcall   10
        dec     eax
        jz      redraw
        dec     eax
        jz      key
; button pressed; we have only one button, close
        mcall   -1
key:
; key pressed, read it and ignore
        mcall   2
        jmp     wait_event

draw_window:
        mcall   12, 1           ; start redraw
        mcall   0, <10,150>, <40,50>, 0x33FFFFFF, , header      ; define&draw window
        mcall   4, <30,10>, 0x80000000, string                  ; display string
        mcall   12, 2           ; end redraw
        ret

DATA
header  db      'HelloWorld test',0
string  db      'Hello, World!',0

UDATA

MEOS_APP_END

fasm hello.asm hello

	bits	32
	%include 'mos.inc'
	section .text

	MOS_HEADER01 main,image_end,memory_end,stacktop,0,0

main:
redraw:
	call	draw_window
wait_event:
	MOS_WAITEVENT
	dec	eax
	jz	redraw
	dec	eax
	jz	key
; button pressed; we have only one button, close
	MOS_EXIT
key:
; key pressed, read it and ignore
	mov	eax, MOS_SC_GETKEY
	int	0x40
	jmp	wait_event

draw_window:
	MOS_STARTREDRAW
	xor	eax, eax
	mov	ebx, 10*65536 + 150
	mov	ecx, 40*65536 + 50
	mov	edx, 0x33FFFFFF
	mov	edi, header
	int	0x40		; define&draw window
	mov	eax, MOS_SC_WRITETEXT
	mov	ebx, 30*65536 + 10
	mov	ecx, 0x80000000
	mov	edx, string
	int	0x40		; display string
	MOS_ENDREDRAW
	ret

	section	.data
header	db	'HelloWorld test',0
string	db	'Hello, World!',0
image_end:

	section .bss
alignb	4
stack	resb	1024
stacktop:

memory_end:

nasm hello.asm

nasmw hello.asm

        .486
        .model  flat

.data
; header
        db      'MENUET01'
        dd      1
        dd      offset _start
        dd      offset bss_start        ; i_end
        dd      offset bss_end          ; memory
        dd      offset stacktop         ; esp
        dd      0, 0                    ; params, icon

header  db      'HelloWorld test',0
string  db      'Hello, World!',0

.data?
bss_start label byte
align 4
        db      1000h dup (?)
stacktop = $
bss_end label byte

.code
_start:
redraw:
        call    draw_window
wait_event:
        mov     eax, 10
        int     40h
        dec     eax
        jz      redraw
        dec     eax
        jz      key
; button pressed; we have only one button, close
        mov     eax, -1
        int     40h
key:
; key pressed, read it and ignore
        mov     eax, 2
        int     40h
        jmp     wait_event

draw_window:
        mov     eax, 12
        mov     ebx, 1
        int     40h             ; start redraw
        xor     eax, eax
        mov     ebx, 10*65536 + 150
        mov     ecx, 40*65536 + 50
        mov     edx, 33FFFFFFh
        mov     edi, offset header
        int     40h             ; define&draw window
        mov     eax, 4
        mov     ebx, 30*65536 + 10
        mov     ecx, 80000000h
        mov     edx, offset string
        int     40h             ; draw string
        mov     eax, 12
        mov     ebx, 2
        int     40h             ; end redraw
        ret

        end     _start

\masm32\bin\ml /nologo /c /coff hello.asm

\masm32\bin\link /fixed /subsystem:native /base:-0x10000 /align:0x10000
		/merge:.data=.text /merge:.rdata=.text /nologo hello.obj

Explanations:

virtual at 0
file 'hello.exe':3Ch,4
load pehea dword from 0
file 'hello.exe':pehea+0F8h,28h
load physofs dword from 4+14h
load mem dword from 4+8
file 'hello.exe':physofs+16,4
load sz dword from $-4
end virtual
file 'hello.exe':physofs,sz
store dword mem at 14h

fasm doexe.asm hello

#include "kosSyst.h"
#include "kosFile.h"

const char header[] = "HelloWorld test";
const char string[] = "Hello, World!";

void draw_window(void)
{
	// start redraw
	kos_WindowRedrawStatus(1);
	// define&draw window
	kos_DefineAndDrawWindow(10,40,150,50,
		0x33,0xFFFFFF,0,0,(Dword)header);
	// display string
	kos_WriteTextToWindow(30,10,8,0,(char*)string,0);
	// end redraw
	kos_WindowRedrawStatus(2);
}

void kos_Main()
{
	draw_window();
	for (;;)
	{
		switch (kos_WaitForEvent())
		{
		case 1:
			draw_window();
			break;
		case 2:
			// key pressed, read it and ignore
			Byte keyCode;
			kos_GetKey(keyCode);
			break;
		case 3:
			// button pressed; we have only one button, close
			kos_ExitApp();
		}
	}
}

pe2kos Release\hello.exe hello

cl /c /O2 /nologo hello.cpp kosFile.cpp kosSyst.cpp mcsmemm.cpp
link /nologo /entry:crtStartUp /subsystem:native /base:0 /fixed
	/align:16 /nodefaultlib hello.obj kosFile.obj kosSyst.obj mcsmemm.obj
pe2kos hello.exe hello

cl /c /O2 /nologo /GS- /GR- hello.cpp kosFile.cpp kosSyst.cpp mcsmemm.cpp
link /nologo /manifest:no /entry:crtStartUp /subsystem:native /base:0 /fixed
	/align:16 /nodefaultlib hello.obj kosFile.obj kosSyst.obj mcsmemm.obj
pe2kos hello.exe hello

#include <menuet/os.h>

const char header[] = "HelloWorld test";
const char string[] = "Hello, World!";

void draw_window(void)
{
	// start redraw
	__menuet__window_redraw(1);
	// define&draw window
	__menuet__define_window(10,40,150,50,
		0x33FFFFFF,0,(__u32)header);
        // display string
        __menuet__write_text(30,10,0x80000000,string,0);
        // end redraw
        __menuet__window_redraw(2);
}

void app_main(void)
{
	draw_window();
	for (;;)
	{
		switch (__menuet__wait_for_event())
		{
		case 1:
			draw_window();
			break;
		case 2:
			// key pressed, read it and ignore
			__menuet__getkey();
			break;
		case 3:
			// button pressed; we have only one button, close
			return;
		}
	}
}

make

OUTFILE = hello
OBJS = hello.o
include $(MENUETDEV)/makefiles/Makefile_for_program

• Before compilation of everything the tools mgcc,mgpp,mld,mmkdep in the folder "linuxtools" are compiled. They simply call accordingly standard tools gcc,g++,ld,mkdep, adding certain command-line options. The full list of adding options can be figured out from the sources, and essential ones for compilation process are the following:

  -nostdinc -I$(MENUETDEV)/include

  for gcc/g++ and

  -nostdlib -L$(MENUETDEV)/lib -T$(MENUETDEV)/include/scripts/menuetos_app_v01.ld
  	$(MENUETDEV)/stub/crt0.o

  for mld. Later instead of standard tools those compiled tools are used.
• The compiler only generates the code. Assembling this code to unified binary is the task of linker. The wish to create binary file is expressed in the script "menuetos_app_v01.ld" (argument of option -T). In fact, this script directs to create certain sections in certain order by grouping existing sections. At that the first section is placed at address 0, next sections in the sequential order. Moreover, the script finds out begin/end of code/data/program, they will be used later.
• The resulting file from linker is passed through tool objcopy, which changes it to binary.
• The stub "stub/crt0.o" plays an important role. It is the file where header with main program parameters is created. Some parameters are declared as extrn, they will be filled by linker with values found by script.

#include <menuet.h>
#include <me_heap.h>
#include <me_file.h>

using namespace Menuet;

const char header[] = "HelloWorld test";
const char string[] = "Hello, World!";

bool MenuetOnStart(TStartData &me_start, TThreadData /*th*/)
{
	me_start.Left = 10;
	me_start.Top = 40;
	me_start.Width = 150;
	me_start.Height = 30;
	me_start.WinData.Title = header;
	return true;
}

void MenuetOnDraw(void)
{
	DrawString(30,10,0,string);
}

bool MenuetOnClose(TThreadData /*th*/)
{return true;}
int MenuetOnIdle(TThreadData /*th*/)
{return -1;}
void MenuetOnSize(int /*window_rect*/[], TThreadData /*th*/)
{}
void MenuetOnKeyPress(TThreadData /*th*/)
{GetKey();}
void MenuetOnMouse(TThreadData /*th*/)
{}

bcc32 -S -v- -R- -6 -a4 -O2 -Og -Oi -Ov -OS -k- -D__MENUET__ -Iinclude hello.cpp
echo include "me_make.inc" > f_hello.asm
t2fasm < hello.asm >> f_hello.asm
fasm f_hello.asm hello

gcc tcc.c -o tcc.exe

#include "mesys.h"

const char header[] = "HelloWorld test";
const char string[] = "Hello, World!";

void draw_window(void)
{
	// start redraw
	_msys_window_redraw(1);
	// define&draw window
	_msys_draw_window(10,40,150,50,0xFFFFFF,0x33,0,0,(int)header);
	// display string
	_msys_write_text(30,10,0x80000000,string,0);
	// end redraw
	_msys_window_redraw(2);
}

int main(int argc, char** argv[])
{
	draw_window();
	for (;;)
	{
		switch (_msys_wait_for_event_infinite())
		{
		case 1:
			draw_window();
			break;
		case 2:
			// key pressed, read it and ignore
			_msys_get_key();
			break;
		case 3:
			// button pressed; we have only one button, close
			return 0;
		}
	}
}

tcc hello.c start.o melibc.a -o hello

Program hello;
Uses kolibri;

var k:TKolibri;
const
	header:string='HelloWorld test'#0;
	str:string='Hello, World!';

procedure draw_window;
begin
	{start redraw}
	k.BeginDraw;
	{define&draw window}
	k.DefineWindow(10,40,150,50,$33FFFFFF,0,integer(@header[1]));
	{display string}
	k.WriteText(30,10,0,0,str);
	{end redraw}
	k.EndDraw;
end;

var key:DWord;
begin
	draw_window;
	while true do
	begin
		case k.WaitForEvent of
		1:draw_window;
		2:k.GetKey(key);{key pressed, read it and ignore}
		3:break;	{button pressed; we have only one button, close}
		end;
	end;
end.

ppro hello