Subversion Repositories Kolibri OS

; �㭪樨 ࠡ��� � ���᮫�� ��� �ணࠬ� �����਎�

; diamond, 2006-2008

format MS COFF

public EXPORTS

section '.flat' code readable align 16

include 'font.inc'

include 'conscrl.inc'

struc process_info

{

  .cpu_usage              dd ?  ; +0

  .window_stack_position  dw ?  ; +4

  .window_stack_value     dw ?  ; +6

                          dw ?  ; +8

  .process_name           rb 12 ; +10

  .memory_start           dd ?  ; +22

  .used_memory            dd ?  ; +26

  .PID                    dd ?  ; +30

  .box.x                  dd ?  ; +34

  .box.y                  dd ?  ; +38

  .box.width              dd ?  ; +42

  .box.height             dd ?  ; +46

  .slot_state             dw ?  ; +50

                          dw ?  ; +52

  .client_box.x           dd ?  ; +54

  .client_box.y           dd ?  ; +58

  .client_box.width       dd ?  ; +62

  .client_box.height      dd ?  ; +66

  .wnd_state              db ?  ; +70

  rb (1024-71)

}

OP_EXIT         = 1

OP_SET_TITLE    = 2

OP_REDRAW       = 3

OP_GETCH        = 4

OP_RESIZE       = 5

;void __stdcall START(dword state);

START:

; N.B. The current kernel implementation does not require

;      evident heap initialization, because if DLL is loaded, heap is already initialized

;      (if heap was not initialized, loader does this implicitly).

;      So this action does nothing useful, but nothing harmful.

        push    ebx

        push    68

        pop     eax

        push    11

        pop     ebx

        int     0x40

        pop     ebx

        or      eax, -1

        ret     4

; ���樠������ ���᮫�

; void __stdcall con_init(dword wnd_width, dword wnd_height,

;       dword scr_width, dword scr_height, const char* title);

align 4

con_init:

        pop     eax

        pop     [con.wnd_width]

        pop     [con.wnd_height]

        pop     [con.main_scr_width]

        pop     [con.main_scr_height]

        pop     [con.title]

        push    eax

        push    ebx

        mov     [con.init_cmd],1

        mov     ecx, 4

        mov     eax, con.wnd_width

        mov     edx, con.def_wnd_width

  .1:

        cmp     dword [eax], -1

        jnz     @f

        mov     ebx, [edx]

        mov     [eax], ebx

  @@:

        add     eax, 4

        add     edx, 4

        loop    .1

; Allocate memory for console data & bitmap data

; First, calculate required amount of bytes

; Main buffer

        mov     eax, [con.main_scr_width]

        mul     [con.main_scr_height]

;       2 bytes per on-screen character (1 flags and 1 ascii)

        lea     ecx, [eax+eax]

; Alternate buffer

        mov     [con.altbuffer], ecx

        mov     eax, [con.wnd_width]

        mul     [con.wnd_height]

;       2 bytes per on-screen character (1 flags and 1 ascii)

        lea     ecx, [ecx+2*eax]

; Bitmap data

        mov     eax, [con.wnd_width]

        mul     [con.wnd_height]

        imul    eax, font_width*font_height

        mov     ebx, eax

        push    ebx ecx

        add     ecx, eax

; malloc

        push    68

        pop     eax

        push    12

        pop     ebx

        int     0x40

        pop     ecx ebx

        mov     edx, con.nomem_err

        test    eax, eax

        jz      .fatal

; Set pointers to the buffers

        mov     [con.mainbuffer], eax

        add     [con.altbuffer], eax

; Set active buffer pointer and dimensions

        mov     [con.data], eax

        push    [con.main_scr_width]

        pop     [con.scr_width]

        push    [con.main_scr_height]

        pop     [con.scr_height]

; Clear text buffers

        push    edi

        mov     edi, eax

        shr     ecx, 1

        mov     ax, 0x0720

        rep     stosw

; Clear bitmap buffer

        mov     ecx, ebx

        mov     [con.image], edi

        xor     eax, eax

        rep     stosb

        pop     edi

        and     byte [con_flags+1], not 2

