Subversion Repositories Kolibri OS

public _InitHeap@4

public _UserAlloc@4

public _GetNotify@4

public _GetMousePos@4

public _get_fileinfo@8

public _create_file@4

public _write_file@20

public _get_key@4

public _remap_key@4

public _get_button_id

public _DrawWindow@36

public _debug_out@4

struc CTRL_INFO

{   .pci_cmd        dd  ?

    .irq            dd  ?

    .glob_cntrl     dd  ?

    .glob_sta       dd  ?

    .codec_io_base  dd  ?

    .ctrl_io_base   dd  ?

    .codec_mem_base dd  ?

    .ctrl_mem_base  dd  ?

    .codec_id       dd  ?

}

CTRL_INFO_SIZE      equ 9*4

align 4

_GetScreenSize@8:

           .x equ esp+12

           .y equ esp+16 

           push ebx

           push ecx

           mov eax, 14

           int 0x40

           mov ebx, [.y]

           movzx ecx, ax

           inc ecx

           mov [ebx], ecx

           mov ebx, [.x]

           shr eax, 16

           inc eax

           mov [ebx], eax

           pop ecx

           pop ebx

           ret 8

           push ebx

           pop ecx

           pop ebx

           ret

endp

align 4

proc _create_file@4 stdcall, name:dword

           push ebx

           xor eax, eax

           mov ebx, [name]

           mov [fileio.cmd], 2

           mov [fileio.offset], eax

           mov [fileio.offset+4], eax

           mov [fileio.count], eax

           mov [fileio.buff], eax

           mov byte [fileio.buff+4], al

           mov [fileio.name], ebx

           mov eax, 70

           lea ebx, [fileio]

           int 0x40

           push edi

           pop edx

           pop edi

           pop esi

           pop ebx

           ret

endp

align 4

proc _write_file@20 stdcall,name:dword, buff:dword, offset:dword,\

                                     count:dword,writes:dword

           push ebx

           push esi

           push edi

           push edx

           xor eax, eax

           mov ebx, [name]

           mov edx, [offset]

           mov esi, [buff]

           mov edi, [count]

           mov [fileio.cmd], 3

           mov [fileio.offset], edx

           mov [fileio.offset+4], eax

           mov [fileio.count], edi

           mov [fileio.buff], esi

           mov byte [fileio.buff+4], al

           mov [fileio.name], ebx

           mov eax, 70

           lea ebx, [fileio]

           int 0x40

           mov esi, [writes]

           test esi, esi

           jz @f

           mov [esi], ebx

@@:

           pop edx

           push ebx

           int 0x40

proc _UserAlloc@4 stdcall, alloc_size:dword

           mov ecx, [alloc_size]

           int 0x40

           pop ecx

           pop ebx

           ret

endp

align 4

proc _UserFree@4 stdcall, pmem:dword

           push ebx

           push ecx

           mov eax, 68

           mov ebx, 13

           mov ecx, [pmem]

           int 0x40

           pop ecx

           pop ebx

           ret

endp           

align 4

proc _GetNotify@4 stdcall, p_ev:dword

           push ebx

           push ecx

           mov eax, 68

           mov ebx, 14

           mov ecx, [p_ev]

align 4

proc _CreateThread@8 stdcall, fn:dword, p_stack:dword

              mov ecx, [fn]

              mov edx,[p_stack]

                               windowtype:dword, bordercolor:dword

           push ebx

           push ecx

           push edi

           push esi

           pop esi

           pop edi

           pop ecx

           pop ebx

  push  ebx

           mov  ecx,[val]

align 4

proc _remap_key@4 stdcall, key:dword

           mov eax, [key]

           and eax, 0x7F

           movzx eax, byte [keymap+eax]

           ret

endp

        ret

;public __allmul

__allmul:

        mov eax, [esp+8]

        mov ecx, [esp+16]

        or ecx,eax

        jnz .hard

        mov eax, [esp+4]

        mul ecx

        ret 16

.hard:

        push ebx

        mul ecx

        mov ebx,eax

        mov eax, [esp+8]

        mul dword [esp+20]

        add ebx,eax

        mov eax,[esp+8]

        add edx,ebx

        pop ebx

;public __allshr

align 4

__allshr:

        cmp cl,64

        cmp cl, 32

        jae .MORE32

        shrd eax,edx,cl

        sar edx,cl

        ret

.MORE32:

        mov     eax,edx

        sar     edx,31

        and     cl,31

        sar     eax,cl

        ret

.sign:

        sar     edx,31

        mov     eax,edx

;public _scalbn

align 4

	          fild	dword [esp+12]

	          fld	qword [esp+4]

	          fscale

	          fstp	st1

	          ret

endp

;public  __alloca_probe_8

;public  __alloca_probe_16

