| /programs/develop/ktcc/trunk/libc/start/start.asm |
|---|
| 0,0 → 1,135 |
| format ELF |
| section '.text' executable |
| public start |
| extrn mf_init |
| extrn main |
| public argc as '__ARGS' |
| __DEBUG__ equ 1 |
| __DEBUG_LEVEL__ equ 1 |
| include 'DEBUG-FDO.INC' |
| virtual at 0 |
| db 'MENUET01' ; 1. Magic number (8 bytes) |
| dd 0x01 ; 2. Version of executable file |
| dd 0x0 ; 3. Start address |
| dd 0x0 ; 4. Size of image |
| dd 0x100000 ; 5. Size of needed memory |
| dd 0x100000 ; 6. Pointer to stack |
| hparams dd 0x0 ; 7. Pointer to program arguments |
| hpath dd 0x0 ; 8. Pointer to program path |
| end virtual |
| start: |
| DEBUGF 1,'Start programm\n' |
| xor eax,eax |
| call mf_init |
| DEBUGF 1,' path "%s"\n params "%s"\n', path, params |
| ; check for overflow |
| mov al, [path+buf_len-1] |
| or al, [params+buf_len-1] |
| jnz .crash |
| ; check if path written by OS |
| mov eax, [hparams] |
| test eax, eax |
| jz .without_path |
| mov eax, path |
| .without_path: |
| mov esi, eax |
| call push_param |
| ; retrieving parameters |
| mov esi, params |
| xor edx, edx ; dl - èä¸ò ïàðàìåòð(1) èëè ðàçäåëèòåëè(0) |
| ; dh - ñèìâîë ñ êîòîðîãî íà÷àëñÿ ïàðàìåòð (1 êàâû÷êè, 0 îñòàëüíîå) |
| mov ecx, 1 ; cl = 1 |
| ; ch = 0 ïðîñòî íîëü |
| .parse: |
| lodsb |
| test al, al |
| jz .run |
| test dl, dl |
| jnz .findendparam |
| ;{åñëè áûë ðàçäåëèòåëü |
| cmp al, ' ' |
| jz .parse ;çàãðóæåí ïðîáåë, ãðóçèì ñëåäóþùèé ñèìâîë |
| mov dl, cl ;íà÷èíàåòñÿ ïàðàìåòð |
| cmp al, '"' |
| jz @f ;çàãðóæåíû êàâû÷êè |
| mov dh, ch ;ïàðàìåòð áåç êàâû÷åê |
| dec esi |
| call push_param |
| inc esi |
| jmp .parse |
| @@: |
| mov dh, cl ;ïàðàìåòð â êàâû÷åêàõ |
| call push_param ;åñëè íå ïðîáåë çíà÷èò íà÷èíàåòñÿ êàêîé òî ïàðàìåòð |
| jmp .parse ;åñëè áûë ðàçäåëèòåëü} |
| .findendparam: |
| test dh, dh |
| jz @f ; áåç êàâû÷åê |
| cmp al, '"' |
| jz .clear |
| jmp .parse |
| @@: |
| cmp al, ' ' |
| jnz .parse |
| .clear: |
| lea ebx, [esi - 1] |
| mov [ebx], ch |
| mov dl, ch |
| jmp .parse |
| .run: |
| DEBUGF 1,'call main(%x, %x) with params:\n', [argc], argv |
| if __DEBUG__ = 1 |
| mov ecx, [argc] |
| @@: |
| lea esi, [ecx * 4 + argv-4] |
| DEBUGF 1,'%d) "%s"\n', cx, [esi] |
| loop @b |
| end if |
| push argv |
| push [argc] |
| call main |
| .exit: |
| DEBUGF 1,'Exit from prog with code: %x\n', eax; |
| xor eax,eax |
| dec eax |
| int 0x40 |
| dd -1 |
| .crash: |
| DEBUGF 1,'E:buffer overflowed\n' |
| jmp .exit |
| ;============================ |
| push_param: |
| ;============================ |
| ;parameters |
| ; esi - pointer |
| ;description |
| ; procedure increase argc |
| ; and add pointer to array argv |
| ; procedure changes ebx |
| mov ebx, [argc] |
| cmp ebx, max_parameters |
| jae .dont_add |
| mov [argv+4*ebx], esi |
| inc [argc] |
| .dont_add: |
| ret |
| ;============================== |
| public params as '__argv' |
| public path as '__path' |
| section '.bss' |
| buf_len = 0x400 |
| max_parameters=0x20 |
| argc rd 1 |
| argv rd max_parameters |
| path rb buf_len |
| params rb buf_len |
| section '.data' |
| include_debug_strings ; ALWAYS present in data section |
| /programs/develop/ktcc/trunk/libc/start/debug-fdo.inc |
|---|
| 0,0 → 1,422 |
| ; |
| ; Formatted Debug Output (FDO) |
| ; Copyright (c) 2005-2006, mike.dld |
| ; Created: 2005-01-29, Changed: 2006-11-10 |
| ; |
| ; For questions and bug reports, mail to mike.dld@gmail.com |
| ; |
| ; Available format specifiers are: %s, %d, %u, %x (with partial width support) |
| ; |
| ; to be defined: |
| ; __DEBUG__ equ 1 |
| ; __DEBUG_LEVEL__ equ 5 |
| macro debug_func name { |
| if used name |
| name@of@func equ name |
| } |
| macro debug_beginf { |
| align 4 |
| name@of@func: |
| } |
| debug_endf fix end if |
| macro DEBUGS _sign,[_str] { |
| common |
| local tp |
| tp equ 0 |
| match _arg:_num,_str \{ |
| DEBUGS_N _sign,_num,_arg |
| tp equ 1 |
| \} |
| match =0 _arg,tp _str \{ |
| DEBUGS_N _sign,,_arg |
| \} |
| } |
| macro DEBUGS_N _sign,_num,[_str] { |
| common |
| pushf |
| pushad |
| local ..str,..label,is_str |
| is_str = 0 |
| forward |
| if _str eqtype '' |
| is_str = 1 |
| end if |
| common |
| if is_str = 1 |
| jmp ..label |
| ..str db _str,0 |
| ..label: |
| add esp,4*8+4 |
| mov edx,..str |
| sub esp,4*8+4 |
| else |
| mov edx,_str |
| end if |
| if ~_num eq |
| if _num eqtype eax |
| if _num in <eax,ebx,ecx,edx,edi,ebp,esp> |
| mov esi,_num |
| else if ~_num eq esi |
| movzx esi,_num |
| end if |
| else if _num eqtype 0 |
| mov esi,_num |
| else |
| local tp |
| tp equ 0 |
| match [_arg],_num \{ |
| mov esi,dword[_arg] |
| tp equ 1 |
| \} |
| match =0 =dword[_arg],tp _num \{ |
| mov esi,dword[_arg] |
| tp equ 1 |
| \} |
| match =0 =word[_arg],tp _num \{ |
| movzx esi,word[_arg] |
| tp equ 1 |
| \} |
| match =0 =byte[_arg],tp _num \{ |
| movzx esi,byte[_arg] |
| tp equ 1 |
| \} |
| match =0,tp \{ |
| 'Error: specified string width is incorrect' |
| \} |
| end if |
| else |
| mov esi,0x7FFFFFFF |
| end if |
| call fdo_debug_outstr |
| popad |
| popf |
| } |
| macro DEBUGD _sign,_dec { |
| local tp |
| tp equ 0 |
| match _arg:_num,_dec \{ |
| DEBUGD_N _sign,_num,_arg |
| tp equ 1 |
| \} |
| match =0 _arg,tp _dec \{ |
| DEBUGD_N _sign,,_arg |
| \} |
| } |
| macro DEBUGD_N _sign,_num,_dec { |
| pushf |
| pushad |
| if (~_num eq) |
| if (_dec eqtype eax | _dec eqtype 0) |
| 'Error: precision allowed only for in-memory variables' |
| end if |
| if (~_num in <1,2,4>) |
| if _sign |
| 'Error: 1, 2 and 4 are only allowed for precision in %d' |
| else |
| 'Error: 1, 2 and 4 are only allowed for precision in %u' |
| end if |
| end if |
| end if |
| if _dec eqtype eax |
| if _dec in <ebx,ecx,edx,esi,edi,ebp,esp> |
| mov eax,_dec |
| else if ~_dec eq eax |
| if _sign = 1 |
| movsx eax,_dec |
| else |
| movzx eax,_dec |
| end if |
| end if |
| else if _dec eqtype 0 |
| mov eax,_dec |
| else |
| add esp,4*8+4 |
| if _num eq |
| mov eax,dword _dec |
| else if _num = 1 |
| if _sign = 1 |
| movsx eax,byte _dec |
| else |
| movzx eax,byte _dec |
| end if |
| else if _num = 2 |
| if _sign = 1 |
| movsx eax,word _dec |
| else |
| movzx eax,word _dec |
| end if |
| else |
| mov eax,dword _dec |
| end if |
| sub esp,4*8+4 |
| end if |
| mov cl,_sign |
| call fdo_debug_outdec |
| popad |
| popf |
| } |
| macro DEBUGH _sign,_hex { |
| local tp |
| tp equ 0 |
| match _arg:_num,_hex \{ |
| DEBUGH_N _sign,_num,_arg |
| tp equ 1 |
| \} |
| match =0 _arg,tp _hex \{ |
| DEBUGH_N _sign,,_arg |
| \} |
| } |
| macro DEBUGH_N _sign,_num,_hex { |
| pushf |
| pushad |
| if (~_num eq) & (~_num in <1,2,3,4,5,6,7,8>) |
| 'Error: 1..8 are only allowed for precision in %x' |
| end if |
| if _hex eqtype eax |
| if _hex in <eax,ebx,ecx,edx,esi,edi,ebp,esp> |
| if ~_hex eq eax |
| mov eax,_hex |
| end if |
| else if _hex in <ax,bx,cx,dx,si,di,bp,sp> |
| if ~_hex eq ax |
| movzx eax,_hex |
| end if |
| shl eax,16 |
| if (_num eq) |
| mov edx,4 |
| end if |
| else if _hex in <al,ah,bl,bh,cl,ch,dl,dh> |
| if ~_hex eq al |
| movzx eax,_hex |
| end if |
| shl eax,24 |
| if (_num eq) |
| mov edx,2 |
| end if |
| end if |
| else if _hex eqtype 0 |
| mov eax,_hex |
| else |
| add esp,4*8+4 |
| mov eax,dword _hex |
| sub esp,4*8+4 |
| end if |
| if ~_num eq |
| mov edx,_num |
| else |
| mov edx,8 |
| end if |
| call fdo_debug_outhex |
| popad |
| popf |
| } |
| ;----------------------------------------------------------------------------- |
| debug_func fdo_debug_outchar |
| debug_beginf |
| pushad |
| mov cl,al |
| mov ebx,1 |
| mov eax,63 |
| int 0x40 |
| popad |
| ret |
| debug_endf |
| debug_func fdo_debug_outstr |
| debug_beginf |
| mov eax,63 |
| mov ebx,1 |
| .l1: dec esi |
| js .l2 |
| mov cl,[edx] |
| or cl,cl |
| jz .l2 |
| int 0x40 |
| inc edx |
| jmp .l1 |
| .l2: ret |
| debug_endf |
| debug_func fdo_debug_outdec |
| debug_beginf |
| or cl,cl |
| jz @f |
| or eax,eax |
| jns @f |
| neg eax |
| push eax |
| mov al,'-' |
| call fdo_debug_outchar |
| pop eax |
| @@: push 10 |
| pop ecx |
| push -'0' |
| .l1: xor edx,edx |
| div ecx |
| push edx |
| test eax,eax |
| jnz .l1 |
| .l2: pop eax |
| add al,'0' |
| jz .l3 |
| call fdo_debug_outchar |
| jmp .l2 |
| .l3: ret |
| debug_endf |
| debug_func fdo_debug_outhex |
| __fdo_hexdigits db '0123456789ABCDEF' |
| debug_beginf |
| mov cl,dl |
| neg cl |
| add cl,8 |
| shl cl,2 |
| rol eax,cl |
| .l1: rol eax,4 |
| push eax |
| and eax,0x0000000F |
| mov al,[__fdo_hexdigits+eax] |
| call fdo_debug_outchar |
| pop eax |
| dec edx |
| jnz .l1 |
| ret |
| debug_endf |
| ;----------------------------------------------------------------------------- |
| macro DEBUGF _level,_format,[_arg] { |
| common |
| if __DEBUG__ = 1 & _level >= __DEBUG_LEVEL__ |
| local ..f1,f2,a1,a2,c1,c2,c3,..lbl |
| _debug_str_ equ __debug_str_ # a1 |
| a1 = 0 |
| c2 = 0 |
| c3 = 0 |
| f2 = 0 |
| repeat ..lbl-..f1 |
| virtual at 0 |
| db _format,0,0 |
| load c1 word from %-1 |
| end virtual |
| if c1 = '%s' |
| virtual at 0 |
| db _format,0,0 |
| store word 0 at %-1 |
| load c1 from f2-c2 |
| end virtual |
| if c1 <> 0 |
| DEBUGS 0,_debug_str_+f2-c2 |
| end if |
| c2 = c2 + 1 |
| f2 = %+1 |
| DEBUGF_HELPER S,a1,0,_arg |
| else if c1 = '%x' |
| virtual at 0 |
| db _format,0,0 |
| store word 0 at %-1 |
| load c1 from f2-c2 |
| end virtual |
| if c1 <> 0 |
| DEBUGS 0,_debug_str_+f2-c2 |
| end if |
| c2 = c2 + 1 |
| f2 = %+1 |
| DEBUGF_HELPER H,a1,0,_arg |
| else if c1 = '%d' | c1 = '%u' |
| local c4 |
| if c1 = '%d' |
| c4 = 1 |
| else |
| c4 = 0 |
| end if |
| virtual at 0 |
| db _format,0,0 |
| store word 0 at %-1 |
| load c1 from f2-c2 |
| end virtual |
| if c1 <> 0 |
| DEBUGS 0,_debug_str_+f2-c2 |
| end if |
| c2 = c2 + 1 |
| f2 = %+1 |
| DEBUGF_HELPER D,a1,c4,_arg |
| else if c1 = '\n' |
| c3 = c3 + 1 |
| end if |
| end repeat |
| virtual at 0 |
| db _format,0,0 |
| load c1 from f2-c2 |
| end virtual |
| if (c1<>0)&(f2<>..lbl-..f1-1) |
| DEBUGS 0,_debug_str_+f2-c2 |
| end if |
| virtual at 0 |
| ..f1 db _format,0 |
| ..lbl: |
| __debug_strings equ __debug_strings,_debug_str_,<_format>,..lbl-..f1-1-c2-c3 |
| end virtual |
| end if |
| } |
| macro __include_debug_strings dummy,[_id,_fmt,_len] { |
| common |
| local c1,a1,a2 |
| forward |
| if defined _len & ~_len eq |
| _id: |
| a1 = 0 |
| a2 = 0 |
| repeat _len |
| virtual at 0 |
| db _fmt,0,0 |
| load c1 word from %+a2-1 |
| end virtual |
| if (c1='%s')|(c1='%x')|(c1='%d')|(c1='%u') |
| db 0 |
| a2 = a2 + 1 |
| else if (c1='\n') |
| dw $0A0D |
| a1 = a1 + 1 |
| a2 = a2 + 1 |
| else |
| db c1 and 0x0FF |
| end if |
| end repeat |
| db 0 |
| end if |
| } |
| macro DEBUGF_HELPER _letter,_num,_sign,[_arg] { |
| common |
| local num |
| num = 0 |
| forward |
| if num = _num |
| DEBUG#_letter _sign,_arg |
| end if |
| num = num+1 |
| common |
| _num = _num+1 |
| } |
| macro include_debug_strings { |
| if __DEBUG__ = 1 |
| match dbg_str,__debug_strings \{ |
| __include_debug_strings dbg_str |
| \} |
| end if |
| } |
| /programs/develop/ktcc/trunk/libc/start/macros.inc |
|---|
| 0,0 → 1,337 |
| ; language for programs |
| lang fix en ; ru en fr ge fi |
| @^ fix macro comment { |
| ^@ fix } |
| ; strings |
| macro sz name,[data] { ; from MFAR [mike.dld] |
| common |
| if used name |
| name db data |
| .size = $-name |
| end if |
| } |
| macro lsz name,[lng,data] { ; from MFAR [mike.dld] |
| common |
| if used name |
| label name |
| forward |
| if lang eq lng |
| db data |
| end if |
| common |
| .size = $-name |
| end if |
| } |
| macro szc name,elsz,[data] { ; from MFAR [mike.dld] |
| common |
| local s,m |
| m = 0 |
| if used name |
| label name |
| virtual at 0 |
| db data |
| s = $ |
| end virtual |
| d#elsz s |
| if m < s |
| m = s |
| end if |
| db data |
| .size = $-name |
| .maxl = m |
| end if |
| } |
| macro lszc name,elsz,[lng,data] { ; from MFAR [mike.dld] |
| common |
| local s,m |
| m = 0 |
| if used name |
| label name |
| forward |
| if lang eq lng |
| virtual at 0 |
| db data |
| s = $ |
| end virtual |
| d#elsz s |
| if m < s |
| m = s |
| end if |
| db data |
| end if |
| common |
| .size = $-name |
| .maxl = m |
| end if |
| } |
| ; easy system call macro |
| macro mpack dest, hsrc, lsrc |
| { |
| if (hsrc eqtype 0) & (lsrc eqtype 0) |
| mov dest, (hsrc) shl 16 + lsrc |
| else |
| if (hsrc eqtype 0) & (~lsrc eqtype 0) |
| mov dest, (hsrc) shl 16 |
| add dest, lsrc |
| else |
| mov dest, hsrc |
| shl dest, 16 |
| add dest, lsrc |
| end if |
| end if |
| } |
| macro __mov reg,a,b { ; mike.dld |
| if (~a eq)&(~b eq) |
| mpack reg,a,b |
| else if (~a eq)&(b eq) |
| mov reg,a |
| end if |
| } |
| macro mcall a,b,c,d,e,f { ; mike.dld |
| __mov eax,a |
| __mov ebx,b |
| __mov ecx,c |
| __mov edx,d |
| __mov esi,e |
| __mov edi,f |
| int 0x40 |
| } |
| ; ------------------------- |
| macro header a,[b] { |
| common |
| use32 |
| org 0 |
| db 'MENUET',a |
| forward |
| if b eq |
| dd 0 |
| else |
| dd b |
| end if } |
| macro section name,algn |
| { |
| local boundary |
| boundary = 16 |
| if ~algn eq |
| boundary = algn |
| end if |
| align boundary |
| label name |
| } |
| macro func name { |
| if ~used name |
| display 'FUNC NOT USED: ',`name,13,10 |
| else |
| align 4 |
| name: |
| ;pushad |
| ;pushfd |
| ;dps `name |
| ;newline |
| ;mcall 5,1 |
| ;popfd |
| ;popad |
| } |
| macro endf { end if } |
| macro jif _op1,_cond,_op2,_label,_op |
| { |
| if _op eq |
| cmp _op1,_op2 |
| else |
| _op _op1,_op2 |
| end if |
| j#_cond _label |
| } |
| macro diff16 title,l1,l2 |
| { |
| local s,d |
| s = l2-l1 |
| display title,': 0x' |
| repeat 8 |
| d = '0' + s shr ((8-%) shl 2) and $0F |
| if d > '9' |
| d = d + 'A'-'9'-1 |
| end if |
| display d |
| end repeat |
| display 13,10 |
| } |
| macro diff10 title,l1,l2 |
| { |
| local s,d,z,m |
| s = l2-l1 |
| z = 0 |
| m = 1000000000 |
| display title,': ' |
| repeat 10 |
| d = '0' + s / m |
| s = s - (s/m)*m |
| m = m / 10 |
| if d <> '0' |
| z = 1 |
| end if |
| if z <> 0 |
| display d |
| end if |
| end repeat |
| display 13,10 |
| } |
| ; optimize the code for size |
| __regs fix <eax,ebx,ecx,edx,esi,edi,ebp,esp> |
| macro add arg1,arg2 |
| { |
| if (arg2 eqtype 0) |
| if (arg2) = 1 |
| inc arg1 |
| else |
| add arg1,arg2 |
| end if |
| else |
| add arg1,arg2 |
| end if |
| } |
| macro sub arg1,arg2 |
| { |
| if (arg2 eqtype 0) |
| if (arg2) = 1 |
| dec arg1 |
| else |
| sub arg1,arg2 |
| end if |
| else |
| sub arg1,arg2 |
| end if |
| } |
| macro mov arg1,arg2 |
| { |
| if (arg1 in __regs) & (arg2 eqtype 0) |
| if (arg2) = 0 |
| xor arg1,arg1 |
| else if (arg2) = 1 |
| xor arg1,arg1 |
| inc arg1 |
| else if (arg2) = -1 |
| or arg1,-1 |
| else if (arg2) > -128 & (arg2) < 128 |
| push arg2 |
| pop arg1 |
| else |
| mov arg1,arg2 |
| end if |
| else |
| mov arg1,arg2 |
| end if |
| } |
| struc POINT _t,_dx,_dy { |
| .x _t _dx |
| .y _t _dy |
| } |
| ; structure definition helper |
| macro struct name, [arg] |
| { |
| common |
| name@struct fix name |
| struc name arg { |
| } |
| macro struct_helper name |
| { |
| virtual at 0 |
| name name |
| sizeof.#name = $ - name |
| name equ sizeof.#name |
| end virtual |
| } |
| ends fix } struct_helper name@struct |
| macro union [def] |
| { |
| common size@union = 0 |
| origin@union = $ |
| forward virtual |
| def |
| if $-origin@union > size@union |
| size@union = $-origin@union |
| end if |
| end virtual |
| common rb size@union |
| } |
| ; structures used in MeOS |
| struc process_information |
| { |
| .cpu_usage dd ? ; +0 |
| .window_stack_position dw ? ; +4 |
| .window_stack_value dw ? ; +6 |
| .not_used1 dw ? ; +8 |
| .process_name rb 12 ; +10 |
| .memory_start dd ? ; +22 |
| .used_memory dd ? ; +26 |
| .PID dd ? ; +30 |
| .x_start dd ? ; +34 |
| .y_start dd ? ; +38 |
| .x_size dd ? ; +42 |
| .y_size dd ? ; +46 |
| .slot_state dw ? ; +50 |
| rb (1024-52) |
| } |
| struc system_colors |
| { |
| .frame dd ? |
| .grab dd ? |
| .grab_button dd ? |
| .grab_button_text dd ? |
| .grab_text dd ? |
| .work dd ? |
| .work_button dd ? |
| .work_button_text dd ? |
| .work_text dd ? |
| .work_graph dd ? |
| } |
| ; constants |
| ; events |
| EV_IDLE = 0 |
| EV_TIMER = 0 |
| EV_REDRAW = 1 |
| EV_KEY = 2 |
| EV_BUTTON = 3 |
| EV_EXIT = 4 |
| EV_BACKGROUND = 5 |
| EV_MOUSE = 6 |
| EV_IPC = 7 |
| EV_STACK = 8 |
| ; event mask bits for function 40 |
| EVM_REDRAW = 1b |
| EVM_KEY = 10b |
| EVM_BUTTON = 100b |
| EVM_EXIT = 1000b |
| EVM_BACKGROUND = 10000b |
| EVM_MOUSE = 100000b |
| EVM_IPC = 1000000b |
| EVM_STACK = 10000000b |
| /programs/develop/ktcc/trunk/libc/start/. |
|---|
| Property changes: |
| Added: svn:ignore |
| +*.o |
| +*.s |