; create console thread

        push    51

        pop     eax

        xor     ebx, ebx

        inc     ebx

        mov     ecx, con.thread

        mov     edx, con.stack_top

        int     0x40

        mov     edx, con.thread_err

        test    eax, eax

        js      .fatal

        mov     [con.console_tid], eax

        pop     ebx

        ret

  .fatal:

; output string to debug board and die

        mov     cl, [edx]

        test    cl, cl

        jz      @f

        push    63

        pop     eax

        xor     ebx, ebx

        inc     ebx

        int     0x40

        inc     edx

        jmp     .fatal

  @@:

        or      eax, -1

        int     0x40

; dword __stdcall con_get_flags(void);

con_get_flags:

        mov     eax, [con_flags]

        ret

; dword __stdcall con_set_flags(dword flags);

con_set_flags:

        mov     eax, [esp+4]

        and     ah, not 2

        xchg    eax, [con_flags]

        ret     4

; dword __stdcall con_get_font_height(void);

con_get_font_height:

        mov     eax, font_height

        ret

; int __stdcall con_get_cursor_height(void);

con_get_cursor_height:

        mov     eax, [con.cursor_height]

        ret

; int __stdcall con_set_cursor_height(int new_height);

con_set_cursor_height:

        mov     eax, [esp+4]

        cmp     eax, font_height

        jae     @f

        xchg    eax, [con.cursor_height]

        ret     4

  @@:

        mov     eax, [con.cursor_height]

        ret     4

con_init_check:

        mov     ah, [con.init_cmd]

        test    ah, ah

        jne     .yes

        push    con.title_init_console

        push    -1

        push    -1

        push    -1

        push    -1

        call    con_init

  .yes:

        ret

; void __stdcall con_write_asciiz(const char* string);

con_write_asciiz:

        call    con_init_check

        push    ebx esi

        or      ebx, -1

        mov     esi, [esp+12]

        call    con.write

        pop     esi ebx

        ret     4

; void __stdcall con_write_string(const char* string, dword length);

con_write_length:

        push    ebx esi

        mov     esi, [esp+12]

        mov     ebx, [esp+16]

        call    con.write

        pop     esi ebx

        ret     8

; ����� ᨬ��� ������������ ��� ���� ��

con.printfc.normal = 0   ; ��ଠ��� ᨬ���

con.printfc.percent = 1  ; '%'

con.printfc.dot = 2      ; '.'

con.printfc.asterisk = 3 ; '*'

con.printfc.zero = 4     ; '0'

con.printfc.digit = 5    ; ���㫥��� ���

con.printfc.plus = 6     ; '+'

con.printfc.minus = 7    ; '-'

con.printfc.sharp = 8    ; '#'

con.printfc.space = 9    ; ' '

con.printfc.long = 10    ; 'l' for 'long'

con.printfc.short = 11   ; 'h' for 'short'

con.printfc.dec = 12     ; 'd' = print decimal

con.printfc.oct = 13     ; 'o' = print octal

con.printfc.unsigned = 14 ; 'u' = print unsigned decimal

con.printfc.hex = 15     ; 'x' = print hexadecimal

con.printfc.pointer = 16 ; 'p' = print pointer

con.printfc.char = 17    ; 'c' = print char

con.printfc.string = 18  ; 's' = print string

macro set char,type