__alloca_probe_16:                       ; 16 byte aligned alloca

        push    ecx

        lea     ecx, [esp + 8]          ; TOS before entering this function

        sub     ecx, eax                ; New TOS

        and     ecx, (16 - 1)           ; Distance from 16 bit align (align down)

        add     eax, ecx                ; Increase allocation size

        sbb     ecx, ecx                ; ecx = 0xFFFFFFFF if size wrapped around

        or      eax, ecx                ; cap allocation size on wraparound

        pop     ecx                     ; Restore ecx

        jmp     __chkstk

alloca_8:                               ; 8 byte aligned alloca

__alloca_probe_8:

        push    ecx

        lea     ecx, [esp+8]          ; TOS before entering this function

        sub     ecx, eax                ; New TOS

        and     ecx, (8 - 1)            ; Distance from 8 bit align (align down)

        add     eax, ecx                ; Increase allocation Size

        sbb     ecx, ecx                ; ecx = 0xFFFFFFFF if size wrapped around

        or      eax, ecx                ; cap allocation size on wraparound

        pop     ecx                     ; Restore ecx

        jmp     __chkstk

;public __chkstk

;public _alloca_probe

align 4

;_alloca_probe:

__chkstk:

        push    ecx

        lea     ecx, [esp+8-4]          ; TOS before entering function + size for ret value

        sub     ecx, eax                ; new TOS

; Handle allocation size that results in wraparound.

; Wraparound will result in StackOverflow exception.

        sbb     eax, eax                ; 0 if CF==0, ~0 if CF==1

        not     eax                     ; ~0 if TOS did not wrapped around, 0 otherwise

        and     ecx, eax                ; set to 0 if wraparound

        mov     eax, esp                ; current TOS

        and     eax, -4096              ; Round down to current page boundary

cs10:

        cmp     ecx, eax                ; Is new TOS

        jb      short cs20              ; in probed page?

        mov     eax, ecx                ; yes.

        pop     ecx

        xchg    esp, eax                ; update esp

        mov     eax, [eax]              ; get return address

        mov     [esp], eax              ; and put it at new TOS

        ret

; Find next lower page and probe

cs20:

        sub     eax, 4096               ; decrease by PAGESIZE

        test    [eax],eax     ; probe page.

        jmp     short cs10

public __ftol2_sse

align 4

__ftol2_sse:

           push ebp

           mov ebp, esp

           sub esp, 20

           and esp, 0xFFFFFFF0

           fld st0

           fst dword [esp+18]

           fistp qword [esp+10]

           fild qword [esp+10]

           mov edx, [esp+18]

           mov eax, [esp+10]

           test eax, eax

           jz .QnaNZ

.not_QnaNZ:

           fsubp st1, st0

           test edx, edx

           jns .pos

           fstp dword [esp]

           mov ecx, [esp]

           xor ecx, 0x80000000

           add ecx, 0x7FFFFFFF

           adc eax, 0

           mov edx, [esp+14]

           adc edx, 0

           jmp .exit

.pos:

           fstp dword [esp]

           mov ecx, [esp]

           add ecx, 0x7FFFFFFF

           sbb eax, 0

           jmp .exit

.QnaNZ:

           mov edx, [esp+14]

           test edx, 0x7FFFFFFF

           jne .not_QnaNZ

           fstp dword [esp+18]

           fstp dword [esp+18]

.exit:

           leave

           ret

section '.data' align 16 data readable writable

align 16

__hexdigits db '0123456789ABCDEF'

         ;  0    1    2    3    4    5    6    7

         ;  8    9    a    b    c    d    e    f

keymap:

     db      0,  27, '1', '2', '3', '4', '5', '6'   ;00

     db    '7', '8', '9', '0', '-', '=',0x7F, 0x9   ;08

     db    'q', 'w', 'e', 'r', 't', 'y', 'u', 'i'   ;10

     db    'o', 'p', '[', ']',  13,0x9D, 'a', 's'   ;18

     db    'd', 'f', 'g', 'h', 'j', 'k', 'l', ';'   ;20

     db      0, '~',0xB6, '|',0x7A,0x87, 'c', 'v'   ;28

     db    'b', 'n', 'm', ',', '.', '/',0xB6, '*'   ;30

     db   0xB8, ' ',   0,0xBB,0xBC,0xBD,0xBE,0xBF   ;38

     db   0xC0,0xC1,0xC2,0xC3,0xC4,   0,   0,   0   ;40

     db   0xAD,   0,   0,0xAC,   0,0xAE,   0,   0   ;48

     db   0xAF,   0,   0,   0,   0,   0,   0,   0   ;50

     db      0,   0,   0,   0,   0,   0,   0,   0   ;58

     db      0,   0,   0,   0,   0,   0,   0,   0   ;60

     db      0,   0,   0,   0,   0,   0,   0,   0   ;68

     db      0,   0,   0,   0,   0,   0,   0,   0   ;70

     db      0,   0,   0,   0,   0,   0,   0,   0   ;78