/programs/games/checkers/trunk/include/me_func.inc |
---|
0,0 → 1,1135 |
;const int |
MENUET_BORDER_SIZE = 4; |
;const int |
MENUET_HEADER_SIZE = 20; |
;const int |
MENUET_THREAD_DATA_USER = 0; // Thread data begin from the user dword |
;const int |
MENUET_THREAD_DATA_ST_BEGIN = 1; // Stack beginning follows after the user dword |
;const int |
MENUET_THREAD_DATA_NEXT = 2; |
;const int |
MENUET_THREAD_DATA_PID = 3; |
;const int |
MENUET_THREAD_DATA_FLAG = 4; |
;const int |
MENUET_THREAD_DATA_X = 5; |
;const int |
MENUET_THREAD_DATA_Y = 6; |
;const int |
MENUET_THREAD_DATA_C_WINDOW = 7; |
;const int |
MENUET_THREAD_DATA_C_HEADER = 8; |
;const int |
MENUET_THREAD_DATA_C_BORDER = 9; |
;const int |
MENUET_THREAD_DATA_C_TITLE = 10; |
;const int |
MENUET_THREAD_DATA_TITLE = 11; |
;const int |
MENUET_THREAD_DATA_PICTURE = 12; |
;const int |
MENUET_THREAD_DATA_SZ_PICT = 13; |
;const int |
MENUET_THREAD_DATA_LAST_SX = 14; |
;const int |
MENUET_THREAD_DATA_LAST_SY = 15; |
;const int |
MENUET_THREAD_DATA_LEN = 16; |
;const int |
MENUET_MUTEX_MAX_TIME_WAIT = 20; |
;const int |
MENUET_FILE_BLOCK_SIZE = 512; |
;const int |
MENUET_FILE_MEMORY_OS_NEED = 4096; |
;/*** |
macro segment name |
{ |
segment name |
if name eq _init_ | name eq _INIT_ |
Menuet_SegmentInit: |
else if name eq _exit_ | name eq _EXIT_ |
Menuet_SegmentExit: |
end if |
} |
macro endseg name |
{ |
if name eq _init_ | name eq _INIT_ |
Menuet_SegmentInitEnd: |
else if name eq _exit_ | name eq _EXIT_ |
Menuet_SegmentExitEnd: |
end if |
endseg name |
} |
macro Menuet_Put_MovEaxVal_Ret address,val |
{ |
mov byte [address],0xB8 |
mov dword [address+4],0xC089C300 |
mov dword [address+1],val |
} |
define @Menuet@Main$qv |
nextdef MenuetEntryPoint |
and esp,not 3 |
sub esp,1024 |
mov eax,9 |
mov ebx,esp |
mov ecx,-1 |
int 0x40 |
mov ebx,[esp+26] |
mov edx,[esp+30] |
lea eax,[ebx-0x20] |
add esp,1024 |
cmp esp,eax |
cmova esp,eax |
and esp,not 3 |
xor eax,eax |
cld |
mov edi,@Menuet@_ThreadTable |
mov ecx,256 |
rep stos dword [edi] |
mov esi,@Menuet@GetPid$qv |
mov edi,@Menuet@_ThreadSavedBegProc |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
mov esi,@Menuet@GetThreadData$qv |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
Menuet_Put_MovEaxVal_Ret @Menuet@GetPid$qv,edx |
if defined MenuetHeapInit |
mov ecx,esp |
push ebx |
push ecx |
push U_END |
call MenuetHeapInit ; Initialize a dynamic heap and create new memory in its begin. |
pop ecx ; Parameters: begin of a new heap, end of data to create in |
mov [esp+4],eax ; the begin of a heap. Return address of the created data. |
mov dword [esp],0 |
else |
xor eax,eax |
push eax |
push eax |
end if |
call @Menuet@ThreadMain$qpvt1 |
nextdef Menuet_ThreadFinish |
add esp,8 |
if defined MenuetHeapFreeAndThreadFinish |
test eax,eax |
jz Menuet_ThreadFinish_end |
push dword @Menuet@_ExitProcessNow |
push eax |
call MenuetHeapFreeAndThreadFinish ; Free the given memory and finish the thread, |
end if ; should exit process if second argument points to not zero. |
Menuet_ThreadFinish_end: |
or eax,-1 |
int 0x40 |
enddef |
define @Menuet@ThreadMain$qpvt1 |
xchg ebx,[esp+4] |
xchg ebp,[esp+8] |
push esi |
push edi |
sub esp,MENUET_THREAD_DATA_LEN*4 |
mov [esp],ebx |
mov [esp+4],ebp |
mov eax,40 |
mov ebx,0x27 |
int 0x40 |
mov ebx,esp |
cmp byte [@Menuet@_ThreadSavedBegProc],0x90 |
jz Menuet_main_else_first_check |
Menuet_Put_MovEaxVal_Ret @Menuet@GetThreadData$qv,esp |
if defined Menuet_SegmentInit & defined Menuet_SegmentInitEnd |
push Menuet_SegmentInitEnd |
push Menuet_SegmentInit |
jmp Menuet_main_after_first_check |
end if |
Menuet_main_else_first_check: |
xor eax,eax |
push eax |
push eax |
Menuet_main_after_first_check: |
push ebx |
call @@Menuet@_CallStart$qppvpvt2 |
add esp,12 |
test al,al |
jnz Menuet_main_test_close_first |
jmp Menuet_main_end |
Menuet_main_close_first: |
btr dword [esp+MENUET_THREAD_DATA_FLAG*4],31 |
push esp |
call @@MenuetOnClose$qppv |
pop ecx |
test al,al |
jnz Menuet_main_end |
Menuet_main_test_close_first: |
cmp dword [esp+MENUET_THREAD_DATA_FLAG*4],0 |
jl Menuet_main_close_first |
; push esp |
; push dword 1 |
; call @Menuet@Redraw$qippv |
; add esp,8 |
Menuet_main_paint_msg: |
or dword [esp+MENUET_THREAD_DATA_FLAG*4],3 |
sub esp,1024 |
mov eax,9 |
mov ebx,esp |
mov ecx,-1 |
int 0x40 |
mov eax,[esp+34] |
mov ebx,[esp+38] |
mov ecx,[esp+42] |
mov edx,[esp+46] |
add esp,1024 |
cmp ecx,[esp+MENUET_THREAD_DATA_LAST_SX*4] |
jnz Menuet_main_size |
cmp edx,[esp+MENUET_THREAD_DATA_LAST_SY*4] |
jz Menuet_main_paint |
Menuet_main_size: |
mov [esp+MENUET_THREAD_DATA_LAST_SX*4],ecx |
mov [esp+MENUET_THREAD_DATA_LAST_SY*4],edx |
push edx |
push ecx |
push ebx |
push eax |
lea ecx,[esp+16] |
mov edx,esp |
push ecx |
push edx |
call @@MenuetOnSize$qpippv |
add esp,24 |
test dword [esp+MENUET_THREAD_DATA_FLAG*4],3 |
jz Menuet_main_cycle |
Menuet_main_paint: |
cmp dword [esp+MENUET_THREAD_DATA_FLAG*4],0 |
jl Menuet_main_close |
push esp |
push dword 0 |
call @Menuet@Redraw$qippv |
add esp,8 |
Menuet_main_cycle: |
mov eax,11 |
Menuet_main_message: |
cmp dword [esp+MENUET_THREAD_DATA_FLAG*4],0 |
jl Menuet_main_close |
int 0x40 |
test eax,eax |
jnz Menuet_main_on_message |
cmp dword [esp+MENUET_THREAD_DATA_FLAG*4],0 |
jne Menuet_main_paint |
push esp |
call @@MenuetOnIdle$qppv |
pop ecx |
test eax,eax |
jz Menuet_main_cycle |
jl Menuet_main_wait_message |
mov ebx,eax |
mov eax,23 |
jmp Menuet_main_message |
Menuet_main_wait_message: |
mov eax,10 |
jmp Menuet_main_message |
Menuet_main_key_press: |
push esp |
call @@MenuetOnKeyPress$qppv |
pop ecx |
jmp Menuet_main_cycle |
Menuet_main_mouse: |
push esp |
call @@MenuetOnMouse$qppv |
pop ecx |
jmp Menuet_main_cycle |
Menuet_main_on_message: |
dec eax |
jz Menuet_main_paint_msg |
dec eax |
jz Menuet_main_key_press |
cmp eax,4 |
jz Menuet_main_mouse |
dec eax |
jnz Menuet_main_cycle |
Menuet_main_button: |
mov eax,17 |
int 0x40 |
test al,al |
jnz Menuet_main_cycle |
Menuet_main_close: |
btr dword [esp+MENUET_THREAD_DATA_FLAG*4],31 |
push esp |
call @@MenuetOnClose$qppv |
pop ecx |
test al,al |
jz Menuet_main_button |
Menuet_main_end: |
mov ebx,esp |
lock dec dword [@Menuet@_ThreadNumber] |
if defined Menuet_SegmentExit & defined Menuet_SegmentExitEnd |
jnz Menuet_main_else_last_check |
push Menuet_SegmentExitEnd |
push Menuet_SegmentExit |
jmp Menuet_main_after_last_check |
end if |
Menuet_main_else_last_check: |
xor eax,eax |
push eax |
push eax |
Menuet_main_after_last_check: |
push ebx |
call @@Menuet@_RemoveThreadData$qppvpvt2 |
add esp,12 |
lock inc dword [@Menuet@_ThreadScanCount+4] |
mov ebx,1 |
jmp Menuet_main_end_wait |
Menuet_main_end_wait_loop: |
mov eax,5 |
int 0x40 |
shl ebx,1 |
cmp ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jna Menuet_main_end_wait |
mov ebx,MENUET_MUTEX_MAX_TIME_WAIT |
Menuet_main_end_wait: |
cmp dword [@Menuet@_ExitProcessNow],0 |
jnz @Menuet@ExitProcess$qv |
cmp dword [@Menuet@_ThreadScanCount],0 |
jnz Menuet_main_end_wait_loop |
lock dec dword [@Menuet@_ThreadScanCount+4] |
mov ebp,[esp+4] |
mov ebx,[esp] |
add esp,MENUET_THREAD_DATA_LEN*4 |
mov eax,ebp |
pop edi |
pop esi |
xchg ebp,[esp+8] |
xchg ebx,[esp+4] |
ret |
enddef |
macro call func |
{ |
if func eq __chkstk |
sub esp,eax |
else |
call func |
end if |
} |
define @Menuet@Redraw$qippv |
push ebp |
mov ebp,[esp+12] |
mov edx,[ebp+MENUET_THREAD_DATA_FLAG*4] |
cmp dword [esp+8],0 |
jl Menuet_redraw_only_inv |
jz Menuet_redraw_no_frame |
or dl,2 |
Menuet_redraw_no_frame: |
bt edx,30 |
jnc Menuet_redraw_begin |
or dl,1 |
mov [ebp+MENUET_THREAD_DATA_FLAG*4],edx |
jmp Menuet_redraw_end |
Menuet_redraw_only_inv: |
test dl,3 |
jnz Menuet_redraw_no_frame |
Menuet_redraw_end: |
pop ebp |
ret |
Menuet_redraw_begin: |
push ebx |
push esi |
push edi |
and dword [ebp+MENUET_THREAD_DATA_FLAG*4],0xFFFFFFFC |
mov eax,12 |
mov ebx,1 |
int 0x40 |
test dl,2 |
jz Menuet_redraw_picture |
push 48 |
pop eax |
push 4 |
pop ebx |
int 0x40 |
mov ebx,[ebp+MENUET_THREAD_DATA_X*4] |
add ebx,2*5-1 |
mov ecx,[ebp+MENUET_THREAD_DATA_Y*4] |
add cx,ax |
add ecx,5-1 |
mov edx,[ebp+MENUET_THREAD_DATA_C_WINDOW*4] |
; mov esi,[ebp+MENUET_THREAD_DATA_C_HEADER*4] |
; mov edi,[ebp+MENUET_THREAD_DATA_C_BORDER*4] |
mov edi,[ebp+MENUET_THREAD_DATA_TITLE*4] |
xor eax,eax |
int 0x40 |
; mov edx,[ebp+MENUET_THREAD_DATA_TITLE*4] |
; test edx,edx |
; jz Menuet_redraw_picture |
; mov edi,edx |
; mov ecx,0xFFFFFFFF |
; xor al,al |
; cld |
; repnz scas byte [edi] |
; not ecx |
; mov esi,ecx |
; dec esi |
; jz Menuet_redraw_picture |
; mov eax,4 |
; mov ebx,0x00070007 |
; mov ecx,[ebp+MENUET_THREAD_DATA_C_TITLE*4] |
; int 0x40 |
Menuet_redraw_picture: |
; mov esi,[ebp+MENUET_THREAD_DATA_PICTURE*4] |
; test esi,esi |
; jz Menuet_redraw_end_draw |
; mov ecx,[ebp+MENUET_THREAD_DATA_SZ_PICT*4] |
; jecxz Menuet_redraw_end_draw |
; mov al,byte [ebp+MENUET_THREAD_DATA_C_WINDOW*4+3] |
; and al,15 |
; mov edx,MENUET_BORDER_SIZE*65536+MENUET_HEADER_SIZE |
; cmp al,3 |
; jnz Menuet_redraw_no_skin |
; mov eax,48 |
; mov ebx,4 |
; int 0x40 |
; mov dx,ax |
;Menuet_redraw_no_skin: |
; mov eax,7 |
; mov ebx,esi |
; int 0x40 |
call @@MenuetOnDraw$qv |
Menuet_redraw_end_draw: |
mov eax,12 |
mov ebx,2 |
int 0x40 |
pop edi |
pop esi |
pop ebx |
pop ebp |
ret |
enddef |
define @Menuet@MoveWindow$qxpxi |
push ebx |
push esi |
mov eax,[esp+12] |
mov ebx,[eax] |
mov ecx,[eax+4] |
mov edx,[eax+8] |
mov esi,[eax+12] |
mov eax,67 |
int 0x40 |
pop esi |
pop ebx |
ret |
enddef |
define @Menuet@Abort$qv |
push dword [@Menuet@DebugPrefix] |
call @Menuet@DebugPutString$qpxc |
mov dword [esp],Menuet_abort_string |
call @Menuet@DebugPutString$qpxc |
pop ecx |
nextdef @Menuet@ExitProcess$qv |
lock bts dword [@Menuet@_ExitProcessNow],0 |
jc Menuet_exit_process_wait |
sub esp,1024 |
mov eax,9 |
mov ebx,esp |
mov ecx,-1 |
int 0x40 |
mov esi,eax |
mov edi,[esp+30] |
Menuet_exit_process_loop: |
mov eax,9 |
mov ebx,esp |
mov ecx,esi |
int 0x40 |
mov eax,[esp+30] |
cmp eax,edi |
jz Menuet_exit_process_continue |
mov ebx,eax |
or bl,15 |
inc ebx |
jz Menuet_exit_process_continue |
mov ebx,eax |
call Menuet_HashInt |
movzx eax,al |
mov eax,dword [@Menuet@_ThreadTable+eax*4] |
jmp Menuet_exit_process_test |
Menuet_exit_process_next: |
mov eax,dword [eax+MENUET_THREAD_DATA_NEXT*4] |
Menuet_exit_process_test: |
test eax,eax |
jz Menuet_exit_process_continue |
cmp ebx,[eax+MENUET_THREAD_DATA_PID*4] |
jnz Menuet_exit_process_next |
mov eax,18 |
mov ebx,2 |
mov ecx,esi |
int 0x40 |
Menuet_exit_process_continue: |
dec esi |
jnl Menuet_exit_process_loop |
add esp,1024 |
mov dword [@Menuet@_ExitProcessNow],-1 |
if defined EMULATOR |
int3 |
call 0x76543210 |
end if |
Menuet_exit_process_end: |
mov dword [@Menuet@_ThreadMutex],0 |
or eax,-1 |
int 0x40 |
Menuet_exit_process_wait: |
mov eax,5 |
mov ebx,1 |
Menuet_exit_process_wait_loop: |
cmp dword [@Menuet@_ExitProcessNow],0 |
jl Menuet_exit_process_end |
int 0x40 |
shl ebx,1 |
cmp ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jna Menuet_exit_process_wait_loop |
mov ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jmp Menuet_exit_process_wait_loop |
enddef |
define @Menuet@ExitThread$qppv,@Menuet@ThreadMain$qpvt1 |
mov esp,[esp+4] |
jmp Menuet_main_end |
enddef |
define @Menuet@ReturnMessageLoop$qppv,@Menuet@ThreadMain$qpvt1 |
mov esp,[esp+4] |
bt dword [esp+MENUET_THREAD_DATA_FLAG*4],30 |
jc Menuet_main_end |
jmp Menuet_main_cycle |
enddef |
define @Menuet@Delay$qui |
push ebx |
mov eax,5 |
mov ebx,[esp+8] |
int 0x40 |
pop ebx |
ret |
enddef |
define @Menuet@Clock$qv |
push ebx |
mov eax,26 |
mov ebx,9 |
int 0x40 |
pop ebx |
ret |
enddef |
define @Menuet@GetPackedTime$qv |
mov eax,3 |
int 0x40 |
ret |
enddef |
define @Menuet@GetTime$qpi |
mov eax,3 |
int 0x40 |
mov edx,[esp+4] |
movzx ecx,al |
shr ecx,4 |
and al,0x0F |
imul ecx,10 |
add cl,al |
mov dword [edx+8],ecx |
mov cl,ah |
shr ecx,4 |
and ah,0x0F |
imul ecx,10 |
add cl,ah |
mov dword [edx+4],ecx |
bswap eax |
mov cl,ah |
shr ecx,4 |
and ah,0x0F |
imul ecx,10 |
add cl,ah |
mov dword [edx],ecx |
ret |
enddef |
define @Menuet@GetPackedDate$qv |
mov eax,29 |
int 0x40 |
ret |
enddef |
define @Menuet@GetDate$qpi |
mov eax,29 |
int 0x40 |
mov edx,[esp+4] |
movzx ecx,al |
shr ecx,4 |
and al,0x0F |
imul ecx,10 |
add cl,al |
mov dword [edx+4],ecx |
mov cl,ah |
shr ecx,4 |
and ah,0x0F |
imul ecx,10 |
add cl,ah |
mov dword [edx],ecx |
bswap eax |
mov cl,ah |
shr ecx,4 |
and ah,0x0F |
imul ecx,10 |
add cl,ah |
mov dword [edx+8],ecx |
ret |
enddef |
define @Menuet@ReadCommonColors$qpui |
push ebx |
mov eax,48 |
mov ebx,3 |
mov ecx,[esp+8] |
mov edx,40 |
int 0x40 |
pop ebx |
ret |
enddef |
define @Menuet@GetProcessInfo$qpuipct1t1piui |
push ebx |
push esi |
push edi |
sub esp,1024 |
mov eax,9 |
mov ebx,esp |
mov ecx,[1024+12+24+esp] |
int 0x40 |
xor edi,edi |
or edi,[1024+12+4+esp] |
jz Menuet_get_proc_info_no_usecpu |
mov ecx,[esp] |
mov [edi],ecx |
xor edi,edi |
Menuet_get_proc_info_no_usecpu: |
or edi,[1024+12+8+esp] |
jz Menuet_get_proc_info_no_name |
lea esi,[esp+10] |
cld |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
mov byte [edi],0 |
xor edi,edi |
Menuet_get_proc_info_no_name: |
or edi,[1024+12+12+esp] |
jz Menuet_get_proc_info_no_mem |
mov ecx,[esp+26] |
mov [edi],ecx |
xor edi,edi |
Menuet_get_proc_info_no_mem: |
or edi,[1024+12+16+esp] |
jz Menuet_get_proc_info_no_pid |
mov ecx,[esp+30] |
mov [edi],ecx |
xor edi,edi |
Menuet_get_proc_info_no_pid: |
or edi,[1024+12+20+esp] |
jz Menuet_get_proc_info_no_rect |
lea esi,[esp+34] |
cld |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
xor edi,edi |
Menuet_get_proc_info_no_rect: |
add esp,1024 |
pop edi |
pop esi |
pop ebx |
ret |
enddef |
define @Menuet@GetPid$qv |
push ebx |
sub esp,1024 |
mov eax,9 |
mov ebx,esp |
mov ecx,-1 |
int 0x40 |
mov eax,[esp+30] |
add esp,1024 |
pop ebx |
ret |
enddef |
define @Menuet@GetPid$qppv |
mov ecx,[esp+4] |
mov eax,[ecx+MENUET_THREAD_DATA_PID*4] |
ret |
enddef |
define @Menuet@_HashByte$qui |
nextdef @Menuet@_HashWord$qui |
nextdef @Menuet@_HashDword$qui |
mov eax,[esp+4] |
nextdef Menuet_HashInt |
mul dword [Menuet_hash_int_val0] |
xor eax,edx |
bswap eax |
mul dword [Menuet_hash_int_val1] |
shrd eax,edx,14 |
bswap eax |
lea eax,[eax+4*eax] |
ror eax,9 |
ret |
Menuet_hash_int_val0: |
dd 0xA82F94C5 |
Menuet_hash_int_val1: |
dd 0x9193780B |
enddef |
define @Menuet@GetThreadData$qv |
call @Menuet@GetPid$qv |
push eax |
call @Menuet@GetThreadData$qui |
pop ecx |
ret |
enddef |
define @Menuet@GetThreadData$qui |
mov eax,[esp+4] |
call Menuet_HashInt |
movzx eax,al |
cmp dword [@Menuet@_ThreadScanCount+4],0 |
jnz Menuet_get_thread_data_wait |
Menuet_get_thread_data_nowait: |
lock inc dword [@Menuet@_ThreadScanCount] |
mov eax,dword [@Menuet@_ThreadTable+eax*4] |
mov ecx,[esp+4] |
jmp Menuet_get_thread_data_test |
Menuet_get_thread_data_loop: |
mov eax,dword [eax+MENUET_THREAD_DATA_NEXT*4] |
Menuet_get_thread_data_test: |
test eax,eax |
jz Menuet_get_thread_data_end |
cmp ecx,[eax+MENUET_THREAD_DATA_PID*4] |
jnz Menuet_get_thread_data_loop |
Menuet_get_thread_data_end: |
lock dec dword [@Menuet@_ThreadScanCount] |
ret |
Menuet_get_thread_data_wait: |
push eax |
push ebx |
mov eax,5 |
mov ebx,1 |
Menuet_get_thread_data_wait_loop: |
int 0x40 |
cmp dword [@Menuet@_ThreadScanCount+4],0 |
jz Menuet_get_thread_data_wait_end |
shl ebx,1 |
cmp ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jna Menuet_get_thread_data_wait_loop |
mov ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jmp Menuet_get_thread_data_wait_loop |
Menuet_get_thread_data_wait_end: |
pop ebx |
pop eax |
jmp Menuet_get_thread_data_nowait |
enddef |
define @Menuet@_GetSkinHeader$qv |
push ebx |
mov eax,48 |
mov ebx,4 |
int 0x40 |
pop ebx |
ret |
enddef |
define @Menuet@GetScreenSize$qrust1 |
mov eax,14 |
int 0x40 |
mov ecx,[esp+8] |
mov word [ecx],ax |
mov ecx,[esp+4] |
shr eax,16 |
mov word [ecx],ax |
ret |
enddef |
define Menuet_MutexLockNoWait |
pop eax |
xor al,al |
ret |
enddef |
define Menuet_MutexLockWait |
push ebx |
mov eax,5 |
xor ebx,ebx |
Menuet_lock_wait_cycle: |
int 0x40 |
shl byte [ecx],1 |
jz Menuet_lock_wait_cycle |
pop ebx |
mov al,1 |
ret |
enddef |
define Menuet_MutexLockWaitTime |
cmp dword [esp+12],0 |
jng Menuet_MutexLockWait |
push ebx |
push edx |
mov edx,[esp+20] |
mov eax,26 |
mov ebx,9 |
int 0x40 |
add edx,eax |
Menuet_lock_wait_time_cycle: |
mov eax,5 |
xor ebx,ebx |
int 0x40 |
shl byte [ecx],1 |
jnz Menuet_lock_wait_time_ret_true |
mov eax,26 |
mov ebx,9 |
int 0x40 |
cmp eax,edx |
js Menuet_lock_wait_time_cycle |
pop edx |
pop ebx |
pop eax |
xor al,al |
ret |
Menuet_lock_wait_time_ret_true: |
pop edx |
pop ebx |
mov al,1 |
ret |
enddef |
define Menuet_MutexLock |
shl byte [ecx],1 |
jnz Menuet_lock_first |
call eax |
Menuet_lock_first: |
mov al,1 |
ret |
enddef |
define @Menuet@TryLock$qp13Menuet@TMutex |
mov eax,Menuet_MutexLockNoWait |
mov ecx,[esp+4] |
jmp Menuet_MutexLock |
enddef |
define @Menuet@Lock$qp13Menuet@TMutex |
mov eax,Menuet_MutexLockWait |
mov ecx,[esp+4] |
jmp Menuet_MutexLock |
enddef |
define @Menuet@LockTime$qp13Menuet@TMutexi |
mov eax,Menuet_MutexLockWaitTime |
mov ecx,[esp+4] |
jmp Menuet_MutexLock |
enddef |
define @Menuet@UnLock$qp13Menuet@TMutex |
mov ecx,[esp+4] |
shr byte [ecx],1 |
jz Menuet_unlock_pause |
ret |
Menuet_unlock_pause: |
mov byte [ecx],0x40 |
push ebx |
mov eax,5 |
xor ebx,ebx |
int 0x40 |
pop ebx |
ret |
enddef |
define Menuet_MutexLockRec |
shl byte [ecx],1 |
jng Menuet_lock_first |
cmp dword [ecx+4],edx |
jz Menuet_lock_rec_self |
call eax |
Menuet_lock_rec_first: |
mov al,1 |
mov dword [ecx+4],edx |
ret |
Menuet_lock_rec_self: |
mov al,1 |
add dword [ecx],0x100 |
jc Menuet_lock_rec_overflow |
ret |
Menuet_lock_rec_overflow: |
push dword [@Menuet@DebugPrefix] |
call @Menuet@DebugPutString$qpxc |
mov dword [esp],Menuet_try_lock_rec_overflow_string |
call @Menuet@DebugPutString$qpxc |
pop ecx |
jmp @Menuet@Abort$qv |
enddef |
define @Menuet@TryLock$qp16Menuet@TRecMutexui |
mov eax,Menuet_MutexLockNoWait |
mov ecx,[esp+4] |
mov edx,[esp+8] |
jmp Menuet_MutexLockRec |
enddef |
define @Menuet@Lock$qp16Menuet@TRecMutexui |
mov eax,Menuet_MutexLockWait |
mov ecx,[esp+4] |
mov edx,[esp+8] |
jmp Menuet_MutexLockRec |
enddef |
define @Menuet@LockTime$qp16Menuet@TRecMutexiui |
mov eax,Menuet_MutexLockWaitTime |
mov ecx,[esp+4] |
mov edx,[esp+12] |
jmp Menuet_MutexLockRec |
enddef |
define @Menuet@UnLock$qp16Menuet@TRecMutexui |
mov ecx,[esp+4] |
mov edx,[esp+8] |
cmp dword [ecx+4],edx |
jnz Menuet_unlock_rec_notlocked |
sub dword [ecx],0x100 |
jnc Menuet_unlock_rec_end |
add dword [ecx],0x100 |
shl byte [ecx],1 |
shr byte [ecx],2 |
jng Menuet_unlock_rec_pause |
Menuet_unlock_rec_end: |
ret |
Menuet_unlock_rec_pause: |
mov byte [ecx],0x20 |
push ebx |
mov eax,5 |
xor ebx,ebx |
int 0x40 |
pop ebx |
ret |
Menuet_unlock_rec_notlocked: |
push dword [@Menuet@DebugPrefix] |
call @Menuet@DebugPutString$qpxc |
mov dword [esp],Menuet_unlock_rec_notlocked_string |
call @Menuet@DebugPutString$qpxc |
pop ecx |
jmp @Menuet@Abort$qv |
enddef |
define @Menuet@DebugPutChar$qc |
mov cl,byte [esp+4] |
cmp cl,13 |
jz Menuet_debug_put_char_ret |
push ebx |
cmp cl,10 |
jz Menuet_debug_put_char_enter |
Menuet_debug_put_char_after_cmp: |
mov eax,63 |
mov ebx,1 |
int 0x40 |
pop ebx |
Menuet_debug_put_char_ret: |
ret |
Menuet_debug_put_char_enter: |
mov cl,13 |
mov eax,63 |
mov ebx,1 |
int 0x40 |
mov cl,10 |
jmp Menuet_debug_put_char_after_cmp |
enddef |
define @Menuet@DebugPutString$qpxc |
push esi |
push dword 0 |
mov esi,dword [esp+12] |
jmp Menuet_debug_put_string_test |
Menuet_debug_put_string_loop: |
mov dword [esp],eax |
call @Menuet@DebugPutChar$qc |
inc esi |
Menuet_debug_put_string_test: |
xor eax,eax |
or al,[esi] |
test al,al |
jnz Menuet_debug_put_string_loop |
pop ecx |
pop esi |
ret |
enddef |
define @Menuet@GetKey$qv |
mov eax,2 |
int 0x40 |
test al,al |
jnz Menuet_get_key_eof |
movzx eax,ah |
ret |
Menuet_get_key_eof: |
mov eax,-1 |
ret |
enddef |
define @Menuet@GetMouseButton$qv |
push ebx |
mov eax,37 |
mov ebx,2 |
int 0x40 |
pop ebx |
ret |
enddef |
define @Menuet@GetMousePosition$qrst1o |
push ebx |
mov eax,37 |
xor ebx,ebx |
cmp byte [esp+16],0 |
jnz Menuet_get_mouse_pos_absolute |
inc ebx |
Menuet_get_mouse_pos_absolute: |
int 0x40 |
mov ecx,[esp+12] |
mov word [ecx],ax |
mov ecx,[esp+8] |
shr eax,16 |
mov word [ecx],ax |
pop ebx |
ret |
enddef |
define @Menuet@WasThreadCreated$qv |
cmp byte [@Menuet@_ThreadSavedBegProc],0x90 |
setz al |
ret |
enddef |
define @Menuet@CreateThread$qpvuit1 |
push ebx |
mov edx,[esp+16] |
mov ebx,[esp+12] |
test edx,edx |
jnz Menuet_create_thread_after_new |
if defined MenuetHeapAlloc |
cmp ebx,4096 |
jnb Menuet_create_thread_alloc |
mov ebx,STACKSIZE |
Menuet_create_thread_alloc: |
push ebx |
call MenuetHeapAlloc ; Create new dynamic memory of the given size |
pop ecx |
test eax,eax |
jnz Menuet_create_thread_mem_created |
end if |
or eax,-1 |
jmp Menuet_create_thread_end |
Menuet_create_thread_mem_created: |
lea edx,[eax+ebx] |
Menuet_create_thread_after_new: |
neg ebx |
jz Menuet_create_thread_test_first |
add ebx,edx |
Menuet_create_thread_test_first: |
cmp byte [@Menuet@_ThreadSavedBegProc],0x90 |
jnz Menuet_create_thread_init |
Menuet_create_thread_fill_stack: |
lock inc dword [@Menuet@_ThreadNumber] |
and edx,not 3 |
sub edx,12 |
mov ecx,[esp+8] |
mov dword [edx+8],ebx |
mov dword [edx+4],ecx |
mov dword [edx],Menuet_ThreadFinish |
mov eax,51 |
mov ebx,1 |
mov ecx,@Menuet@ThreadMain$qpvt1 |
int 0x40 |
mov ebx,eax |
or bl,15 |
inc ebx |
jnz Menuet_create_thread_end |
lock dec dword [@Menuet@_ThreadNumber] |
if defined MenuetHeapFree |
or ebx,[edx+8] |
jz Menuet_create_thread_end |
push ebx |
call MenuetHeapFree ; Delete the given dynamic memory |
pop ecx |
end if |
Menuet_create_thread_end: |
pop ebx |
ret |
Menuet_create_thread_init: |
push esi |
push edi |
cld |
mov esi,@Menuet@_ThreadSavedBegProc |
mov edi,@Menuet@GetPid$qv |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
mov edi,@Menuet@GetThreadData$qv |
movs dword [edi],[esi] |
movs dword [edi],[esi] |
mov eax,0x90909090 |
mov edi,@Menuet@_ThreadSavedBegProc |
stos dword [edi] |
stos dword [edi] |
stos dword [edi] |
stos dword [edi] |
pop edi |
pop esi |
jmp Menuet_create_thread_fill_stack |
enddef |
define @Menuet@_FileAccess$qpv |
push ebx |
mov eax,58 |
mov ebx,[esp+8] |
int 0x40 |
mov ecx,[esp+8] |
mov [ecx],ebx |
pop ebx |
cmp eax,5 |
jz Menuet_file_access_ret_zero |
ret |
Menuet_file_access_ret_zero: |
xor eax,eax |
ret |
enddef |
__pure_error_: |
jmp $ |
define Menuet_abort_string |
db 'Abnormal program termination.',10,0 |
newdef Menuet_try_lock_rec_overflow_string |
db 'Recursive mutex lock count overflow.',10,0 |
newdef Menuet_unlock_rec_notlocked_string |
db 'Recursive mutex unlock error.',10,0 |
enddef |
include "me_lib.inc" |
;/**/ |
/programs/games/checkers/trunk/include/me_heap.h |
---|
0,0 → 1,90 |
#ifndef __MENUET_HEAP_H_INCLUDED_ |
#define __MENUET_HEAP_H_INCLUDED_ |
#include <menuet.h> |
#include <memheap.h> |
// Menuet memory heap interface. |
namespace Menuet // All menuet functions, types and data are nested in the (Menuet) namespace. |
{ |
void *Alloc(unsigned int size); |
void *ReAlloc(void *mem, unsigned int size); |
void Free(void *mem); |
} |
#ifdef __MENUET__ |
namespace Menuet |
{ |
// Global variables |
MemoryHeap::TFreeSpace _MenuetFreeSpace; |
MemoryHeap::TMemBlock _MenuetMemBlock; |
TMutex _MemHeapMutex = MENUET_MUTEX_INIT; |
// Functions |
void *_HeapInit(void *begin, void *use_end, void *end) |
{ |
MemoryHeap::InitFreeSpace(_MenuetFreeSpace); |
_MenuetMemBlock = MemoryHeap::CreateBlock(begin, end, _MenuetFreeSpace); |
unsigned int use_beg = (unsigned int)MemoryHeap::BlockBegin(_MenuetMemBlock) + |
MemoryHeap::BlockAddSize - MemoryHeap::BlockEndSize; |
unsigned int use_size = (unsigned int)use_end; |
if (use_size <= use_beg) return 0; |
else use_size -= use_beg; |
return MemoryHeap::Alloc(_MenuetFreeSpace, use_size); |
} |
bool _SetUseMemory(unsigned int use_mem); |
int _RecalculateUseMemory(unsigned int use_mem); |
void *Alloc(unsigned int size) |
{ |
if (!size) return 0; |
Lock(&_MemHeapMutex); |
void *res = MemoryHeap::Alloc(_MenuetFreeSpace, size); |
if (!res) |
{ |
unsigned use_mem = (unsigned int)MemoryHeap::BlockEndFor(_MenuetMemBlock, size); |
if (_SetUseMemory(_RecalculateUseMemory(use_mem))) |
{ |
res = MemoryHeap::Alloc(_MenuetFreeSpace, size); |
} |
} |
UnLock(&_MemHeapMutex); |
return res; |
} |
void *ReAlloc(void *mem, unsigned int size) |
{ |
Lock(&_MemHeapMutex); |
void *res = MemoryHeap::ReAlloc(_MenuetFreeSpace, mem, size); |
if (!res && size) |
{ |
unsigned use_mem = (unsigned int)MemoryHeap::BlockEndFor(_MenuetMemBlock, size); |
if (_SetUseMemory(_RecalculateUseMemory(use_mem))) |
{ |
res = MemoryHeap::ReAlloc(_MenuetFreeSpace, mem, size); |
} |
} |
UnLock(&_MemHeapMutex); |
return res; |
} |
void Free(void *mem) |
{ |
Lock(&_MemHeapMutex); |
MemoryHeap::Free(_MenuetFreeSpace, mem); |
UnLock(&_MemHeapMutex); |
} |
void _FreeAndThreadFinish(void *mem, int *exit_proc_now); |
} |
#endif // def __MENUET__ |
#endif // ndef __MENUET_HEAP_H_INCLUDED_ |
/programs/games/checkers/trunk/include/me_heap.inc |
---|
0,0 → 1,284 |
;/*** |
MenuetHeapInit = @@Menuet@_HeapInit$qpvt1t1 |
MenuetHeapAlloc = @@Menuet@Alloc$qui |
MenuetHeapReAlloc = @@Menuet@ReAlloc$qpvui |
MenuetHeapFree = @@Menuet@Free$qpv |
MenuetHeapFreeAndThreadFinish = @Menuet@_FreeAndThreadFinish$qpvpi |
define @Menuet@_SetUseMemory$qui |
push ebx |
mov eax,64 |
mov ebx,1 |
mov ecx,[esp+8] |
int 0x40 |
pop ebx |
test eax,eax |
jnz Menuet_set_use_memory_nomem |
push ecx |
push dword [@Menuet@_MenuetMemBlock] |
call @@MemoryHeap@ResizeBlock$q20MemoryHeap@TMemBlockpv |
add esp,8 |
mov al,1 |
ret |
Menuet_set_use_memory_nomem: |
xor al,al |
ret |
enddef |
define @Menuet@_RecalculateUseMemory$qui |
mov eax,dword [esp+4] |
mov ecx,(U_END + 3) and not 3 |
cmp eax,ecx |
jna Menuet_recalculate_use_memory_min |
push ebx |
sub eax,ecx |
mov ebx,6 |
mul ebx |
dec ebx |
div ebx |
add eax,((U_END + 3) and not 3) + 3 |
and eax,not 3 |
pop ebx |
ret |
Menuet_recalculate_use_memory_min: |
mov eax,ecx |
ret |
enddef |
define @Menuet@_FreeAndThreadFinish$qpvpi |
mov ebx,1 |
mov ecx,[esp+8] |
jmp Menuet_heap_free_tf_wait |
Menuet_heap_free_tf_wait_loop: |
mov eax,5 |
int 0x40 |
shl ebx,1 |
cmp ebx,MENUET_MUTEX_MAX_TIME_WAIT |
jna Menuet_heap_free_tf_wait |
mov ebx,MENUET_MUTEX_MAX_TIME_WAIT |
Menuet_heap_free_tf_wait: |
cmp dword [ecx],0 |
jnz @Menuet@ExitProcess$qv |
lock bts dword [@Menuet@_MemHeapMutex],0 |
jc Menuet_heap_free_tf_wait_loop |
push dword [esp+4] |
push @Menuet@_MenuetFreeSpace |
call @@MemoryHeap@Free$qr21MemoryHeap@TFreeSpacepv |
add esp,8 |
mov byte [@Menuet@_MemHeapMutex],0x40 |
or eax,-1 |
int 0x40 |
enddef |
macro call func |
{ |
if func eq @MemoryHeap@_FirstNotZeroBit$qui |
bsf eax,[esp] |
else if func eq @MemoryHeap@_CopyMemItemArray$quiuiui |
xchg edi,[esp] |
xchg esi,[esp+4] |
mov ecx,[esp+8] |
cld |
sub ecx,esi |
shr ecx,2 |
rep movs dword [edi],[esi] |
xchg edi,[esp] |
xchg esi,[esp+4] |
else |
call func |
end if |
} |
@$bnwa$qui = @@Menuet@Alloc$qui |
@$bnew$qui = @@Menuet@Alloc$qui |
@$bdla$qpv = @@Menuet@Free$qpv |
@$bdele$qpv = @@Menuet@Free$qpv |
define @_vector_new_ldtc_$qpvuiuiuit1uit1 |
.var_2C = -0Ch |
.var_28 = -8 |
.var_24 = -4 |
.arg_0 = 8 |
.arg_4 = 0Ch |
.arg_8 = 10h |
.arg_C = 14h |
.arg_10 = 18h |
push ebp |
mov ebp, esp |
add esp, -0Ch |
push ebx |
push esi |
push edi |
mov edi, [ebp+.arg_10] |
mov esi, [ebp+.arg_C] |
cmp dword [ebp+.arg_0], 0 |
jnz .loc_10070 |
mov edx, [ebp+.arg_4] |
imul edx, [ebp+.arg_8] |
test esi, 10h |
jz @f |
add edx, 4 |
@@: |
push edx |
call @$bnwa$qui |
pop ecx |
mov [ebp+.arg_0], eax |
test eax, eax |
jz .ret |
mov dword [ebp+.var_2C], 1 |
jmp @f |
.loc_10070: |
and dword [ebp+.var_2C], 0 |
@@: |
test esi, 10h |
jz @f |
mov edx, [ebp+.arg_0] |
mov ecx, [ebp+.arg_8] |
mov [edx], ecx |
add dword [ebp+.arg_0], 4 |
@@: |
mov eax, [ebp+.arg_0] |
test edi, edi |
jz .ret |
mov ecx, [ebp+.arg_8] |
mov [ebp+.var_28], ecx |
mov ebx, eax |
jmp .loc_100EF |
.loc_100B0: |
mov eax, esi |
and eax, 7 |
dec eax |
jz .loc_100CB |
dec eax |
jz .loc_100D1 |
dec eax |
jz .loc_100D6 |
dec eax |
dec eax |
jz .loc_100DC |
jmp $ |
.loc_100CB: |
push ebx |
call edi |
pop ecx |
jmp .loc_100EC |
.loc_100D1: |
.loc_100DC: |
push ebx |
call edi |
jmp .loc_100EC |
.loc_100D6: |
mov eax, ebx |
call edi |
.loc_100EC: |
add ebx, [ebp+.arg_4] |
.loc_100EF: |
dec dword [ebp+.var_28] |
jns .loc_100B0 |
mov eax, [ebp+.arg_0] |
.ret: |
pop edi |
pop esi |
pop ebx |
mov esp, ebp |
pop ebp |
ret |
enddef |
define @_vector_delete_ldtc_$qpvuiuiuit1 |
.arg_0 = 8 |
.arg_4 = 0Ch |
.arg_8 = 10h |
.arg_C = 14h |
.arg_10 = 18h |
push ebp |
mov ebp, esp |
push ebx |
push esi |
push edi |
mov edi, [ebp+.arg_C] |
mov esi, edi |
and esi, 10h |
and edi, 8 |
cmp dword [ebp+.arg_0], 0 |
jz .ret |
test esi, esi |
jz @f |
mov ecx, [ebp+.arg_0] |
mov eax, [ecx-4] |
mov [ebp+.arg_8], eax |
@@: |
mov ebx, [ebp+.arg_8] |
dec ebx |
imul ebx, [ebp+.arg_4] |
add ebx, [ebp+.arg_0] |
jmp .loc_100D3 |
.loc_1008B: |
mov eax, [ebp+.arg_C] |
and eax, 7 |
dec eax |
jz .loc_1009E |
dec eax |
jz .loc_100A9 |
dec eax |
jz .loc_100B1 |
dec eax |
dec eax |
jz .loc_100BD |
jmp $ |
.loc_1009E: |
push 2 |
push ebx |
call dword [ebp+.arg_10] |
add esp, 8 |
jmp .loc_100D0 |
.loc_100A9: |
push 2 |
push ebx |
call dword [ebp+.arg_10] |
jmp .loc_100D0 |
.loc_100B1: |
mov edx, 2 |
mov eax, ebx |
call dword [ebp+.arg_10] |
jmp .loc_100D0 |
.loc_100BD: |
push 2 |
push ebx |
call dword [ebp+.arg_10] |
.loc_100D0: |
sub ebx, [ebp+.arg_4] |
.loc_100D3: |
dec dword [ebp+.arg_8] |
jns .loc_1008B |
test esi, esi |
jz @f |
sub dword [ebp+.arg_0], 4 |
@@: |
test edi, edi |
jz @f |
push dword [ebp+.arg_0] |
call @$bdla$qpv |
pop ecx |
jmp .ret |
@@: |
mov eax, [ebp+.arg_0] |
jmp .reteax |
.ret: |
xor eax, eax |
.reteax: |
pop edi |
pop esi |
pop ebx |
mov esp, ebp |
pop ebp |
ret |
enddef |
;/**/ |
/programs/games/checkers/trunk/include/me_lib.h |
---|
0,0 → 1,16 |
#ifndef __MENUET_LIB_H_INCLUDED_ |
#define __MENUET_LIB_H_INCLUDED_ |
// Menuet interface. |
namespace Menuet // All menuet functions, types and data are nested in the (Menuet) namespace. |
{ |
unsigned int StrLen(const char *str); |
char *StrCopy(char *dest, const char *src); |
void *MemCopy(void *dest, const void *src, unsigned int n); |
void *MemSet(void *s, char c, unsigned int n); |
double Floor(double x); |
} |
#endif // __MENUET_LIB_H_INCLUDED_ |
/programs/games/checkers/trunk/include/me_lib.inc |
---|
0,0 → 1,118 |
define @Menuet@StrLen$qpxc |
push edi |
cld |
mov edi,[esp+8] |
mov ecx,-1 |
xor al,al |
repnz scas byte [edi] |
not ecx |
lea eax,[ecx-1] |
pop edi |
ret |
enddef |
define @Menuet@StrCopy$qpcpxc |
push esi |
push edi |
cld |
mov edi,[esp+16] |
mov ecx,-1 |
mov esi,edi |
xor al,al |
repnz scas byte [edi] |
not ecx |
mov edi,[esp+12] |
mov edx,ecx |
mov eax,edi |
shr ecx,2 |
rep movs dword [edi],[esi] |
mov ecx,edx |
and ecx,3 |
rep movs byte [edi],[esi] |
pop edi |
pop esi |
ret |
enddef |
define @Menuet@MemCopy$qpvpxvui |
push esi |
push edi |
cld |
mov edi,[esp+12] |
mov eax,edi |
mov ecx,[esp+20] |
mov esi,[esp+16] |
mov edx,ecx |
shr ecx,2 |
rep movs dword [edi],[esi] |
mov ecx,edx |
and ecx,3 |
rep movs byte [edi],[esi] |
pop edi |
pop esi |
ret |
enddef |
define @Menuet@MemSet$qpvcui |
push edi |
cld |
mov edi,[esp+8] |
mov al,[esp+12] |
mov ah,al |
mov dx,ax |
shl eax,16 |
mov ax,dx |
mov ecx,[esp+16] |
mov edx,ecx |
shr ecx,2 |
rep stos dword [edi] |
mov ecx,edx |
and ecx,3 |
rep stos byte [edi] |
pop edi |
mov eax,[esp+4] |
ret |
enddef |
define __ftol |
sub esp,12 |
wait |
fstcw word [esp+8] |
wait |
mov al,[esp+9] |
or byte [esp+9],0x0c |
fldcw word [esp+8] |
fistp qword [esp] |
mov [esp+9],al |
fldcw word [esp+8] |
mov eax,[esp] |
mov edx,[esp+4] |
add esp,12 |
ret |
enddef |
define @Menuet@Floor$qd |
fld qword [esp+4] |
mov ax,[esp+10] |
shl ax,1 |
cmp ax,0x8680 |
ja Menuet_floor_end |
mov ch,4 |
sub esp,2 |
wait |
fstcw word [esp] |
mov ax,0xf3ff |
wait |
mov dx,[esp] |
and ax,dx |
or ah,ch |
mov [esp],ax |
fldcw word [esp] |
frndint |
mov [esp],dx |
fldcw word [esp] |
add esp,2 |
Menuet_floor_end: |
ret |
enddef |
/programs/games/checkers/trunk/include/me_start.inc |
---|
0,0 → 1,90 |
use32 |
org 0x0 |
db 'MENUET01' |
dd 0x1 |
dd MenuetEntryPoint |
dd I_END |
dd U_END+STACKSIZE+HEAPSIZE |
dd U_END+STACKSIZE |
dd 0x0,0x0 |
ptr equ |
offset equ |
short equ |
tbyte equ tword |
PTR equ |
OFFSET equ |
SHORT equ |
TBYTE equ TWORD |
macro movsb a,b |
{ |
if a eq & b eq |
movsb |
else |
movsx a,b |
end if |
} |
macro movsw a,b |
{ |
if a eq & b eq |
movsw |
else |
movsx a,b |
end if |
} |
macro segment name {} |
macro endseg name {} |
macro usedef [link] |
{ |
common |
if ~link eq |
virtual at 0 |
forward |
dd link |
common |
end virtual |
end if |
} |
macro define x,[link] |
{ |
common |
if x eq |
else if used x |
x: |
usedef link |
} |
macro enddef [link] |
{ |
common |
usedef link |
end if |
} |
macro newdef x,[link] |
{ |
common |
end if |
if x eq |
else if used x |
x: |
usedef link |
} |
macro nextdef x,[link] |
{ |
common |
usedef x |
end if |
if x eq |
else if used x |
x: |
usedef link |
} |
/programs/games/checkers/trunk/include/memheap.h |
---|
0,0 → 1,626 |
#ifndef __MEMORY_HEAP_RBTREE_H_INCLUDED_ |
#define __MEMORY_HEAP_RBTREE_H_INCLUDED_ |
namespace MemoryHeap |
{ |
typedef unsigned int TMemItem; |
enum {NumTreeSmall = 8 * sizeof(TMemItem)}; |
// Memory heap interface. |
struct TFreeSpace |
{ |
TMemItem Small[NumTreeSmall], Min, SmallMask; |
}; |
struct TMemBlock |
{ |
TMemItem *Begin; |
}; |
bool BlockValid(const TMemBlock &block); // Is the given memory block valid? |
void *BlockBegin(const TMemBlock &block); // Return the beginning address of the block. |
void *BlockEnd(const TMemBlock &block); // Return the ending address of the block. |
TFreeSpace &BlockFreeSpace(const TMemBlock &block); // Return the free space of the block. |
void InitFreeSpace(TFreeSpace &fs); // Initialize the free space. |
TMemBlock NullBlock(); // Return null invalid block. |
TMemBlock CreateBlock(void *begin, void *end, TFreeSpace &fs); |
// Create a memory block with the given begin and end and add free space of it to (fs), |
//_ give (BlockAddSize) bytes of the block for it's data. |
//_ (Program can alloc (end - begin - BlockAddSize) bytes after it, |
//_ that must be not less than (MemMinSize) ). |
TMemBlock CreateBlock(void *begin, void *end); |
// Create a memory block with the given begin and end and new free space for it, |
//_ give (BlockAddSizeFS) bytes of the block for it's data. |
//_ (Program can alloc (end - begin - BlockAddSizeFS) bytes after it, |
//_ that must be not less than (MemMinSize) ). |
void ResizeBlock(TMemBlock block, void *new_end); // Resize the memory block to the given new end. |
void RemoveBlock(TMemBlock block); // Remove the given memory block. |
void *BlockEndFor(TMemBlock block, unsigned int size); |
// Return the new end of the block needed for (ResizeBlock) to alloc the given size of memory. |
unsigned int BlockSize(TMemBlock block); // Return the size of the given block. |
unsigned int MemSize(void *mem); // Return the size of the allocced memory. |
void *Alloc(TFreeSpace &fs, unsigned int size); |
// Alloc a memory in the given free space, give (MemAddSize) bytes for it's data. |
void *ReAlloc(TFreeSpace &fs, unsigned int size, void *mem); |
// ReAlloc the given memory, it must lie in the block with the given free space. |
void Free(TFreeSpace &fs, void *mem); |
// Free the given memory, it must lie in the block with the given free space. |
// Macro definitions. |
#define MEMORY_HEAP_ALIGN_DOWN(s) (MemoryHeap::TMemItem(s) & ~(MemoryHeap::MemAlign - 1)) |
#define MEMORY_HEAP_ALIGN_UP(s) ((MemoryHeap::TMemItem(s) + (MemoryHeap::MemAlign - 1)) & ~(MemoryHeap::MemAlign - 1)) |
#define MEMORY_HEAP_ITEM(s,k) ( ((MemoryHeap::TMemItem*)(s))[(k)] ) |
#define MEMORY_HEAP_NEXT(s) (MEMORY_HEAP_ITEM((s),-1)) |
#define MEMORY_HEAP_PREV(s) (MEMORY_HEAP_ITEM((s),-2)) |
#define MEMORY_HEAP_FREE(s) (MEMORY_HEAP_ITEM((s),-1) & 1) |
// Constants. |
enum {MemAlign = sizeof(TMemItem)}; |
enum {MemAddSize = MEMORY_HEAP_ALIGN_UP(2 * sizeof(TMemItem))}; |
enum {BlockEndSize = MemAddSize}; |
enum {BlockAddSize = MEMORY_HEAP_ALIGN_UP(4 * sizeof(TMemItem)) + BlockEndSize}; |
enum {BlockAddSizeFS = BlockAddSize + BlockEndSize + MEMORY_HEAP_ALIGN_UP(sizeof(TFreeSpace))}; |
enum {MemMinSize = MEMORY_HEAP_ALIGN_UP(2 * sizeof(TMemItem))}; |
// Inline functions. |
inline bool BlockValid(const TMemBlock &block) {return block.Begin != 0;} |
inline void *BlockBegin(const TMemBlock &block) {return (void*)block.Begin;} |
inline void *BlockEnd(const TMemBlock &block) {return block.Begin ? (void*)block.Begin[1] : 0;} |
inline TFreeSpace &BlockFreeSpace(const TMemBlock &block) {return *(TFreeSpace*)block.Begin[0];} |
inline TMemBlock NullBlock() {TMemBlock block; block.Begin = 0; return block;} |
inline void *BlockEndFor(TMemBlock block, unsigned int size) |
{ |
TMemItem last = (TMemItem)block.Begin[1]; |
TMemItem prevlast = MEMORY_HEAP_PREV(last); |
return (void*)( (MEMORY_HEAP_FREE(prevlast) ? prevlast : last) + MemAddSize + |
((size <= MemMinSize) ? MemMinSize : MEMORY_HEAP_ALIGN_UP(size)) ); |
} |
inline unsigned int BlockSize(TMemBlock block) |
{ |
if (!block.Begin) return 0; |
return (unsigned int)(block.Begin[1] - (TMemItem)block.Begin); |
} |
inline unsigned int MemSize(void *mem) |
{ |
if (!mem) return 0; |
TMemItem c = (TMemItem)mem; |
return MEMORY_HEAP_NEXT(c) - c - MemAddSize; |
} |
// Free space item functions. |
TMemItem _FirstNotZeroBit(TMemItem i) |
{ |
TMemItem r = 0; |
while ((i >>= 1) != 0) r++; |
return r; |
} |
void _RBTreeRotate(TMemItem parent, TMemItem item, int side) |
{ |
TMemItem temp = MEMORY_HEAP_ITEM(parent,0); |
MEMORY_HEAP_ITEM(item,0) = temp; |
if (temp) |
{ |
if (MEMORY_HEAP_ITEM(temp,2) == parent) |
{ |
MEMORY_HEAP_ITEM(temp,2) = item; |
} |
else MEMORY_HEAP_ITEM(temp,3) = item; |
} |
temp = MEMORY_HEAP_ITEM(item,side^1); |
if (temp) MEMORY_HEAP_ITEM(temp,0) = parent; |
MEMORY_HEAP_ITEM(parent,side) = temp; |
MEMORY_HEAP_ITEM(parent,0) = item; |
MEMORY_HEAP_ITEM(item,side^1) = parent; |
temp = MEMORY_HEAP_ITEM(parent,1); |
MEMORY_HEAP_ITEM(parent,1) = MEMORY_HEAP_ITEM(item,1); |
MEMORY_HEAP_ITEM(item,1) = temp; |
} |
void InitFreeSpace(TFreeSpace &fs) |
{ |
TMemItem i; |
for (i = 0; i <= NumTreeSmall; i++) fs.Small[i] = 0; |
fs.Min = 0; fs.SmallMask = 0; |
} |
void _FreeAdd(TFreeSpace &fs, TMemItem item) |
{ |
TMemItem size = MEMORY_HEAP_NEXT(item) - item; |
if (size < MemAddSize + MemMinSize + MemAlign * NumTreeSmall) |
{ |
TMemItem s = (size - (MemAddSize + MemMinSize)) / MemAlign; |
TMemItem &addto = fs.Small[s]; |
MEMORY_HEAP_ITEM(item,1) = (TMemItem)(&addto); |
MEMORY_HEAP_ITEM(item,0) = (TMemItem)addto; |
if (addto) MEMORY_HEAP_ITEM(addto,1) = item; |
addto = item; |
fs.SmallMask |= TMemItem(1) << s; |
return; |
} |
TMemItem addto = fs.Min, parent, temp; |
MEMORY_HEAP_ITEM(item,2) = 0; |
MEMORY_HEAP_ITEM(item,3) = 0; |
if (!addto) |
{ |
MEMORY_HEAP_ITEM(item,0) = 0; |
MEMORY_HEAP_ITEM(item,1) = 1; |
fs.Min = item; |
return; |
} |
MEMORY_HEAP_ITEM(item,1) = 0; |
TMemItem side = 2; |
if (MEMORY_HEAP_NEXT(addto) - addto >= size) fs.Min = item; |
else |
{ |
for (;;) |
{ |
parent = MEMORY_HEAP_ITEM(addto,0); |
if (!parent) break; |
if (MEMORY_HEAP_NEXT(parent) - parent < size) addto = parent; |
else break; |
} |
for (;;) |
{ |
if (MEMORY_HEAP_NEXT(addto) - addto < size) |
{ |
temp = MEMORY_HEAP_ITEM(addto,3); |
if (!temp) {side = 3; break;} |
addto = temp; |
} |
else |
{ |
temp = MEMORY_HEAP_ITEM(addto,2); |
if (!temp) break; |
addto = temp; |
} |
} |
} |
MEMORY_HEAP_ITEM(item,0) = addto; |
MEMORY_HEAP_ITEM(addto,side) = item; |
for (;;) |
{ |
if (MEMORY_HEAP_ITEM(addto,1) != 0) return; |
parent = MEMORY_HEAP_ITEM(addto,0); |
temp = MEMORY_HEAP_ITEM(parent,2); |
if (temp == addto) |
{ |
temp = MEMORY_HEAP_ITEM(parent,3); |
side = 2; |
} |
else side = 3; |
if (!temp || MEMORY_HEAP_ITEM(temp,1) != 0) break; |
MEMORY_HEAP_ITEM(addto,1) = 1; |
MEMORY_HEAP_ITEM(temp,1) = 1; |
item = parent; |
addto = MEMORY_HEAP_ITEM(item,0); |
if (!addto) return; |
MEMORY_HEAP_ITEM(item,1) = 0; |
} |
if (MEMORY_HEAP_ITEM(addto,side) != item) |
{ |
temp = MEMORY_HEAP_ITEM(item,side); |
if (temp) MEMORY_HEAP_ITEM(temp,0) = addto; |
MEMORY_HEAP_ITEM(addto,side^1) = temp; |
MEMORY_HEAP_ITEM(addto,0) = item; |
MEMORY_HEAP_ITEM(item,side) = addto; |
MEMORY_HEAP_ITEM(item,0) = parent; |
MEMORY_HEAP_ITEM(parent,side) = item; |
} |
else item = addto; |
_RBTreeRotate(parent, item, side); |
} |
void _FreeDel(TFreeSpace &fs, TMemItem item) |
{ |
TMemItem size = MEMORY_HEAP_NEXT(item) - item; |
if (size < MemAddSize + MemMinSize + MemAlign * NumTreeSmall) |
{ |
TMemItem prev = MEMORY_HEAP_ITEM(item,1); |
TMemItem next = MEMORY_HEAP_ITEM(item,0); |
MEMORY_HEAP_ITEM(prev,0) = next; |
if (next) MEMORY_HEAP_ITEM(next,1) = prev; |
else |
{ |
TMemItem s = (size - (MemAddSize + MemMinSize)) / MemAlign; |
if (!fs.Small[s]) fs.SmallMask &= ~(TMemItem(1) << s); |
} |
return; |
} |
TMemItem parent, temp, second, add; |
TMemItem side = 2; |
temp = MEMORY_HEAP_ITEM(item,3); |
if (temp) |
{ |
for (;;) |
{ |
second = temp; |
temp = MEMORY_HEAP_ITEM(temp,2); |
if (!temp) break; |
} |
if (fs.Min == item) fs.Min = second; |
add = MEMORY_HEAP_ITEM(second,3); |
parent = MEMORY_HEAP_ITEM(second,0); |
if (parent == item) {parent = second; side = 3;} |
else |
{ |
temp = MEMORY_HEAP_ITEM(item,3); |
MEMORY_HEAP_ITEM(second,3) = temp; |
MEMORY_HEAP_ITEM(temp,0) = second; |
} |
temp = MEMORY_HEAP_ITEM(item,2); |
MEMORY_HEAP_ITEM(second,2) = temp; |
if (temp) MEMORY_HEAP_ITEM(temp,0) = second; |
temp = MEMORY_HEAP_ITEM(item,0); |
MEMORY_HEAP_ITEM(second,0) = temp; |
if (temp) |
{ |
if (MEMORY_HEAP_ITEM(temp,2) == item) |
{ |
MEMORY_HEAP_ITEM(temp,2) = second; |
} |
else MEMORY_HEAP_ITEM(temp,3) = second; |
} |
MEMORY_HEAP_ITEM(parent,side) = add; |
if (add) MEMORY_HEAP_ITEM(add,0) = parent; |
bool color = MEMORY_HEAP_ITEM(second,1); |
MEMORY_HEAP_ITEM(second,1) = MEMORY_HEAP_ITEM(item,1); |
if (!color) return; |
} |
else |
{ |
if (fs.Min == item) fs.Min = MEMORY_HEAP_ITEM(item,0); |
add = MEMORY_HEAP_ITEM(item,2); |
parent = MEMORY_HEAP_ITEM(item,0); |
if (add) MEMORY_HEAP_ITEM(add,0) = parent; |
if (parent) |
{ |
if (MEMORY_HEAP_ITEM(parent,2) == item) |
{ |
MEMORY_HEAP_ITEM(parent,2) = add; |
} |
else |
{ |
MEMORY_HEAP_ITEM(parent,3) = add; |
side = 3; |
} |
} |
else |
{ |
if (add) MEMORY_HEAP_ITEM(add,1) = 1; |
return; |
} |
if (!MEMORY_HEAP_ITEM(item,1)) return; |
} |
if (add && !MEMORY_HEAP_ITEM(add,1)) |
{ |
MEMORY_HEAP_ITEM(add,1) = 1; |
return; |
} |
for (;;) |
{ |
second = MEMORY_HEAP_ITEM(parent,side^1); |
if (!MEMORY_HEAP_ITEM(second,1)) |
{ |
_RBTreeRotate(parent, second, side^1); |
second = MEMORY_HEAP_ITEM(parent,side^1); |
} |
temp = MEMORY_HEAP_ITEM(second,side^1); |
if (temp && !MEMORY_HEAP_ITEM(temp,1)) |
{ |
MEMORY_HEAP_ITEM(temp,1) = 1; |
break; |
} |
temp = MEMORY_HEAP_ITEM(second,side); |
if (temp && !MEMORY_HEAP_ITEM(temp,1)) |
{ |
_RBTreeRotate(second, temp, side); |
MEMORY_HEAP_ITEM(second,1) = 1; |
second = temp; |
break; |
} |
MEMORY_HEAP_ITEM(second,1) = 0; |
if (!MEMORY_HEAP_ITEM(parent,1)) |
{ |
MEMORY_HEAP_ITEM(parent,1) = 1; |
return; |
} |
second = parent; |
parent = MEMORY_HEAP_ITEM(second,0); |
if (!parent) return; |
if (MEMORY_HEAP_ITEM(parent,2) == second) side = 2; |
else side = 3; |
} |
_RBTreeRotate(parent, second, side^1); |
} |
TMemItem _FreeFindAfter(TMemItem item, TMemItem size) |
{ |
if (!item) return 0; |
TMemItem paritem, s; |
if (MEMORY_HEAP_NEXT(item) - item >= size) return item; |
for (;;) |
{ |
paritem = MEMORY_HEAP_ITEM(item,0); |
if (!paritem) break; |
s = MEMORY_HEAP_NEXT(paritem) - paritem; |
if (s == size) return paritem; |
if (s < size) item = paritem; |
else break; |
} |
MEMORY_HEAP_ITEM(item,3); |
for (;;) |
{ |
if (!item) return paritem; |
s = MEMORY_HEAP_NEXT(item) - item; |
if (s == size) return item; |
if (s < size) item = MEMORY_HEAP_ITEM(item,3); |
else |
{ |
paritem = item; |
item = MEMORY_HEAP_ITEM(item,2); |
} |
} |
} |
TMemItem _FreeFind(TFreeSpace &fs, TMemItem size) |
{ |
TMemItem item, nextitem, s; |
if (size < MemAddSize + MemMinSize + MemAlign * NumTreeSmall) |
{ |
TMemItem m, t; |
s = (size - (MemAddSize + MemMinSize)) / MemAlign; |
item = fs.Small[s]; |
if (item) return item; |
if (size < MemAlign * NumTreeSmall) |
{ |
t = size / MemAlign; |
m = fs.SmallMask >> t; |
if (m) return fs.Small[t + _FirstNotZeroBit(m)]; |
else if (fs.Min) return fs.Min; |
} |
else |
{ |
item = _FreeFindAfter(fs.Min, size + 1 + MemAddSize + MemMinSize); |
if (item) return item; |
} |
m = fs.SmallMask >> s; |
if (m) return fs.Small[s + _FirstNotZeroBit(m)]; |
else return fs.Min; |
} |
item = _FreeFindAfter(fs.Min, ++size); |
if (!item) return 0; |
s = MEMORY_HEAP_NEXT(item) - item; |
if (s == size) return item; |
size += MemAddSize + MemMinSize; |
if (s >= size) return item; |
nextitem = _FreeFindAfter(item, size); |
return nextitem ? nextitem : item; |
} |
// Block functions. |
inline void _CreateBlockEnd(TMemBlock &block, TFreeSpace &fs, TMemItem c, TMemItem e) |
{ |
block.Begin[0] = (TMemItem)(&fs); |
if (e - c < TMemItem(MemAddSize + MemMinSize)) |
{ |
MEMORY_HEAP_NEXT(c) = 0; |
block.Begin[1] = c; |
} |
else |
{ |
MEMORY_HEAP_NEXT(c) = e + 1; |
_FreeAdd(fs, c); |
MEMORY_HEAP_PREV(e) = c; |
MEMORY_HEAP_NEXT(e) = 0; |
block.Begin[1] = e; |
} |
} |
TMemBlock CreateBlock(void *begin, void *end, TFreeSpace &fs) |
{ |
TMemBlock block = {0}; |
TMemItem b = MEMORY_HEAP_ALIGN_UP(begin); |
TMemItem e = MEMORY_HEAP_ALIGN_DOWN(end); |
if (e <= b || e - b < TMemItem(BlockAddSize - MemAddSize)) return block; |
block.Begin = (TMemItem*)b; |
b += MEMORY_HEAP_ALIGN_UP(4 * sizeof(TMemItem)); |
MEMORY_HEAP_PREV(b) = 0; |
_CreateBlockEnd(block, fs, b, e); |
return block; |
} |
TMemBlock CreateBlock(void *begin, void *end) |
{ |
TMemBlock block = {0}; |
TMemItem b = MEMORY_HEAP_ALIGN_UP(begin); |
TMemItem e = MEMORY_HEAP_ALIGN_DOWN(end); |
if (e <= b || e - b < TMemItem(BlockAddSizeFS - MemAddSize)) return block; |
block.Begin = (TMemItem*)b; |
b += MEMORY_HEAP_ALIGN_UP(4 * sizeof(TMemItem)); |
TMemItem c = b + MemAddSize + MEMORY_HEAP_ALIGN_UP(sizeof(TFreeSpace)); |
MEMORY_HEAP_PREV(b) = 0; |
MEMORY_HEAP_NEXT(b) = c; |
MEMORY_HEAP_PREV(c) = b; |
InitFreeSpace(*(TFreeSpace*)b); |
_CreateBlockEnd(block, *(TFreeSpace*)b, c, e); |
return block; |
} |
void ResizeBlock(TMemBlock block, void *new_end) |
{ |
if (!BlockValid(block)) return; |
TMemItem e = MEMORY_HEAP_ALIGN_DOWN(new_end); |
TMemItem c = block.Begin[1]; |
TFreeSpace &fs = *(TFreeSpace*)block.Begin[0]; |
do |
{ |
if (c == e) return; |
else if (c > e) |
{ |
while ((c = MEMORY_HEAP_PREV(c)) > e) |
{ |
if (MEMORY_HEAP_FREE(c)) _FreeDel(fs, c); |
} |
if (!c) {block.Begin = 0; return;} |
if (MEMORY_HEAP_FREE(c)) |
{ |
_FreeDel(fs, c); |
if (e - c < TMemItem(MemAddSize + MemMinSize)) e = c; |
else |
{ |
MEMORY_HEAP_NEXT(c) = e + 1; |
_FreeAdd(*(TFreeSpace*)block.Begin[0], c); |
break; |
} |
} |
else if (e - c >= TMemItem(MemAddSize + MemMinSize)) |
{ |
MEMORY_HEAP_NEXT(c) = e; break; |
} |
MEMORY_HEAP_NEXT(c) = 0; |
block.Begin[1] = c; |
if (c == e) return; |
} |
TMemItem pc = MEMORY_HEAP_PREV(c); |
if (pc && MEMORY_HEAP_FREE(pc)) _FreeDel(fs, c = pc); |
else if (e - c < TMemItem(MemAddSize + MemMinSize)) return; |
MEMORY_HEAP_NEXT(c) = e + 1; |
_FreeAdd(fs, c); |
} while(false); |
MEMORY_HEAP_PREV(e) = c; |
MEMORY_HEAP_NEXT(e) = 0; |
block.Begin[1] = e; |
} |
void RemoveBlock(TMemBlock block) |
{ |
if (!BlockValid(block)) return; |
TMemItem e = block.Begin[1]; |
TFreeSpace &fs = *(TFreeSpace*)block.Begin[0]; |
while ((e = MEMORY_HEAP_PREV(e)) != 0) |
{ |
if (MEMORY_HEAP_FREE(e)) _FreeDel(fs, e); |
} |
block.Begin = 0; |
} |
// Free space functions. |
void _CopyMemItemArray(TMemItem dest, TMemItem src, TMemItem end) |
{ |
TMemItem k = (end - src) / sizeof(TMemItem); |
TMemItem *d = (TMemItem*)dest; |
TMemItem *s = (TMemItem*)src; |
while (k--) *(d++) = *(s++); |
} |
void *Alloc(TFreeSpace &fs, unsigned int size) |
{ |
if (!size) return 0; |
TMemItem s = MEMORY_HEAP_ALIGN_UP(size) + MemAddSize; |
if (s < MemAddSize + MemMinSize) s = MemAddSize + MemMinSize; |
TMemItem c = _FreeFind(fs, s); |
if (!c) return 0; |
_FreeDel(fs, c); |
TMemItem nc = --MEMORY_HEAP_NEXT(c); |
TMemItem mc = c + s; |
if (nc - (MemAddSize + MemMinSize) >= mc) |
{ |
MEMORY_HEAP_NEXT(c) = mc; |
MEMORY_HEAP_PREV(mc) = c; |
MEMORY_HEAP_NEXT(mc) = nc + 1; |
MEMORY_HEAP_PREV(nc) = mc; |
_FreeAdd(fs, mc); |
} |
return (void*)c; |
} |
void *ReAlloc(TFreeSpace &fs, void *mem, unsigned int size) |
{ |
if (!mem) return Alloc(fs, size); |
if (!size) {Free(fs, mem); return 0;} |
TMemItem s = MEMORY_HEAP_ALIGN_UP(size) + MemAddSize; |
TMemItem c = (TMemItem)mem; |
TMemItem mc = MEMORY_HEAP_NEXT(c); |
TMemItem nc = MEMORY_HEAP_NEXT(mc); |
if (--nc & 1) nc = mc; |
if (s < MemAddSize + MemMinSize) s = MemAddSize + MemMinSize; |
if (nc - c < s) |
{ |
mem = Alloc(fs, size); |
if (mem) |
{ |
_CopyMemItemArray((TMemItem)mem, c, mc - MemAddSize); |
Free(fs, (void*)c); |
return mem; |
} |
else |
{ |
TMemItem pc = MEMORY_HEAP_PREV(c); |
if (pc && MEMORY_HEAP_FREE(pc) && nc - pc >= s) |
{ |
_FreeDel(fs, pc); |
_CopyMemItemArray(pc, c, mc - MemAddSize); |
c = pc; |
} |
else return 0; |
} |
} |
if (mc < nc) _FreeDel(fs, mc); |
mc = c + s; |
if (nc - (MemAddSize + MemMinSize) >= mc) |
{ |
MEMORY_HEAP_NEXT(c) = mc; |
MEMORY_HEAP_PREV(mc) = c; |
MEMORY_HEAP_NEXT(mc) = nc + 1; |
MEMORY_HEAP_PREV(nc) = mc; |
_FreeAdd(fs, mc); |
} |
else |
{ |
MEMORY_HEAP_NEXT(c) = nc; |
MEMORY_HEAP_PREV(nc) = c; |
} |
return (void*)c; |
} |
int free_a = 0; |
void Free(TFreeSpace &fs, void *mem) |
{ |
TMemItem c = (TMemItem)mem; |
if (!c) return; |
TMemItem pc = MEMORY_HEAP_PREV(c); |
TMemItem mc = MEMORY_HEAP_NEXT(c); |
TMemItem nc = MEMORY_HEAP_NEXT(mc); |
if (--nc & 1) nc = mc; |
else _FreeDel(fs, mc); |
if (free_a == 1) return; |
if (pc && MEMORY_HEAP_FREE(pc)) _FreeDel(fs, c = pc); |
MEMORY_HEAP_NEXT(c) = nc + 1; |
MEMORY_HEAP_PREV(nc) = c; |
if (free_a == 2) return; |
_FreeAdd(fs, c); |
} |
} |
#endif // ndef __MEMORY_HEAP_RBTREE_H_INCLUDED_ |
/programs/games/checkers/trunk/include/menuet.h |
---|
0,0 → 1,536 |
#ifndef __MENUET_H_INCLUDED_ |
#define __MENUET_H_INCLUDED_ |
#include <me_lib.h> |
// Menuet interface. |
namespace Menuet // All menuet functions, types and data are nested in the (Menuet) namespace. |
{ |
const char *DebugPrefix = "User program: "; |
struct TWindowData // Data for drawing a window. |
{ |
unsigned short WindowType, HeaderType; |
unsigned long WindowColor, HeaderColor, BorderColor, TitleColor; |
const char *Title; |
}; |
struct TStartData // This structure is used only for MenuetOnStart function. |
{ |
unsigned short Left, Width, Top, Height; // Initial window rectangle. |
TWindowData WinData; |
}; |
typedef void **TThreadData; // Thread data are the fast identifier of thread, contains user dword in |
//_ the zero element and stack beginning (or zero if it is unknown) in the first element. |
//_ The stack will be deleted from dynamic memory at the finish of the thread if stack beginning is not zero. |
struct TMutex; // Simple mutex can be locked only once at a time. |
#define MENUET_MUTEX_INIT {} // Simple mutex initializer, cat be redefined in a realization of the library |
struct TRecMutex; // Recursive mutex can be locked many times by a single thread at a time. |
#define MENUET_REC_MUTEX_INIT {} // Recursive mutex initializer, cat be redefined in a realization of the library |
// Some functions have two forms: the fast form with (thread_data) parameter and the form without it. |
// Note: pass only thread data of current thread as (thread_data) parameter to these functions. |
void Main(); // Main function is called at program startup. |
void* ThreadMain(void *user = 0, void *stack_begin = 0); |
// Called at thread startup, (user) is placed in thread data as a user dword, |
//_ (stack_begin) is placed in thread data as a stack beginning. |
//_ Return new value of stack beginning that can be changed in the thread data. |
void GetWindowData(TWindowData &win_data); // Write current window data to (win_data). |
void GetWindowData(TWindowData &win_data, TThreadData thread_data); |
void SetWindowData(const TWindowData &win_data); // Replace current window data by (win_data). |
void SetWindowData(const TWindowData &win_data, TThreadData thread_data); |
void CloseWindow(); // Close current window when returning to message loop. |
void CloseWindow(TThreadData thread_data); |
void Redraw(int frame = 0); // Redraw current window immediately, if (frame) is positive redraw the frame too, |
void Redraw(int frame, TThreadData thread_data); //_ if (frame) is negative redraw only invalideted window. |
void Invalidate(int frame = 0); // Redraw current window when no message will be is the queue, |
void Invalidate(int frame, TThreadData thread_data); //_ if (frame) is positive redraw the frame too, |
//_ if (frame) is negative do nothing. |
void MoveWindow(const int window_rect[/* 4 */]); // Move and resize current window. |
void Abort(); // Abnormally terminate a program. |
void ExitProcess(); // Exit from the process, don't call any destructors of global varyables |
void ExitThread(); // Exit from the current thread |
void ExitThread(TThreadData thread_data); |
void ReturnMessageLoop(); // Return to the message loop of the thread. Exit from the thread |
void ReturnMessageLoop(TThreadData thread_data); //_ if it is called from (MenuetOnStart). |
void Delay(unsigned int time); // Delay the execution of the program during (time) hundredth seconds. |
unsigned int Clock(); // Return the time from starting of the system to this moment in hundredth of seconds. |
int GetPackedTime(); // Return the current time of day in binary-decimal format 0x00SSMMHH. |
void GetTime(int t[/* 3 */]); // Write the current time to (t): t[0] = second, t[1] = minute, t[2] = hour. |
int GetPackedDate(); // Return the current date in binary-decimal format 0x00YYDDMM. |
void GetDate(int d[/* 3 */]); // Write the current date to (d): d[0] = day, d[1] = month, d[2] = year. |
void GetTimeDate(int t[/* 6 */]); // Write the current time and date to (t): t[0] = second, |
//_ t[1] = minute, t[2] = hour, t[3] = day, t[4] = month, t[5] = year. |
void ReadCommonColors(unsigned int colors[/* 10 */]); // Writes standart window colors to (colors). |
unsigned int GetProcessInfo(unsigned int *use_cpu, char process_name[/* 13 */], unsigned int *use_memory, |
unsigned int *pid, int window_rect[/* 4 */], unsigned int pid_for = -1); |
// Write (pid_for) process information to variables parameters points, return |
//_ the number of processes. (pid_for) equal to (-1) means current process. |
unsigned int GetPid(); // Return the current thread identifier (pid). |
unsigned int GetPid(TThreadData thread_data); |
TThreadData GetThreadData(); // Return the thread data of the current thread. |
TThreadData GetThreadData(unsigned int pid); // Return the thread data of the thread with the given pid. |
void* GetPicture(unsigned short &width, unsigned short &height); |
void* GetPicture(unsigned short &width, unsigned short &height, TThreadData thread_data); |
// Return the picture on the window and write its width and height to (width) and (height). |
void SetPicture(void *picture, unsigned short width, unsigned short height); |
void SetPicture(void *picture, unsigned short width, unsigned short height, TThreadData thread_data); |
// Replace the picture on the window by the given picture with the given width and height. |
void GetBorderHeader(unsigned short &border_size, unsigned short &header_size); |
void GetBorderHeader(unsigned short &border_size, unsigned short &header_size, TThreadData thread_data); |
// Write the border thickness to (border_size) and header height to (header_size). |
void GetClientSize(unsigned short &width, unsigned short &height); |
void GetClientSize(unsigned short &width, unsigned short &height, TThreadData thread_data); |
// Write the client area width and height to (width) and (height) parameters. |
void GetClientSize(unsigned short &width, unsigned short &height, int win_width, int win_height); |
void GetClientSize(unsigned short &width, unsigned short &height, int win_width, int win_height, TThreadData thread_data); |
// Write the client area size of window with the width (win_width) |
//_ and height (win_height) to (width) and (height) parameters. |
void GetScreenSize(unsigned short &width, unsigned short &height); |
// Write the screen width and height to (width) and (height) parameters. |
void InitMutex(TMutex *mutex); // Initialize the simple mutex. |
void InitRecMutex(TRecMutex *mutex); // Initialize the recursive mutex. |
bool TryLock(TMutex *mutex); // Try to lock the mutex without waitting, return true if lock. |
bool TryLock(TRecMutex *mutex); |
bool TryLock(TRecMutex *mutex, TThreadData thread_data); |
bool TryLock(TRecMutex *mutex, unsigned int pid); |
void Lock(TMutex *mutex); // Lock mutex and wait for it if this necessary. |
void Lock(TRecMutex *mutex); |
void Lock(TRecMutex *mutex, TThreadData thread_data); |
void Lock(TRecMutex *mutex, unsigned int pid); |
bool LockTime(TMutex *mutex, int time); |
bool LockTime(TRecMutex *mutex, int time); // Lock mutex and wait for it during (time) hundredth seconds. |
bool LockTime(TRecMutex *mutex, int time, TThreadData thread_data); |
bool LockTime(TRecMutex *mutex, int time, unsigned int pid); |
void UnLock(TMutex *mutex); // Unlock mutex |
void UnLock(TRecMutex *mutex); |
void UnLock(TRecMutex *mutex, TThreadData thread_data); |
void UnLock(TRecMutex *mutex, unsigned int pid); |
void DebugPutChar(char c); // Put the character to the debug board. |
void DebugPutString(const char *s); // Put the string to the debug board. |
int GetKey(); // Return key pressed by user or -1 if no key was pressed. |
int GetMouseButton(); // Return buttons pressed: 0 - no buttons, 1 - left button, 2 - right button, 3 - both buttons. |
void GetMousePosition(short &x, short &y, bool absolute = false); |
// Write mouse position to (x) and (y): absolute if (absolute) is true and relative the window otherwise. |
void GetMousePosPicture(short &x, short &y); |
int GetThreadNumber(); // Return the number of threads currently executing. |
bool WasThreadCreated(); // Return true if there was created at least one thread except the main thred. |
unsigned int CreateThread(void *user = 0, unsigned int stack_size = 0, void *stack_end = 0); |
// Create a new thread with the user dword (user) and stack pointer (stack_end). |
//_ If (stack_end) is zero, create stack in dynamic memory of size (stack_size) or |
//_ the same size as the main thread if (stack_size) less that 4096. Set the beginning |
//_ of the stack if (stack_end) is zero or (stack_size) is not zero, in this case stack |
//_ will be deleted automaticaly from dynamic memory at the finish of the thread. |
} |
// Function, defined outside. |
bool MenuetOnStart(Menuet::TStartData &me_start, Menuet::TThreadData thread_data); |
// Window will be created iff return value is true. |
bool MenuetOnClose(Menuet::TThreadData thread_data); // Window will be closed iff return value is true. |
int MenuetOnIdle(Menuet::TThreadData thread_data); // Return the time to wait next message. |
void MenuetOnSize(int window_rect[/* 4 */], Menuet::TThreadData thread_data); // When the window is resized. |
void MenuetOnKeyPress(Menuet::TThreadData thread_data); // When user press a key. |
void MenuetOnMouse(Menuet::TThreadData thread_data); // When user move a mouse. |
#ifdef __MENUET__ |
namespace Menuet |
{ |
// Structures. |
struct TMutex // Simple mutex can be locked only once at a time. |
{ |
unsigned int mut; |
}; |
#undef MENUET_MUTEX_INIT |
#define MENUET_MUTEX_INIT {0x40} // Simple mutex initializer, cat be redefined in a realization of the library |
struct TRecMutex // Recursive mutex can be locked many times by a single thread at a time. |
{ |
unsigned int mut, pid; |
}; |
#undef MENUET_REC_MUTEX_INIT |
#define MENUET_REC_MUTEX_INIT {0x20,-1} // Recursive mutex initializer, cat be redefined in a realization of the library |
// Global variables. |
volatile TThreadData _ThreadTable[256]; |
volatile unsigned int _ThreadScanCount[2] = {0, 0}; |
volatile int _ThreadNumber = 1; |
volatile int _ExitProcessNow = 0; |
TMutex _ThreadMutex = MENUET_MUTEX_INIT; |
unsigned int _ThreadSavedBegProc[4]; |
// Inline functions. |
inline void GetWindowData(TWindowData &win_data) {GetWindowData(win_data, GetThreadData());} |
inline void SetWindowData(const TWindowData &win_data) {SetWindowData(win_data, GetThreadData());} |
inline void CloseWindow() {CloseWindow(GetThreadData());} |
inline void Redraw(int frame) {Redraw(frame, GetThreadData());} |
inline void Invalidate(int frame) {Invalidate(frame, GetThreadData());} |
inline void* GetPicture(unsigned short &width, unsigned short &height) |
{ |
return GetPicture(width, height, GetThreadData()); |
} |
inline void SetPicture(void *picture, unsigned short width, unsigned short height) |
{ |
SetPicture(picture, width, height, GetThreadData()); |
} |
inline void GetBorderHeader(unsigned short &border_size, unsigned short &header_size) |
{ |
GetBorderHeader(border_size, header_size, GetThreadData()); |
} |
inline void GetClientSize(unsigned short &width, unsigned short &height) |
{ |
unsigned int pid; |
int rect[4]; |
GetProcessInfo(0, 0, 0, &pid, rect); |
GetClientSize(width, height, rect[2], rect[3], GetThreadData(pid)); |
} |
inline void GetClientSize(unsigned short &width, unsigned short &height, TThreadData thread_data) |
{ |
int rect[4]; |
GetProcessInfo(0, 0, 0, 0, rect); |
GetClientSize(width, height, rect[2], rect[3], thread_data); |
} |
inline void GetClientSize(unsigned short &width, unsigned short &height, int win_width, int win_height) |
{ |
GetClientSize(width, height, win_width, win_height, GetThreadData()); |
} |
inline void GetTimeDate(int t[/* 6 */]) {GetTime(t); GetDate(t + 3);} |
inline void InitMutex(TMutex *mutex) {mutex->mut = 0;} |
inline void InitRecMutex(TRecMutex *mutex) {mutex->mut = 0; mutex->pid = -1;} |
inline bool TryLock(TRecMutex *mutex) {return TryLock(mutex, GetPid());} |
inline bool TryLock(TRecMutex *mutex, TThreadData thread_data) {return TryLock(mutex, GetPid(thread_data));} |
inline void Lock(TRecMutex *mutex) {Lock(mutex, GetPid());} |
inline void Lock(TRecMutex *mutex, TThreadData thread_data) {Lock(mutex, GetPid(thread_data));} |
inline bool LockTime(TRecMutex *mutex, int time) {return LockTime(mutex, time, GetPid());} |
inline bool LockTime(TRecMutex *mutex, int time, TThreadData thread_data) |
{return LockTime(mutex, time, GetPid(thread_data));} |
inline void UnLock(TRecMutex *mutex) {UnLock(mutex, GetPid());} |
inline void UnLock(TRecMutex *mutex, TThreadData thread_data) {UnLock(mutex, GetPid(thread_data));} |
inline int GetThreadNumber() {return _ThreadNumber;} |
// Constants from fasm. |
#include <me_func.inc> |
// Functions. |
unsigned char _HashByte(unsigned int value); |
unsigned short _HashWord(unsigned int value); |
unsigned int _HashDword(unsigned int value); |
void _GetStartData(TStartData &start_data, TThreadData thread_data) |
{ |
start_data.Left = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_X] >> 16); |
start_data.Width = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_X]); |
start_data.Top = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_Y] >> 16); |
start_data.Height = (unsigned short)((unsigned long)thread_data[MENUET_THREAD_DATA_Y]); |
GetWindowData(start_data.WinData, thread_data); |
} |
void _SetStartData(const TStartData &start_data, TThreadData thread_data) |
{ |
(unsigned long&)thread_data[MENUET_THREAD_DATA_X] = |
((unsigned int)start_data.Left << 16) | start_data.Width; |
(unsigned long&)thread_data[MENUET_THREAD_DATA_Y] = |
((unsigned int)start_data.Top << 16) | start_data.Height; |
SetWindowData(start_data.WinData, thread_data); |
} |
void _ApplyCommonColors(TWindowData &win_data) |
{ |
unsigned int colors[10]; |
ReadCommonColors(colors); |
win_data.WindowColor = colors[5]; |
win_data.HeaderColor = colors[1]; |
win_data.BorderColor = colors[0]; |
win_data.TitleColor = colors[4]; |
} |
void _SetValueFunctionPriority(void *beg, int n) |
{ |
int k, i; |
unsigned char num[256]; |
for (i = 0; i < 256; i++) num[i] = 0; |
for (k = 0; k < n; k++) |
{ |
i = ((unsigned char*)beg + 6*k)[1]; |
((unsigned char*)beg + 6*k)[0] = num[i]; |
if (num[i] != 255) num[i]++; |
} |
} |
void _CallFunctionPriority(void *beg, void *end, bool reverse = false) |
{ |
struct _Local |
{ |
static int cmp(void *beg, int i, int j) |
{ |
unsigned char *x = (unsigned char*)beg + 6*i; |
unsigned char *y = (unsigned char*)beg + 6*j; |
if (*(unsigned short*)x < *(unsigned short*)y) return -1; |
if (*(unsigned short*)x > *(unsigned short*)y) return 1; |
return 0; |
} |
static void swap(void *beg, int i, int j) |
{ |
unsigned char *x = (unsigned char*)beg + 6*i; |
unsigned char *y = (unsigned char*)beg + 6*j; |
short s; |
int t; |
s = *(short*)x; *(short*)x = *(short*)y; *(short*)y = s; |
x += 2; y += 2; |
t = *(int*)x; *(int*)x = *(int*)y; *(int*)y = t; |
} |
static void call(void *beg, int i) |
{ |
unsigned char *x = (unsigned char*)beg + 6*i; |
(*(void(**)())(x+2))(); |
} |
}; |
if (!beg || !end || end <= beg) return; |
int i, j, k, m, n; |
n = ((unsigned char*)end - (unsigned char*)beg) / 6; |
if (n <= 0) return; |
_SetValueFunctionPriority(beg, n); |
m = n; k = n; |
while (m > 1) |
{ |
if (k > 0) k--; |
else _Local::swap(beg, 0, --m); |
j = k; |
for (;;) |
{ |
i = j; |
if (2*i + 1 >= m) break; |
if (_Local::cmp(beg, 2*i + 1, j) > 0) j = 2*i + 1; |
if (2*i + 2 < m && _Local::cmp(beg, 2*i + 2, j) > 0) j = 2*i + 2; |
if (i == j) break; |
_Local::swap(beg, i, j); |
} |
} |
if (!reverse) |
{ |
for (k = 0; k < n; k++) _Local::call(beg, k); |
} |
else |
{ |
for (k = n-1; k >= 0; k--) _Local::call(beg, k); |
} |
} |
bool _CallStart(TThreadData thread_data, void *init = 0, void *init_end = 0) |
{ |
struct _TThreadDataTemplate |
{ |
unsigned int data[12]; |
}; |
static const _TThreadDataTemplate _ThreadDataTemplate = |
{{3, 0x00320100, 0x00320100, 0x33FFFFFF, 0x806060FF, 0x00000000, 0x00FFFF40, 0, 0, 0, -1, -1}}; |
unsigned int pid = GetPid(); |
volatile TThreadData *thread_table_item; |
Lock(&_ThreadMutex); |
if (_ExitProcessNow) ExitProcess(); |
thread_table_item = &_ThreadTable[_HashByte(pid)]; |
thread_data[MENUET_THREAD_DATA_NEXT] = (void*)*thread_table_item; |
(unsigned int&)thread_data[MENUET_THREAD_DATA_PID] = pid; |
*(_TThreadDataTemplate*)(thread_data + MENUET_THREAD_DATA_FLAG) = _ThreadDataTemplate; |
*thread_table_item = thread_data; |
UnLock(&_ThreadMutex); |
if (_ExitProcessNow) ExitProcess(); |
_CallFunctionPriority(init, init_end, false); |
TStartData start_data; |
_GetStartData(start_data, thread_data); |
// _ApplyCommonColors(start_data.WinData); |
(unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] |= 0x40000000; |
thread_data[MENUET_THREAD_DATA_TITLE] = (void*)(&start_data); |
if (!MenuetOnStart(start_data, thread_data)) return false; |
(unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] &= ~0x40000000; |
_SetStartData(start_data, thread_data); |
return true; |
} |
void _RemoveThreadData(TThreadData thread_data, void *exit = 0, void *exit_end = 0) |
{ |
_CallFunctionPriority(exit, exit_end, true); |
volatile TThreadData *thread_table_item; |
Lock(&_ThreadMutex); |
if (_ExitProcessNow) ExitProcess(); |
thread_table_item = &_ThreadTable[_HashByte(GetPid(thread_data))]; |
while (*thread_table_item) |
{ |
if (*thread_table_item == thread_data) |
{ |
*thread_table_item = (TThreadData)thread_data[MENUET_THREAD_DATA_NEXT]; |
break; |
} |
thread_table_item = (TThreadData*)(*thread_table_item + MENUET_THREAD_DATA_NEXT); |
} |
UnLock(&_ThreadMutex); |
if (_ExitProcessNow) ExitProcess(); |
} |
void GetWindowData(TWindowData &win_data, TThreadData thread_data) |
{ |
if ((unsigned int)thread_data[MENUET_THREAD_DATA_FLAG] & 0x40000000) |
{ |
win_data = ((TStartData*)thread_data[MENUET_THREAD_DATA_TITLE])->WinData; |
return; |
} |
win_data.WindowType = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_C_WINDOW] >> 24); |
win_data.HeaderType = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_C_HEADER] >> 24); |
win_data.WindowColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_WINDOW] & 0xFFFFFF; |
win_data.HeaderColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_HEADER] & 0xFFFFFF; |
win_data.BorderColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_BORDER] & 0xFFFFFF; |
win_data.TitleColor = (unsigned int)thread_data[MENUET_THREAD_DATA_C_TITLE] & 0xFFFFFF; |
win_data.Title = (char*)thread_data[MENUET_THREAD_DATA_TITLE]; |
} |
void SetWindowData(const TWindowData &win_data, TThreadData thread_data) |
{ |
if ((unsigned int)thread_data[MENUET_THREAD_DATA_FLAG] & 0x40000000) |
{ |
((TStartData*)thread_data[MENUET_THREAD_DATA_TITLE])->WinData = win_data; |
return; |
} |
(unsigned int&)thread_data[MENUET_THREAD_DATA_C_WINDOW] = |
((unsigned int)win_data.WindowType << 24) | (win_data.WindowColor & 0xFFFFFF); |
(unsigned int&)thread_data[MENUET_THREAD_DATA_C_HEADER] = |
((unsigned int)win_data.HeaderType << 24) | (win_data.HeaderColor & 0xFFFFFF); |
(unsigned int&)thread_data[MENUET_THREAD_DATA_C_BORDER] = win_data.BorderColor & 0xFFFFFF; |
(unsigned int&)thread_data[MENUET_THREAD_DATA_C_TITLE] = win_data.TitleColor & 0xFFFFFF; |
thread_data[MENUET_THREAD_DATA_TITLE] = (void*)win_data.Title; |
Invalidate(1, thread_data); |
} |
void CloseWindow(TThreadData thread_data) |
{ |
(unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] |= 0x80000000; |
} |
void Invalidate(int frame, TThreadData thread_data) |
{ |
if (frame < 0) return; |
(unsigned int&)thread_data[MENUET_THREAD_DATA_FLAG] |= (frame ? 3 : 1); |
} |
void* GetPicture(unsigned short &width, unsigned short &height, TThreadData thread_data) |
{ |
width = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_SZ_PICT] >> 16); |
height = (unsigned short)((unsigned int)thread_data[MENUET_THREAD_DATA_SZ_PICT]); |
return (void*)thread_data[MENUET_THREAD_DATA_PICTURE]; |
} |
void SetPicture(void *picture, unsigned short width, unsigned short height, TThreadData thread_data) |
{ |
thread_data[MENUET_THREAD_DATA_PICTURE] = (void*)picture; |
(unsigned int&)thread_data[MENUET_THREAD_DATA_SZ_PICT] = |
(width == 0 || height == 0) ? 0 : (((unsigned int)width << 16) | height); |
Invalidate(0, thread_data); |
} |
int _GetSkinHeader(); |
void GetBorderHeader(unsigned short &border_size, unsigned short &header_size, TThreadData thread_data) |
{ |
int win_type = ((unsigned int)thread_data[MENUET_THREAD_DATA_FLAG] & 0x40000000) ? |
((TStartData*)thread_data[MENUET_THREAD_DATA_TITLE])->WinData.WindowType : |
((unsigned int)thread_data[MENUET_THREAD_DATA_C_WINDOW] >> 24); |
border_size = MENUET_BORDER_SIZE; |
header_size = short(((win_type & 15) == 3) ? _GetSkinHeader() : MENUET_HEADER_SIZE); |
} |
void GetClientSize(unsigned short &width, unsigned short &height, |
int win_width, int win_height, TThreadData thread_data) |
{ |
const int MAX_SIZE = 32767; |
unsigned short border_size, header_size; |
GetBorderHeader(border_size, header_size, thread_data); |
win_width -= 2 * border_size; |
win_height -= border_size + header_size; |
if (win_width < 0) win_width = 0; |
else if (win_width > MAX_SIZE) win_width = MAX_SIZE; |
if (win_height < 0) win_height = 0; |
else if (win_height > MAX_SIZE) win_height = MAX_SIZE; |
width = (unsigned short)win_width; |
height = (unsigned short)win_height; |
} |
void GetMousePosPicture(short &x, short &y) |
{ |
unsigned short dx, dy; |
GetMousePosition(x, y); |
GetBorderHeader(dx, dy); |
x -= dx; y -= dy; |
} |
} |
#else // def __MENUET__ |
namespace Menuet |
{ |
struct TMutex |
{ |
unsigned int mut; |
TMutex(); |
~TMutex(); |
}; |
#undef MENUET_MUTEX_INIT |
#define MENUET_MUTEX_INIT TMutex() |
struct TRecMutex |
{ |
unsigned int mut; |
TRecMutex(); |
~TRecMutex(); |
}; |
#undef MENUET_REC_MUTEX_INIT |
#define MENUET_REC_MUTEX_INIT TRecMutex() |
} |
#endif // else: def __MENUET__ |
#endif // ndef __MENUET_H_INCLUDED_ |
/programs/games/checkers/trunk/include/stdarg.h |
---|
0,0 → 1,13 |
#ifndef __STDARG_H |
#define __STDARG_H |
typedef void *va_list; |
#define __size(x) ((sizeof(x)+sizeof(int)-1) & ~(sizeof(int)-1)) |
#define va_start(ap, parmN) ((void)((ap) = (va_list)((char *)(&parmN)+__size(parmN)))) |
#define va_arg(ap, type) (*(type *)(((*(char **)&(ap))+=__size(type))-(__size(type)))) |
#define va_end(ap) ((void)0) |
#endif /* __STDARG_H */ |
/programs/games/checkers/trunk/include/write_macro.inc |
---|
0,0 → 1,49 |
macro writestr [arg] |
{ |
common |
local straddr |
local strend |
pushad |
push straddr |
push strend |
jmp @Menuet@DebugPutString$qpxc |
straddr db arg,0 |
strend: |
pop eax |
popad |
} |
macro writeint arg |
{ |
push dword arg |
xchg eax,[esp] |
pushad |
push eax |
call @DebugPutNumber$qi |
pop eax |
popad |
pop eax |
} |
macro write [arg] |
{ |
forward |
if arg eq |
else if arg eq endline |
writestr 10 |
else if arg eqtype '' |
writestr arg |
else |
writeint arg |
end if |
} |
macro writeln [arg] |
{ |
common |
write arg,endline |
} |
/programs/games/checkers/trunk/include/. |
---|
Property changes: |
Added: tsvn:logminsize |
+5 |
\ No newline at end of property |