{store byte con.printfc.#type at con.charcodes + char - ' '}

con.charcodes:

times 'x'-' '+1         db      con.printfc.normal

        set     '%', percent

        set     '.', dot

        set     '*', asterisk

        set     '0', zero

        set     '1', digit

        set     '2', digit

        set     '3', digit

        set     '4', digit

        set     '5', digit

        set     '6', digit

        set     '7', digit

        set     '8', digit

        set     '9', digit

        set     ' ', space

        set     '#', sharp

        set     '+', plus

        set     '-', minus

        set     'X', hex

        set     'x', hex

        set     'c', char

        set     'd', dec

        set     'h', short

        set     'i', dec

        set     'l', long

        set     'o', oct

        set     'p', pointer

        set     's', string

        set     'u', unsigned

purge set

align 4

con.charjump:

        dd      con_printf.normal

        dd      con_printf.percent

        dd      con_printf.dot

        dd      con_printf.asterisk

        dd      con_printf.zero

        dd      con_printf.digit

        dd      con_printf.plus

        dd      con_printf.minus

        dd      con_printf.sharp

        dd      con_printf.space

        dd      con_printf.long

        dd      con_printf.short

        dd      con_printf.dec

        dd      con_printf.oct

        dd      con_printf.unsigned

        dd      con_printf.hex

        dd      con_printf.pointer

        dd      con_printf.char

        dd      con_printf.string

; int __cdecl con_printf(const char* format, ...)

con_printf:

        call    con_init_check

        xor     eax, eax

        pushad

        call    con.get_data_ptr

        lea     ebp, [esp+20h+8]

        mov     esi, [ebp-4]

        sub     esp, 64         ; reserve space for buffer

  .loop:

        xor     eax, eax

        lodsb

        test    al, al

        jz      .done

        cmp     al, '%'

        jz      .spec_begin

  .normal:

        call    con.write_char_ex

        inc     dword [esp+64+28]

        jmp     .loop

  .errspec:

  .percent:

        add     esp, 12

        jmp     .normal

  .spec_begin:

        xor     ebx, ebx

; bl = ⨯ ����樨:

; 0 = ��砫�

; 1 = ���⠭ ����騩 0 � ᯥ�䨪�樨 �ଠ�

; 2 = �⠥� ���� �ਭ�

; 3 = �⠥� ���� �筮��

; 4 = ���⠭� ���� ࠧ��� ��㬥��

; 5 = �⠥� ���� ⨯�

; bh = 䫠��:

; 1 = 䫠� '#', �뢮���� 0/0x/0X

; 2 = 䫠� '-', ��ࠢ������� �����

; 4 = 䫠� '0', ���������� ��ﬨ

; 8 = 䫠� 'h', ���⪨� ��㬥��

        push    -1

; dword [esp+8] = precision

        push    -1

; dword [esp+4] = width

        push    0

; byte [esp] = 䫠� 0/'+'/' '

  .spec:

        xor     eax, eax

        lodsb

        test    al, al

        jz      .done

        cmp     al, ' '

        jb      .normal

        cmp     al, 'x'

        ja      .normal

        movzx   ecx, byte [con.charcodes + eax - ' ']

        jmp     dword[con.charjump + ecx*4]

  .sharp:

        test    bl, bl

        jnz     .errspec

        or      bh, 1

        jmp     .spec

  .minus:

        test    bl, bl

        jnz     .errspec

        or      bh, 2

        jmp     .spec

  .plus:

  .space:

        test    bl, bl

        jnz     .errspec

        cmp     byte [esp], '+'

        jz      .spec

        mov     byte [esp], al

        jmp     .spec

  .zero:

        test    bl, bl

        jnz     .digit

        test    bh, 2

        jnz     .spec

        or      bh, 4

        inc     ebx

        jmp     .spec

  .digit:

        sub     al, '0'

        cmp     bl, 2

        ja      .precision

        mov     bl, 2

        xchg    eax, [esp+4]

        test    eax, eax

        js      .spec

        lea     eax, [eax*5]

        add     eax, eax

        add     [esp+4], eax

        jmp     .spec

  .precision:

        cmp     bl, 3

        jnz     .errspec

        xchg    eax, [esp+8]

        lea     eax, [eax*5]

        add     eax, eax

        add     [esp+8], eax

        jmp     .spec

  .asterisk:

        mov     eax, [ebp]

        add     ebp, 4

        cmp     bl, 2

        ja      .asterisk_precision

        test    eax, eax

        jns     @f

        neg     eax

        or      bh, 2

  @@:

        mov     [esp+4], eax

        mov     bl, 3

        jmp     .spec

  .asterisk_precision:

        cmp     bl, 3

        jnz     .errspec

        mov     [esp+8], eax

        inc     ebx

        jmp     .spec

  .dot:

        cmp     bl, 2

        ja      .errspec

        mov     bl, 3

        and     dword [esp+8], 0

        jmp     .spec

  .long:

        cmp     bl, 3

        ja      .errspec

        mov     bl, 4

        jmp     .spec

  .short:

        cmp     bl, 3

        ja      .errspec

        mov     bl, 4

        or      bh, 8

        jmp     .spec

  .unsigned:

  .dec:

        push    10

        jmp     .write_number

  .pointer:

        mov     dword [esp+12], 8

        or      bh, 4

        and     bh, not 8

  .hex:

        push    16

        jmp     @f

  .oct:

        push    8

  @@:

        mov     byte [esp+4], 0

  .write_number:

        pop     ecx

        push    edi

        lea     edi, [esp+16+64-1]      ; edi -> end of buffer

        mov     byte [edi], 0

        push    edx

        push    eax

        mov     eax, [ebp]

        add     ebp, 4

        test    bh, 8

        jz      @f

        movzx   eax, ax

        cmp     byte [esp], 'd'

        jnz     @f

        movsx   eax, ax

  @@:

        xor     edx, edx

        test    eax, eax

        jns     @f

        cmp     byte [esp], 'd'

        jnz     @f

        inc     edx

        neg     eax

  @@:

        push    edx

        xor     edx, edx

; �᫮ � eax, �᭮����� ��⥬� ��᫥��� � ecx

  @@:

        cmp     dword [esp+16+8], 0

        jnz     .print_num

        test    eax, eax

        jz      .zeronum

  .print_num:

        div     ecx

        xchg    eax, edx

        cmp     al, 10

        sbb     al, 69h

        das

        cmp     byte [esp+4], 'x'

        jnz     @f

        or      al, 20h

  @@:

        dec     edi

        mov     [edi], al

        xor     eax, eax

        xchg    eax, edx

        test    eax, eax

        jnz     .print_num

  .zeronum:

        push    0

        mov     edx, [esp+12]

        lea     eax, [esp+32+64-1]

        sub     eax, edi

        cmp     dword [esp+20+8], -1

        jz      .noprec1

        cmp     eax, [esp+20+8]

        jae     .len_found1

        mov     eax, [esp+20+8]

        jmp     .len_found1

  .noprec1:

        test    bh, 4

        jnz     .do_print_num

  .len_found1:

        test    bh, 2

        jnz     .do_print_num

        cmp     byte [esp+20], 0

        jz      @f

        inc     eax

  @@:

        cmp     byte [esp+20], 0

        jnz     @f

        cmp     byte [esp+4], 0

        jz      @f

        inc     eax

  @@:

        test    bh, 1

        jz      .nosharp1

        cmp     cl, 8

        jnz     @f

        inc     eax

        jmp     .nosharp1

  @@:

        cmp     cl, 16

        jnz     .nosharp1

        inc     eax

        inc     eax

  .nosharp1:

        cmp     dword [esp+20+4], -1

        jz      .do_print_num

        sub     eax, [esp+20+4]

        jae     .do_print_num

        push    ecx

        mov     ecx, eax

        mov     al, ' '

  @@:

        xchg    edi, [esp+20]

        call    con.write_char_ex

        inc     dword [esp+24+12+64+28]

        xchg    edi, [esp+20]

        inc     dword [esp+4]

        inc     ecx

        jnz     @b

        pop     ecx

  .do_print_num:

        mov     al, '-'

        cmp     byte [esp+4], 0

        jnz     .write_sign

        mov     al, [esp+20]

        test    al, al

        jz      .sign_written

  .write_sign:

        call    .num_write_char

  .sign_written:

        test    bh, 1

        jz      .nosharp2

        mov     al, '0'

        cmp     cl, 8

        jz      @f

        cmp     cl, 16

        jnz     .nosharp2

        call    .num_write_char

        mov     al, [esp+8]

  @@:

        call    .num_write_char

  .nosharp2:

        lea     ecx, [esp+32+64-1]

        sub     ecx, edi

        cmp     dword [esp+20+8], -1

        jz      .noprec2

        sub     ecx, [esp+20+8]

        jmp     .lead_zeroes

  .noprec2:

        test    bh, 4

        jz      .do_print_num2

        add     ecx, [esp]

        sub     ecx, [esp+20+4]

  .lead_zeroes:

        jae     .do_print_num2

  @@:

        mov     al, '0'

        call    .num_write_char

        inc     ecx

        jnz     @b

  .do_print_num2:

        mov     al, [edi]

        test    al, al

        jz      .num_written

        call    .num_write_char

        inc     edi

        jmp     .do_print_num2

  .num_written:

        pop     ecx

        mov     edi, [esp+12]

        cmp     dword [esp+16+4], -1

        jz      .num_written2

  @@:

        cmp     ecx, [esp+16+4]

        jae     .num_written2

        mov     al, ' '

        call    con.write_char

        inc     ecx

        jmp     @b

  .num_written2:

        add     esp, 16

  .spec_done:

        add     esp, 12

        jmp     .loop

  .char:

        mov     ecx, [esp+4]

        cmp     ecx, -1

        jnz     @f

        inc     ecx

  @@:

        test    ecx, ecx

        jnz     @f

        inc     ecx

  @@:

        test    bh, 2

        jnz     .char_left_pad

        mov     al, ' '

        dec     ecx

        jz      .nowidth

        add     [esp+12+64+28], ecx

  @@:

        call    con.write_char

        loop    @b

  .nowidth:

        mov     al, [ebp]

        add     ebp, 4

        jmp     .percent

  .char_left_pad:

        mov     al, [ebp]

        add     ebp, 4

        call    con.write_char_ex

        add     [esp+12+64+28], ecx

        dec     ecx

        jz      .nowidth2

        mov     al, ' '

  @@:

        call    con.write_char

        loop    @b

  .nowidth2:

        jmp     .spec_done

  .string:

        push    esi

        mov     esi, [ebp]

        test    esi, esi

        jnz     @f

        mov     esi, con.aNull

  @@:

        add     ebp, 4

        or      ecx, -1

  @@:

        inc     ecx

        cmp     byte [esi+ecx], 0

        jnz     @b

        cmp     ecx, [esp+12]

        jb      @f

        mov     ecx, [esp+12]

  @@:

        test    bh, 2

        jnz     .write_string

        cmp     dword [esp+8], -1

        jz      .write_string

        push    ecx

        sub     ecx, [esp+12]

        jae     .nospace

        mov     al, ' '

  @@:

        call    con.write_char

        inc     dword [esp+20+64+28]

        inc     ecx

        jnz     @b

  .nospace:

        pop     ecx

  .write_string:

        jecxz   .string_written

        add     dword [esp+16+64+28], ecx

        push    ecx

  @@:

        lodsb

        call    con.write_char_ex

        loop    @b

        pop     ecx

  .string_written:

        pop     esi

        test    bh, 2

        jz      .spec_done

        cmp     dword [esp+4], -1

        jz      .spec_done

        sub     ecx, [esp+4]

        jae     .spec_done

        mov     al, ' '

  @@:

        call    con.write_char

        inc     dword [esp+12+64+28]

        inc     ecx

        jnz     @b

        jmp     .spec_done

  .done:

        add     esp, 64

        popad

        jmp     con.update_screen

  .num_write_char:

        xchg    edi, [esp+20]

        call    con.write_char_ex

        inc     dword [esp+24+12+64+28]

        xchg    edi, [esp+20]

        inc     dword [esp+4]

        ret

con.write:

; esi = string, ebx = length (ebx=-1 for ASCIIZ strings)

        push    edi

        call    con.get_data_ptr

        test    ebx, ebx

        jz      .done

  .loop:

        lodsb

        cmp     ebx, -1

        jnz     @f

        test    al, al

        jz      .done

  @@:

        call    con.write_char_ex

  .next:

        cmp     ebx, -1

        jz      .loop

        dec     ebx

        jnz     .loop

  .done:

        pop     edi

        jmp     con.update_screen

con.get_data_ptr:

        mov     edi, [con.cur_y]

        imul    edi, [con.scr_width]

        add     edi, [con.cur_x]

        add     edi, edi

        add     edi, [con.data]

        ret

con.write_char_ex:

        test    byte [con_flags+1], 1

        jz      con.write_special_char

con.write_char:

        push    eax

        mov     eax, [con.cur_x]

        cmp     eax, [con.scr_width]

        jb      @f

        and     [con.cur_x], 0

        call    con.newline

  @@:

        mov     eax, [esp]

        stosb

        mov     al, byte [con_flags]

        stosb

        mov     eax, [con.cur_x]

        inc     eax

        mov     [con.cur_x], eax

        pop     eax

        ret

con.write_special_char:

        cmp     [con_esc], 0

        jnz     .esc_mode

  .normal_mode:

        cmp     al, 10

        jz      .write_lf

        cmp     al, 13

        jz      .write_cr

        cmp     al, 27

        jz      .write_esc

        cmp     al, 8

        jz      .write_bs

        cmp     al, 7

        jz      .bell

        cmp     al, 9

        jnz     con.write_char

  .write_tab:

        mov     al, ' '

        call    con.write_char

        test    [con.cur_x], 7

        jnz     .write_tab

        ret

  .write_cr:

        and     [con.cur_x], 0

        jmp     con.get_data_ptr

  .write_lf:

        and     [con.cur_x], 0

        jmp     con.newline

  .write_bs:

        cmp     [con.cur_x], 0

        jz      @f

        dec     [con.cur_x]

        dec     edi

        dec     edi

        ret

  @@:

        push    eax

        mov     eax, [con.cur_y]

        dec     eax

        js      @f

        mov     [con.cur_y], eax

        mov     eax, [con.scr_width]

        dec     eax

        mov     [con.cur_x], eax

        dec     edi

        dec     edi

  @@:

        pop     eax

        ret

  .bell:

        pusha

        push    55

        pop     eax

        mov     ebx, eax

        mov     esi, con.bell

        int     0x40

        popa

        ret

  .write_esc:

        mov     [con_esc], 1

        mov     [con_esc_attr_n], 1

        and     [con_esc_attrs], 0

        ret

  .esc_mode:

        cmp     [con_sci], 0

        jnz     .esc_sci

        cmp     al, '['         ; CSI - Control Sequence Introducer

        je      .esc_sqro

        cmp     al, ']'         ; OSC - Operating System Command

        je      .esc_sqrc

        cmp     al, '('         ; Designate G0 Character Set, VT100, ISO 2022.

        je      .esc_rndo

        cmp     al, '>'         ; Normal Keypad (DECKPNM), VT100.

        je      .keypm_norm

        cmp     al, '='         ; Application Keypad (DECKPAM).

        je      .keypm_alt

; Control characters

        cmp     al, 'G'

        je      .bell

        cmp     al, 'H'

        je      .write_bs

        cmp     al, 'I'

        je      .write_tab

        cmp     al, 'J'

        je      .write_lf

        cmp     al, 'M'

        je      .write_cr

; Unrecognized escape sequence, print it to screen

        push    eax

        mov     al, 27

        call    con.write_char

        pop     eax

        jmp     con.write_char

  .esc_sqro:

        mov     [con_sci], 1

        ret

  .esc_sqrc:

        mov     [con_sci], 2

        ret

  .esc_rndo:

        mov     [con_sci], 4

        ret

.keypm_norm:

; TODO: turn numlock on

        mov     [con_esc], 0

        ret

.keypm_alt:

; TODO: turn numlock off

        mov     [con_esc], 0

        ret

.esc_sci:

        cmp     [con_sci], 3

        je      .string

        cmp     [con_sci], 4

        je      .g0charset

; this is real Esc sequence

        cmp     al, '?'         ; DEC private mode (DECSET/DECRST sequences)

        je      .questionmark

        cmp     al, ';'

        jz      .next_arg

        cmp     al, '0'

        jb      .not_digit

        cmp     al, '9'

        ja      .not_digit

        push    eax ecx edx

        sub     al, '0'

        movzx   eax, al

        mov     ecx, [con_esc_attr_n]

        mov     edx, [con_esc_attrs+(ecx-1)*4]

        lea     edx, [edx*5]

        lea     edx, [edx*2+eax]

        mov     [con_esc_attrs+(ecx-1)*4], edx

        pop     edx ecx eax

        ret

.g0charset:

; Designate G0 Character Set

; Unimplemented: read and ignore.

        mov     [con_sci], 0

        mov     [con_esc], 0

        ret

.string:

        cmp     al, 0x07        ; bell

        je      .string_end

        cmp     al, 0x9C        ; string terminator

        je      .string_end

        push    ecx

        mov     ecx, [con_osc_strlen]

        cmp     ecx, 255

        jae     @f

        mov     [con_osc_str+ecx], al

        inc     [con_osc_strlen]

@@:

        pop     ecx

        ret

.string_end:

        mov     [con_sci], 0

        mov     [con_esc], 0

        pusha

        mov     ecx, [con_osc_strlen]

        mov     byte[con_osc_str+ecx], 0

        cmp     [con_esc_attrs+0], 0            ; Set Icon and Window Title

        je      .set_title

        cmp     [con_esc_attrs+0], 2            ; Set Window Title

        je      .set_title

        ret

.set_title:

        push    con_osc_str

        call    con_set_title

        popa

        ret

.questionmark:

        push    ecx

        mov     ecx, [con_esc_attr_n]

        mov     dword[con_esc_attrs+(ecx-1)*4], 0xffffffff

        pop     ecx

.next_arg:

        push    eax

        mov     eax, [con_esc_attr_n]

        inc     eax

        cmp     al, 4

        jbe     @f

        dec     eax

@@:

        mov     [con_esc_attr_n], eax

        and     [con_esc_attrs+(eax-1)*4], 0

; Check for operating system command

        cmp     [con_sci], 2

        jne     @f

        cmp     [con_esc_attr_n], 2

        jne     @f

; Next argument is string

        mov     [con_sci], 3

        mov     [con_osc_strlen], 0

@@:

        pop     eax

        ret

.not_digit:

        mov     [con_esc], 0

        mov     [con_sci], 0    ; in any case, leave Esc mode

;        cmp     al, '@'

;        je      .insert_chars

        cmp     al, 'A'

        je      .cursor_up

        cmp     al, 'B'

        je      .cursor_down

        cmp     al, 'C'

        je      .cursor_right

        cmp     al, 'D'

        je      .cursor_left

;        cmp     al, 'E'

;        je      .cursor_next_line

;        cmp     al, 'F'

;        je      .cursor_prev_line

;        cmp     al, 'G'

;        je      .cursor_next_line

;        cmp     al, 'S'

;        je      .scroll_page_up

;        cmp     al, 'T'

;        je      .scroll_page_down

        cmp     al, 'H'

        je      .cursor_position

        cmp     al, 'J'

        je      .erase_in_display

        cmp     al, 'K'

        je      .erase_in_line

        cmp     al, 'L'

        je      .insert_lines

        cmp     al, 'M'

        je      .delete_lines

        cmp     al, 'P'

        je      .delete_chars

        cmp     al, 'X'

        je      .erase_chars

        cmp     al, 'd'

        je      .line_position_abs

;        cmp     al, 'e'

;        je      .line_position_rel

        cmp     al, 'f'

        je      .cursor_position

        cmp     al, 'h'

        je      .set_mode

        cmp     al, 'l'

        je      .reset_mode

        cmp     al, 'm'

        je      .set_attr

        cmp     al, 'r'

        je      .scroll_region

;        cmp     al, 's'

;        je      .save_cursor_pos

;        cmp     al, 't'

;        je      .window_manip

;        cmp     al, 'u'

;        je      .restore_cursor_pos

        ret     ; simply skip unknown sequences

.insert_lines:

        push    eax ebx ecx esi

        mov     eax, [con_esc_attrs+0]  ; amount of lines to scroll down

        test    eax, eax

        jnz     @f                      ; default is 1

        inc     eax

  @@:

; Check that we are inside the scroll region

        mov     ebx, [con.cur_y]

        cmp     ebx, [con.scroll_top]

        jb      .no_insert_lines