/kernel/branches/net/blkdev/cd_drv.inc |
---|
12,7 → 12,7 |
; Íåïîñðåäñòâåííàÿ ðàáîòà ñ óñòðîéñòâîì ÑD (ATAPI) |
;********************************************************** |
; Àâòîð ÷àñòè èñõîäíîãî òåêñòà Êóëàêîâ Âëàäèìèð Ãåííàäüåâè÷ |
; Àäàïòàöèÿ, äîðàáîòêà è ðàçðàáîòêà Mario79 |
; Àäàïòàöèÿ, äîðàáîòêà è ðàçðàáîòêà Mario79,<Lrz> |
; Ìàêñèìàëüíîå êîëè÷åñòâî ïîâòîðåíèé îïåðàöèè ÷òåíèÿ |
MaxRetr equ 10 |
20,46 → 20,7 |
; (â òèêàõ) |
BSYWaitTime equ 1000 ;2 |
NoTickWaitTime equ 0xfffff |
;************************************************* |
;* ÏÎËÍÎÅ ×ÒÅÍÈÅ ÑÅÊÒÎÐÀ ÊÎÌÏÀÊÒ-ÄÈÑÊÀ * |
;* Ñ÷èòûâàþòñÿ äàííûå ïîëüçîâàòåëÿ, èíôîðìàöèÿ * |
;* ñóáêàíàëà è êîíòðîëüíàÿ èíôîðìàöèÿ * |
;* Âõîäíûå ïàðàìåòðû ïåðåäàþòñÿ ÷åðåç ãëîáàëüíûå * |
;* ïåðìåííûå: * |
;* ChannelNumber - íîìåð êàíàëà; * |
;* DiskNumber - íîìåð äèñêà íà êàíàëå; * |
;* CDSectorAddress - àäðåñ ñ÷èòûâàåìîãî ñåêòîðà. * |
;* Äàííûå ñ÷èòûâàåòñÿ â ìàññèâ CDDataBuf. * |
;************************************************* |
ReadCD: |
pusha |
; Çàäàòü ðàçìåð ñåêòîðà |
mov [CDBlockSize],2048 ;2352 |
; Î÷èñòèòü áóôåð ïàêåòíîé êîìàíäû |
call clear_packet_buffer |
; Ñôîðìèðîâàòü ïàêåòíóþ êîìàíäó äëÿ ñ÷èòûâàíèÿ |
; ñåêòîðà äàííûõ |
; Çàäàòü êîä êîìàíäû Read CD |
mov [PacketCommand],byte 0x28 ;0xBE |
; Çàäàòü àäðåñ ñåêòîðà |
mov AX,word [CDSectorAddress+2] |
xchg AL,AH |
mov word [PacketCommand+2],AX |
mov AX,word [CDSectorAddress] |
xchg AL,AH |
mov word [PacketCommand+4],AX |
; mov eax,[CDSectorAddress] |
; mov [PacketCommand+2],eax |
; Çàäàòü êîëè÷åñòâî ñ÷èòûâàåìûõ ñåêòîðîâ |
mov [PacketCommand+8],byte 1 |
; Çàäàòü ñ÷èòûâàíèå äàííûõ â ïîëíîì îáúåìå |
; mov [PacketCommand+9],byte 0xF8 |
; Ïîäàòü êîìàíäó |
call SendPacketDatCommand |
popa |
ret |
CDBlockSize equ 2048 |
;******************************************** |
;* ×ÒÅÍÈÅ ÑÅÊÒÎÐÀ Ñ ÏÎÂÒÎÐÀÌÈ * |
;* Ìíîãîêðàòíîå ïîâòîðåíèå ÷òåíèÿ ïðè ñáîÿõ * |
73,8 → 34,9 |
mov eax,[CDSectorAddress] |
mov ebx,[CDDataBuf_pointer] |
call cd_calculate_cache |
xor edi,edi |
add esi,8 |
mov edi,1 |
inc edi |
.hdreadcache: |
; cmp dword [esi+4],0 ; empty |
; je .nohdcache |
128,10 → 90,50 |
mov ECX,MaxRetr |
@@NextRetr: |
; Ïîäàòü êîìàíäó |
call ReadCD |
cmp [DevErrorCode],0 |
je @@End_4 |
;************************************************* |
;* ÏÎËÍÎÅ ×ÒÅÍÈÅ ÑÅÊÒÎÐÀ ÊÎÌÏÀÊÒ-ÄÈÑÊÀ * |
;* Ñ÷èòûâàþòñÿ äàííûå ïîëüçîâàòåëÿ, èíôîðìàöèÿ * |
;* ñóáêàíàëà è êîíòðîëüíàÿ èíôîðìàöèÿ * |
;* Âõîäíûå ïàðàìåòðû ïåðåäàþòñÿ ÷åðåç ãëîáàëüíûå * |
;* ïåðìåííûå: * |
;* ChannelNumber - íîìåð êàíàëà; * |
;* DiskNumber - íîìåð äèñêà íà êàíàëå; * |
;* CDSectorAddress - àäðåñ ñ÷èòûâàåìîãî ñåêòîðà. * |
;* Äàííûå ñ÷èòûâàåòñÿ â ìàññèâ CDDataBuf. * |
;************************************************* |
;ReadCD: |
push ecx |
; pusha |
; Çàäàòü ðàçìåð ñåêòîðà |
; mov [CDBlockSize],2048 ;2352 |
; Î÷èñòèòü áóôåð ïàêåòíîé êîìàíäû |
call clear_packet_buffer |
; Ñôîðìèðîâàòü ïàêåòíóþ êîìàíäó äëÿ ñ÷èòûâàíèÿ |
; ñåêòîðà äàííûõ |
; Çàäàòü êîä êîìàíäû Read CD |
mov [PacketCommand],byte 0x28 ;0xBE |
; Çàäàòü àäðåñ ñåêòîðà |
mov AX,word [CDSectorAddress+2] |
xchg AL,AH |
mov word [PacketCommand+2],AX |
mov AX,word [CDSectorAddress] |
xchg AL,AH |
mov word [PacketCommand+4],AX |
; mov eax,[CDSectorAddress] |
; mov [PacketCommand+2],eax |
; Çàäàòü êîëè÷åñòâî ñ÷èòûâàåìûõ ñåêòîðîâ |
mov [PacketCommand+8],byte 1 |
; Çàäàòü ñ÷èòûâàíèå äàííûõ â ïîëíîì îáúåìå |
; mov [PacketCommand+9],byte 0xF8 |
; Ïîäàòü êîìàíäó |
call SendPacketDatCommand |
pop ecx |
; ret |
; cmp [DevErrorCode],0 |
test eax,eax |
jz @@End_4 |
or ecx,ecx ;{SPraid.simba} (for cd load) |
jz @@End_4 |
dec ecx |
141,8 → 143,8 |
mov eax,NoTickWaitTime |
.wait: |
dec eax |
cmp eax,0 |
je @@NextRetr |
; test eax,eax |
jz @@NextRetr |
jmp .wait |
@@: |
; Çàäåðæêà íà 2,5 ñåêóíäû |
154,6 → 156,7 |
; ja @@Wait |
loop @@NextRetr |
@@End_4: |
mov dword [DevErrorCode],eax |
popad |
ret |
163,14 → 166,15 |
; Ìàêñèìàëüíî äîïóñòèìîå âðåìÿ îæèäàíèÿ ðåàêöèè |
; óñòðîéñòâà íà ïàêåòíóþ êîìàíäó (â òèêàõ) |
MaxCDWaitTime equ 1000 ;200 ;10 ñåêóíä |
uglobal |
; Îáëàñòü ïàìÿòè äëÿ ôîðìèðîâàíèÿ ïàêåòíîé êîìàíäû |
PacketCommand: rb 12 ;DB 12 DUP (?) |
; Îáëàñòü ïàìÿòè äëÿ ïðèåìà äàííûõ îò äèñêîâîäà |
;CDDataBuf DB 4096 DUP (0) |
; Ðàçìåð ïðèíèìàåìîãî áëîêà äàííûõ â áàéòàõ |
CDBlockSize DW ? |
;CDBlockSize DW ? |
; Àäðåñ ñ÷èòûâàåìîãî ñåêòîðà äàííûõ |
CDSectorAddress: DD ? |
; Âðåìÿ íà÷àëà î÷åðåäíîé îïåðàöèè ñ äèñêîì |
179,7 → 183,7 |
WURStartTime DD 0 |
; óêàçàòåëü áóôåðà äëÿ ñ÷èòûâàíèÿ |
CDDataBuf_pointer dd 0 |
endg |
;**************************************************** |
;* ÏÎÑËÀÒÜ ÓÑÒÐÎÉÑÒÂÓ ATAPI ÏÀÊÅÒÍÓÞ ÊÎÌÀÍÄÓ, * |
;* ÏÐÅÄÓÑÌÀÒÐÈÂÀÞÙÓÞ ÏÅÐÅÄÀ×Ó ÎÄÍÎÃÎ ÑÅÊÒÎÐÀ ÄÀÍÍÛÕ * |
190,24 → 194,26 |
;* DiskNumber - íîìåð äèñêà íà êàíàëå; * |
;* PacketCommand - 12-áàéòíûé êîìàíäíûé ïàêåò; * |
;* CDBlockSize - ðàçìåð ïðèíèìàåìîãî áëîêà äàííûõ. * |
; return eax DevErrorCode |
;**************************************************** |
SendPacketDatCommand: |
pushad |
mov [DevErrorCode],0 |
xor eax,eax |
; mov byte [DevErrorCode],al |
; Çàäàòü ðåæèì CHS |
mov [ATAAddressMode],0 |
mov byte [ATAAddressMode],al |
; Ïîñëàòü ATA-êîìàíäó ïåðåäà÷è ïàêåòíîé êîìàíäû |
mov [ATAFeatures],0 |
mov [ATASectorCount],0 |
mov [ATASectorNumber],0 |
mov byte [ATAFeatures],al |
mov byte [ATASectorCount],al |
mov byte [ATASectorNumber],al |
; Çàãðóçèòü ðàçìåð ïåðåäàâàåìîãî áëîêà |
mov AX,[CDBlockSize] |
mov [ATACylinder],AX |
mov [ATAHead],0 |
mov [ATAHead],al |
; mov AX,[CDBlockSize] |
mov [ATACylinder],CDBlockSize |
mov [ATACommand],0A0h |
call SendCommandToHDD_1 |
cmp [DevErrorCode],0 ;ïðîâåðèòü êîä îøèáêè |
jne @@End_8 ;çàêîí÷èòü, ñîõðàíèâ êîä îøèáêè |
test eax,eax |
; cmp [DevErrorCode],0 ;ïðîâåðèòü êîä îøèáêè |
jnz @@End_8 ;çàêîí÷èòü, ñîõðàíèâ êîä îøèáêè |
; Îæèäàíèå ãîòîâíîñòè äèñêîâîäà ê ïðèåìó |
; ïàêåòíîé êîìàíäû |
218,8 → 224,8 |
cmp [timer_ticks_enable],0 |
jne @f |
dec ecx |
cmp ecx,0 |
je @@Err1_1 |
; test ecx,ecx |
jz @@Err1_1 |
jmp .test |
@@: |
call change_task |
261,8 → 267,8 |
cmp [timer_ticks_enable],0 |
jne @f |
dec ecx |
cmp ecx,0 |
je @@Err1_1 |
; test ecx,ecx |
jz @@Err1_1 |
jmp .test_1 |
@@: |
call change_task |
286,7 → 292,7 |
mov DX,[ATABasePortAddr] ;ïîðò 1x0h |
; Çàãðóçèòü â ñ÷åò÷èê ðàçìåð áëîêà â áàéòàõ |
xor ecx,ecx |
mov CX,[CDBlockSize] |
mov CX,CDBlockSize |
; Âû÷èñëèòü ðàçìåð áëîêà â 16-ðàçðÿäíûõ ñëîâàõ |
shr CX,1 ;ðàçäåëèòü ðàçìåð áëîêà íà 2 |
; Ïðèíÿòü áëîê äàííûõ |
295,20 → 301,28 |
rep insw |
sti |
; Óñïåøíîå çàâåðøåíèå ïðèåìà äàííûõ |
jmp @@End_8 |
@@End_8: |
xor eax,eax |
ret |
; Çàïèñàòü êîä îøèáêè |
@@Err1_1: |
mov [DevErrorCode],1 |
jmp @@End_8 |
xor eax,eax |
inc eax |
ret |
; mov [DevErrorCode],1 |
; ret |
@@Err6_temp: |
mov [DevErrorCode],7 |
jmp @@End_8 |
mov eax,7 |
ret |
; mov [DevErrorCode],7 |
; ret |
@@Err6: |
mov [DevErrorCode],6 |
@@End_8: |
popad |
mov eax,6 |
ret |
; mov [DevErrorCode],6 |
;@@End_8: |
; ret |
323,19 → 337,21 |
;*********************************************** |
SendPacketNoDatCommand: |
pushad |
mov [DevErrorCode],0 |
xor eax,eax |
; mov byte [DevErrorCode],al |
; Çàäàòü ðåæèì CHS |
mov [ATAAddressMode],0 |
mov byte [ATAAddressMode],al |
; Ïîñëàòü ATA-êîìàíäó ïåðåäà÷è ïàêåòíîé êîìàíäû |
mov [ATAFeatures],0 |
mov [ATASectorCount],0 |
mov [ATASectorNumber],0 |
mov [ATACylinder],0 |
mov [ATAHead],0 |
mov byte [ATAFeatures],al |
mov byte [ATASectorCount],al |
mov byte [ATASectorNumber],al |
mov word [ATACylinder],ax |
mov byte [ATAHead],al |
mov [ATACommand],0A0h |
call SendCommandToHDD_1 |
cmp [DevErrorCode],0 ;ïðîâåðèòü êîä îøèáêè |
jne @@End_9 ;çàêîí÷èòü, ñîõðàíèâ êîä îøèáêè |
; cmp [DevErrorCode],0 ;ïðîâåðèòü êîä îøèáêè |
test eax,eax |
jnz @@End_9 ;çàêîí÷èòü, ñîõðàíèâ êîä îøèáêè |
; Îæèäàíèå ãîòîâíîñòè äèñêîâîäà ê ïðèåìó |
; ïàêåòíîé êîìàíäû |
mov DX,[ATABasePortAddr] |
372,7 → 388,7 |
out DX,AX |
; sti |
cmp [ignore_CD_eject_wait],1 |
je @@End_9 |
je @@clear_DEC |
; Îæèäàíèå ïîäòâåðæäåíèÿ ïðèåìà êîìàíäû |
mov DX,[ATABasePortAddr] |
add DX,7 ;ïîðò 1õ7h |
391,15 → 407,19 |
jnz @@Err6_1 |
test AL,40h ;ñîñòîÿíèå ñèãíàëà DRDY |
jz @@WaitDevice1_1 |
jmp @@End_9 |
@@clear_DEC: |
and [DevErrorCode],0 |
popad |
ret |
; Çàïèñàòü êîä îøèáêè |
@@Err1_3: |
mov [DevErrorCode],1 |
xor eax,eax |
inc eax |
jmp @@End_9 |
@@Err6_1: |
mov [DevErrorCode],6 |
mov eax,6 |
@@End_9: |
mov [DevErrorCode],eax |
popad |
ret |
420,11 → 440,11 |
;* â ATABasePortAddr - áàçîâûé àäðåñ HDD; * |
;* â DevErrorCode - íîëü. * |
;* Ïðè âîçíèêíîâåíèè îøèáêè â DevErrorCode áóäåò * |
;* âîçâðàùåí êîä îøèáêè. * |
;* âîçâðàùåí êîä îøèáêè â eax * |
;**************************************************** |
SendCommandToHDD_1: |
pushad |
mov [DevErrorCode],0 |
; pushad |
; mov [DevErrorCode],0 not need |
; Ïðîâåðèòü çíà÷åíèå êîäà ðåæèìà |
cmp [ATAAddressMode],1 |
ja @@Err2_4 |
459,8 → 479,8 |
cmp [timer_ticks_enable],0 |
jne @f |
dec ecx |
cmp ecx,0 |
je @@Err1_4 |
; test ecx,ecx |
jz @@Err1_4 |
jmp .test |
@@: |
call change_task |
514,28 → 534,35 |
out DX,AL |
sti |
; Ñáðîñèòü ïðèçíàê îøèáêè |
mov [DevErrorCode],0 |
jmp @@End_10 |
; mov [DevErrorCode],0 |
@@End_10: |
xor eax,eax |
ret |
; Çàïèñàòü êîä îøèáêè |
@@Err1_4: |
mov [DevErrorCode],1 |
jmp @@End_10 |
xor eax,eax |
inc eax |
; mov [DevErrorCode],1 |
ret |
@@Err2_4: |
mov [DevErrorCode],2 |
jmp @@End_10 |
mov eax,2 |
; mov [DevErrorCode],2 |
ret |
@@Err3_4: |
mov [DevErrorCode],3 |
jmp @@End_10 |
mov eax,3 |
; mov [DevErrorCode],3 |
ret |
@@Err4_4: |
mov [DevErrorCode],4 |
jmp @@End_10 |
mov eax,4 |
; mov [DevErrorCode],4 |
ret |
@@Err5_4: |
mov [DevErrorCode],5 |
mov eax,5 |
; mov [DevErrorCode],5 |
; Çàâåðøåíèå ðàáîòû ïðîãðàììû |
@@End_10: |
ret |
; sti |
popad |
ret |
; popad |
;************************************************* |
;* ÎÆÈÄÀÍÈÅ ÃÎÒÎÂÍÎÑÒÈ ÓÑÒÐÎÉÑÒÂÀ Ê ÐÀÁÎÒÅ * |
563,8 → 590,8 |
cmp [DevErrorCode],0 |
je @@End_11 |
dec ecx |
cmp ecx,0 |
je .Error |
; cmp ecx,0 |
jz .Error |
jmp @@SendCommand |
@@: |
call change_task |
815,7 → 842,7 |
call EjectMedium |
mov [ignore_CD_eject_wait],0 |
ret |
iglobal |
timer_ATAPI_check dd 0 |
ATAPI_IDE0_lock db 0 |
ATAPI_IDE1_lock db 0 |
822,7 → 849,7 |
ATAPI_IDE2_lock db 0 |
ATAPI_IDE3_lock db 0 |
ignore_CD_eject_wait db 0 |
endg |
;************************************************* |
;* Ïîëó÷èòü ñîîáùåíèå î ñîáûòèè èëè ñîñòîÿíèè * |
;* óñòðîéñòâà * |
896,7 → 923,7 |
clear_packet_buffer: |
; Î÷èñòèòü áóôåð ïàêåòíîé êîìàíäû |
mov [PacketCommand],dword 0 |
mov [PacketCommand+4],dword 0 |
mov [PacketCommand+8],dword 0 |
and [PacketCommand],dword 0 |
and [PacketCommand+4],dword 0 |
and [PacketCommand+8],dword 0 |
ret |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/blkdev/cdrom.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/blkdev/fdc.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/blkdev/flp_drv.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/blkdev/hd_drv.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/blkdev/ide_cache.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/blkdev/rd.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/blkdev/rdsave.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/ETFONT.FNT |
---|
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/boot/bootcode.inc |
---|
42,7 → 42,7 |
@@: |
call putchar |
lodsb |
cmp al, 0 |
test al,al |
jnz @b |
popa |
ret |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/booteng.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/bootet.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/bootge.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/bootru.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/bootstr.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/bootvesa.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/et.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/preboot.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/rdload.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/ru.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/boot/shutdown.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/bus/pci/pci16.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/bus/pci/pci32.inc |
---|
30,7 → 30,9 |
; Description |
; entry point for system PCI calls |
;*************************************************************************** |
;mmio_pci_addr equ 0x400 ; set actual PCI address here to activate user-MMIO |
align 4 |
pci_api: |
74,9 → 76,18 |
cmp al,10 |
jz pci_write_reg ;dword |
if defined mmio_pci_addr |
cmp al,11 ; user-level MMIO functions |
jz pci_mmio_init |
cmp al,12 |
jz pci_mmio_map |
cmp al,13 |
jz pci_mmio_unmap |
end if |
no_pci_access_for_applications: |
mov eax,-1 |
or eax,-1 |
ret |
366,19 → 377,150 |
dec eax |
ret |
if defined mmio_pci_addr ; must be set above |
;*************************************************************************** |
; Function |
; pci_mmio_init |
; |
; Description |
; IN: bx = device's PCI bus address (bbbbbbbbdddddfff) |
; Returns eax = user heap space available (bytes) |
; Error codes |
; eax = -1 : PCI user access blocked, |
; eax = -2 : device not registered for uMMIO service |
; eax = -3 : user heap initialization failure |
;*************************************************************************** |
pci_mmio_init: |
cmp bx, mmio_pci_addr |
jz @f |
mov eax,-2 |
ret |
@@: |
call init_heap ; (if not initialized yet) |
or eax,eax |
jz @f |
ret |
@@: |
mov eax,-3 |
ret |
;*************************************************************************** |
; Function |
; pci_mmio_map |
; |
; Description |
; maps a block of PCI memory to user-accessible linear address |
; |
; WARNING! This VERY EXPERIMENTAL service is for one chosen PCI device only! |
; The target device address should be set in kernel var mmio_pci_addr |
; |
; IN: ah = BAR#; |
; IN: ebx = block size (bytes); |
; IN: ecx = offset in MMIO block (in 4K-pages, to avoid misaligned pages); |
; |
; Returns eax = MMIO block's linear address in the userspace (if no error) |
; |
; |
; Error codes |
; eax = -1 : user access to PCI blocked, |
; eax = -2 : an invalid BAR register referred |
; eax = -3 : no i/o space on that BAR |
; eax = -4 : a port i/o BAR register referred |
; eax = -5 : dynamic userspace allocation problem |
;*************************************************************************** |
pci_mmio_map: |
and edx,0x0ffff |
cmp ah,6 |
jc .bar_0_5 |
jz .bar_rom |
mov eax,-2 |
ret |
.bar_rom: |
mov ah, 8 ; bar6 = Expansion ROM base address |
.bar_0_5: |
push ecx |
add ebx, 4095 |
and ebx,-4096 |
push ebx |
mov bl, ah ; bl = BAR# (0..5), however bl=8 for BAR6 |
shl bl, 1 |
shl bl, 1 |
add bl, 0x10 ; now bl = BAR offset in PCI config. space |
mov ax, mmio_pci_addr |
mov bh, al ; bh = dddddfff |
mov al, 2 ; al : DW to read |
call pci_read_reg |
or eax, eax |
jnz @f |
mov eax,-3 ; empty I/O space |
jmp mmio_ret_fail |
@@: |
test eax, 1 |
jz @f |
mov eax,-4 ; damned ports (not MMIO space) |
jmp mmio_ret_fail |
@@: |
pop ecx ; ecx = block size, bytes (expanded to whole page) |
mov ebx, ecx ; user_alloc destroys eax, ecx, edx, but saves ebx |
push eax ; store MMIO physical address + keep 2DWords in the stack |
stdcall user_alloc, ecx |
or eax, eax |
jnz mmio_map_over |
mov eax,-5 ; problem with page allocation |
mmio_ret_fail: |
pop ecx |
pop edx |
ret |
mmio_map_over: |
mov ecx, ebx ; ecx = size (bytes, expanded to whole page) |
shr ecx, 12 ; ecx = number of pages |
mov ebx, eax ; ebx = linear address |
pop eax ; eax = MMIO start |
pop edx ; edx = MMIO shift (pages) |
shl edx, 12 ; edx = MMIO shift (bytes) |
add eax, edx ; eax = uMMIO physical address |
or eax, PG_SHARED |
or eax, PG_UW |
or eax, PG_NOCACHE |
mov edi, ebx |
call commit_pages |
mov eax, edi |
ret |
;*************************************************************************** |
; Function |
; pci_mmio_unmap_page |
; |
; Description |
; unmaps the linear space previously tied to a PCI memory block |
; |
; IN: ebx = linear address of space previously allocated by pci_mmio_map |
; returns eax = 1 if successfully unmapped |
; |
; Error codes |
; eax = -1 if no user PCI access allowed, |
; eax = 0 if unmapping failed |
;*************************************************************************** |
pci_mmio_unmap: |
stdcall user_free, ebx |
ret |
end if |
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= |
uglobal |
align 4 |
; VendID (2), DevID (2), Revision = 0 (1), Class Code (3), FNum (1), Bus (1) |
pci_emu_dat: times 30*10 db 0 |
endg |
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= |
align 4 |
sys_pcibios: |
xchg ebx, eax |
xchg ecx, eax |
xchg edx, eax |
xchg esi, eax |
xchg edi, eax |
cmp [pci_access_enabled], 1 |
jne .unsupported_func |
cmp [pci_bios_entry], 0 |
470,14 → 612,14 |
.not_WRITE_CONFIG: |
.unsupported_func: |
mov ah, 0x81 ; FUNC_NOT_SUPPORTED |
.return:mov dword[esp + 8 ], edi |
mov dword[esp + 12], esi |
.return:mov dword[esp + 4 ], edi |
mov dword[esp + 8], esi |
.return_abcd: |
mov dword[esp + 28], edx |
mov dword[esp + 24], edx |
.return_abc: |
mov dword[esp + 32], ecx |
mov dword[esp + 28], ecx |
.return_ab: |
mov dword[esp + 24], ebx |
mov dword[esp + 20], ebx |
.return_a: |
mov dword[esp + 36], eax |
mov dword[esp + 32], eax |
ret |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/const.inc |
---|
1,6 → 1,6 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;; |
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
309,15 → 309,13 |
BgrDrawMode equ (OS_BASE+0x033BFF4) |
BgrDataWidth equ (OS_BASE+0x033BFF8) |
BgrDataHeight equ (OS_BASE+0x033BFFC) |
WinMapAddress equ (OS_BASE+0x033C000) |
display_data equ (OS_BASE+0x033C000) ;1024*1280=0x140000 |
virtual at (OS_BASE+0x047CF80) |
sys_pgmap equ (OS_BASE+0x033C000) |
virtual at (OS_BASE+0x05FFF80) |
tss TSS |
end virtual |
sys_pgmap equ (OS_BASE+0x047F000) |
HEAP_BASE equ (OS_BASE+0x0800000) |
HEAP_MIN_SIZE equ 0x01000000 |
439,7 → 437,8 |
APP_EV_OFFSET equ 40 |
struc CURSOR |
{;common object header |
{ |
;common object header |
.magic dd ? ;'CURS' |
.destroy dd ? ;internal destructor |
.fd dd ? ;next object in list |
450,12 → 449,17 |
.base dd ? ;allocated memory |
.hot_x dd ? ;hotspot coords |
.hot_y dd ? |
.list_next dd ? ;next cursor in cursor list |
.list_prev dd ? ;prev cursor in cursor list |
.dev_obj dd ? ;device depended data |
.sizeof: |
} |
virtual at 0 |
CURSOR CURSOR |
end virtual |
CURSOR_SIZE equ 32 |
struc EVENT |
{ |
511,7 → 515,78 |
SMAP SMAP |
end virtual |
struc DLLDESCR |
{ |
.bk dd ? |
.fd dd ? ;+4 |
.data dd ? ;+8 |
.size dd ? ;+12 |
.timestamp dq ? |
.refcount dd ? |
.defaultbase dd ? |
.coff_hdr dd ? |
.symbols_ptr dd ? |
.symbols_num dd ? |
.symbols_lim dd ? |
.exports dd ? ;export table |
.name: |
.sizeof: |
} |
struc HDLL |
{ |
.fd dd ? ;next object in list |
.bk dd ? ;prev object in list |
.pid dd ? ;owner id |
.base dd ? ;mapped base |
.size dd ? ;mapped size |
.refcount dd ? ;reference counter for this process and this lib |
.parent dd ? ;DLLDESCR |
.sizeof: |
} |
virtual at 0 |
DLLDESCR DLLDESCR |
end virtual |
virtual at 0 |
HDLL HDLL |
end virtual |
struc display_t |
{ |
.x dd ? |
.y dd ? |
.width dd ? |
.height dd ? |
.bpp dd ? |
.vrefresh dd ? |
.pitch dd ? |
.lfb dd ? |
.modes dd ? |
.ddev dd ? |
.connector dd ? |
.crtc dd ? |
.cr_list.next dd ? |
.cr_list.prev dd ? |
.cursor dd ? |
.init_cursor dd ? |
.select_cursor dd ? |
.show_cursor dd ? |
.move_cursor dd ? |
.restore_cursor dd ? |
.disable_mouse dd ? |
} |
virtual at 0 |
display_t display_t |
end virtual |
struc HEAP_DATA |
{ |
.mutex rd 1 |
595,7 → 670,8 |
;} |
struc SRV |
{ .srv_name rb 16 ;ASCIIZ string |
{ |
.srv_name rb 16 ;ASCIIZ string |
.magic dd ? ;+0x10 ;'SRV ' |
.size dd ? ;+0x14 ;size of structure SRV |
.fd dd ? ;+0x18 ;next SRV descriptor |
602,11 → 678,12 |
.bk dd ? ;+0x1C ;prev SRV descriptor |
.base dd ? ;+0x20 ;service base address |
.entry dd ? ;+0x24 ;service START function |
.srv_proc dd ? ;+0x28 ;main service handler |
.srv_proc dd ? ;+0x28 ;user mode service handler |
.srv_proc_ex dd ? ;+0x2C ;kernel mode service handler |
.sizeof: |
} |
SRV_FD_OFFSET equ 0x18 |
SRV_SIZE equ 44 |
DRV_ENTRY equ 1 |
DRV_EXIT equ -1 |
/kernel/branches/net/core/conf_lib.inc |
---|
12,11 → 12,11 |
$Revision$ |
iglobal |
conf_path_sect: db 'path',0 |
conf_fname db '/sys/sys.conf',0 |
endg |
; set soke kernel configuration |
proc set_kernel_conf |
locals |
64,7 → 64,7 |
popad |
ret |
endp |
iglobal |
ugui db 'gui',0 |
ugui_mouse_speed db 'mouse_speed',0 |
ugui_mouse_speed_def db '2',0 |
74,8 → 74,63 |
udev db 'dev',0 |
udev_midibase db 'midibase',0 |
udev_midibase_def db '0x320',0 |
endg |
;set up netvork configuration |
proc set_network_conf |
locals |
par db 30 dup(?) |
endl |
pushad |
;[net] |
;active |
lea eax,[par] |
invoke ini.get_int,conf_fname, unet, unet_active, 0 |
or eax,eax |
jz .do_not_set_net |
mov eax, [stack_config] |
and eax, 0xFFFFFF80 |
add eax, 3 |
mov [stack_config], eax |
call ash_eth_enable |
;addr |
lea eax,[par] |
push eax |
invoke ini.get_str,conf_fname, unet, unet_addr, eax,30, unet_def |
pop eax |
stdcall do_inet_adr,eax |
mov [stack_ip], eax |
;mask |
lea eax,[par] |
push eax |
invoke ini.get_str,conf_fname, unet, unet_mask, eax,30, unet_def |
pop eax |
stdcall do_inet_adr,eax |
mov [subnet_mask], eax |
;gate |
lea eax,[par] |
push eax |
invoke ini.get_str,conf_fname, unet, unet_gate, eax,30, unet_def |
pop eax |
stdcall do_inet_adr,eax |
mov [gateway_ip], eax |
.do_not_set_net: |
popad |
ret |
endp |
iglobal |
unet db 'net',0 |
unet_active db 'active',0 |
unet_addr db 'addr',0 |
unet_mask db 'mask',0 |
unet_gate db 'gate',0 |
unet_def db 0 |
endg |
; convert string to DWord |
proc strtoint stdcall,strs |
pushad |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/debug.inc |
---|
10,10 → 10,12 |
; diamond, 2006 |
sys_debug_services: |
cmp eax, 9 |
cmp ebx, 9 |
ja @f |
jmp dword [sys_debug_services_table+eax*4] |
jmp dword [sys_debug_services_table+ebx*4] |
@@: ret |
iglobal |
align 4 |
sys_debug_services_table: |
dd debug_set_event_data |
dd debug_getcontext |
25,21 → 27,21 |
dd debug_write_process_memory |
dd debug_terminate |
dd debug_set_drx |
endg |
debug_set_event_data: |
; in: ebx = pointer |
; in: ecx = pointer |
; destroys eax |
mov eax, [current_slot] |
mov [eax+APPDATA.dbg_event_mem], ebx |
mov [eax+APPDATA.dbg_event_mem], ecx |
ret |
get_debuggee_slot: |
; in: ebx=PID |
; in: ecx=PID |
; out: CF=1 if error |
; CF=0 and eax=slot*0x20 if ok |
; out: interrupts disabled |
cli |
mov eax, ebx |
mov eax, ecx |
call pid_to_slot |
test eax, eax |
jz .ret_bad |
56,7 → 58,7 |
ret |
debug_detach: |
; in: ebx=pid |
; in: ecx=pid |
; destroys eax,ebx |
call get_debuggee_slot |
jc .ret |
67,54 → 69,55 |
ret |
debug_terminate: |
; in: ebx=pid |
; in: ecx=pid |
call get_debuggee_slot |
jc debug_detach.ret |
mov ecx, eax |
shr ecx, 5 |
push 2 |
pop ebx |
jmp sys_system |
; push 2 |
; pop ebx |
mov edx,esi |
jmp sysfn_terminate |
debug_suspend: |
; in: ebx=pid |
; destroys eax,ebx |
; in: ecx=pid |
; destroys eax,ecx |
cli |
mov eax, ebx |
mov eax, ecx |
call pid_to_slot |
shl eax, 5 |
jz .ret |
mov bl, [CURRENT_TASK+eax+TASKDATA.state] ; process state |
test bl, bl |
mov cl, [CURRENT_TASK+eax+TASKDATA.state] ; process state |
test cl, cl |
jz .1 |
cmp bl, 5 |
cmp cl, 5 |
jnz .ret |
mov bl, 2 |
.2: mov [CURRENT_TASK+eax+TASKDATA.state], bl |
mov cl, 2 |
.2: mov [CURRENT_TASK+eax+TASKDATA.state], cl |
.ret: |
sti |
ret |
.1: |
inc ebx |
inc ecx |
jmp .2 |
do_resume: |
mov bl, [CURRENT_TASK+eax+TASKDATA.state] |
cmp bl, 1 |
mov cl, [CURRENT_TASK+eax+TASKDATA.state] |
cmp cl, 1 |
jz .1 |
cmp bl, 2 |
cmp cl, 2 |
jnz .ret |
mov bl, 5 |
.2: mov [CURRENT_TASK+eax+TASKDATA.state], bl |
mov cl, 5 |
.2: mov [CURRENT_TASK+eax+TASKDATA.state], cl |
.ret: ret |
.1: dec ebx |
.1: dec ecx |
jmp .2 |
debug_resume: |
; in: ebx=pid |
; in: ecx=pid |
; destroys eax,ebx |
cli |
mov eax, ebx |
mov eax, ecx |
call pid_to_slot |
shl eax, 5 |
jz .ret |
124,23 → 127,24 |
debug_getcontext: |
; in: |
; ebx=pid |
; ecx=sizeof(CONTEXT) |
; edx->CONTEXT |
; ecx=pid |
; edx=sizeof(CONTEXT) |
; esi->CONTEXT |
; destroys eax,ecx,edx,esi,edi |
cmp ecx, 28h |
cmp edx, 28h |
jnz .ret |
push ebx |
mov ebx, edx |
; push ecx |
; mov ecx, esi |
call check_region |
pop ebx |
; pop ecx |
dec eax |
jnz .ret |
call get_debuggee_slot |
jc .ret |
mov edi, esi |
mov eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack] |
lea esi, [eax+RING0_STACK_SIZE] |
mov edi, edx |
.ring0: |
; note that following code assumes that all interrupt/exception handlers |
; saves ring-3 context by pushad in this order |
174,23 → 178,24 |
debug_setcontext: |
; in: |
; ebx=pid |
; ecx=sizeof(CONTEXT) |
; edx->CONTEXT |
; ecx=pid |
; edx=sizeof(CONTEXT) |
; esi->CONTEXT |
; destroys eax,ecx,edx,esi,edi |
cmp ecx, 28h |
cmp edx, 28h |
jnz .ret |
push ebx |
mov ebx, edx |
; push ebx |
; mov ebx, edx |
call check_region |
pop ebx |
; pop ebx |
dec eax |
jnz .ret |
call get_debuggee_slot |
jc .stiret |
; mov esi, edx |
mov eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack] |
lea edi, [eax+RING0_STACK_SIZE] |
mov esi, edx |
.ring0: |
sub edi, 8+12+20h |
mov eax, [esi+24h] ;edi |
227,22 → 232,26 |
lea eax, [eax*8+SLOT_BASE+APPDATA.dbg_regs] |
; [eax]=dr0, [eax+4]=dr1, [eax+8]=dr2, [eax+C]=dr3 |
; [eax+10]=dr7 |
cmp edx, OS_BASE |
cmp esi, OS_BASE |
jae .errret |
cmp cl, 3 |
cmp dl, 3 |
ja .errret |
mov ebx, dr7 |
shr ebx, cl |
shr ebx, cl |
test ebx, 2 ; bit 1+2*index = G0..G3, global break enable |
mov ecx, dr7 |
;fix me |
xchg ecx,edx |
shr edx, cl |
shr edx, cl |
xchg ecx,edx |
test ecx, 2 ; bit 1+2*index = G0..G3, global break enable |
jnz .errret2 |
test ch, ch |
test dh, dh |
jns .new |
; clear breakpoint |
movzx ecx, cl |
add ecx, ecx |
and dword [eax+ecx*2], 0 ; clear DR<i> |
btr dword [eax+10h], ecx ; clear L<i> bit |
movzx edx, dl |
add edx, edx |
and dword [eax+edx*2], 0 ; clear DR<i> |
btr dword [eax+10h], edx ; clear L<i> bit |
test byte [eax+10h], 55h |
jnz .okret |
; imul eax, ebp, tss_step/32 |
249,45 → 258,49 |
; and byte [eax + tss_data + TSS._trap], not 1 |
and [ebp*8 + SLOT_BASE+APPDATA.dbg_state], not 1 |
.okret: |
and dword [esp+36], 0 |
and dword [esp+32], 0 |
sti |
ret |
.errret: |
sti |
mov dword [esp+36], 1 |
mov dword [esp+32], 1 |
ret |
.errret2: |
sti |
mov dword [esp+36], 2 |
mov dword [esp+32], 2 |
ret |
.new: |
; add new breakpoint |
; cl=index; ch=flags; edx=address |
test ch, 0xF0 |
; dl=index; dh=flags; esi=address |
test dh, 0xF0 |
jnz .errret |
mov bl, ch |
and bl, 3 |
cmp bl, 2 |
mov cl, dh |
and cl, 3 |
cmp cl, 2 |
jz .errret |
mov bl, ch |
shr bl, 2 |
cmp bl, 2 |
mov cl, dh |
shr cl, 2 |
cmp cl, 2 |
jz .errret |
test dl, bl |
mov ebx,esi |
test bl, dl |
jnz .errret |
or byte [eax+10h+1], 3 ; set GE and LE flags |
movzx ebx, ch |
movzx ecx, cl |
movzx edx, dh |
movzx ecx, dl |
add ecx, ecx |
bts dword [eax+10h], ecx ; set L<i> flag |
add ecx, ecx |
mov [eax+ecx], edx ; set DR<i> |
mov [eax+ecx], ebx;esi ; set DR<i> |
shl edx, cl |
mov ebx, 0xF |
shl ebx, cl |
mov edx, 0xF |
shl edx, cl |
not edx |
and [eax+10h+2], dx |
or [eax+10h+2], bx ; set R/W and LEN fields |
not ebx |
and [eax+10h+2], bx |
or [eax+10h+2], dx ; set R/W and LEN fields |
; imul eax, ebp, tss_step/32 |
; or byte [eax + tss_data + TSS._trap], 1 |
or [ebp*8 + SLOT_BASE+APPDATA.dbg_state], 1 |
295,51 → 308,51 |
debug_read_process_memory: |
; in: |
; ebx=pid |
; ecx=length |
; esi->buffer in debugger |
; edx=address in debuggee |
; ecx=pid |
; edx=length |
; edi->buffer in debugger |
; esi=address in debuggee |
; out: [esp+36]=sizeof(read) |
; destroys all |
push ebx |
mov ebx, esi |
; push ebx |
; mov ebx, esi |
call check_region |
pop ebx |
; pop ebx |
dec eax |
jnz .err |
call get_debuggee_slot |
jc .err |
shr eax, 5 |
mov ebx, esi |
; mov ebx, esi |
call read_process_memory |
sti |
mov dword [esp+36], eax |
mov dword [esp+32], eax |
ret |
.err: |
or dword [esp+36], -1 |
or dword [esp+32], -1 |
ret |
debug_write_process_memory: |
; in: |
; ebx=pid |
; ecx=length |
; esi->buffer in debugger |
; edx=address in debuggee |
; ecx=pid |
; edx=length |
; edi->buffer in debugger |
; esi=address in debuggee |
; out: [esp+36]=sizeof(write) |
; destroys all |
push ebx |
mov ebx, esi |
; push ebx |
; mov ebx, esi |
call check_region |
pop ebx |
; pop ebx |
dec eax |
jnz debug_read_process_memory.err |
call get_debuggee_slot |
jc debug_read_process_memory.err |
shr eax, 5 |
mov ebx, esi |
; mov ebx, esi |
call write_process_memory |
sti |
mov [esp+36], eax |
mov [esp+32], eax |
ret |
debugger_notify: |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/dll.inc |
---|
1,6 → 1,6 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;; |
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
315,7 → 315,7 |
cmp [edi+SRV.magic], ' SRV' |
jne .fail |
cmp [edi+SRV.size], SRV_SIZE |
cmp [edi+SRV.size], SRV.sizeof |
jne .fail |
stdcall [edi+SRV.srv_proc], esi |
333,7 → 333,7 |
endp |
; param |
; ebx= io_control |
; ecx= io_control |
; |
; retval |
; eax= error code |
340,17 → 340,17 |
align 4 |
srv_handlerEx: |
cmp ebx, OS_BASE |
cmp ecx, OS_BASE |
jae .fail |
mov eax, [ebx+handle] |
mov eax, [ecx+handle] |
cmp [eax+SRV.magic], ' SRV' |
jne .fail |
cmp [eax+SRV.size], SRV_SIZE |
cmp [eax+SRV.size], SRV.sizeof |
jne .fail |
stdcall [eax+SRV.srv_proc], ebx |
stdcall [eax+SRV.srv_proc], ecx |
ret |
.fail: |
or eax, -1 |
402,8 → 402,8 |
cmp [handler], eax |
je .fail |
mov eax, SRV_SIZE |
call malloc ;call alloc_service |
mov eax, SRV.sizeof |
call malloc |
test eax, eax |
jz .fail |
411,13 → 411,15 |
push edi |
mov edi, eax |
mov esi, [name] |
mov ecx, 16/4 |
rep movsd |
movsd |
movsd |
movsd |
movsd |
pop edi |
pop esi |
mov [eax+SRV.magic], ' SRV' |
mov [eax+SRV.size], SRV_SIZE |
mov [eax+SRV.size], SRV.sizeof |
mov ebx, srv.fd-SRV_FD_OFFSET |
mov edx, [ebx+SRV.fd] |
472,8 → 474,8 |
xor eax, eax |
ret |
.ok: |
mov ebx, [pSym] |
mov eax, [ebx+8] |
mov eax, [pSym] |
mov eax, [eax+8] |
ret |
endp |
611,7 → 613,10 |
jz .cleanup |
mov [file2], eax |
pushfd |
cli |
stdcall unpack, [file], eax |
popfd |
stdcall kernel_free, [file] |
mov eax, [file2] |
mov ebx, [file_size] |
676,7 → 681,7 |
endp |
align 4 |
proc fix_coff_symbols stdcall, sec:dword, symbols:dword,\ |
proc fix_coff_symbols stdcall uses ebx esi, sec:dword, symbols:dword,\ |
sym_count:dword, strings:dword, imports:dword |
locals |
retval dd ? |
738,7 → 743,8 |
endp |
align 4 |
proc fix_coff_relocs stdcall, coff:dword, sec:dword, sym:dword |
proc fix_coff_relocs stdcall uses ebx esi, coff:dword, sym:dword, \ |
delta:dword |
locals |
n_sec dd ? |
endl |
746,8 → 752,8 |
mov eax, [coff] |
movzx ebx, [eax+CFH.nSections] |
mov [n_sec], ebx |
lea esi, [eax+20] |
.fix_sec: |
mov esi, [sec] |
mov edi, [esi+CFS.PtrReloc] |
add edi, [coff] |
754,7 → 760,7 |
movzx ecx, [esi+CFS.NumReloc] |
test ecx, ecx |
jz .next |
.next_reloc: |
.reloc_loop: |
mov ebx, [edi+CRELOC.SymIndex] |
add ebx,ebx |
lea ebx,[ebx+ebx*8] |
777,12 → 783,14 |
mov eax, [edi+CRELOC.VirtualAddress] |
add eax, [esi+CFS.VirtualAddress] |
.fix: |
add eax, [delta] |
add [eax], edx |
.next_reloc: |
add edi, 10 |
dec ecx |
jnz .next_reloc |
jnz .reloc_loop |
.next: |
add [sec], COFF_SECTION_SIZE |
add esi, COFF_SECTION_SIZE |
dec [n_sec] |
jnz .fix_sec |
.exit: |
789,6 → 797,43 |
ret |
endp |
proc rebase_coff stdcall uses ebx esi, coff:dword, sym:dword, \ |
delta:dword |
locals |
n_sec dd ? |
endl |
mov eax, [coff] |
movzx ebx, [eax+CFH.nSections] |
mov [n_sec], ebx |
lea esi, [eax+20] |
mov edx, [delta] |
.fix_sec: |
mov edi, [esi+CFS.PtrReloc] |
add edi, [coff] |
movzx ecx, [esi+CFS.NumReloc] |
test ecx, ecx |
jz .next |
.reloc_loop: |
cmp [edi+CRELOC.Type], 6 |
jne .next_reloc |
.dir_32: |
mov eax, [edi+CRELOC.VirtualAddress] |
add eax, [esi+CFS.VirtualAddress] |
add [eax+edx], edx |
.next_reloc: |
add edi, 10 |
dec ecx |
jnz .reloc_loop |
.next: |
add esi, COFF_SECTION_SIZE |
dec [n_sec] |
jnz .fix_sec |
.exit: |
ret |
endp |
align 4 |
proc load_driver stdcall, driver_name:dword |
locals |
900,10 → 945,8 |
jz .link_fail |
mov ebx, [coff] |
add ebx, 20 |
stdcall fix_coff_relocs, [coff], ebx, [sym] |
stdcall fix_coff_relocs, ebx, [sym], 0 |
mov ebx, [coff] |
stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion |
test eax, eax |
jz .link_fail |
975,117 → 1018,530 |
ret |
endp |
; in: edx -> COFF_SECTION struct |
; out: eax = alignment as mask for bits to drop |
coff_get_align: |
; Rules: |
; - if alignment is not given, use default = 4K; |
; - if alignment is given and is no more than 4K, use it; |
; - if alignment is more than 4K, revert to 4K. |
push ecx |
mov cl, byte [edx+CFS.Characteristics+2] |
mov eax, 1 |
shr cl, 4 |
dec cl |
js .default |
cmp cl, 12 |
jbe @f |
.default: |
mov cl, 12 |
@@: |
shl eax, cl |
pop ecx |
dec eax |
ret |
align 4 |
proc load_library stdcall, file_name:dword |
locals |
fullname rb 260 |
fileinfo rb 40 |
coff dd ? |
sym dd ? |
strings dd ? |
img_size dd ? |
img_base dd ? |
exports dd ? |
endl |
cli |
stdcall load_file, [file_name] |
; resolve file name |
mov ebx, [file_name] |
lea edi, [fullname+1] |
mov byte [edi-1], '/' |
stdcall get_full_file_name, edi, 259 |
test al, al |
jz .fail |
; scan for required DLL in list of already loaded for this process, |
; ignore timestamp |
mov esi, [CURRENT_TASK] |
shl esi, 8 |
lea edi, [fullname] |
mov ebx, [esi+SLOT_BASE+APPDATA.dlls_list_ptr] |
test ebx, ebx |
jz .not_in_process |
mov esi, [ebx+HDLL.fd] |
.scan_in_process: |
cmp esi, ebx |
jz .not_in_process |
mov eax, [esi+HDLL.parent] |
add eax, DLLDESCR.name |
stdcall strncmp, eax, edi, -1 |
test eax, eax |
jnz .next_in_process |
; simple variant: load DLL which is already loaded in this process |
; just increment reference counters and return address of exports table |
inc [esi+HDLL.refcount] |
mov ecx, [esi+HDLL.parent] |
inc [ecx+DLLDESCR.refcount] |
mov eax, [ecx+DLLDESCR.exports] |
sub eax, [ecx+DLLDESCR.defaultbase] |
add eax, [esi+HDLL.base] |
ret |
.next_in_process: |
mov esi, [esi+HDLL.fd] |
jmp .scan_in_process |
.not_in_process: |
; scan in full list, compare timestamp |
lea eax, [fileinfo] |
stdcall get_fileinfo, edi, eax |
test eax, eax |
jnz .fail |
mov esi, [dll_list.fd] |
.scan_for_dlls: |
cmp esi, dll_list |
jz .load_new |
lea eax, [esi+DLLDESCR.name] |
stdcall strncmp, eax, edi, -1 |
test eax, eax |
jnz .continue_scan |
.test_prev_dll: |
mov eax, dword [fileinfo+24] ; last modified time |
mov edx, dword [fileinfo+28] ; last modified date |
cmp dword [esi+DLLDESCR.timestamp], eax |
jnz .continue_scan |
cmp dword [esi+DLLDESCR.timestamp+4], edx |
jz .dll_already_loaded |
.continue_scan: |
mov esi, [esi+DLLDESCR.fd] |
jmp .scan_for_dlls |
; new DLL |
.load_new: |
; load file |
stdcall load_file, edi |
test eax, eax |
jz .fail |
mov [coff], eax |
mov dword [fileinfo+32], ebx |
mov [coff], eax |
movzx ecx, [eax+CFH.nSections] |
; allocate DLLDESCR struct; size is DLLDESCR.sizeof plus size of DLL name |
mov esi, edi |
mov ecx, -1 |
xor eax, eax |
repnz scasb |
not ecx |
lea eax, [ecx+DLLDESCR.sizeof] |
push ecx |
call malloc |
pop ecx |
test eax, eax |
jz .fail_and_free_coff |
; save timestamp |
lea edi, [eax+DLLDESCR.name] |
rep movsb |
mov esi, eax |
mov eax, dword [fileinfo+24] |
mov dword [esi+DLLDESCR.timestamp], eax |
mov eax, dword [fileinfo+28] |
mov dword [esi+DLLDESCR.timestamp+4], eax |
; initialize DLLDESCR struct |
and dword [esi+DLLDESCR.refcount], 0 ; no HDLLs yet; later it will be incremented |
mov [esi+DLLDESCR.fd], dll_list |
mov eax, [dll_list.bk] |
mov [dll_list.bk], esi |
mov [esi+DLLDESCR.bk], eax |
mov [eax+DLLDESCR.fd], esi |
; calculate size of loaded DLL |
mov edx, [coff] |
movzx ecx, [edx+CFH.nSections] |
xor ebx, ebx |
lea edx, [eax+20] |
add edx, 20 |
@@: |
call coff_get_align |
add ebx, eax |
not eax |
and ebx, eax |
add ebx, [edx+CFS.SizeOfRawData] |
add ebx, 15 |
and ebx, not 15 |
add edx, COFF_SECTION_SIZE |
dec ecx |
jnz @B |
mov [img_size], ebx |
call init_heap |
stdcall user_alloc, [img_size] |
; it must be nonzero and not too big |
mov [esi+DLLDESCR.size], ebx |
test ebx, ebx |
jz .fail_and_free_dll |
cmp ebx, MAX_DEFAULT_DLL_ADDR-MIN_DEFAULT_DLL_ADDR |
ja .fail_and_free_dll |
; allocate memory for kernel-side image |
stdcall kernel_alloc, ebx |
test eax, eax |
jz .fail |
mov [img_base], eax |
jz .fail_and_free_dll |
mov [esi+DLLDESCR.data], eax |
; calculate preferred base address |
add ebx, 0x1FFF |
and ebx, not 0xFFF |
mov ecx, [dll_cur_addr] |
lea edx, [ecx+ebx] |
cmp edx, MAX_DEFAULT_DLL_ADDR |
jb @f |
mov ecx, MIN_DEFAULT_DLL_ADDR |
lea edx, [ecx+ebx] |
@@: |
mov [esi+DLLDESCR.defaultbase], ecx |
mov [dll_cur_addr], edx |
; copy sections and set correct values for VirtualAddress'es in headers |
push esi |
mov edx, [coff] |
movzx ebx, [edx+CFH.nSections] |
mov edi, [img_base] |
lea eax, [edx+20] |
mov edi, eax |
add edx, 20 |
cld |
@@: |
mov [eax+CFS.VirtualAddress], edi |
mov esi, [eax+CFS.PtrRawData] |
call coff_get_align |
add ecx, eax |
add edi, eax |
not eax |
and ecx, eax |
and edi, eax |
mov [edx+CFS.VirtualAddress], ecx |
add ecx, [edx+CFS.SizeOfRawData] |
mov esi, [edx+CFS.PtrRawData] |
push ecx |
mov ecx, [edx+CFS.SizeOfRawData] |
test esi, esi |
jnz .copy |
add edi, [eax+CFS.SizeOfRawData] |
xor eax, eax |
rep stosb |
jmp .next |
.copy: |
add esi, edx |
mov ecx, [eax+CFS.SizeOfRawData] |
cld |
add esi, [coff] |
rep movsb |
.next: |
add edi, 15 ;-new_app_base |
and edi, -16 |
add eax, COFF_SECTION_SIZE |
pop ecx |
add edx, COFF_SECTION_SIZE |
dec ebx |
jnz @B |
pop esi |
; save some additional data from COFF file |
; later we will use COFF header, headers for sections and symbol table |
; and also relocations table for all sections |
mov edx, [coff] |
mov ebx, [edx+CFH.pSymTable] |
mov edi, dword [fileinfo+32] |
sub edi, ebx |
jc .fail_and_free_data |
mov [esi+DLLDESCR.symbols_lim], edi |
add ebx, edx |
mov [sym], ebx |
movzx ecx, [edx+CFH.nSections] |
lea ecx, [ecx*5] |
lea edi, [edi+ecx*8+20] |
add edx, 20 |
@@: |
movzx eax, [edx+CFS.NumReloc] |
lea eax, [eax*5] |
lea edi, [edi+eax*2] |
add edx, COFF_SECTION_SIZE |
sub ecx, 5 |
jnz @b |
stdcall kernel_alloc, edi |
test eax, eax |
jz .fail_and_free_data |
mov edx, [coff] |
movzx ecx, [edx+CFH.nSections] |
lea ecx, [ecx*5] |
lea ecx, [ecx*2+5] |
mov [esi+DLLDESCR.coff_hdr], eax |
push esi |
mov esi, edx |
mov edi, eax |
rep movsd |
pop esi |
mov [esi+DLLDESCR.symbols_ptr], edi |
push esi |
mov ecx, [edx+CFH.nSymbols] |
mov [esi+DLLDESCR.symbols_num], ecx |
mov ecx, [esi+DLLDESCR.symbols_lim] |
mov esi, ebx |
rep movsb |
pop esi |
mov ebx, [esi+DLLDESCR.coff_hdr] |
push esi |
movzx eax, [edx+CFH.nSections] |
lea edx, [ebx+20] |
@@: |
movzx ecx, [edx+CFS.NumReloc] |
lea ecx, [ecx*5] |
mov esi, [edx+CFS.PtrReloc] |
mov [edx+CFS.PtrReloc], edi |
sub [edx+CFS.PtrReloc], ebx |
add esi, [coff] |
shr ecx, 1 |
rep movsd |
adc ecx, ecx |
rep movsw |
add edx, COFF_SECTION_SIZE |
dec eax |
jnz @b |
pop esi |
; fixup symbols |
mov edx, ebx |
mov eax, [ebx+CFH.nSymbols] |
add edx, 20 |
mov ecx, [esi+DLLDESCR.symbols_num] |
lea ecx, [ecx*9] |
add ecx,ecx |
lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE |
add ecx, [sym] |
mov [strings], ecx |
add ecx, [esi+DLLDESCR.symbols_ptr] |
lea eax, [edx+20] |
stdcall fix_coff_symbols, edx, [esi+DLLDESCR.symbols_ptr], eax,\ |
ecx, 0 |
; test eax, eax |
; jnz @F |
; |
;@@: |
stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\ |
[strings], dword 0 |
stdcall get_coff_sym,[esi+DLLDESCR.symbols_ptr],[ebx+CFH.nSymbols],szEXPORTS |
test eax, eax |
jnz @F |
stdcall get_coff_sym,[esi+DLLDESCR.symbols_ptr],[ebx+CFH.nSymbols],sz_EXPORTS |
@@: |
mov edx, [coff] |
movzx ebx, [edx+CFH.nSections] |
mov edi, new_app_base |
lea eax, [edx+20] |
@@: |
add [eax+CFS.VirtualAddress], edi ;patch user space offset |
add eax, COFF_SECTION_SIZE |
dec ebx |
jnz @B |
mov [esi+DLLDESCR.exports], eax |
add edx, 20 |
stdcall fix_coff_relocs, [coff], edx, [sym] |
; fix relocs in the hidden copy in kernel memory to default address |
; it is first fix; usually this will be enough, but second fix |
; can be necessary if real load address will not equal assumption |
mov eax, [esi+DLLDESCR.data] |
sub eax, [esi+DLLDESCR.defaultbase] |
stdcall fix_coff_relocs, ebx, [esi+DLLDESCR.symbols_ptr], eax |
mov ebx, [coff] |
stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS |
stdcall kernel_free, [coff] |
.dll_already_loaded: |
inc [esi+DLLDESCR.refcount] |
push esi |
call init_heap |
pop esi |
mov edi, [esi+DLLDESCR.size] |
stdcall user_alloc_at, [esi+DLLDESCR.defaultbase], edi |
test eax, eax |
jnz @F |
jnz @f |
stdcall user_alloc, edi |
test eax, eax |
jz .fail_and_dereference |
@@: |
mov [img_base], eax |
mov eax, HDLL.sizeof |
call malloc |
test eax, eax |
jz .fail_and_free_user |
mov ebx, [CURRENT_TASK] |
shl ebx, 5 |
mov edx, [CURRENT_TASK+ebx+TASKDATA.pid] |
mov [eax+HDLL.pid], edx |
push eax |
call init_dlls_in_thread |
pop ebx |
test eax, eax |
jz .fail_and_free_user |
mov edx, [eax+HDLL.fd] |
mov [ebx+HDLL.fd], edx |
mov [ebx+HDLL.bk], eax |
mov [eax+HDLL.fd], ebx |
mov [edx+HDLL.bk], ebx |
mov eax, ebx |
mov ebx, [img_base] |
mov [eax+HDLL.base], ebx |
mov [eax+HDLL.size], edi |
mov [eax+HDLL.refcount], 1 |
mov [eax+HDLL.parent], esi |
mov edx, ebx |
shr edx, 12 |
or dword [page_tabs+(edx-1)*4], DONT_FREE_BLOCK |
; copy entries of page table from kernel-side image to usermode |
; use copy-on-write for user-mode image, so map as readonly |
xor edi, edi |
mov ecx, [esi+DLLDESCR.data] |
shr ecx, 12 |
.map_pages_loop: |
mov eax, [page_tabs+ecx*4] |
and eax, not 0xFFF |
or al, PG_USER |
xchg eax, [page_tabs+edx*4] |
test al, 1 |
jz @f |
call free_page |
@@: |
invlpg [ebx+edi] |
inc ecx |
inc edx |
add edi, 0x1000 |
cmp edi, [esi+DLLDESCR.size] |
jb .map_pages_loop |
mov ebx, [coff] |
stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],sz_EXPORTS |
; if real user-mode base is not equal to preferred base, relocate image |
sub ebx, [esi+DLLDESCR.defaultbase] |
jz @f |
stdcall rebase_coff, [esi+DLLDESCR.coff_hdr], [esi+DLLDESCR.symbols_ptr], ebx |
@@: |
mov [exports], eax |
mov eax, [esi+DLLDESCR.exports] |
sub eax, [esi+DLLDESCR.defaultbase] |
add eax, [img_base] |
ret |
.fail_and_free_data: |
stdcall kernel_free, [esi+DLLDESCR.data] |
.fail_and_free_dll: |
mov eax, esi |
call free |
.fail_and_free_coff: |
stdcall kernel_free, [coff] |
mov eax, [exports] |
ret |
.fail: |
xor eax, eax |
ret |
.fail_and_free_user: |
stdcall user_free, [img_base] |
.fail_and_dereference: |
mov eax, 1 ; delete 1 reference |
call dereference_dll |
xor eax, eax |
ret |
endp |
; initialize [APPDATA.dlls_list_ptr] for given thread |
; DLL is per-process object, so APPDATA.dlls_list_ptr must be |
; kept in sync for all threads of one process. |
; out: eax = APPDATA.dlls_list_ptr if all is OK, |
; NULL if memory allocation failed |
init_dlls_in_thread: |
mov ebx, [current_slot] |
mov eax, [ebx+APPDATA.dlls_list_ptr] |
test eax, eax |
jnz .ret |
push [ebx+APPDATA.dir_table] |
mov eax, 8 |
call malloc |
pop edx |
test eax, eax |
jz .ret |
mov [eax], eax |
mov [eax+4], eax |
mov ecx, [TASK_COUNT] |
mov ebx, SLOT_BASE+256 |
.set: |
cmp [ebx+APPDATA.dir_table], edx |
jnz @f |
mov [ebx+APPDATA.dlls_list_ptr], eax |
@@: |
add ebx, 256 |
dec ecx |
jnz .set |
.ret: |
ret |
; in: eax = number of references to delete, esi -> DLLDESCR struc |
dereference_dll: |
sub [esi+DLLDESCR.refcount], eax |
jnz .ret |
mov eax, [esi+DLLDESCR.fd] |
mov edx, [esi+DLLDESCR.bk] |
mov [eax+DLLDESCR.bk], edx |
mov [edx+DLLDESCR.fd], eax |
stdcall kernel_free, [esi+DLLDESCR.coff_hdr] |
stdcall kernel_free, [esi+DLLDESCR.data] |
mov eax, esi |
call free |
.ret: |
ret |
destroy_hdll: |
push ebx ecx esi edi |
push eax |
mov ebx, [eax+HDLL.base] |
mov esi, [eax+HDLL.parent] |
mov edx, [esi+DLLDESCR.size] |
; The following actions require the context of application where HDLL is mapped. |
; However, destroy_hdll can be called in the context of OS thread when |
; cleaning up objects created by the application which is destroyed. |
; So remember current cr3 and set it to page table of target. |
mov eax, [ecx+APPDATA.dir_table] |
; Because we cheat with cr3, disable interrupts: task switch would restore |
; page table from APPDATA of current thread. |
; Also set [current_slot] because it is used by user_free. |
pushf |
cli |
push [current_slot] |
mov [current_slot], ecx |
mov ecx, cr3 |
push ecx |
mov cr3, eax |
push ebx ; argument for user_free |
mov eax, ebx |
shr ebx, 12 |
push ebx |
mov esi, [esi+DLLDESCR.data] |
shr esi, 12 |
.unmap_loop: |
push eax |
mov eax, 2 |
xchg eax, [page_tabs+ebx*4] |
mov ecx, [page_tabs+esi*4] |
and eax, not 0xFFF |
and ecx, not 0xFFF |
cmp eax, ecx |
jz @f |
call free_page |
@@: |
pop eax |
invlpg [eax] |
add eax, 0x1000 |
inc ebx |
inc esi |
sub edx, 0x1000 |
ja .unmap_loop |
pop ebx |
and dword [page_tabs+(ebx-1)*4], not DONT_FREE_BLOCK |
call user_free |
; Restore context. |
pop eax |
mov cr3, eax |
pop [current_slot] |
popf |
; Ok, cheating is done. |
pop eax |
push eax |
mov esi, [eax+HDLL.parent] |
mov eax, [eax+HDLL.refcount] |
call dereference_dll |
pop eax |
mov edx, [eax+HDLL.bk] |
mov ebx, [eax+HDLL.fd] |
mov [ebx+HDLL.bk], edx |
mov [edx+HDLL.fd], ebx |
call free |
pop edi esi ecx ebx |
ret |
; ecx -> APPDATA for slot, esi = dlls_list_ptr |
destroy_all_hdlls: |
test esi, esi |
jz .ret |
.loop: |
mov eax, [esi+HDLL.fd] |
cmp eax, esi |
jz free |
call destroy_hdll |
jmp .loop |
.ret: |
ret |
align 4 |
proc stop_all_services |
stop_all_services: |
push ebp |
mov edx, [srv.fd] |
.next: |
cmp edx, srv.fd-SRV_FD_OFFSET |
1092,7 → 1548,7 |
je .done |
cmp [edx+SRV.magic], ' SRV' |
jne .next |
cmp [edx+SRV.size], SRV_SIZE |
cmp [edx+SRV.size], SRV.sizeof |
jne .next |
mov ebx, [edx+SRV.entry] |
1101,12 → 1557,16 |
jz .next |
push edx |
stdcall ebx, dword -1 |
mov ebp, esp |
push 0 |
push -1 |
call ebx |
mov esp, ebp |
pop edx |
jmp .next |
.done: |
pop ebp |
ret |
endp |
; param |
; eax= size |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/export.inc |
---|
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/exports.inc |
---|
60,10 → 60,6 |
szClearEvent db 'ClearEvent',0 |
szLoadCursor db 'LoadCursor',0 |
szSelectHwCursor db 'SelectHwCursor',0 |
szSetHwCursor db 'SetHwCursor',0 |
szHwCursorRestore db 'HwCursorRestore', 0 |
szHwCursorCreate db 'HwCursorCreate', 0 |
szSysMsgBoardStr db 'SysMsgBoardStr', 0 |
szSysMsgBoardChar db 'SysMsgBoardChar', 0 |
139,11 → 135,6 |
dd szLoadCursor , load_cursor ;stdcall |
dd szSelectHwCursor , select_hw_cursor ;import stdcall |
dd szSetHwCursor , set_hw_cursor ;import stdcall |
dd szHwCursorRestore , hw_restore ;import |
dd szHwCursorCreate , create_cursor ;import |
dd szSysMsgBoardStr , sys_msg_board_str |
dd szSysMsgBoardChar , sys_msg_board |
dd szGetCurrentTask , get_curr_task |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/ext_lib.inc |
---|
13,7 → 13,9 |
$Revision$ |
if 0 |
; The code currently does not work. Kill "if 0/end if" only after correcting |
; to current kernel (dll.inc). |
macro library [name,fname] |
{ |
forward |
315,3 → 317,4 |
uglobal |
s_libname db 64 dup (0) |
endg |
end if |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/fpu.inc |
---|
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/heap.inc |
---|
1,6 → 1,6 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;; |
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
140,7 → 140,7 |
mov ecx, [pg_data.kernel_pages] |
shl ecx, 12 |
sub ecx, HEAP_BASE+4096*MEM_BLOCK_SIZE |
sub ecx, HEAP_BASE-OS_BASE+4096*MEM_BLOCK_SIZE |
mov [heap_size], ecx |
mov [heap_free], ecx |
mov [ebx+block_size], ecx |
759,6 → 759,102 |
endp |
align 4 |
proc user_alloc_at stdcall, address:dword, alloc_size:dword |
push ebx |
push esi |
push edi |
mov ebx, [current_slot] |
mov edx, [address] |
and edx, not 0xFFF |
mov [address], edx |
sub edx, 0x1000 |
jb .error |
mov esi, [ebx+APPDATA.heap_base] |
mov edi, [ebx+APPDATA.heap_top] |
cmp edx, esi |
jb .error |
.scan: |
cmp esi, edi |
jae .error |
mov ebx, esi |
shr ebx, 12 |
mov eax, [page_tabs+ebx*4] |
mov ecx, eax |
and ecx, 0xFFFFF000 |
add ecx, esi |
cmp edx, ecx |
jb .found |
mov esi, ecx |
jmp .scan |
.error: |
xor eax, eax |
pop edi |
pop esi |
pop ebx |
ret |
.found: |
test al, FREE_BLOCK |
jz .error |
mov eax, ecx |
sub eax, edx |
sub eax, 0x1000 |
cmp eax, [alloc_size] |
jb .error |
; Here we have 1 big free block which includes requested area. |
; In general, 3 other blocks must be created instead: |
; free at [esi, edx); |
; busy at [edx, edx+0x1000+ALIGN_UP(alloc_size,0x1000)); |
; free at [edx+0x1000+ALIGN_UP(alloc_size,0x1000), ecx) |
; First or third block (or both) may be absent. |
mov eax, edx |
sub eax, esi |
jz .nofirst |
or al, FREE_BLOCK |
mov [page_tabs+ebx*4], eax |
.nofirst: |
mov eax, [alloc_size] |
add eax, 0x1FFF |
and eax, not 0xFFF |
mov ebx, edx |
add edx, eax |
shr ebx, 12 |
or al, USED_BLOCK |
mov [page_tabs+ebx*4], eax |
shr eax, 12 |
dec eax |
jz .second_nofill |
inc ebx |
.fill: |
mov dword [page_tabs+ebx*4], 2 |
inc ebx |
dec eax |
jnz .fill |
.second_nofill: |
sub ecx, edx |
jz .nothird |
or cl, FREE_BLOCK |
mov [page_tabs+ebx*4], ecx |
.nothird: |
mov edx, [current_slot] |
mov ebx, [alloc_size] |
add ebx, 0xFFF |
and ebx, not 0xFFF |
add ebx, [edx+APPDATA.mem_size] |
call update_mem_size |
mov eax, [address] |
pop edi |
pop esi |
pop ebx |
ret |
endp |
align 4 |
proc user_free stdcall, base:dword |
push esi |
1221,10 → 1317,10 |
and eax, SHM_OPEN_MASK |
mov [action], eax |
mov eax, [name] |
test eax, eax |
mov ebx, [name] |
test ebx, ebx |
mov edx, E_PARAM |
jz .exit |
jz .fail |
mov esi, [shmem_list.fd] |
align 4 |
1233,7 → 1329,7 |
je .not_found |
lea edx, [esi+SMEM.name] ; link , base, size |
stdcall strncmp, edx, eax, 32 |
stdcall strncmp, edx, ebx, 32 |
test eax, eax |
je .found |
1245,7 → 1341,7 |
cmp eax, SHM_OPEN |
mov edx, E_NOTFOUND |
je .exit |
je .fail |
cmp eax, SHM_CREATE |
mov edx, E_PARAM |
1252,13 → 1348,13 |
je .create_shm |
cmp eax, SHM_OPEN_ALWAYS |
jne .exit |
jne .fail |
.create_shm: |
mov ecx, [size] |
test ecx, ecx |
jz .exit |
jz .fail |
add ecx, 4095 |
and ecx, -4096 |
1269,7 → 1365,7 |
test eax, eax |
mov esi, eax |
mov edx, E_NOMEM |
jz .exit |
jz .fail |
stdcall kernel_alloc, [size] |
test eax, eax |
1312,7 → 1408,7 |
je .create_map |
cmp eax, SHM_OPEN_ALWAYS |
jne .exit |
jne .fail |
.create_map: |
1321,7 → 1417,7 |
cmp eax, [esi+SMEM.access] |
mov [access], eax |
mov edx, E_ACCESS |
ja .exit |
ja .fail |
mov ebx, [CURRENT_TASK] |
shl ebx, 5 |
1332,12 → 1428,14 |
test eax, eax |
mov edi, eax |
mov edx, E_NOMEM |
jz .exit |
jz .fail |
inc [esi+SMEM.refcount] |
mov [edi+SMAP.magic], 'SMAP' |
mov [edi+SMAP.destroy], destroy_smap |
mov [edi+SMAP.parent], esi |
mov [edi+SMAP.base], 0 |
mov [edi+SMAP.parent], 0 |
stdcall user_alloc, [esi+SMEM.size] |
test eax, eax |
1345,9 → 1443,7 |
mov edx, E_NOMEM |
jz .cleanup2 |
lock inc [esi+SMEM.refcount] |
mov [edi+SMAP.base], eax |
mov [edi+SMAP.parent], esi |
mov ecx, [esi+SMEM.size] |
mov [size], ecx |
1374,10 → 1470,10 |
xor edx, edx |
cmp [owner_access], 0 |
jne .exit |
jne .fail |
.exit: |
mov edx, [size] |
.exit: |
.fail: |
mov eax, [mapped] |
popfd |
1385,13 → 1481,14 |
pop esi |
pop ebx |
ret |
.cleanup: |
mov [size], edx |
mov eax, esi |
call free |
jmp .exit |
.cleanup2: |
mov [size], edx |
mov eax, edi |
call destroy_smap |
jmp .exit |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/malloc.inc |
---|
1,6 → 1,6 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;; |
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
20,6 → 20,7 |
; esi= nb |
; ebx= idx |
; |
align 16 |
malloc: |
push esi |
134,13 → 135,17 |
mov [eax+12], ecx ; r->bk = B; |
mov eax, ebx |
pop esi |
mov [mst.mutex], 0 |
ret |
.small: |
; if (ms.treemap != 0 && (mem = malloc_small(nb)) != 0) |
cmp [mst.treemap], 0 |
je .from_top |
;;;;;;;;;;; start a change <lrz> |
mov eax,[mst.treemap] |
test eax,eax |
;;;;;;;;;;; end the change <lrz> |
; cmp [mst.treemap], 0 |
jz .from_top |
mov eax, esi |
call malloc_small |
test eax, eax |
196,7 → 201,6 |
; param |
; eax= mem |
align 4 |
free: |
push edi |
mov edi, eax |
246,7 → 250,7 |
shr ecx, 3 |
cmp eax, edx |
jne @F |
and [mst.smallmap], ecx |
btr [mst.smallmap], ecx |
@@: |
mov [eax+12], edx ;F->bk = B; |
mov [edx+8], eax ;B->fd = F |
383,7 → 387,6 |
; ecx = chunk |
; eax = size |
align 4 |
insert_chunk: |
cmp eax, 256 |
416,13 → 419,11 |
and [mst.mutex], 0 |
ret |
align 4 |
; param |
; esi= chunk |
; ebx= size |
align 4 |
insert_large_chunk: |
; I = compute_tree_index(S); |
475,7 → 476,6 |
shl eax, cl ;eax= K |
jmp .loop |
.not_eq_size: |
; C = &(T->child[(K >> 31) & 1]); |
517,7 → 517,6 |
mov [esi+8], eax |
mov [esi+12], edx |
ret |
.insert_child: |
; *C = X; |
536,7 → 535,6 |
; param |
; edx= chunk |
align 4 |
unlink_large_chunk: |
mov eax, [edx+12] |
593,6 → 591,7 |
btr [mst.treemap], ecx |
pop edi |
ret |
.l3: |
cmp [edi+16], edx |
jne @F |
599,11 → 598,14 |
mov [edi+16], eax |
jmp .l4 |
@@: |
mov [edi+20], eax |
.l4: |
test eax, eax |
je .done |
.l5: |
mov [eax+24], edi |
mov ecx, [edx+16] |
612,6 → 614,7 |
mov [eax+16], ecx |
mov [ecx+24], eax |
.l6: |
mov edx, [edx+20] |
test edx, edx |
619,6 → 622,7 |
mov [eax+20], edx |
mov [edx+24], eax |
.done: |
pop edi |
ret |
626,7 → 630,6 |
; param |
; esi= nb |
align 4 |
malloc_small: |
push ebp |
mov ebp, esi |
641,8 → 644,10 |
mov edi, [ecx+4] |
and edi, -4 |
sub edi, esi |
.loop: |
mov ebx, ecx |
.loop_1: |
; while ((t = leftmost_child(t)) != 0) |
652,8 → 657,10 |
jz @F |
mov ecx, eax |
jmp .l1 |
@@: |
mov ecx, [ecx+20] |
.l1: |
test ecx, ecx |
jz .unlink |
704,6 → 711,7 |
lea eax, [ebx+8] |
ret |
.split: |
; v->head = nb|PINUSE_BIT|CINUSE_BIT; |
736,6 → 744,7 |
pop ebp |
lea eax, [ebx+8] |
ret |
.large: |
lea eax, [ebx+8] |
push eax |
750,12 → 759,12 |
; param |
; esi= nb |
align 4 |
malloc_large: |
.idx equ esp+4 |
.rst equ esp |
push ebp |
push esi |
push edi |
sub esp, 8 |
; v = 0; |
789,11 → 798,13 |
jne @F |
xor ecx, ecx |
jmp .l1 |
@@: |
mov edx, ecx |
shr edx, 1 |
mov ecx, 37 |
sub ecx, edx |
.l1: |
mov edx, ebx |
shl edx, cl |
800,6 → 811,7 |
; rst = 0; |
mov [.rst], ebp |
.loop: |
; trem = (t->head & ~INUSE_BITS) - nb; |
819,6 → 831,7 |
mov ebp, eax |
mov edi, ecx |
je .l2 |
@@: |
; rt = t->child[1]; |
840,6 → 853,7 |
; rst = rt; |
mov [.rst], ecx |
@@: |
; if (t == 0) |
850,9 → 864,11 |
add edx, edx |
jmp .loop |
@@: |
; t = rst; |
mov eax, [.rst] |
.l2: |
; if (t == 0 && v == 0) |
861,6 → 877,7 |
test ebp, ebp |
jne .l7 |
mov ecx, [.idx] |
.l3: |
; leftbits = (-1<<idx) & ms.treemap; |
874,11 → 891,13 |
bsf eax, edx |
; t = ms.treebins[i]; |
mov eax, [mst.treebins+eax*4] |
@@: |
; while (t != 0) |
test eax, eax |
jz .l5 |
.l4: |
; trem = (t->head & ~INUSE_BITS) - nb; |
896,6 → 915,7 |
mov edi, ecx |
; v = t; |
mov ebp, eax |
@@: |
; t = leftmost_child(t); |
905,8 → 925,10 |
je @F |
mov eax, ecx |
jmp .l6 |
@@: |
mov eax, [eax+20] |
.l6: |
; while (t != 0) |
913,6 → 935,7 |
test eax, eax |
jne .l4 |
.l5: |
; if (v != 0) |
919,6 → 942,7 |
test ebp, ebp |
jz .done |
.l7: |
; r = chunk_plus_offset((mchunkptr)v, nb); |
947,8 → 971,10 |
lea eax, [ebp+8] |
add esp, 8 |
pop edi |
pop esi |
pop ebp |
ret |
.large: |
; v->head = nb|PINUSE_BIT|CINUSE_BIT; |
971,16 → 997,18 |
lea eax, [ebp+8] |
add esp, 8 |
pop edi |
pop esi |
pop ebp |
ret |
.done: |
add esp, 8 |
pop edi |
pop esi |
pop ebp |
xor eax, eax |
ret |
align 4 |
init_malloc: |
stdcall kernel_alloc, 0x40000 |
989,6 → 1017,7 |
mov [mst.topsize], 128*1024 |
mov dword [eax+4], (128*1024) or 1 |
mov eax, mst.smallbins |
@@: |
mov [eax+8], eax |
mov [eax+12], eax |
998,6 → 1027,3 |
ret |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/memory.inc |
---|
1,6 → 1,6 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;; |
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
167,7 → 167,7 |
@@: |
mov [page_tabs+eax*4], edx |
; push eax |
; invlpg [ebx] |
invlpg [ebx] |
; pop eax |
inc eax |
add ebx, edi |
205,7 → 205,7 |
@@: |
mov [page_tabs+ebx*4], eax |
; push eax |
; invlpg [edi] |
invlpg [edi] |
; pop eax |
add edi, edx |
add eax, edx |
321,8 → 321,17 |
cmp dword [LFBAddress], -1 |
jne @f |
mov [BOOT_VAR+0x901c],byte 2 |
stdcall kernel_alloc, 0x280000 |
mov [LFBAddress], eax |
stdcall alloc_pages, (0x280000 / 4096) |
push eax |
call alloc_page |
stdcall map_page_table, LFB_BASE, eax |
pop eax |
or eax, PG_UW |
mov ebx, LFB_BASE |
mov ecx, 0x280000 / 4096 |
call commit_pages |
mov [LFBAddress], dword LFB_BASE |
ret |
@@: |
test [SCR_MODE],word 0100000000000000b |
334,7 → 343,7 |
mov edx, LFB_BASE |
mov esi, [LFBAddress] |
mov edi, 0x00800000 |
mov edi, 0x00C00000 |
mov dword [exp_lfb+4], edx |
shr edi, 12 |
558,14 → 567,6 |
push ebx ;that is locals: .err_addr = cr2 |
inc [pg_data.pages_faults] |
; push eax |
; push edx |
; mov edx, 0x400 ;bochs |
; mov al,0xff ;bochs |
; out dx, al ;bochs |
; pop edx |
; pop eax |
mov eax, [pf_err_code] |
cmp ebx, OS_BASE ;ebx == .err_addr |
592,6 → 593,11 |
pop ebx ;restore exception number (#PF) |
ret |
; xchg bx, bx |
; add esp,12 ;clear in stack: locals(.err_addr) + #PF + ret_to_caller |
; restore_ring3_context |
; iretd |
.user_space: |
test eax, PG_MAP |
jnz .err_access ;Ñòðàíèöà ïðèñóòñòâóåò |
614,7 → 620,7 |
test eax, eax |
jz .fail |
stdcall map_page,[.err_addr],eax,dword PG_UW |
stdcall map_page,[.err_addr],eax,PG_UW |
mov edi, [.err_addr] |
and edi, 0xFFFFF000 |
627,9 → 633,40 |
restore_ring3_context |
iretd |
.err_access = .fail |
;íèêîãäà íå ïðîèñõîäèò |
;jmp .fail |
.err_access: |
; access denied? this may be a result of copy-on-write protection for DLL |
; check list of HDLLs |
and ebx, not 0xFFF |
mov eax, [CURRENT_TASK] |
shl eax, 8 |
mov eax, [SLOT_BASE+eax+APPDATA.dlls_list_ptr] |
test eax, eax |
jz .fail |
mov esi, [eax+HDLL.fd] |
.scan_hdll: |
cmp esi, eax |
jz .fail |
mov edx, ebx |
sub edx, [esi+HDLL.base] |
cmp edx, [esi+HDLL.size] |
jb .fault_in_hdll |
.scan_hdll.next: |
mov esi, [esi+HDLL.fd] |
jmp .scan_hdll |
.fault_in_hdll: |
; allocate new page, map it as rw and copy data |
call alloc_page |
test eax, eax |
jz .fail |
stdcall map_page,ebx,eax,PG_UW |
mov edi, ebx |
mov ecx, 1024 |
sub ebx, [esi+HDLL.base] |
mov esi, [esi+HDLL.parent] |
mov esi, [esi+DLLDESCR.data] |
add esi, ebx |
rep movsd |
jmp .exit |
.kernel_space: |
test eax, PG_MAP |
677,14 → 714,17 |
jmp .exit |
endp |
align 4 |
proc map_mem stdcall, lin_addr:dword,pdir:dword,\ |
ofs:dword,buf_size:dword |
mov eax, [buf_size] |
test eax, eax |
; returns number of mapped bytes |
proc map_mem stdcall, lin_addr:dword,slot:dword,\ |
ofs:dword,buf_size:dword,req_access:dword |
push 0 ; initialize number of mapped bytes |
cmp [buf_size], 0 |
jz .exit |
mov eax, [pdir] |
mov eax, [slot] |
shl eax, 8 |
mov eax, [SLOT_BASE+eax+APPDATA.dir_table] |
and eax, 0xFFFFF000 |
stdcall map_page,[ipc_pdir],eax,PG_UW |
716,10 → 756,11 |
and edx, 0x3FF |
mov esi, [ipc_ptab] |
.map: mov eax, [esi+edx*4] |
and eax, 0xFFFFF000 |
jz .exit |
stdcall map_page,edi,eax,PG_UW |
.map: |
stdcall safe_map_page,[slot],[req_access],[ofs] |
jnc .exit |
add dword [ebp-4], 4096 |
add [ofs], 4096 |
dec ecx |
jz .exit |
add edi, 0x1000 |
736,20 → 777,23 |
jmp .map |
.exit: |
pop eax |
ret |
endp |
align 4 |
proc map_memEx stdcall, lin_addr:dword,pdir:dword,\ |
ofs:dword,buf_size:dword |
mov eax, [buf_size] |
test eax, eax |
proc map_memEx stdcall, lin_addr:dword,slot:dword,\ |
ofs:dword,buf_size:dword,req_access:dword |
push 0 ; initialize number of mapped bytes |
cmp [buf_size], 0 |
jz .exit |
mov eax, [pdir] |
mov eax, [slot] |
shl eax, 8 |
mov eax, [SLOT_BASE+eax+APPDATA.dir_table] |
and eax, 0xFFFFF000 |
stdcall map_page,[proc_mem_pdir],eax,dword PG_UW |
stdcall map_page,[proc_mem_pdir],eax,PG_UW |
mov ebx, [ofs] |
shr ebx, 22 |
mov esi, [proc_mem_pdir] |
758,7 → 802,7 |
and eax, 0xFFFFF000 |
test eax, eax |
jz .exit |
stdcall map_page,edi,eax,dword PG_UW |
stdcall map_page,edi,eax,PG_UW |
@@: mov edi, [lin_addr] |
and edi, 0xFFFFF000 |
772,22 → 816,102 |
and edx, 0x3FF |
mov esi, [proc_mem_tab] |
.map: mov eax, [esi+edx*4] |
; and eax, 0xFFFFF000 |
; test eax, eax |
; jz .exit |
stdcall map_page,edi,eax,dword PG_UW |
.map: |
stdcall safe_map_page,[slot],[req_access],[ofs] |
jnc .exit |
add dword [ebp-4], 0x1000 |
add edi, 0x1000 |
add [ofs], 0x1000 |
inc edx |
dec ecx |
jnz .map |
.exit: |
pop eax |
ret |
endp |
; in: esi+edx*4 = pointer to page table entry |
; in: [slot], [req_access], [ofs] on the stack |
; in: edi = linear address to map |
; out: CF cleared <=> failed |
; destroys: only eax |
proc safe_map_page stdcall, slot:dword, req_access:dword, ofs:dword |
mov eax, [esi+edx*4] |
test al, PG_MAP |
jz .not_present |
test al, PG_WRITE |
jz .resolve_readonly |
; normal case: writable page, just map with requested access |
.map: |
stdcall map_page, edi, eax, [req_access] |
stc |
.fail: |
ret |
.not_present: |
; check for alloc-on-demand page |
test al, 2 |
jz .fail |
; allocate new page, save it to source page table |
push ecx |
call alloc_page |
pop ecx |
test eax, eax |
jz .fail |
or al, PG_UW |
mov [esi+edx*4], eax |
jmp .map |
.resolve_readonly: |
; readonly page, probably copy-on-write |
; check: readonly request of readonly page is ok |
test [req_access], PG_WRITE |
jz .map |
; find control structure for this page |
pushf |
cli |
cld |
push ebx ecx |
mov eax, [slot] |
shl eax, 8 |
mov eax, [SLOT_BASE+eax+APPDATA.dlls_list_ptr] |
test eax, eax |
jz .no_hdll |
mov ecx, [eax+HDLL.fd] |
.scan_hdll: |
cmp ecx, eax |
jz .no_hdll |
mov ebx, [ofs] |
and ebx, not 0xFFF |
sub ebx, [ecx+HDLL.base] |
cmp ebx, [ecx+HDLL.size] |
jb .hdll_found |
mov ecx, [ecx+HDLL.fd] |
jmp .scan_hdll |
.no_hdll: |
pop ecx ebx |
popf |
clc |
ret |
.hdll_found: |
; allocate page, save it in page table, map it, copy contents from base |
mov eax, [ecx+HDLL.parent] |
add ebx, [eax+DLLDESCR.data] |
call alloc_page |
test eax, eax |
jz .no_hdll |
or al, PG_UW |
mov [esi+edx*4], eax |
stdcall map_page, edi, eax, [req_access] |
push esi edi |
mov esi, ebx |
mov ecx, 4096/4 |
rep movsd |
pop edi esi |
pop ecx ebx |
popf |
stc |
ret |
endp |
sys_IPC: |
;input: |
; eax=1 - set ipc buffer area |
870,15 → 994,15 |
mov ecx, [ipc_tmp] |
cmp esi, 0x40000-0x1000 ; size of [ipc_tmp] minus one page |
jbe @f |
push eax esi edi |
push esi edi |
add esi,0x1000 |
stdcall alloc_kernel_space,esi |
mov ecx, eax |
pop edi esi eax |
pop edi esi |
@@: |
mov [used_buf], ecx |
stdcall map_mem, ecx, [SLOT_BASE+eax+0xB8],\ |
edi, esi |
stdcall map_mem, ecx, [dst_slot],\ |
edi, esi, PG_SW |
mov edi, [dst_offset] |
add edi, [used_buf] |
986,109 → 1110,99 |
mov [ecx+24], eax |
ret |
.fail: |
mov dword [esp+32], -1 |
or dword [esp+32], -1 |
ret |
iglobal |
align 4 |
f68call: |
dd f68.11 |
dd f68.12 |
dd f68.13 |
dd f68.14 |
dd f68.11 ; init_heap |
dd f68.12 ; user_alloc |
dd f68.13 ; user_free |
dd f68.14 ; get_event_ex |
dd f68.fail ;moved to f68.24 |
dd f68.16 |
dd f68.17 |
dd f68.16 ; get_service |
dd f68.17 ; call_service |
dd f68.fail ;moved to f68.25 |
dd f68.19 |
dd f68.20 |
dd f68.21 |
dd f68.22 |
dd f68.23 |
dd f68.19 ; load_dll |
dd f68.20 ; user_realloc |
dd f68.21 ; load_driver |
dd f68.22 ; shmem_open |
dd f68.23 ; shmem_close |
dd f68.24 |
dd f68.25 |
endg |
align 4 |
f68: |
cmp eax,4 |
jle sys_sheduler |
cmp ebx,4 |
jbe sys_sheduler |
cmp eax, 11 |
cmp ebx, 11 |
jb .fail |
cmp eax, 25 |
cmp ebx, 25 |
ja .fail |
jmp dword [f68call+eax*4-11*4] |
jmp dword [f68call+ebx*4-11*4] |
.11: |
call init_heap |
mov [esp+36], eax |
mov [esp+32], eax |
ret |
.12: |
stdcall user_alloc, ebx |
mov [esp+36], eax |
stdcall user_alloc, ecx |
mov [esp+32], eax |
ret |
.13: |
stdcall user_free, ebx |
mov [esp+36], eax |
stdcall user_free, ecx |
mov [esp+32], eax |
ret |
.14: |
cmp ebx, OS_BASE |
cmp ecx, OS_BASE |
jae .fail |
mov edi,ebx |
mov edi,ecx |
call get_event_ex |
mov [esp+36], eax |
mov [esp+32], eax |
ret |
.24: |
mov eax, [current_slot] |
xchg ebx, [eax+APPDATA.exc_handler] |
xchg ecx, [eax+APPDATA.except_mask] |
mov [esp+36], ebx ; reg_eax+8 |
mov [esp+24], ecx ; reg_ebx+8 |
ret |
.16: |
test ebx, ebx |
test ecx, ecx |
jz .fail |
cmp ebx, OS_BASE |
cmp ecx, OS_BASE |
jae .fail |
stdcall get_service, ebx |
mov [esp+36], eax |
stdcall get_service, ecx |
mov [esp+32], eax |
ret |
.17: |
call srv_handlerEx ;ebx |
mov [esp+36], eax |
call srv_handlerEx ;ecx |
mov [esp+32], eax |
ret |
.25: |
cmp ebx,32 |
jae .fail |
mov eax, [current_slot] |
btr [eax+APPDATA.except_mask],ebx |
setc byte[esp+36] |
jecxz @f |
bts [eax+APPDATA.except_mask],ebx |
@@: ret |
.19: |
cmp ebx, OS_BASE |
cmp ecx, OS_BASE |
jae .fail |
stdcall load_library, ebx |
mov [esp+36], eax |
stdcall load_library, ecx |
mov [esp+32], eax |
ret |
.20: |
mov eax, ecx |
call user_realloc |
mov [esp+36], eax |
mov eax, edx |
mov ebx, ecx |
call user_realloc ;in: eax = pointer, ebx = new size |
mov [esp+32], eax |
ret |
.21: |
cmp ecx, OS_BASE |
jae .fail |
cmp ebx, OS_BASE |
jae .fail |
stdcall load_PE, ebx |
mov edi, edx |
stdcall load_PE, ecx |
mov esi, eax |
test eax, eax |
jz @F |
mov esi, eax |
stdcall eax, DRV_ENTRY |
push edi |
push DRV_ENTRY |
call eax |
add esp, 8 |
test eax, eax |
jz @F |
1095,28 → 1209,45 |
mov [eax+SRV.entry], esi |
@@: |
mov [esp+36], eax |
mov [esp+32], eax |
ret |
.22: |
cmp ebx, OS_BASE |
cmp ecx, OS_BASE |
jae .fail |
stdcall shmem_open, ebx, ecx, edx |
mov [esp+28], edx |
mov [esp+36], eax |
stdcall shmem_open, ecx, edx, esi |
mov [esp+24], edx |
mov [esp+32], eax |
ret |
.23: |
cmp ebx, OS_BASE |
cmp ecx, OS_BASE |
jae .fail |
stdcall shmem_close, ebx |
mov [esp+36], eax |
stdcall shmem_close, ecx |
mov [esp+32], eax |
ret |
.24: |
mov eax, [current_slot] |
xchg ecx, [eax+APPDATA.exc_handler] |
xchg edx, [eax+APPDATA.except_mask] |
mov [esp+32], ecx ; reg_eax+8 |
mov [esp+20], edx ; reg_ebx+8 |
ret |
.25: |
cmp ecx,32 |
jae .fail |
mov eax, [current_slot] |
btr [eax+APPDATA.except_mask],ecx |
setc byte[esp+32] |
jecxz @f |
bts [eax+APPDATA.except_mask],ecx |
@@: |
ret |
.fail: |
xor eax, eax |
mov [esp+36], eax |
mov [esp+32], eax |
ret |
align 4 |
1156,41 → 1287,52 |
mov ecx, 0x2FF |
rdmsr ; |
; has BIOS already initialized MTRRs? |
test ah, 8 |
jnz .skip_init |
; rarely needed, so mainly placeholder |
; main memory - cached |
push eax |
xor edx, edx |
xor eax, eax |
mov ecx, 0x2FF |
wrmsr ;disable all MTRR |
mov eax, [MEM_AMOUNT] |
; round eax up to next power of 2 |
dec eax |
bsr ecx, eax |
mov eax, 2 |
shl eax, cl |
stdcall set_mtrr, edx,edx,eax,MEM_WB |
stdcall set_mtrr, 1,[LFBAddress],[LFBSize],MEM_WC |
mov ebx, 2 |
shl ebx, cl |
dec ebx |
; base of memory range = 0, type of memory range = MEM_WB |
xor edx, edx |
mov eax, MEM_WB |
mov ecx, 0x200 |
wrmsr |
; mask of memory range = 0xFFFFFFFFF - (size - 1), ebx = size - 1 |
mov eax, 0xFFFFFFFF |
mov edx, 0x0000000F |
sub eax, ebx |
sbb edx, 0 |
or eax, 0x800 |
inc ecx |
wrmsr |
; clear unused MTRRs |
xor eax, eax |
mov ecx, 0x204 |
mov ebx, 6 |
xor edx, edx |
@@: |
wrmsr ;disable unused MTRR |
wrmsr |
inc ecx |
cmp ecx, 0x210 |
jb @b |
; enable MTRRs |
pop eax |
or ah, 8 |
and al, 0xF0 ; default memtype = UC |
mov ecx, 0x2FF |
wrmsr |
inc ecx |
dec ebx |
jnz @b |
.skip_init: |
stdcall set_mtrr, [LFBAddress],[LFBSize],MEM_WC |
wbinvd ;again invalidate |
pop eax |
or eax, 0x800 ;set default memtype to UC |
and al, 0xF0 |
mov ecx, 0x2FF |
wrmsr ;and enable MTRR |
mov eax, cr0 |
and eax, not 0x60000000 |
mov cr0, eax ; enable caching |
1199,13 → 1341,29 |
endp |
align 4 |
proc set_mtrr stdcall, reg:dword,base:dword,size:dword,mem_type:dword |
proc set_mtrr stdcall, base:dword,size:dword,mem_type:dword |
; find unused register |
mov ecx, 0x201 |
@@: |
rdmsr |
dec ecx |
test ah, 8 |
jz .found |
rdmsr |
mov al, 0 ; clear memory type field |
cmp eax, [base] |
jz .ret |
add ecx, 3 |
cmp ecx, 0x210 |
jb @b |
; no free registers, ignore the call |
.ret: |
ret |
.found: |
; found, write values |
xor edx, edx |
mov eax, [base] |
or eax, [mem_type] |
mov ecx, [reg] |
lea ecx, [0x200+ecx*2] |
wrmsr |
mov ebx, [size] |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/peload.inc |
---|
280,6 → 280,8 |
__exports: |
export 'KERNEL', \ |
alloc_kernel_space, 'AllocKernelSpace', \ ; stdcall |
alloc_page, 'AllocPage', \ ; gcc ABI |
alloc_pages, 'AllocPages', \ ; stdcall |
commit_pages, 'CommitPages', \ ; eax, ebx, ecx |
create_kernel_object, 'CreateObject', \ |
create_ring_buffer, 'CreateRingBuffer', \ ; stdcall |
287,17 → 289,12 |
free_kernel_space, 'FreeKernelSpace', \ ; stdcall |
kernel_alloc, 'KernelAlloc', \ ; stdcall |
kernel_free, 'KernelFree', \ ; stdcall |
alloc_pages, 'AllocPages', \ ; stdcall |
malloc, 'Kmalloc', \ |
free, 'Kfree', \ |
map_io_mem, 'MapIoMem', \ ; stdcall |
get_pg_addr, 'GetPgAddr', \ ; eax |
\ |
select_hw_cursor, 'SelectHwCursor', \ ; stdcall |
set_hw_cursor, 'SetHwCursor', \ ; stdcall |
hw_restore, 'HwCursorRestore', \ ; |
create_cursor, 'HwCursorCreate', \ ; |
\ |
get_display, 'GetDisplay', \ |
set_screen, 'SetScreen', \ |
pci_api, 'PciApi', \ |
pci_read8, 'PciRead8', \ ; stdcall |
307,6 → 304,7 |
pci_write16, 'PciWrite16', \ ; stdcall |
pci_write32, 'PciWrite32', \ ; stdcall |
\ |
get_service, 'GetService', \ ; |
reg_service, 'RegService', \ ; stdcall |
attach_int_handler, 'AttachIntHandler', \ ; stdcall |
user_alloc, 'UserAlloc', \ ; stdcall |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/sched.inc |
---|
174,8 → 174,23 |
cmp eax, [esi+ecx] ;offset>0x7F |
je @f |
mov cr3, eax |
@@: ; set tss.esp0 |
@@: |
; set tss.esp0 |
Mov [tss._esp0],eax,[ebx+APPDATA.saved_esp0] |
mov edx, [ebx+APPDATA.tls_base] |
cmp edx, [esi+APPDATA.tls_base] |
je @f |
mov [tls_data_l+2],dx |
shr edx,16 |
mov [tls_data_l+4],dl |
mov [tls_data_l+7],dh |
mov dx, app_tls |
mov fs, dx |
@@: |
; set gs selector unconditionally |
Mov gs,ax,graph_data |
; set CR0.TS |
211,6 → 226,7 |
.arg dd ? |
} |
MAX_PROIRITY 0 ; highest, used for kernel tasks |
MAX_USER_PRIORITY 0 ; highest priority for user processes |
USER_PRIORITY 7 ; default (should correspond to nice 0) |
218,7 → 234,9 |
IDLE_PRIORITY 15 ; lowest, only IDLE process goes here |
NR_SCHED_QUEUES 16 ; MUST equal IDLE_PRIORYTY + 1 |
uglobal |
rdy_head rd 16 |
endg |
align 4 |
pick_task: |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/string.inc |
---|
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/sync.inc |
---|
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/sys32.inc |
---|
279,14 → 279,19 |
iret |
ready_for_next_irq: |
mov [check_idle_semaphore],5 |
mov al, 0x20 |
mov eax,5 |
mov [check_idle_semaphore],eax |
; mov al, 0x20 |
add eax,(0x20-0x5) |
out 0x20, al |
ret |
;destroy eax |
ready_for_next_irq_1: |
mov [check_idle_semaphore],5 |
mov al, 0x20 |
mov eax,5 |
mov [check_idle_semaphore],eax |
; mov al, 0x20 |
add eax,(0x20-0x5) |
out 0xa0,al |
out 0x20, al |
ret |
293,7 → 298,7 |
irqD: |
push eax |
mov al,0 |
xor eax,eax |
out 0xf0,al |
mov al,0x20 |
out 0xa0,al |
396,7 → 401,8 |
cmp eax,[application_table_status] |
jne apptsl1 |
mov [application_table_status],0 |
xor eax,eax |
mov [application_table_status],eax |
apptsl1: |
pop eax |
403,30 → 409,25 |
ret |
; * eax = 64 - íîìåð ôóíêöèè |
; * ebx = 1 - åäèíñòâåííàÿ ïîäôóíêöèÿ |
; * ecx = íîâûé ðàçìåð ïàìÿòè |
;Âîçâðàùàåìîå çíà÷åíèå: |
; * eax = 0 - óñïåøíî |
; * eax = 1 - íåäîñòàòî÷íî ïàìÿòè |
sys_resize_app_memory: |
; eax = 1 - resize |
; ebx = new amount of memory |
; ebx = 1 - resize |
; ecx = new amount of memory |
cmp eax,1 |
jne .no_application_mem_resize |
stdcall new_mem_resize, ebx |
mov [esp+36], eax |
ret |
; cmp eax,1 |
dec ebx |
jnz .no_application_mem_resize |
stdcall new_mem_resize, ecx |
mov [esp+32], eax |
.no_application_mem_resize: |
ret |
sys_threads: |
; eax=1 create thread |
; |
; ebx=thread start |
; ecx=thread stack value |
; |
; on return : eax = pid |
jmp new_sys_threads |
iglobal |
; process_terminating db 'K : Process - terminating',13,10,0 |
; process_terminated db 'K : Process - done',13,10,0 |
497,10 → 498,10 |
pop esi |
jmp @B |
@@: |
mov eax, [.slot] |
shl eax, 8 |
mov eax,[SLOT_BASE+eax+APPDATA.dir_table] |
stdcall destroy_app_space, eax |
stdcall destroy_app_space, [SLOT_BASE+eax+APPDATA.dir_table], [SLOT_BASE+eax+APPDATA.dlls_list_ptr] |
mov esi, [.slot] |
cmp [fpu_owner],esi ; if user fpu last -> fpu user = 1 |
586,13 → 587,13 |
shl esi,5 |
add esi,window_data |
mov eax,[esi+WDATA.box.left] |
mov [dlx],eax |
mov [draw_limits.left],eax |
add eax,[esi+WDATA.box.width] |
mov [dlxe],eax |
mov [draw_limits.right],eax |
mov eax,[esi+WDATA.box.top] |
mov [dly],eax |
mov [draw_limits.top],eax |
add eax,[esi+WDATA.box.height] |
mov [dlye],eax |
mov [draw_limits.bottom],eax |
xor eax, eax |
mov [esi+WDATA.box.left],eax |
641,12 → 642,12 |
add edi,SLOT_BASE |
mov eax, [edi+APPDATA.io_map] |
cmp eax, (tss._io_map_0-OS_BASE+PG_MAP) |
cmp eax, [SLOT_BASE+256+APPDATA.io_map] |
je @F |
call free_page |
@@: |
mov eax, [edi+APPDATA.io_map+4] |
cmp eax, (tss._io_map_1-OS_BASE+PG_MAP) |
cmp eax, [SLOT_BASE+256+APPDATA.io_map+4] |
je @F |
call free_page |
@@: |
689,22 → 690,22 |
cmp [hd1_status], esi |
jnz @f |
call free_hd_channel |
mov [hd1_status], 0 |
and [hd1_status], 0 |
@@: |
cmp [cd_status], esi |
jnz @f |
call free_cd_channel |
mov [cd_status], 0 |
and [cd_status], 0 |
@@: |
cmp [flp_status], esi |
jnz @f |
mov [flp_status], 0 |
and [flp_status], 0 |
@@: |
pop esi |
cmp [bgrlockpid], esi |
jnz @f |
and [bgrlockpid], 0 |
mov [bgrlock], 0 |
and [bgrlock], 0 |
@@: |
pusha ; remove all irq reservations |
736,8 → 737,8 |
mov esi,[RESERVED_PORTS] |
cmp esi,0 |
je rmpr9 |
test esi,esi |
jz rmpr9 |
rmpr3: |
796,10 → 797,10 |
; call systest |
sti ; .. and life goes on |
mov eax, [dlx] |
mov ebx, [dly] |
mov ecx, [dlxe] |
mov edx, [dlye] |
mov eax, [draw_limits.left] |
mov ebx, [draw_limits.top] |
mov ecx, [draw_limits.right] |
mov edx, [draw_limits.bottom] |
call calculatescreen |
xor eax, eax |
xor esi, esi |
808,7 → 809,7 |
mov [MOUSE_BACKGROUND],byte 0 ; no mouse background |
mov [DONT_DRAW_MOUSE],byte 0 ; draw mouse |
mov [application_table_status],0 |
and [application_table_status],0 |
;mov esi,process_terminated |
;call sys_msg_board_str |
add esp, 4 |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/syscall.inc |
---|
20,7 → 20,6 |
call dword [servetable+edi*4] |
ret |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; SYSENTER ENTRY ;; |
123,17 → 122,9 |
dd 0 |
dd 0 |
dd 0 |
dd sys_midi ; 20-ResetMidi and OutputMidi |
dd sys_setup ; 21-SetMidiBase,SetKeymap,SetShiftKeymap,. |
dd sys_settime ; 22-setting date,time,clock and alarm-clock |
dd 0 |
dd syscall_cdaudio ; 24-PlayCdTrack,StopCd and GetCdPlaylist |
dd 0 ; |
dd sys_getsetup ; 26-GetMidiBase,GetKeymap,GetShiftKeymap,. |
dd 0 |
dd 0 ; |
dd 0 |
dd sys_current_directory ; 30-Get/SetCurrentDirectory |
dd 0 |
dd 0 |
dd 0 |
140,27 → 131,35 |
dd 0 |
dd 0 |
dd 0 |
dd readmousepos ; 37-GetMousePosition_ScreenRelative,. |
dd 0 ; 38-DrawLine |
dd sys_getbackground ; 39-GetBackgroundSize,ReadBgrData,. |
dd 0 |
dd 0 |
dd 0 |
dd sys_outport ; 43-SendDeviceData |
dd 0 |
dd 0 |
dd syscall_reserveportarea ; 46-ReservePortArea and FreePortArea |
dd display_number ; 47-WriteNum |
dd display_settings ; 48-SetRedrawType and SetButtonType |
dd sys_apm ; 49-Advanced Power Management (APM) |
dd random_shaped_window ; 50-Window shape & scale |
dd syscall_threads ; 51-Threads |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd 0 |
dd sound_interface ; 55-Sound interface |
dd 0 |
dd sys_pcibios ; 57-PCI BIOS32 |
dd 0 |
dd file_system ; 58-Common file system interface |
dd 0 |
dd sys_IPC ; 60-Inter Process Communication |
167,16 → 166,14 |
dd sys_gs ; 61-Direct graphics access |
dd sys_pci ; 62-PCI functions |
dd sys_msg_board ; 63-System message board |
dd sys_resize_app_memory ; 64-Resize application memory usage |
dd 0 |
dd syscall_putimage_palette; 65-PutImagePalette |
dd sys_process_def ; 66-Process definitions - keyboard |
dd sys_window_move ; 67-Window move or resize |
dd f68 ; 68-Some internal services |
dd sys_debug_services ; 69-Debug |
dd 0 |
dd 0 |
dd file_system_lfn ; 70-Common file system interface, version 2 |
dd syscall_windowsettings ; 71-Window settings |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; NEW SYSTEM FUNCTIONS TABLE ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
191,7 → 188,7 |
dd delay_hs ; 5-DelayHs |
dd syscall_openramdiskfile ; 6-OpenRamdiskFile |
dd syscall_putimage ; 7-PutImage |
dd sys_button ; 8-DefineButton |
dd syscall_button ; 8-DefineButton |
dd sys_cpuusage ; 9-GetProcessInfo |
dd sys_waitforevent ; 10-WaitForEvent |
dd sys_getevent ; 11-CheckForEvent |
203,17 → 200,17 |
dd sys_getbutton ; 17-GetButton |
dd sys_system ; 18-System Services |
dd paleholder ; 19-reserved |
dd cross_order ; 20-ResetMidi and OutputMidi |
dd cross_order ; 21-SetMidiBase,SetKeymap,SetShiftKeymap,. |
dd cross_order ; 22-setting date,time,clock and alarm-clock |
dd sys_midi ; 20-ResetMidi and OutputMidi |
dd sys_setup ; 21-SetMidiBase,SetKeymap,SetShiftKeymap,. |
dd sys_settime ; 22-setting date,time,clock and alarm-clock |
dd sys_wait_event_timeout ; 23-TimeOutWaitForEvent |
dd cross_order ; 24-PlayCdTrack,StopCd and GetCdPlaylist |
dd syscall_cdaudio ; 24-PlayCdTrack,StopCd and GetCdPlaylist |
dd undefined_syscall ; 25-reserved |
dd cross_order ; 26-GetMidiBase,GetKeymap,GetShiftKeymap,. |
dd sys_getsetup ; 26-GetMidiBase,GetKeymap,GetShiftKeymap,. |
dd undefined_syscall ; 27-reserved |
dd undefined_syscall ; 28-reserved |
dd sys_date ; 29-GetDate |
dd cross_order ; 30-Get/SetCurrentDirectory |
dd sys_current_directory ; 30-Get/SetCurrentDirectory |
dd undefined_syscall ; 31-reserved |
dd undefined_syscall ; 32-reserved |
dd undefined_syscall ; 33-reserved |
220,27 → 217,27 |
dd undefined_syscall ; 34-reserved |
dd syscall_getpixel ; 35-GetPixel |
dd syscall_getarea ; 36-GetArea |
dd cross_order ; 37-GetMousePosition_ScreenRelative,. |
dd readmousepos ; 37-GetMousePosition_ScreenRelative,. |
dd syscall_drawline ; 38-DrawLine |
dd cross_order ; 39-GetBackgroundSize,ReadBgrData,. |
dd sys_getbackground ; 39-GetBackgroundSize,ReadBgrData,. |
dd set_app_param ; 40-WantEvents |
dd syscall_getirqowner ; 41-GetIrqOwner |
dd get_irq_data ; 42-ReadIrqData |
dd cross_order ; 43-SendDeviceData |
dd sys_outport ; 43-SendDeviceData |
dd sys_programirq ; 44-ProgramIrqs |
dd reserve_free_irq ; 45-ReserveIrq and FreeIrq |
dd cross_order ; 46-ReservePortArea and FreePortArea |
dd cross_order ; 47-WriteNum |
dd cross_order ; 48-SetRedrawType and SetButtonType |
dd cross_order ; 49-Advanced Power Management (APM) |
dd cross_order ; 50-Window shape & scale |
dd cross_order ; 51-Threads |
dd cross_order ; 52-Stack driver status |
dd cross_order ; 53-Socket interface |
dd syscall_reserveportarea ; 46-ReservePortArea and FreePortArea |
dd display_number ; 47-WriteNum |
dd syscall_display_settings ; 48-SetRedrawType and SetButtonType |
dd sys_apm ; 49-Advanced Power Management (APM) |
dd syscall_set_window_shape ; 50-Window shape & scale |
dd syscall_threads ; 51-Threads |
dd undefined_syscall ; 52-Stack driver status |
dd undefined_syscall ; 53-Socket interface |
dd undefined_syscall ; 54-reserved |
dd cross_order ; 55-Sound interface |
dd undefined_syscall ; 56-reserved |
dd cross_order ; 57-PCI BIOS32 |
dd sys_pcibios ; 57-PCI BIOS32 |
dd cross_order ; 58-Common file system interface |
dd undefined_syscall ; 59-reserved |
dd cross_order ; 60-Inter Process Communication |
247,14 → 244,14 |
dd cross_order ; 61-Direct graphics access |
dd cross_order ; 62-PCI functions |
dd cross_order ; 63-System message board |
dd cross_order ; 64-Resize application memory usage |
dd sys_resize_app_memory ; 64-Resize application memory usage |
dd cross_order ; 65-PutImagePalette |
dd cross_order ; 66-Process definitions - keyboard |
dd cross_order ; 67-Window move or resize |
dd cross_order ; 68-Some internal services |
dd cross_order ; 69-Debug |
dd f68 ; 68-Some internal services |
dd sys_debug_services ; 69-Debug |
dd cross_order ; 70-Common file system interface, version 2 |
dd cross_order ; 71-Window settings |
dd syscall_windowsettings ; 71-Window settings |
dd sys_sendwindowmsg ; 72-Send window message |
dd sys_network ; 73-Network stack |
dd sys_socket ; 74-Sockets |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/taskman.inc |
---|
113,6 → 113,7 |
popad |
mov eax, -ERROR_FILE_NOT_FOUND |
ret |
.namecopied: |
mov [cmdline], ebx |
150,8 → 151,8 |
.get_lock: |
mov eax, 1 |
xchg eax, [application_table_status] |
cmp eax, 0 |
jne .wait_lock |
test eax, eax |
jnz .wait_lock |
call set_application_table_status |
201,6 → 202,14 |
mov eax,[hdr_mem] |
mov [ebx+APPDATA.mem_size],eax |
xor edx, edx |
cmp word [6], '02' |
jne @f |
not edx |
@@: |
mov [ebx+APPDATA.tls_base],edx |
if GREEDY_KERNEL |
else |
mov ecx, [hdr_mem] |
278,8 → 287,10 |
.check_01_header: |
cmp [eax+6],word '01' |
je @f |
cmp [eax+6], word '02' |
jne .fail |
@@: |
mov ecx,[APP_HEADER_01.start] |
mov [ebx+0x08], ecx ;app_eip |
mov edx,[APP_HEADER_01.mem_size] |
475,7 → 486,7 |
dec [pg_data.pg_mutex] |
cmp [dir_addr], 0 |
je @f |
stdcall destroy_app_space, [dir_addr] |
stdcall destroy_app_space, [dir_addr], 0 |
@@: |
xor eax, eax |
ret |
512,12 → 523,10 |
endp |
align 4 |
proc destroy_app_space stdcall, pg_dir:dword |
proc destroy_app_space stdcall, pg_dir:dword, dlls_list:dword |
mov ebx, pg_data.pg_mutex |
call wait_mutex ;ebx |
xor edx,edx |
push edx |
mov eax,0x2 |
mov ebx, [pg_dir] |
.loop: |
527,8 → 536,10 |
cmp byte [CURRENT_TASK+ecx+0xa],9 ;if process running? |
jz @f ;skip empty slots |
shl ecx,3 |
cmp [SLOT_BASE+ecx+0xB8],ebx ;compare page directory addresses |
add ecx,SLOT_BASE |
cmp [ecx+APPDATA.dir_table],ebx ;compare page directory addresses |
jnz @f |
mov [ebp-4],ecx |
inc edx ;thread found |
@@: |
inc eax |
537,13 → 548,19 |
;edx = number of threads |
;our process is zombi so it isn't counted |
pop ecx |
cmp edx,1 |
jg .exit |
jg .ret |
;if there isn't threads then clear memory. |
mov esi, [dlls_list] |
call destroy_all_hdlls |
mov ebx, pg_data.pg_mutex |
call wait_mutex ;ebx |
mov eax, [pg_dir] |
and eax, not 0xFFF |
stdcall map_page,[tmp_task_pdir],eax,dword PG_SW |
stdcall map_page,[tmp_task_pdir],eax,PG_SW |
mov esi, [tmp_task_pdir] |
mov edi, (OS_BASE shr 20)/4 |
.destroy: |
551,7 → 568,7 |
test eax, 1 |
jz .next |
and eax, not 0xFFF |
stdcall map_page,[tmp_task_ptab],eax,dword PG_SW |
stdcall map_page,[tmp_task_ptab],eax,PG_SW |
stdcall destroy_page_table, [tmp_task_ptab] |
mov eax, [esi] |
call free_page |
563,9 → 580,10 |
mov eax, [pg_dir] |
call free_page |
.exit: |
stdcall map_page,[tmp_task_ptab],dword 0,dword PG_UNMAP |
stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP |
stdcall map_page,[tmp_task_ptab],0,PG_UNMAP |
stdcall map_page,[tmp_task_pdir],0,PG_UNMAP |
dec [pg_data.pg_mutex] |
.ret: |
ret |
endp |
613,24 → 631,24 |
check_region: |
;input: |
; ebx - start of buffer |
; ecx - size of buffer |
; esi - start of buffer |
; edx - size of buffer |
;result: |
; eax = 1 region lays in app memory |
; eax = 0 region don't lays in app memory |
mov eax,[CURRENT_TASK] |
jmp check_process_region |
; jmp check_process_region |
;----------------------------------------------------------------------------- |
check_process_region: |
;check_process_region: |
;input: |
; eax - slot |
; ebx - start of buffer |
; ecx - size of buffer |
; esi - start of buffer |
; edx - size of buffer |
;result: |
; eax = 1 region lays in app memory |
; eax = 0 region don't lays in app memory |
test ecx,ecx |
test edx,edx |
jle .ok |
shl eax,5 |
cmp word [CURRENT_TASK+eax+0xa],0 |
698,9 → 716,9 |
proc read_process_memory |
;Input: |
; eax - process slot |
; ebx - buffer address |
; ecx - buffer size |
; edx - start address in other process |
; ecx - buffer address |
; edx - buffer size |
; esi - start address in other process |
;Output: |
; eax - number of bytes read. |
locals |
712,10 → 730,10 |
endl |
mov [slot], eax |
mov [buff], ebx |
mov [buff], ecx |
and [r_count], 0 |
mov [tmp_r_cnt], ecx |
mov [offset], edx |
mov [tmp_r_cnt], edx |
mov [offset], esi |
pushad |
.read_mem: |
733,18 → 751,22 |
jna @F |
mov ecx, 0x8000 |
@@: |
mov eax, [slot] |
shl eax,8 |
mov ebx, [offset] |
; add ebx, new_app_base |
push ecx |
stdcall map_memEx, [proc_mem_map],\ |
[SLOT_BASE+eax+0xB8],\ |
ebx, ecx |
[slot], ebx, ecx, PG_MAP |
pop ecx |
mov esi, [offset] |
and esi, 0xfff |
sub eax, esi |
jbe .ret |
cmp ecx, eax |
jbe @f |
mov ecx, eax |
mov [tmp_r_cnt], eax |
@@: |
add esi, [proc_mem_map] |
mov edi, [buff] |
mov edx, ecx |
754,7 → 776,7 |
add [offset], edx |
sub [tmp_r_cnt], edx |
jnz .read_mem |
.ret: |
popad |
mov eax, [r_count] |
ret |
764,9 → 786,9 |
proc write_process_memory |
;Input: |
; eax - process slot |
; ebx - buffer address |
; ecx - buffer size |
; edx - start address in other process |
; ecx - buffer address |
; edx - buffer size |
; esi - start address in other process |
;Output: |
; eax - number of bytes written |
779,10 → 801,10 |
endl |
mov [slot], eax |
mov [buff], ebx |
mov [buff], ecx |
and [w_count], 0 |
mov [tmp_w_cnt], ecx |
mov [offset], edx |
mov [tmp_w_cnt], edx |
mov [offset], esi |
pushad |
.read_mem: |
800,18 → 822,22 |
jna @F |
mov ecx, 0x8000 |
@@: |
mov eax, [slot] |
shl eax,8 |
mov ebx, [offset] |
; add ebx, new_app_base |
push ecx |
stdcall map_memEx, [proc_mem_map],\ |
[SLOT_BASE+eax+0xB8],\ |
ebx, ecx |
[slot], ebx, ecx, PG_SW |
pop ecx |
mov edi, [offset] |
and edi, 0xfff |
sub eax, edi |
jbe .ret |
cmp ecx, eax |
jbe @f |
mov ecx, eax |
mov [tmp_w_cnt], eax |
@@: |
add edi, [proc_mem_map] |
mov esi, [buff] |
mov edx, ecx |
821,7 → 847,7 |
add [offset], edx |
sub [tmp_w_cnt], edx |
jnz .read_mem |
.ret: |
popad |
mov eax, [w_count] |
ret |
838,15 → 864,14 |
app_mem dd ? ;0x10 |
endl |
cmp eax,1 |
cmp ebx,1 |
jne .failed ;other subfunctions |
xor eax,eax |
mov [app_eip], ecx |
mov [app_cmdline], eax |
mov [app_esp], edx |
mov [app_path], eax |
mov [app_eip], ebx |
mov [app_esp], ecx |
;mov esi,new_process_loading |
;call sys_msg_board_str |
.wait_lock: |
858,8 → 883,8 |
.get_lock: |
mov eax, 1 |
xchg eax, [application_table_status] |
cmp eax, 0 |
jne .wait_lock |
test eax, eax |
jnz .wait_lock |
call set_application_table_status |
897,6 → 922,21 |
mov ecx,[ebx+APPDATA.dir_table] |
mov [edx+APPDATA.dir_table],ecx ;copy page directory |
mov eax,[ebx+APPDATA.dlls_list_ptr] |
mov [edx+APPDATA.dlls_list_ptr],eax |
mov eax, [ebx+APPDATA.tls_base] |
test eax, eax |
jz @F |
push edx |
stdcall user_alloc, 4096 |
pop edx |
test eax, eax |
jz .failed1 ;eax=0 |
@@: |
mov [edx+APPDATA.tls_base], eax |
lea eax, [app_cmdline] |
stdcall set_app_params ,[slot],eax,dword 0,\ |
dword 0,dword 0 |
903,13 → 943,15 |
;mov esi,new_process_running |
;call sys_msg_board_str ;output information about succefull startup |
mov [application_table_status],0 ;unlock application_table_status mutex |
xor eax,eax |
mov [application_table_status],eax ;unlock application_table_status mutex |
mov eax,[process_number] ;set result |
ret |
.failed: |
mov [application_table_status],0 |
mov eax,-1 |
xor eax,eax |
.failed1: |
mov [application_table_status],eax |
dec eax ;-1 |
ret |
endp |
931,6 → 973,24 |
pop eax |
ret |
align 4 |
tls_app_entry: |
call init_heap |
stdcall user_alloc, 4096 |
mov edx, [current_slot] |
mov [edx+APPDATA.tls_base], eax |
mov [tls_data_l+2],ax |
shr eax,16 |
mov [tls_data_l+4],al |
mov [tls_data_l+7],ah |
mov dx, app_tls |
mov fs, dx |
popad |
iretd |
EFL_IF equ 0x0200 |
EFL_IOPL1 equ 0x1000 |
EFL_IOPL2 equ 0x2000 |
959,10 → 1019,10 |
mov [eax+SLOT_BASE+APPDATA.except_mask], 0 |
;set default io permission map |
mov [eax+SLOT_BASE+APPDATA.io_map],\ |
(tss._io_map_0-OS_BASE+PG_MAP) |
mov [eax+SLOT_BASE+APPDATA.io_map+4],\ |
(tss._io_map_1-OS_BASE+PG_MAP) |
mov ecx, [SLOT_BASE+256+APPDATA.io_map] |
mov [eax+SLOT_BASE+APPDATA.io_map], ecx |
mov ecx, [SLOT_BASE+256+APPDATA.io_map+4] |
mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx |
mov esi, fpu_data |
mov ecx, 512/4 |
1037,6 → 1097,11 |
shl ebx,5 |
lea ecx,[draw_data+ebx] ;ecx - pointer to draw data |
mov edx, irq0.return |
cmp [ebx*8+SLOT_BASE+APPDATA.tls_base], -1 |
jne @F |
mov edx, tls_app_entry |
@@: |
; set window state to 'normal' (non-minimized/maximized/rolled-up) state |
mov [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL |
mov [ebx+window_data+WDATA.fl_redraw], 1 |
1050,9 → 1115,9 |
mov [ebx+4],eax ;set PID |
;set draw data to full screen |
mov [ecx+0],dword 0 |
mov [ecx+4],dword 0 |
xor eax,eax |
mov [ecx+0],dword eax |
mov [ecx+4],dword eax |
mov eax,[Screen_Max_X] |
mov [ecx+8],eax |
mov eax,[Screen_Max_Y] |
1063,7 → 1128,7 |
lea ecx, [ebx+REG_EIP] |
xor eax, eax |
mov [ebx+REG_RET], dword irq0.return |
mov [ebx+REG_RET], edx |
mov [ebx+REG_EDI], eax |
mov [ebx+REG_ESI], eax |
mov [ebx+REG_EBP], eax |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/test_malloc.asm |
---|
0,0 → 1,223 |
; Tests of malloc()/free() from the kernel heap. |
; This file is not included in the kernel, it is just test application. |
use32 |
db 'MENUET01' |
dd 1, start, i_end, mem, mem, 0, 0 |
start: |
; Zero-initialize uglobals (as in kernel at boot) |
mov ecx, (zeroend - zerostart + 3) / 4 |
xor eax, eax |
mov edi, zerostart |
rep stosd |
; Initialize small heap (as in kernel at boot) |
call init_malloc |
; Run tests |
call run_test1 |
call run_test2 |
call run_test3 |
; All is OK, return |
or eax, -1 |
int 0x40 |
run_test1: |
; basic test |
mov eax, 1 |
call malloc_with_test |
mov byte [eax], 0xDD |
mov esi, eax |
mov eax, 1 |
call malloc_with_test |
cmp byte [esi], 0xDD |
jnz memory_destroyed |
mov byte [eax], 0xEE |
xchg eax, esi |
call free |
cmp byte [esi], 0xEE |
jnz memory_destroyed |
xchg eax, esi |
call free |
ret |
run_test2: |
ret |
run_test3: |
; 1024000 times run random operation. |
; Randomly select malloc(random size from 1 to 1023) |
; or free(random of previously allocated areas) |
mov edi, 0x12345678 |
xor esi, esi ; 0 areas allocated |
mov ebx, 1024000 |
.loop: |
imul edi, 1103515245 |
add edi, 12345 |
mov eax, edi |
shr eax, 16 |
test ebx, 64 |
jz .prefer_free |
.prefer_malloc: |
test eax, 3 |
jz .free |
jmp @f |
.prefer_free: |
test eax, 3 |
jnz .free |
@@: |
shr eax, 2 |
and eax, 1023 |
jz .loop |
push ebx |
push eax |
; mov ecx, [saved_state_num] |
; mov [saved_state+ecx*8], eax |
call malloc_with_test |
; mov ecx, [saved_state_num] |
; mov [saved_state+ecx*8+4], eax |
; inc [saved_state_num] |
pop ecx |
pop ebx |
inc esi |
push ecx eax |
push edi |
mov edi, eax |
mov eax, esi |
rep stosb |
pop edi |
jmp .common |
.free: |
test esi, esi |
jz .loop |
xor edx, edx |
div esi |
sub edx, esi |
neg edx |
dec edx |
mov eax, [esp+edx*8] |
; mov ecx, [saved_state_num] |
; mov [saved_state+ecx*8], -1 |
; mov [saved_state+ecx*8+4], eax |
; inc [saved_state_num] |
mov ecx, [esp+edx*8+4] |
push edi eax |
mov edi, eax |
mov al, [edi] |
repz scasb |
jnz memory_destroyed |
pop eax edi |
push ebx edx |
call free |
pop edx ebx |
dec esi |
pop eax ecx |
push edi |
lea edi, [esp+4] |
@@: |
dec edx |
js @f |
xchg eax, [edi] |
xchg ecx, [edi+4] |
add edi, 8 |
jmp @b |
@@: |
pop edi |
.common: |
dec ebx |
jnz .loop |
@@: |
dec esi |
js @f |
pop eax ecx |
call free |
jmp @b |
@@: |
ret |
malloc_with_test: |
; calls malloc() and checks returned value |
call malloc |
test eax, eax |
jz generic_malloc_fail |
call check_mutex |
call check_range |
ret |
; Stubs for kernel procedures used by heap code |
wait_mutex: |
inc dword [ebx] |
ret |
kernel_alloc: |
cmp dword [esp+4], bufsize |
jnz error1 |
mov eax, buffer |
ret 4 |
macro $Revision [args] |
{ |
} |
; Error handlers |
error1: |
mov eax, 1 |
jmp error_with_code |
generic_malloc_fail: |
mov eax, 2 |
jmp error_with_code |
check_mutex: |
cmp [mst.mutex], 0 |
jnz @f |
ret |
@@: |
mov eax, 3 |
jmp error_with_code |
check_range: |
cmp eax, buffer |
jb @f |
cmp eax, buffer+bufsize |
jae @f |
ret |
@@: |
mov eax, 4 |
jmp error_with_code |
memory_destroyed: |
mov eax, 5 |
jmp error_with_code |
error_with_code: |
mov edx, saved_state_num |
; eax = error code |
; 1 signals error in testing code (wrong bufsize) |
; 2 = malloc() returned NULL |
; 3 = mutex not released |
; 4 = weird returned value from malloc() |
; 5 = memory destroyed by malloc() or free() |
int3 ; simplest way to report error |
jmp $-1 ; just in case |
; Include main heap code |
include '../proc32.inc' |
include '../const.inc' |
include 'malloc.inc' |
i_end: |
align 4 |
zerostart: |
mst MEM_STATE |
align 16 |
bufsize = 0x40000 ; change if malloc.inc changes |
buffer rb bufsize |
zeroend: |
saved_state_num dd ? |
saved_state rd 0x10000 |
align 4 |
rb 0x10000 ; for stack |
mem: |
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/core/v86.inc |
---|
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/data32.inc |
---|
1,6 → 1,6 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;; |
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
47,7 → 47,6 |
db 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' |
boot_memdetect db 'Determining amount of memory',0 |
boot_fonts db 'Fonts loaded',0 |
boot_tss db 'Setting TSSs',0 |
119,34 → 118,21 |
.bk dd shmem_list |
.fd dd shmem_list |
dll_list: |
.bk dd dll_list |
.fd dd dll_list |
MAX_DEFAULT_DLL_ADDR = 0x20000000 |
MIN_DEFAULT_DLL_ADDR = 0x10000000 |
dll_cur_addr dd MIN_DEFAULT_DLL_ADDR |
; supported videomodes |
mode_1280_1024_32: |
dw 1280,1024,32,60 |
mode_1280_1024_24: |
dw 1280,1024,24,60 |
mode_1024_768_32: |
dw 1024,768,32,60 |
mode_1024_768_24: |
dw 1024,768,24,60 |
mode_800_600_32: |
dw 800,600,32,60 |
mode_800_600_24: |
dw 800,600,24,60 |
mode_640_480_32: |
dw 640,480,32,60 |
mode_640_480_24: |
dw 640,480,24,60 |
mode_640_480_16: |
dw 640,480,16,60 |
mode_320_240_8: |
dw 320,240,8,60 |
; mike.dld { |
db 0 |
dd servetable-0x10000 |
draw_line dd __sys_draw_line |
disable_mouse dd __sys_disable_mouse |
draw_pointer dd __sys_draw_pointer |
;//mike.dld, 2006-08-02 [ |
;drawbar dd __sys_drawbar |
202,7 → 188,7 |
dw 0 |
db 0 |
db cpl3 |
dw G32+D32+(new_app_base shr 16)+0xF; |
dw G32+D32+0xF; |
app_data_l: |
dw 0xFFFF |
209,7 → 195,7 |
dw 0 |
db 0 |
db drw3 |
dw G32+D32+(new_app_base shr 16)+0xF; |
dw G32+D32+0xF; |
; ------------- PCI BIOS ------------------ |
260,6 → 246,14 |
db (tss shr 16) and 0xFF |
db 10001001b |
dw (tss shr 16) and 0xFF00 |
tls_data_l: |
dw 0x0FFF |
dw 0 |
db 0 |
db drw3 |
dw D32 |
endofcode: |
gdte: |
321,23 → 315,27 |
srv.fd rd 1 |
srv.bk rd 1 |
scr_width rd 1 |
scr_height rd 1 |
create_cursor rd 1 |
select_hw_cursor rd 1 |
set_hw_cursor rd 1 |
hw_restore rd 1 |
align 16 |
_display display_t |
_WinMapAddress rd 1 |
_WinMapSize rd 1 |
def_cursor rd 1 |
current_cursor rd 1 |
hw_cursor rd 1 |
cur_def_interl rd 1 |
cur_saved_base rd 1 |
cur_saved_interl rd 1 |
cur_saved_w rd 1 |
cur_saved_h rd 1 |
cur.lock rd 1 ;1 - lock update, 2- hide |
cur.left rd 1 ;cursor clip box |
cur.top rd 1 |
cur.right rd 1 |
cur.bottom rd 1 |
cur.w rd 1 |
cur.h rd 1 |
ipc_tmp rd 1 |
ipc_pdir rd 1 |
ipc_ptab rd 1 |
/kernel/branches/net/detect/biosdisk.inc |
---|
55,7 → 55,8 |
inc ax |
cmp word [si], 170h |
jz @f |
mov ax, -1 |
or ax,-1 |
; mov ax, -1 |
@@: |
stosw |
pop ds |
63,10 → 64,14 |
bddl: |
mov al, dl |
stosb |
mov al, 0 |
xor ax,ax |
stosb |
mov ax, -1 |
dec ax |
stosw |
; mov al, 0 |
; stosb |
; mov ax, -1 |
; stosw |
bddc2: |
cmp cl, [es:0x475] |
jae bdde |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/detect/biosmem.inc |
---|
Property changes: |
Deleted: svn:keywords |
-Revision |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/detect/dev_fd.inc |
---|
24,7 → 24,7 |
mov cx,0xff |
wait_cmos: |
dec cx |
cmp cx,0 |
jne wait_cmos |
test cx,cx |
jnz wait_cmos |
in al,0x71 |
mov [DRIVE_DATA],al |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/detect/dev_hdcd.inc |
---|
72,8 → 72,9 |
; Àäðåñ ñ÷èòûâàåìîãî ñåêòîðà â ðåæèìå LBA |
uglobal |
SectorAddress DD ? |
endg |
;************************************************* |
;* ×ÒÅÍÈÅ ÈÄÅÍÒÈÔÈÊÀÒÎÐÀ ÆÅÑÒÊÎÃÎ ÄÈÑÊÀ * |
;* Âõîäíûå ïàðàìåòðû ïåðåäàþòñÿ ÷åðåç ãëîáàëüíûå * |
99,8 → 100,8 |
@@WaitCompleet: |
; Ïðîâåðèòü âðåìÿ âûïîëíåíèÿ êîìàíäû |
dec ecx |
cmp ecx,0 |
je @@Error1 ;îøèáêà òàéì-àóòà |
; cmp ecx,0 |
jz @@Error1 ;îøèáêà òàéì-àóòà |
; Ïðîâåðèòü ãîòîâíîñòü |
in AL,DX |
test AL,80h ;ñîñòîÿíèå ñèãíàëà BSY |
116,19 → 117,21 |
mov DX,[ATABasePortAddr] ;ðåãèñòð äàííûõ |
mov CX,256 ;÷èñëî ñ÷èòûâàåìûõ ñëîâ |
rep insw ;ïðèíÿòü áëîê äàííûõ |
jmp @@End |
ret |
; Çàïèñàòü êîä îøèáêè |
@@Error1: |
mov [DevErrorCode],1 |
jmp @@End |
ret |
@@Error6: |
mov [DevErrorCode],6 |
@@End: ret |
iglobal |
; Ñòàíäàðòíûå áàçîâûå àäðåñà êàíàëîâ 1 è 2 |
StandardATABases DW 1F0h, 170h |
endg |
uglobal |
; Íîìåð êàíàëà |
ChannelNumber DW ? |
; Íîìåð äèñêà |
148,8 → 151,8 |
; 3 - íåâåðíûé íîìåð êàíàëà, 4 - íåâåðíûé íîìåð äèñêà, |
; 5 - íåâåðíûé íîìåð ãîëîâêè, 6 - îøèáêà ïðè âûïîëíåíèè |
; êîìàíäû) |
DevErrorCode DB ? |
DevErrorCode dd ? |
endg |
;**************************************************** |
;* ÏÎÑËÀÒÜ ÊÎÌÀÍÄÓ ÇÀÄÀÍÍÎÌÓ ÄÈÑÊÓ * |
;* Âõîäíûå ïàðàìåòðû ïåðåäàþòñÿ ÷åðåç ãëîáàëüíûå * |
203,8 → 206,8 |
@@WaitHDReady: |
; Ïðîâåðèòü âðåìÿ îæèäàíè |
dec ecx |
cmp ecx,0 |
je @@Err1 |
; cmp ecx,0 |
jz @@Err1 |
; mov eax,[timer_ticks] |
; sub eax,[TickCounter_1] |
; cmp eax,300 ;îæèäàòü 300 òèêîâ |
253,19 → 256,18 |
sti |
; Ñáðîñèòü ïðèçíàê îøèáêè |
mov [DevErrorCode],0 |
jmp @@End_2 |
ret |
; Çàïèñàòü êîä îøèáêè |
@@Err1: mov [DevErrorCode],1 |
jmp @@End_2 |
ret |
@@Err2: mov [DevErrorCode],2 |
jmp @@End_2 |
ret |
@@Err3: mov [DevErrorCode],3 |
jmp @@End_2 |
ret |
@@Err4: mov [DevErrorCode],4 |
jmp @@End_2 |
ret |
@@Err5: mov [DevErrorCode],5 |
; Çàâåðøåíèå ðàáîòû ïðîãðàììû |
@@End_2: |
ret |
;************************************************* |
297,8 → 299,8 |
@@WaitCompleet_1: |
; Ïðîâåðèòü âðåì |
dec ecx |
cmp ecx,0 |
je @@Error1_1 ;îøèáêà òàéì-àóòà |
; cmp ecx,0 |
jz @@Error1_1 ;îøèáêà òàéì-àóòà |
; Ïðîâåðèòü ãîòîâíîñòü |
in AL,DX |
test AL,80h ;ñîñòîÿíèå ñèãíàëà BSY |
314,11 → 316,11 |
mov DX,[ATABasePortAddr] ;ïîðò 1x0h |
mov CX,256 ;÷èñëî ñ÷èòûâàåìûõ ñëîâ |
rep insw |
jmp @@End_1 |
ret |
; Çàïèñàòü êîä îøèáêè |
@@Error1_1: |
mov [DevErrorCode],1 |
jmp @@End_1 |
ret |
@@Error6_1: |
mov [DevErrorCode],6 |
@@End_1: |
360,7 → 362,7 |
@@WaitHDReady_1: |
; Ïðîâåðèòü âðåìÿ îæèäàíè |
dec ecx |
cmp ecx,0 |
; cmp ecx,0 |
je @@Err1_2 ;îøèáêà òàéì-àóòà |
; Ïðî÷èòàòü ðåãèñòð ñîñòîÿíè |
in AL,DX |
369,15 → 371,14 |
jnz @@WaitHDReady_1 |
; Ñáðîñèòü ïðèçíàê îøèáêè |
mov [DevErrorCode],0 |
jmp @@End_3 |
ret |
; Îáðàáîòêà îøèáîê |
@@Err1_2: mov [DevErrorCode],1 |
jmp @@End_3 |
ret |
@@Err3_2: mov [DevErrorCode],3 |
jmp @@End_3 |
ret |
@@Err4_2: mov [DevErrorCode],4 |
; Çàïèñàòü êîä îøèáêè |
@@End_3: |
ret |
EndFindHDD: |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/detect/disks.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/detect/getcache.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/detect/sear_par.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/fdo.inc |
---|
6,6 → 6,7 |
$Revision$ |
_esp equ esp |
; |
; Formatted Debug Output (FDO) |
61,9 → 62,11 |
jmp ..label |
..str db _str,0 |
..label: |
add esp,4*8+4 |
; add esp,4*8+4 |
esp equ esp+4*8+4 |
mov edx,..str |
sub esp,4*8+4 |
esp equ _esp |
; sub esp,4*8+4 |
else |
mov edx,_str |
end if |
147,7 → 150,8 |
else if _dec eqtype 0 |
mov eax,_dec |
else |
add esp,4*8+4 |
; add esp,4*8+4 |
esp equ esp+4*8+4 |
if _num eq |
mov eax,dword _dec |
else if _num = 1 |
165,7 → 169,8 |
else |
mov eax,dword _dec |
end if |
sub esp,4*8+4 |
esp equ _esp |
; sub esp,4*8+4 |
end if |
mov cl,_sign |
call fdo_debug_outdec |
215,9 → 220,11 |
else if _hex eqtype 0 |
mov eax,_hex |
else |
add esp,4*8+4 |
; add esp,4*8+4 |
esp equ esp+4*8+4 |
mov eax,dword _hex |
sub esp,4*8+4 |
esp equ _esp |
; sub esp,4*8+4 |
end if |
if ~_num eq |
mov edx,_num |
286,9 → 293,8 |
.l3: ret |
debug_endf |
debug_func fdo_debug_outhex |
__fdo_hexdigits db '0123456789ABCDEF' |
debug_func fdo_debug_outhex |
debug_beginf |
mov cl,dl |
neg cl |
/kernel/branches/net/fs/fat12.inc |
---|
65,13 → 65,13 |
mov [save_flag],0 |
mov [path_pointer_flp],edi |
cmp esi,0 ; return ramdisk root |
jne fr_noroot_1 |
test esi,esi ; return ramdisk root |
jnz fr_noroot_1 |
cmp ebx,224/16 |
jbe fr_do_1 |
mov eax,5 |
mov ebx,0 |
mov [flp_status],0 |
xor ebx,ebx |
mov [flp_status],ebx |
ret |
fr_do_1: |
88,14 → 88,17 |
shl ecx,9 |
cld |
rep movsb |
mov eax,0 ; ok read |
mov ebx,0 |
mov [flp_status],0 |
xor eax,eax |
xor ebx,ebx |
; mov eax,0 ; ok read |
; mov ebx,0 |
mov [flp_status],eax |
ret |
fdc_status_error_1: |
mov [flp_status],0 |
xor eax,eax |
mov [flp_status],eax |
mov eax,10 |
mov ebx,-1 |
or ebx,-1 |
ret |
fr_noroot_1: |
102,12 → 105,12 |
sub esp,32 |
call expand_filename |
frfloppy_1: |
cmp ebx,0 |
jne frfl5_1 |
test ebx,ebx |
jnz frfl5_1 |
mov ebx,1 |
frfl5_1: |
cmp ecx,0 |
jne frfl6_1 |
test ecx,ecx |
jnz frfl6_1 |
mov ecx,1 |
frfl6_1: |
dec ebx |
137,14 → 140,14 |
add ecx,21 |
add edi, ecx ;Advance to next entry |
dec dl |
cmp dl,0 |
jne l.21_1 |
test dl,dl |
jnz l.21_1 |
dec dh |
cmp dh,0 |
jne l.20_1 |
test dh,dh |
jnz l.20_1 |
fdc_status_error_3: |
mov eax,5 ; file not found ? |
mov ebx,-1 |
or ebx,-1 |
add esp,32+28 |
mov [flp_status],0 |
ret |
232,8 → 235,8 |
add esp,4 |
pop ebx ; ebx <- eax : size of file |
add esp,36 |
mov eax,0 |
mov [flp_status],0 |
xor eax,eax |
mov [flp_status],eax |
ret |
fdc_status_error_5: |
499,8 → 502,8 |
div ebx |
mov [FDD_Track],al |
mov [FDD_Head],0 |
cmp edx,0 |
je no_head_2 |
test edx,edx |
jz no_head_2 |
inc [FDD_Head] |
no_head_2: |
mov dl,[old_track] |
2131,7 → 2134,7 |
popa |
pop edi |
xor eax, eax |
cmp [FDC_Status], 0 |
cmp [FDC_Status], al |
jz @f |
mov al, 11 |
@@: |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/fs/fat32.inc |
---|
169,6 → 169,7 |
call clear_hd_cache |
@@: |
pop eax |
sti |
.ret: |
ret |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/fs/fs.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/fs/fs_lfn.inc |
---|
1,6 → 1,6 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;; |
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
372,7 → 372,7 |
mov edi, fs_additional_handlers |
@@: |
cmp dword [edi], 0 |
jz @f |
jz .notfound |
call dword [edi] |
scasd |
scasd |
967,43 → 967,76 |
ret |
sys_current_directory: |
mov esi, [current_slot] |
mov esi, [esi+APPDATA.cur_dir] |
mov edx, esi |
dec eax |
; mov esi, [current_slot] |
; mov esi, [esi+APPDATA.cur_dir] |
; mov edx, esi |
;get length string of appdata.cur_dir |
mov eax, [current_slot] |
mov edi, [eax+APPDATA.cur_dir] |
dec ebx |
jz .set |
dec eax |
dec ebx |
jz .get |
ret |
.get: |
; sysfunction 30.2: [for app] eax=30,ebx=2,ecx->buffer,edx=len |
; for our code: ebx->buffer,ecx=len |
@@: |
lodsb |
test al, al |
jnz @b |
sub esi, edx |
inc esi |
mov [esp+36], esi |
cmp ecx, esi |
max_cur_dir equ 0x1000 |
mov ebx,edi |
push ecx |
push edi |
xor eax,eax |
mov ecx,max_cur_dir |
repne scasb ;find zerro at and string |
jnz .error ; no zero in cur_dir: internal error, should not happen |
sub edi,ebx ;lenght for copy |
inc edi |
mov [esp+32+8],edi ;return in eax |
cmp edx, edi |
jbe @f |
mov ecx, esi |
mov edx, edi |
@@: |
cmp ecx, 1 |
;source string |
pop esi |
;destination string |
pop edi |
cmp edx, 1 |
jbe .ret |
mov esi, edx |
mov edi, ebx |
mov al, '/' |
mov al,'/' ;start string with '/' |
stosb |
dec ecx |
dec ecx |
rep movsb |
mov byte [edi], 0 |
.ret: |
mov ecx,edx |
rep movsb ;copy string |
.ret: ret |
.error: add esp,8 |
or dword [esp+32],-1 ;error not found zerro at string ->[eax+APPDATA.cur_dir] |
ret |
.set: |
; sysfunction 30.1: [for app] eax=30,ebx=1,ecx->string |
; for our code: ebx->string to set |
; use generic resolver with APPDATA.cur_dir as destination |
push max_cur_dir ;0x1000 |
push edi ;destination |
mov ebx,ecx |
call get_full_file_name |
ret |
; in: ebx = file name, [esp+4] = destination, [esp+8] = sizeof destination |
; destroys all registers except ebp,esp |
get_full_file_name: |
push ebp |
mov esi, [current_slot] |
mov esi, [esi+APPDATA.cur_dir] |
mov edx, esi |
@@: |
inc esi |
cmp byte [esi-1], 0 |
1012,6 → 1045,7 |
cmp byte [ebx], '/' |
jz .set_absolute |
; string gives relative path |
mov edi, [esp+8] ; destination |
.relative: |
cmp byte [ebx], 0 |
jz .set_ok |
1032,33 → 1066,67 |
dec esi |
cmp byte [esi], '/' |
jnz @b |
mov byte [esi], 0 |
add ebx, 3 |
jmp .relative |
.set_ok: |
cmp edx, edi ; is destination equal to APPDATA.cur_dir? |
jz .set_ok.cur_dir |
sub esi, edx |
cmp esi, [esp+12] |
jb .set_ok.copy |
.fail: |
mov byte [edi], 0 |
xor eax, eax ; fail |
pop ebp |
ret 8 |
.set_ok.copy: |
mov ecx, esi |
mov esi, edx |
rep movsb |
mov byte [edi], 0 |
.ret.ok: |
mov al, 1 ; ok |
pop ebp |
ret 8 |
.set_ok.cur_dir: |
mov byte [esi], 0 |
jmp .ret.ok |
.doset_relative: |
add edx, 0x1000 |
mov byte [esi], '/' |
inc esi |
cmp esi, edx |
jae .overflow_esi |
cmp edx, edi |
jz .doset_relative.cur_dir |
sub esi, edx |
cmp esi, [esp+12] |
jae .fail |
mov ecx, esi |
mov esi, edx |
mov edx, edi |
rep movsb |
jmp .doset_relative.copy |
.doset_relative.cur_dir: |
mov edi, esi |
.doset_relative.copy: |
add edx, [esp+12] |
mov byte [edi], '/' |
inc edi |
cmp edi, edx |
jae .overflow |
@@: |
mov al, [ebx] |
inc ebx |
mov [esi], al |
inc esi |
stosb |
test al, al |
jz .set_ok |
cmp esi, edx |
jz .ret.ok |
cmp edi, edx |
jb @b |
.overflow_esi: |
mov byte [esi-1], 0 ; force null-terminated string |
.set_ok: |
ret |
.overflow: |
dec edi |
jmp .fail |
.set_absolute: |
lea esi, [ebx+1] |
call process_replace_file_name |
mov edi, edx |
add edx, 0x1000 |
mov edi, [esp+8] |
mov edx, [esp+12] |
add edx, edi |
.set_copy: |
lodsb |
stosb |
1067,13 → 1135,11 |
.set_copy_cont: |
cmp edi, edx |
jb .set_copy |
.overflow_edi: |
mov byte [edi-1], 0 |
ret |
jmp .overflow |
.set_part2: |
mov esi, ebp |
xor ebp, ebp |
test esi, esi |
jz .set_ok |
jz .ret.ok |
mov byte [edi-1], '/' |
jmp .set_copy_cont |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/fs/iso9660.inc |
---|
5,7 → 5,7 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision$ |
$Revision:1322 $ |
uglobal |
625,8 → 625,8 |
mov ebp,[cd_current_pointer_of_input_2] |
mov [cd_current_pointer_of_input],ebp |
mov eax,[ebp] |
cmp eax,0 ; âõîäû çàêîí÷èëèñü? |
je .next_sector |
test eax,eax ; âõîäû çàêîí÷èëèñü? |
jz .next_sector |
cmp ebp,CDDataBuf+2048 ; áóôåð çàêîí÷èëñÿ? |
jae .next_sector |
movzx eax, byte [ebp] |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/fs/ntfs.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/fs/parse_fn.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/fs/part_set.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/gui/button.inc |
---|
3,89 → 3,172 |
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;; |
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision$ |
max_buttons=4095 |
dececx: |
push edx |
push ecx |
button._.MAX_BUTTONS = 4095 |
mov edx,2 |
.loop: |
cmp byte [esp+edx],0x20 |
jae @f |
mov [esp+edx],byte 0x20 |
@@: |
sub [esp+edx],byte 0x20 |
;============================================================================== |
;///// public functions /////////////////////////////////////////////////////// |
;============================================================================== |
dec edx |
jns .loop |
struc SYS_BUTTON |
{ |
.pslot dw ? |
.id_lo dw ? |
.left dw ? |
.width dw ? |
.top dw ? |
.height dw ? |
.id_hi dw ? |
.sizeof: |
} |
virtual at 0 |
SYS_BUTTON SYS_BUTTON |
end virtual |
pop ecx |
pop edx |
ret |
iglobal |
mx dw 0x0 ; keeps the x mouse's position when it was clicked |
my dw 0x0 ; keeps the y mouse's position when it was clicked |
bPressedMouseXY_B db 0x0 |
btn_down_determ db 0x0 |
endg |
incecx: |
push edx |
push ecx |
align 4 |
;------------------------------------------------------------------------------ |
syscall_button: ;///// system function 8 ////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? Define/undefine GUI button object |
;------------------------------------------------------------------------------ |
;; Define button: |
;> ebx = pack[16(x), 16(width)] |
;> ecx = pack[16(y), 16(height)] |
;> edx = pack[8(flags), 24(button identifier)] |
;> flags bits: |
;> 7 (31) = 0 |
;> 6 (30) = don't draw button |
;> 5 (29) = don't draw button frame when pressed |
;> esi = button color |
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
;; Undefine button: |
;> edx = pack[8(flags), 24(button identifier)] |
;> flags bits: |
;> 7 (31) = 1 |
;------------------------------------------------------------------------------ |
; do we actually need to undefine the button? |
test edx, 0x80000000 |
jnz .remove_button |
mov edx,2 |
.loop: |
; do we have free button slots available? |
mov edi, [BTN_ADDR] |
mov eax, [edi] |
cmp eax, button._.MAX_BUTTONS |
jge .exit |
cmp byte [esp+edx],0xdf |
jbe @f |
mov [esp+edx],byte 0xdf |
@@: |
add [esp+edx],byte 0x20 |
; does it have positive size? (otherwise it doesn't have sense) |
or bx, bx |
jle .exit |
or cx, cx |
jle .exit |
dec edx |
jns .loop |
pop ecx |
pop edx |
ret |
; make coordinates clientbox-relative |
push eax |
mov eax, [current_slot] |
rol ebx, 16 |
add bx, word[eax + APPDATA.wnd_clientbox.left] |
rol ebx, 16 |
rol ecx, 16 |
add cx, word[eax + APPDATA.wnd_clientbox.top] |
rol ecx, 16 |
pop eax |
incecx2: |
push edx |
push ecx |
; basic checks passed, define the button |
push ebx ecx edx |
inc eax |
mov [edi], ax |
shl eax, 4 |
add edi, eax |
; NOTE: this code doesn't rely on SYS_BUTTON struct, please revise it |
; if you change something |
mov ax, [CURRENT_TASK] |
stosw |
mov ax, dx |
stosw ; button id number: bits 0-15 |
mov eax, ebx |
rol eax, 16 |
stosd ; x start | x size |
mov eax, ecx |
rol eax, 16 |
stosd ; y start | y size |
mov eax, edx |
shr eax, 16 |
stosw ; button id number: bits 16-31 |
pop edx ecx ebx |
mov edx,2 |
.loop: |
; do we also need to draw the button? |
test edx, 0x40000000 |
jnz .exit |
cmp byte [esp+edx],0xeb |
jbe @f |
mov [esp+edx],byte 0xeb |
@@: |
add [esp+edx],byte 0x14 |
; draw button body |
dec edx |
jns .loop |
pop ecx |
pop edx |
ret |
pushad |
drawbuttonframes: |
; calculate window-relative coordinates |
movzx edi, cx |
shr ebx, 16 |
shr ecx, 16 |
mov eax, [TASK_BASE] |
add ebx, [eax - twdw + WDATA.box.left] |
add ecx, [eax - twdw + WDATA.box.top] |
mov eax, ebx |
shl eax, 16 |
mov ax, bx |
add ax, word[esp + 16] |
mov ebx, ecx |
shl ebx, 16 |
mov bx, cx |
push esi |
; calculate initial color |
mov ecx, esi |
cmp [buttontype], 0 |
je @f |
call button._.incecx2 |
; set button height counter |
@@: mov edx, edi |
.next_line: |
call button._.button_dececx |
push edi |
push eax |
push ebx |
push ecx |
push edx |
xor edi, edi |
call [draw_line] |
pop edi |
add ebx, 0x00010001 |
dec edx |
jnz .next_line |
popad |
; draw button frame |
push ebx ecx |
; calculate window-relative coordinates |
shr ebx,16 |
shr ecx,16 |
mov eax,[TASK_BASE] |
add ebx,[eax-twdw + WDATA.box.left] |
add ecx,[eax-twdw + WDATA.box.top] |
; top border |
mov eax, ebx |
shl eax, 16 |
mov ax, bx |
add ax, word [esp+8] |
add ax, [esp + 4] |
mov ebx, ecx |
shl ebx, 16 |
mov bx, cx |
92,17 → 175,19 |
push ebx |
xor edi, edi |
mov ecx, esi |
call incecx |
call button._.incecx |
call [draw_line] |
movzx edx,word [esp+4+4] |
; bottom border |
movzx edx, word[esp + 4 + 0] |
add ebx,edx |
shl edx,16 |
add ebx,edx |
mov ecx,esi |
call dececx |
call button._.dececx |
call [draw_line] |
; left border |
pop ebx |
push edx |
mov edx,eax |
111,342 → 196,92 |
mov edx,ebx |
shr edx,16 |
mov bx,dx |
mov dx,[esp+4+4] |
add bx,dx |
add bx, [esp + 4 + 0] |
pop edx |
mov ecx,esi |
call incecx |
call button._.incecx |
call [draw_line] |
mov dx,[esp+8] |
; right border |
mov dx, [esp + 4] |
add ax,dx |
shl edx,16 |
add eax,edx |
add ebx,1*65536 |
add ebx, 0x00010000 |
mov ecx,esi |
call dececx |
call button._.dececx |
call [draw_line] |
pop edx |
pop ecx |
pop ebx |
pop eax |
pop edi |
pop esi |
pop ecx ebx |
.exit: |
ret |
button_dececx: |
cmp [buttontype],dword 1 |
jne .finish |
; je bdece |
; ret |
; bdece: |
push eax |
mov eax,0x01 |
cmp edi,20 |
jg @f |
mov eax,0x02 |
@@: |
test ecx,0xff |
jz @f |
sub ecx,eax |
@@: |
shl eax,8 |
test ecx,0xff00 |
jz @f |
sub ecx,eax |
@@: |
shl eax,8 |
test ecx,0xff0000 |
jz @f |
sub ecx,eax |
@@: |
pop eax |
.finish: |
ret |
sys_button: |
mov eax, [current_slot] |
rol ebx, 16 |
add bx, word [eax+APPDATA.wnd_clientbox.left] |
rol ebx, 16 |
rol ecx, 16 |
add cx, word [eax+APPDATA.wnd_clientbox.top] |
rol ecx, 16 |
.forced: |
test edx, 0x80000000 |
jnz remove_button |
or bx, bx |
jle noaddbutt |
or cx, cx |
jle noaddbutt |
test edx, 0x40000000 |
jnz button_no_draw |
pushad ; button body |
movzx edi, cx |
shr ebx, 16 |
shr ecx, 16 |
mov eax, [TASK_BASE] |
add ebx, [eax-twdw + WDATA.box.left] |
add ecx, [eax-twdw + WDATA.box.top] |
mov eax, ebx |
shl eax, 16 |
mov ax, bx |
add ax, word [esp+16] |
mov ebx, ecx |
shl ebx, 16 |
mov bx, cx |
mov ecx, esi |
cmp [buttontype], 0 |
je @f |
call incecx2 |
@@: |
mov edx, edi |
.newline: |
call button_dececx |
push edi |
xor edi, edi |
call [draw_line] |
pop edi |
add ebx, 1*65536+1 ; [ y start | y end ] |
dec edx |
jnz .newline |
popad |
call drawbuttonframes |
button_no_draw: |
; FIXME: mutex needed |
syscall_button.remove_button: |
and edx, 0x00ffffff |
mov edi, [BTN_ADDR] |
movzx eax, word [edi] |
cmp eax, max_buttons |
jge noaddbutt |
inc eax |
mov [edi], ax |
shl eax, 4 |
add edi, eax |
mov ax, [CURRENT_TASK] |
stosw |
mov ax, dx |
stosw ; button id number: bits 0-15 |
mov eax, ebx |
rol eax, 16 |
stosd ; x start | x size |
mov eax, ecx |
rol eax, 16 |
stosd ; y start | y size |
mov eax, edx |
shr eax, 16 |
stosw ; button id number: bits 16-31 |
noaddbutt: |
ret |
remove_button: |
and edx, 0x7fffffff |
rnewba2: |
mov edi, [BTN_ADDR] |
mov eax, edi |
movzx ebx, word [edi] |
mov ebx, [edi] |
inc ebx |
imul esi, ebx, SYS_BUTTON.sizeof |
add esi, edi |
xor ecx, ecx |
add ecx, -SYS_BUTTON.sizeof |
rnewba: |
.next_button: |
dec ebx |
jz rnmba |
jz .exit |
add eax, 0x10 |
add ecx, SYS_BUTTON.sizeof |
add esi, -SYS_BUTTON.sizeof |
mov cx, [CURRENT_TASK] |
cmp cx, [eax] |
jnz rnewba |
cmp dx, [eax+2] |
jnz rnewba |
; does it belong to our process? |
mov ax, [CURRENT_TASK] |
cmp ax, [esi + SYS_BUTTON.pslot] |
jne .next_button |
lea ecx, [ebx+1] |
shl ecx, 4 |
mov ebx, eax |
add eax, 0x10 |
; does the identifier match? |
mov eax, dword[esi + SYS_BUTTON.id_hi - 2] |
mov ax, [esi + SYS_BUTTON.id_lo] |
and eax, 0x00ffffff |
cmp edx, eax |
jne .next_button |
; okay, undefine it |
push ebx |
mov ebx, esi |
lea eax, [esi + SYS_BUTTON.sizeof] |
call memmove |
dec dword [edi] |
jmp rnewba2 |
add ecx, -SYS_BUTTON.sizeof |
pop ebx |
jmp .next_button |
rnmba: |
.exit: |
ret |
find_pressed_button_frames: |
pushad |
movzx ebx,word [eax+0] |
shl ebx,5 |
add ebx,window_data |
mov ecx, [ebx+ WDATA.box.left] ; window x start |
movzx edx,word [eax+4] ; button x start |
add ecx,edx |
push ecx |
mov dx,[eax+6] ; button x size |
add cx,dx |
mov esi,ecx |
inc esi |
mov ecx, [ebx+WDATA.box.top] ; window y start |
mov dx,[eax+8] ; button y start |
add ecx,edx |
mov ebx,ecx |
mov dx,[eax+10] ; button y size |
add dx,cx |
inc dx |
pop eax |
; eax x beginning |
; ebx y beginning |
; esi x end |
; edx y end |
; ecx color |
mov [pressed_button_eax],eax |
mov [pressed_button_ebx],ebx |
mov [pressed_button_ecx],ecx |
mov [pressed_button_edx],edx |
mov [pressed_button_esi],esi |
popad |
ret |
uglobal |
pressed_button_eax dd 0 |
pressed_button_ebx dd 0 |
pressed_button_ecx dd 0 |
pressed_button_edx dd 0 |
pressed_button_esi dd 0 |
endg |
; negative button image |
negativebutton: |
; If requested, do not display button |
; boarder on press. |
test ebx,0x20000000 |
jz draw_negative_button |
ret |
draw_negative_button: |
pushad |
mov eax,[pressed_button_eax] |
mov ebx,[pressed_button_ebx] |
mov ecx,[pressed_button_ecx] |
mov edx,[pressed_button_edx] |
mov esi,[pressed_button_esi] |
mov ecx,0x01000000 |
dec edx |
push edx |
inc edx |
dec esi |
push esi |
inc esi |
push eax |
push ebx |
push ecx |
push edx |
push edi |
call [disable_mouse] |
bdbnewline: |
mov edi,1 ; force |
cmp eax,[esp+16] |
jz bneg |
cmp eax,[esp+20] |
jz bneg |
cmp ebx,[esp+12] |
jz bneg |
cmp ebx,[esp+24] |
jnz nbneg |
; jz bneg |
; jmp nbneg |
bneg: |
;;;call [disable_mouse] |
call [putpixel] |
nbneg: |
inc eax |
cmp eax,esi |
jnz bdbnewline |
mov eax,[esp+16] |
inc ebx |
cmp ebx,edx |
jnz bdbnewline |
add esp,28 |
popad |
ret |
; check buttons |
; 0000 word process number |
; 0002 word button id number : bits 0-15 |
; 0004 word x start |
; 0006 word x size |
; 0008 word y start |
; 000A word y size |
; 000C word button id number : bits 16-31 |
; |
; button table in 0x10 increments |
; |
; first at 0x10 |
align 4 |
checkbuttons: |
cmp [BTN_DOWN],byte 0 ; mouse buttons pressed |
;------------------------------------------------------------------------------ |
check_buttons: ;/////////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
cmp byte[BTN_DOWN], 0 ; mouse buttons pressed |
jnz @f |
;..................................... start 1/5 : modified by vhanla ............................. |
mov [bPressedMouseXY_B],0 |
;..................................... end 1/5 : modified by vhanla ............................. |
ret |
@@: |
pushad |
@@: pushad |
xor esi, esi |
mov edi, [BTN_ADDR] |
movzx edx, word [edi] |
mov edx, [edi] |
test edx, edx |
jne @f |
popad |
ret |
@@: |
;..................................... start 2/5 : modified by vhanla ............................. |
;here i catch the coordinates when the mouse's button is clicked |
push ax |
@@: push ax |
cmp [bPressedMouseXY_B],0;FALSE |
jnz @f |
mov [bPressedMouseXY_B],1;TRUE - it was already clicked |
454,28 → 289,24 |
mov [mx],ax |
mov ax,[MOUSE_Y] |
mov [my],ax |
@@: |
pop ax |
@@: pop ax |
;and it is only refreshed after the mouse's button release |
;..................................... end 2/5 : modified by vhanla ............................. |
push esi |
inc edx |
push edx |
buttonnewcheck: |
.buttonnewcheck: |
pop edx |
pop esi |
inc esi |
cmp edx,esi |
jge bch |
jge .bch |
popad ; no button pressed |
popad |
ret |
bch: |
.bch: |
push esi |
push edx |
mov eax,esi |
483,67 → 314,56 |
add eax,edi |
; check that button is at top of windowing stack |
movzx ebx,word [eax] |
movzx ebx, [eax + SYS_BUTTON.pslot] |
movzx ecx,word [WIN_STACK + ebx * 2] |
cmp ecx,[TASK_COUNT] |
jne buttonnewcheck |
jne .buttonnewcheck |
; check that button start is inside window x/y end |
movzx ebx,word [eax+0] |
shl ebx,5 |
test [ebx+window_data+WDATA.fl_wstate],WSTATE_MINIMIZED |
jnz buttonnewcheck |
jnz .buttonnewcheck |
; add ebx,window_data |
; mov ecx,[window_data+ebx+8] ; window end X |
movzx edx,word [eax+4] ; button start X |
movzx edx, [eax + SYS_BUTTON.left] |
cmp edx, [window_data+ebx+WDATA.box.width] ;ecx |
jge buttonnewcheck |
jge .buttonnewcheck |
; mov ecx,[window_data+ebx+12] ; window end Y |
movzx edx, word [eax+8] ; button start Y |
movzx edx, [eax + SYS_BUTTON.top] |
cmp edx, [window_data+ebx+WDATA.box.height] ;ecx |
jge buttonnewcheck |
jge .buttonnewcheck |
; check coordinates |
; mouse x >= button x ? |
movzx ebx,word [eax+0] |
shl ebx,5 |
add ebx,window_data |
mov ecx, [ebx+WDATA.box.left] ; window x start |
movzx edx,word [eax+4] ; button x start |
mov ecx, [ebx + WDATA.box.left] |
movzx edx, [eax + SYS_BUTTON.left] |
add edx,ecx |
;..................................... start 3/5 : modified by vhanla ............................. |
mov cx,[mx] ;mov cx,[MOUSE_X] |
;..................................... end 3/5 : modified by vhanla ............................. |
cmp edx,ecx |
jg buttonnewcheck |
jg .buttonnewcheck |
movzx ebx,word [eax+6] ; button x size |
movzx ebx, [eax + SYS_BUTTON.width] |
add edx,ebx |
cmp ecx,edx |
jg buttonnewcheck |
jg .buttonnewcheck |
; mouse y >= button y ? |
movzx ebx,word [eax+0] |
movzx ebx, [eax + SYS_BUTTON.pslot] |
shl ebx,5 |
add ebx,window_data |
mov ecx, [ebx+WDATA.box.top] ; window y start |
movzx edx,word [eax+8] ; button y start |
mov ecx, [ebx + WDATA.box.top] |
movzx edx, [eax + SYS_BUTTON.top] |
add edx,ecx |
;..................................... start 4/5 : modified by vhanla ............................. |
mov cx,[my] ;mov cx,[MOUSE_Y] |
;..................................... start 4/5 : modified by vhanla ............................. |
cmp edx,ecx |
jg buttonnewcheck |
jg .buttonnewcheck |
movzx ebx,word [eax+10] ; button y size |
movzx ebx, [eax + SYS_BUTTON.height] |
add edx,ebx |
cmp ecx,edx |
jg buttonnewcheck |
jg .buttonnewcheck |
; mouse on button |
550,27 → 370,21 |
pop edx |
pop esi |
mov bx,[eax+0xc] ; button id : bits 16-31 |
shl ebx,16 |
mov bx,[eax+2] ; button id : bits 00-16 |
mov ebx, dword[eax + SYS_BUTTON.id_hi - 2] ; button id : bits 16-31 |
mov bx, [eax + SYS_BUTTON.id_lo] ; button id : bits 00-16 |
push ebx |
mov [MOUSE_DOWN],byte 1 ; no mouse down checks |
call find_pressed_button_frames |
call negativebutton |
mov byte[MOUSE_DOWN], 1 ; no mouse down checks |
call button._.negative_button |
pushad |
; // Alver 22.06.2008 // { |
push eax |
mov al, byte [BTN_DOWN] |
mov al, [BTN_DOWN] |
mov byte [btn_down_determ], al |
pop eax |
; } \\ Alver \\ |
cbwaitmouseup: |
.cbwaitmouseup: |
call checkidle |
call [draw_pointer] |
pushad |
577,68 → 391,189 |
call stack_handler |
popad |
cmp [BTN_DOWN],byte 0 ; mouse buttons pressed ? |
jnz cbwaitmouseup |
cmp byte[BTN_DOWN], 0 ; mouse buttons pressed ? |
jnz .cbwaitmouseup |
popad |
call negativebutton |
mov [MOUSE_BACKGROUND],byte 0 ; no mouse background |
mov [DONT_DRAW_MOUSE],byte 0 ; draw mouse |
;..................................... start 5/5 : modified by vhanla ............................. |
call button._.negative_button |
mov byte[MOUSE_BACKGROUND], 0 ; no mouse background |
mov byte[DONT_DRAW_MOUSE], 0 ; draw mouse |
; check coordinates |
iglobal |
mx dw 0x0 ; keeps the x mouse's position when it was clicked |
my dw 0x0 ; keeps the y mouse's position when it was clicked |
bPressedMouseXY_B db 0x0 |
btn_down_determ db 0x0 ; << // Alver 22.06.2008// << |
endg |
pusha |
pusha |
; mouse x >= button x ? |
movzx ebx,word [eax+0] |
movzx ebx, [eax + SYS_BUTTON.pslot] |
shl ebx,5 |
add ebx,window_data |
mov ecx, [ebx+WDATA.box.left] ; window x start |
movzx edx,word [eax+4] ; button x start |
mov ecx, [ebx + WDATA.box.left] |
movzx edx, [eax + SYS_BUTTON.left] |
add edx,ecx |
mov cx,[MOUSE_X] |
cmp edx,ecx |
jg no_on_button ;if we release the pointer out of the button area |
jg .no_on_button ;if we release the pointer out of the button area |
movzx ebx,word [eax+6] ; button x size |
movzx ebx, [eax + SYS_BUTTON.width] |
add edx,ebx |
cmp ecx,edx |
jg no_on_button |
jg .no_on_button |
; mouse y >= button y ? |
movzx ebx,word [eax+0] |
movzx ebx, [eax + SYS_BUTTON.pslot] |
shl ebx,5 |
add ebx,window_data |
mov ecx, [ebx+WDATA.box.top] ; window y start |
movzx edx,word [eax+8] ; button y start |
mov ecx, [ebx + WDATA.box.top] |
movzx edx, [eax + SYS_BUTTON.top] |
add edx,ecx |
mov cx,[MOUSE_Y] |
cmp edx,ecx |
jg no_on_button |
jg .no_on_button |
movzx ebx,word [eax+10] ; button y size |
movzx ebx, [eax + SYS_BUTTON.height] |
add edx,ebx |
cmp ecx,edx |
jg no_on_button |
jg .no_on_button |
popa |
mov [BTN_COUNT],byte 1 ; no of buttons in buffer |
mov byte[BTN_COUNT], 1 ; no of buttons in buffer |
pop ebx |
mov [BTN_BUFF],ebx ; lets put the button id in buffer |
push ebx |
pusha |
jmp yes_on_button |
no_on_button: |
mov [BTN_COUNT],byte 0 ; no of buttons in buffer |
yes_on_button: |
mov [MOUSE_DOWN],byte 0 ; mouse down -> do not draw |
jmp .yes_on_button |
.no_on_button: |
mov byte[BTN_COUNT], 0 ; no of buttons in buffer |
.yes_on_button: |
mov byte[MOUSE_DOWN], 0 ; mouse down -> do not draw |
popa |
pop ebx |
popa |
ret |
;..................................... end 5/5 : modified by vhanla ................................ |
;============================================================================== |
;///// private functions ////////////////////////////////////////////////////// |
;============================================================================== |
;------------------------------------------------------------------------------ |
button._.dececx: ;///////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
sub cl, 0x20 |
jnc @f |
xor cl, cl |
@@: sub ch, 0x20 |
jnc @f |
xor ch, ch |
@@: rol ecx, 16 |
sub cl, 0x20 |
jnc @f |
xor cl, cl |
@@: rol ecx, 16 |
ret |
;------------------------------------------------------------------------------ |
button._.incecx: ;///////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
add cl, 0x20 |
jnc @f |
or cl, -1 |
@@: add ch, 0x20 |
jnc @f |
or ch, -1 |
@@: rol ecx, 16 |
add cl, 0x20 |
jnc @f |
or cl, -1 |
@@: rol ecx, 16 |
ret |
;------------------------------------------------------------------------------ |
button._.incecx2: ;//////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
add cl, 0x14 |
jnc @f |
or cl, -1 |
@@: add ch, 0x14 |
jnc @f |
or ch, -1 |
@@: rol ecx, 16 |
add cl, 0x14 |
jnc @f |
or cl, -1 |
@@: rol ecx, 16 |
ret |
;------------------------------------------------------------------------------ |
button._.button_dececx: ;////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
cmp [buttontype], 1 |
jne .finish |
push eax |
mov al, 1 |
cmp edi, 20 |
jg @f |
mov al, 2 |
@@: sub cl, al |
jnc @f |
xor cl, cl |
@@: sub ch, al |
jnc @f |
xor ch, ch |
@@: rol ecx, 16 |
sub cl, al |
jnc @f |
xor cl, cl |
@@: rol ecx, 16 |
pop eax |
.finish: |
ret |
;------------------------------------------------------------------------------ |
button._.negative_button: ;//////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
; if requested, do not display button border on press. |
test ebx, 0x20000000 |
jnz .exit |
pushad |
xchg esi, eax |
movzx ecx, [esi + SYS_BUTTON.pslot] |
shl ecx, 5 |
add ecx, window_data |
mov eax, dword[esi + SYS_BUTTON.left] |
mov ebx, dword[esi + SYS_BUTTON.top] |
add eax, [ecx + WDATA.box.left] |
add ebx, [ecx + WDATA.box.top] |
push eax ebx |
pop edx ecx |
rol eax, 16 |
rol ebx, 16 |
add ax, cx |
add bx, dx |
mov esi, 0x01000000 |
call draw_rectangle.forced |
popad |
.exit: |
ret |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/gui/event.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/gui/font.inc |
---|
33,7 → 33,7 |
.1: |
; } \\ Alver \\ |
pushad |
call [disable_mouse] |
call [_display.disable_mouse] |
movsx eax, bx ; eax=y |
sar ebx, 16 ; ebx=x |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/gui/mouse.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/gui/skincode.inc |
---|
311,7 → 311,6 |
; shr esi,1 |
; and esi,0x007f7f7f |
mov esi,[ebp+SKIN_DATA.colors.outer] |
or [edi+WDATA.fl_wdrawn], 4 |
call draw_rectangle |
mov ecx,3 |
_dw3l: |
455,12 → 454,6 |
no_skin_add_button: |
pop edi |
and [edi+WDATA.fl_wdrawn], not 4 |
test [edi+WDATA.fl_wdrawn], 2 |
jz @f |
call drawwindowframes2 |
@@: |
popa |
ret 4 |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/gui/skindata.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/gui/window.inc |
---|
9,658 → 9,606 |
$Revision$ |
get_titlebar_height: ; edi = window draw_data pointer |
mov al,[edi+WDATA.fl_wstyle] |
and al,0x0F |
cmp al,0x03 |
jne @f |
mov eax,[_skinh] |
;============================================================================== |
;///// public functions /////////////////////////////////////////////////////// |
;============================================================================== |
macro FuncTable name, [label] |
{ |
common |
align 4 |
\label name#.ftable dword |
forward |
dd name#.#label |
common |
name#.sizeof.ftable = $ - name#.ftable |
} |
iglobal |
FuncTable syscall_display_settings, \ |
00, 01, 02, 03, 04, 05, 06, 07, 08 |
endg |
uglobal |
common_colours rd 32 |
new_window_starting dd ? |
latest_window_touch dd ? |
latest_window_touch_delta dd ? |
old_window_pos BOX |
new_window_pos BOX |
draw_limits RECT |
bPressedMouseXY_W db ? |
do_resize db ? |
do_resize_from_corner db ? |
reposition db ? |
endg |
align 4 |
;------------------------------------------------------------------------------ |
syscall_display_settings: ;///// system function 48 /////////////////////////// |
;------------------------------------------------------------------------------ |
;; Redraw screen: |
;< ebx = 0 |
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
;; Set button style: |
;< ebx = 1 |
;< ecx = 0 (flat) or 1 (with gradient) |
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
;; Set system color palette: |
;< ebx = 2 |
;< ecx = pointer to color table |
;< edx = size of color table |
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
;; Get system color palette: |
;< ebx = 3 |
;< ecx = pointer to color table buffer |
;< edx = size of color table buffer |
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
;; Get skinned caption height: |
;< ebx = 4 |
;> eax = height in pixels |
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
;; Get screen working area: |
;< ebx = 5 |
;> eax = pack[16(left), 16(right)] |
;> ebx = pack[16(top), 16(bottom)] |
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
;; Set screen working area: |
;< ebx = 6 |
;< ecx = pack[16(left), 16(right)] |
;< edx = pack[16(top), 16(bottom)] |
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
;; Get skin margins: |
;< ebx = 7 |
;> eax = pack[16(left), 16(right)] |
;> ebx = pack[16(top), 16(bottom)] |
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
;; Set skin: |
;< ebx = 8 |
;< ecx = pointer to FileInfoBlock struct |
;> eax = FS error code |
;------------------------------------------------------------------------------ |
cmp ebx, .sizeof.ftable / 4 |
ja @f |
jmp [.ftable + ebx * 4] |
@@: ret |
align 4 |
syscall_display_settings.00: |
xor eax, eax |
inc ebx |
cmp [windowtypechanged], ebx |
jne .exit |
mov [windowtypechanged], eax |
jmp syscall_display_settings._.redraw_whole_screen |
.exit: |
ret |
@@: mov eax,21 |
align 4 |
syscall_display_settings.01: |
and ecx, 1 |
cmp ecx, [buttontype] |
je .exit |
mov [buttontype], ecx |
mov [windowtypechanged], ebx |
.exit: |
ret |
get_rolledup_height: ; edi = window draw_data pointer |
mov al,[edi+WDATA.fl_wstyle] |
and al,0x0F |
cmp al,0x03 |
jb @f |
mov eax,[_skinh] |
add eax,3 |
align 4 |
syscall_display_settings.02: |
dec ebx |
mov esi, ecx |
and edx, 127 |
mov edi, common_colours |
mov ecx, edx |
rep movsb |
mov [windowtypechanged], ebx |
ret |
@@: or al,al |
jnz @f |
mov eax,21 |
align 4 |
syscall_display_settings.03: |
mov edi, ecx |
and edx, 127 |
mov esi, common_colours |
mov ecx, edx |
rep movsb |
ret |
@@: mov eax,21+2 |
align 4 |
syscall_display_settings.04: |
mov eax, [_skinh] |
mov [esp + 32], eax |
ret |
align 4 |
syscall_display_settings.05: |
mov eax, [screen_workarea.left - 2] |
mov ax, word[screen_workarea.right] |
mov [esp + 32], eax |
mov eax, [screen_workarea.top - 2] |
mov ax, word[screen_workarea.bottom] |
mov [esp + 20], eax |
ret |
setwindowdefaults: |
pushad |
align 4 |
syscall_display_settings.06: |
xor esi, esi |
mov edi, [Screen_Max_X] |
mov eax, ecx |
movsx ebx, ax |
sar eax, 16 |
cmp eax, ebx |
jge .check_horizontal |
inc esi |
or eax, eax |
jge @f |
xor eax,eax |
mov ecx,WIN_STACK |
@@: |
inc eax |
add ecx,2 |
mov [ecx+0x000],ax ; process no |
mov [ecx+0x400],ax ; positions in stack |
cmp ecx,WIN_POS-2 ; the more high, the more surface |
jnz @b |
@@: mov [screen_workarea.left], eax |
cmp ebx, edi |
jle @f |
mov ebx, edi |
@@: mov [screen_workarea.right], ebx |
popad |
.check_horizontal: |
mov edi, [Screen_Max_Y] |
mov eax, edx |
movsx ebx, ax |
sar eax, 16 |
cmp eax, ebx |
jge .check_if_redraw_needed |
inc esi |
or eax, eax |
jge @f |
xor eax, eax |
@@: mov [screen_workarea.top], eax |
cmp ebx, edi |
jle @f |
mov ebx, edi |
@@: mov [screen_workarea.bottom], ebx |
.check_if_redraw_needed: |
or esi, esi |
jz .exit |
call repos_windows |
jmp syscall_display_settings._.calculate_whole_screen |
.exit: |
ret |
align 4 |
syscall_display_settings.07: |
mov eax, [_skinmargins + 0] |
mov [esp + 32], eax |
mov eax, [_skinmargins + 4] |
mov [esp + 20], eax |
ret |
align 4 |
syscall_display_settings.08: |
mov ebx, ecx |
call read_skin_file |
mov [esp + 32], eax |
test eax, eax |
jnz .exit |
; eax = cx |
; ebx = cy |
; ecx = ex |
; edx = ey |
; èäåÿ: ïåðåáðàòü âñå îêíà, íà÷èíàÿ ñ ñàìîãî íèæíåãî, |
; è äëÿ ïîïàâøèõ â çàäàííóþ îáëàñòü |
; ÷àñòåé îêîí âûçâàòü setscreen |
call syscall_display_settings._.calculate_whole_screen |
jmp syscall_display_settings._.redraw_whole_screen |
.exit: |
ret |
syscall_display_settings._.calculate_whole_screen: |
xor eax, eax |
xor ebx, ebx |
mov ecx, [Screen_Max_X] |
mov edx, [Screen_Max_Y] |
jmp calculatescreen |
syscall_display_settings._.redraw_whole_screen: |
xor eax, eax |
mov [draw_limits.left], eax |
mov [draw_limits.top], eax |
mov eax, [Screen_Max_X] |
mov [draw_limits.right], eax |
mov eax, [Screen_Max_Y] |
mov [draw_limits.bottom], eax |
mov eax, window_data |
jmp redrawscreen |
align 4 |
calculatescreen: |
pushad |
;------------------------------------------------------------------------------ |
syscall_set_window_shape: ;///// system function 50 /////////////////////////// |
;------------------------------------------------------------------------------ |
;; Set window shape address: |
;> ebx = 0 |
;> ecx = shape data address |
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - |
;; Set window shape scale: |
;> ebx = 1 |
;> ecx = scale power (resulting scale is 2^ebx) |
;------------------------------------------------------------------------------ |
mov edi, [current_slot] |
test ebx, ebx |
jne .shape_scale |
mov [edi + APPDATA.wnd_shape], ecx |
.shape_scale: |
dec ebx |
jnz .exit |
mov [edi + APPDATA.wnd_shape_scale], ecx |
.exit: |
ret |
align 4 |
;------------------------------------------------------------------------------ |
set_window_defaults: ;///////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
push eax ecx |
xor eax, eax |
mov ecx, WIN_STACK |
@@: inc eax |
add ecx, 2 |
; process no |
mov [ecx + 0x000], ax |
; positions in stack |
mov [ecx + 0x400], ax |
cmp ecx, WIN_POS - 2 |
jne @b |
pop ecx eax |
ret |
align 4 |
;------------------------------------------------------------------------------ |
calculatescreen: ;///////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? Scan all windows from bottom to top, calling `setscreen` for each one |
;? intersecting given screen area |
;------------------------------------------------------------------------------ |
;> eax = left |
;> ebx = top |
;> ecx = right |
;> edx = bottom |
;------------------------------------------------------------------------------ |
push esi |
pushfd |
cli |
push edx ecx ebx eax |
mov esi, 1 |
call setscreen |
call window._.set_screen |
mov ebp, [TASK_COUNT] ; number of processes |
push ebp |
mov ebp, [TASK_COUNT] |
cmp ebp, 1 |
jbe .finish |
align 4 |
.new_wnd: |
jbe .exit |
push edx ecx ebx eax |
.next_window: |
movzx edi, word [WIN_POS + esi * 2] |
shl edi, 5 |
cmp [CURRENT_TASK+edi+TASKDATA.state], byte 9 |
je .not_wnd |
cmp [CURRENT_TASK + edi + TASKDATA.state], TSTATE_FREE |
je .skip_window |
add edi, window_data |
test [edi+WDATA.fl_wstate], WSTATE_MINIMIZED |
jnz .not_wnd |
jnz .skip_window |
mov eax,[edi+WDATA.box.left] |
cmp eax, [esp+RECT.right] |
ja .out_of_bounds |
jg .skip_window |
mov ebx,[edi+WDATA.box.top] |
cmp ebx, [esp+RECT.bottom] |
ja .out_of_bounds |
jg .skip_window |
mov ecx,[edi+WDATA.box.width] |
add ecx, eax |
cmp ecx, [esp+RECT.left] |
jb .out_of_bounds |
jl .skip_window |
mov edx,[edi+WDATA.box.height] |
add edx, ebx |
cmp edx, [esp+RECT.top] |
jb .out_of_bounds |
jl .skip_window |
cmp eax, [esp+RECT.left] |
jae @f |
mov eax, [esp+RECT.left] |
@@: |
cmp ebx, [esp+RECT.top] |
@@: cmp ebx, [esp + RECT.top] |
jae @f |
mov ebx, [esp+RECT.top] |
@@: |
cmp ecx, [esp+RECT.right] |
@@: cmp ecx, [esp + RECT.right] |
jbe @f |
mov ecx, [esp+RECT.right] |
@@: |
cmp edx, [esp+RECT.bottom] |
@@: cmp edx, [esp + RECT.bottom] |
jbe @f |
mov edx, [esp+RECT.bottom] |
@@: |
push esi |
@@: push esi |
movzx esi, word [WIN_POS + esi * 2] |
call setscreen |
call window._.set_screen |
pop esi |
.not_wnd: |
.out_of_bounds: |
.skip_window: |
inc esi |
dec ebp |
jnz .new_wnd |
.finish: |
jnz .next_window |
pop eax ebx ecx edx |
.exit: |
pop ebp |
popfd |
popad |
pop esi |
ret |
virtual at esp |
ff_x dd ? |
ff_y dd ? |
ff_width dd ? |
ff_xsz dd ? |
ff_ysz dd ? |
ff_scale dd ? |
end virtual |
align 4 |
; ðåçåðâèðóåò ìåñòî ïîä îêíî çàäàííîãî ïðîöåññà |
setscreen: |
; eax x start |
; ebx y start |
; ecx x end |
; edx y end |
; esi process number |
pushad |
; \begin{diamond}[29.08.2006] |
cmp esi, 1 |
jz @f |
mov edi, esi |
shl edi, 5 |
cmp [edi+window_data+WDATA.box.width], 0 |
jnz @f |
cmp [edi+window_data+WDATA.box.height], 0 |
jz .ret |
@@: |
; \end{diamond}[29.08.2006] |
mov edi, esi ;;;word [esi*2+WIN_POS] |
shl edi, 8 |
add edi, SLOT_BASE ; address of random shaped window area |
cmp [edi+APPDATA.wnd_shape], dword 0 |
jne .free_form |
; get x&y size |
sub ecx, eax |
sub edx, ebx |
inc ecx |
inc edx |
; get WinMap start |
mov edi, [Screen_Max_X] ; screen_sx |
inc edi |
imul edi, ebx |
add edi, eax |
add edi, WinMapAddress |
.new_y: |
push ecx ; sx |
push edx |
mov edx, esi |
align 4 |
.new_x: |
mov byte [edi], dl |
inc edi |
dec ecx |
jnz .new_x |
pop edx |
pop ecx |
add edi, [Screen_Max_X] |
inc edi |
sub edi, ecx |
dec edx |
jnz .new_y |
.ret: |
popad |
ret |
.read_byte: |
;eax - address |
;esi - slot |
push eax |
push ebx |
push ecx |
push edx |
mov edx,eax |
mov eax,esi |
lea ebx,[esp+12] |
mov ecx,1 |
call read_process_memory |
pop edx |
pop ecx |
pop ebx |
pop eax |
ret |
.free_form: |
; for (y=0; y <= x_size; y++) |
; for (x=0; x <= x_size; x++) |
; if (shape[coord(x,y,scale)]==1) |
; set_pixel(x, y, process_number); |
sub ecx, eax |
sub edx, ebx |
inc ecx |
inc edx |
push dword [edi+APPDATA.wnd_shape_scale] ; push scale first -> for loop |
; get WinMap start -> ebp |
push eax |
mov eax, [Screen_Max_X] ; screen_sx |
inc eax |
imul eax, ebx |
add eax, [esp] |
add eax, WinMapAddress |
mov ebp, eax |
mov edi, [edi+APPDATA.wnd_shape] |
pop eax |
; eax = x_start |
; ebx = y_start |
; ecx = x_size |
; edx = y_size |
; esi = process_number |
; edi = &shape |
; [scale] |
push edx ecx ; for loop - x,y size |
mov ecx, esi |
shl ecx, 5 |
mov edx, [window_data+ecx+WDATA.box.top] |
push [window_data+ecx+WDATA.box.width] ; for loop - width |
mov ecx, [window_data+ecx+WDATA.box.left] |
sub ebx, edx |
sub eax, ecx |
push ebx eax ; for loop - x,y |
add [ff_xsz], eax |
add [ff_ysz], ebx |
mov ebx, [ff_y] |
.ff_new_y: |
mov edx, [ff_x] |
.ff_new_x: |
; -- body -- |
mov ecx, [ff_scale] |
mov eax, [ff_width] |
inc eax |
shr eax, cl |
push ebx edx |
shr ebx, cl |
shr edx, cl |
imul eax, ebx |
add eax, edx |
pop edx ebx |
add eax, edi |
call .read_byte |
test al,al |
jz @f |
mov eax, esi |
mov [ebp], al |
@@: |
; -- end body -- |
inc ebp |
inc edx |
cmp edx, [ff_xsz] |
jb .ff_new_x |
sub ebp, [ff_xsz] |
add ebp, [ff_x] |
add ebp, [Screen_Max_X] ; screen.x |
inc ebp |
inc ebx |
cmp ebx, [ff_ysz] |
jb .ff_new_y |
add esp, 24 |
popad |
ret |
display_settings: |
; eax = 0 ; DISPLAY redraw |
; ebx = 0 ; all |
; |
; eax = 1 ; BUTTON type |
; ebx = 0 ; flat |
; ebx = 1 ; 3D |
; eax = 2 ; set WINDOW colours |
; ebx = pointer to table |
; ecx = number of bytes define |
; eax = 3 ; get WINDOW colours |
; ebx = pointer to table |
; ecx = number of bytes wanted |
; eax = 4 ; get skin height |
; input : nothing |
; output : eax = skin height in pixel |
; eax = 5 ; get screen workarea |
; input : nothing |
; output : eax = [left]*65536+[right] |
; ebx = [top]*65536+[bottom] |
; eax = 6 ; set screen workarea |
; input : ecx = [left]*65536+[right] |
; edx = [top]*65536+[bottom] |
; output : nothing |
; eax = 7 ; get skin margins |
; input : nothing |
; output : eax = [left]*65536+[right] |
; ebx = [top]*65536+[bottom] |
; eax = 8 ; set window skin |
; input : ecx = pointer to file info block |
; output : eax = FS error code |
pushad |
test eax, eax ; redraw display |
jnz dspl0 |
test ebx, ebx |
jnz dspl0 |
cmp [windowtypechanged],dword 1 |
jne dspl00 |
mov [windowtypechanged],dword 0 |
redraw_screen_direct: |
mov [dlx],dword 0 |
mov [dly],dword 0 |
mov eax,[Screen_Max_X] |
mov [dlxe],eax |
mov eax,[Screen_Max_Y] |
mov [dlye],eax |
mov eax,window_data |
call redrawscreen |
dspl00: |
popad |
ret |
dspl0: |
cmp eax,1 ; button type |
jne dspl1 |
and ebx,1 |
cmp ebx,[buttontype] |
je dspl9 |
mov [buttontype],ebx |
mov [windowtypechanged],dword 1 |
dspl9: |
popad |
ret |
dspl1: |
cmp eax,2 ; set common window colours |
jne no_com_colours |
mov [windowtypechanged],dword 1 |
mov esi,[TASK_BASE] |
add esi,TASKDATA.mem_start |
add ebx,[esi] |
mov esi,ebx |
mov edi,common_colours |
and ecx,127 |
cld |
rep movsb |
popad |
ret |
no_com_colours: |
cmp eax,3 ; get common window colours |
jne no_get_com |
mov esi,[TASK_BASE] |
add esi,TASKDATA.mem_start |
add ebx,[esi] |
mov edi,ebx |
mov esi,common_colours |
and ecx,127 |
cld |
rep movsb |
popad |
ret |
no_get_com: |
cmp eax,4 ; get skin height |
jne no_skin_height |
popad |
mov eax,[_skinh] |
mov [esp+36],eax |
ret |
no_skin_height: |
cmp eax,5 ; get screen workarea |
jne no_get_workarea |
popad |
mov eax,[screen_workarea.left-2] |
mov ax,word[screen_workarea.right] |
mov [esp+36],eax |
mov eax,[screen_workarea.top-2] |
mov ax,word[screen_workarea.bottom] |
mov [esp+24],eax |
ret |
no_get_workarea: |
cmp eax,6 ; set screen workarea |
jne no_set_workarea |
movsx eax,word[esp+16+2] |
movsx ebx,word[esp+16] |
cmp eax,ebx |
jge .lp1 |
or eax,eax;[Screen_Max_X] |
jl @f |
mov [screen_workarea.left],eax |
@@: cmp ebx,[Screen_Max_X] |
jg .lp1 |
mov [screen_workarea.right],ebx |
.lp1: movsx eax,word[esp+24+2] |
movsx ebx,word[esp+24] |
cmp eax,ebx |
jge .lp2 |
or eax,eax;[0xFE04] |
jl @f |
mov [screen_workarea.top],eax |
@@: cmp ebx,[Screen_Max_Y] |
jg .lp2 |
mov [screen_workarea.bottom],ebx |
.lp2: call repos_windows |
mov eax, 0 |
mov ebx, 0 |
mov ecx, [Screen_Max_X] |
mov edx, [Screen_Max_Y] |
call calculatescreen |
; jmp redraw_screen_direct |
.exit: |
popad |
ret |
no_set_workarea: |
cmp eax,7 ; get skin margins |
jne no_get_skinmargins |
popad |
mov eax,dword[_skinmargins+0] |
mov [esp+36],eax |
mov eax,dword[_skinmargins+4] |
mov [esp+24],eax |
ret |
no_get_skinmargins: |
cmp eax,8 ; set window skin |
jne no_set_skin |
call read_skin_file |
mov [esp+32+36], eax |
test eax, eax |
jnz .ret |
xor eax, eax |
xor ebx, ebx |
mov ecx, [Screen_Max_X] |
mov edx, [Screen_Max_Y] |
call calculatescreen |
jmp redraw_screen_direct |
.ret: |
popad |
ret |
no_set_skin: |
popad |
ret |
repos_windows: |
;------------------------------------------------------------------------------ |
repos_windows: ;/////////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
mov ecx,[TASK_COUNT] |
mov edi, OS_BASE+0x20*2 |
mov edi, window_data + WDATA.sizeof * 2 |
call force_redraw_background |
dec ecx |
jge @f |
ret |
@@: mov [edi+WDATA.fl_redraw],1 |
jle .exit |
.next_window: |
mov [edi + WDATA.fl_redraw], 1 |
test [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED |
jz .lp2 |
mov eax,[screen_workarea.left] |
mov [edi+WDATA.box.left],eax |
sub eax,[screen_workarea.right] |
neg eax |
mov [edi+WDATA.box.width],eax |
mov eax,[screen_workarea.top] |
mov [edi+WDATA.box.top],eax |
test [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP |
jnz .lp1 |
sub eax,[screen_workarea.bottom] |
neg eax |
mov [edi+WDATA.box.height],eax |
.lp1: |
jnz .fix_maximized |
call set_window_clientbox |
add edi,0x20 |
loop @b |
ret |
.lp2: mov eax,[edi+WDATA.box.left] |
mov eax, [edi + WDATA.box.left] |
add eax,[edi+WDATA.box.width] |
mov ebx,[Screen_Max_X] |
; inc ebx |
cmp eax,ebx |
jle .lp4 |
jle .fix_vertical |
mov eax,[edi+WDATA.box.width] |
sub eax,ebx |
jle .lp3 |
jle @f |
mov [edi+WDATA.box.width],ebx |
.lp3: sub ebx,[edi+WDATA.box.width] |
@@: sub ebx, [edi + WDATA.box.width] |
mov [edi+WDATA.box.left],ebx |
.lp4: mov eax,[edi+WDATA.box.top] |
.fix_vertical: |
mov eax, [edi + WDATA.box.top] |
add eax,[edi+WDATA.box.height] |
mov ebx,[Screen_Max_Y] |
; inc ebx |
cmp eax,ebx |
jle .lp6 |
jle .fix_client_box |
mov eax,[edi+WDATA.box.height] |
sub eax,ebx |
jle .lp5 |
jle @f |
mov [edi+WDATA.box.height],ebx |
.lp5: sub ebx,[edi+WDATA.box.height] |
@@: sub ebx, [edi + WDATA.box.height] |
mov [edi+WDATA.box.top],ebx |
.lp6: jmp .lp1 |
jmp .fix_client_box |
uglobal |
common_colours: |
times 128 db 0x0 |
endg |
.fix_maximized: |
mov eax, [screen_workarea.left] |
mov [edi + WDATA.box.left], eax |
sub eax, [screen_workarea.right] |
neg eax |
mov [edi + WDATA.box.width], eax |
mov eax, [screen_workarea.top] |
mov [edi + WDATA.box.top], eax |
test [edi + WDATA.fl_wstate], WSTATE_ROLLEDUP |
jnz .fix_client_box |
sub eax, [screen_workarea.bottom] |
neg eax |
mov [edi + WDATA.box.height], eax |
.fix_client_box: |
call set_window_clientbox |
add edi, WDATA.sizeof |
loop .next_window |
.exit: |
ret |
check_window_position: |
align 4 |
;------------------------------------------------------------------------------ |
check_window_position: ;/////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? Check if window is inside screen area |
;------------------------------------------------------------------------------ |
;> edi = pointer to WDATA |
;------------------------------------------------------------------------------ |
push eax ebx ecx edx esi |
pushad ; window inside screen ? |
mov eax, [edi+WDATA.box.left] |
mov ebx, [edi+WDATA.box.top] |
mov ecx, [edi+WDATA.box.width] |
mov edx, [edi+WDATA.box.height] |
cmp ecx,[Screen_Max_X] ; check x size |
jbe x_size_ok |
mov ecx,[Screen_Max_X] |
mov [edi+WDATA.box.width],ecx |
mov esi, [Screen_Max_X] |
cmp ecx, esi |
ja .fix_width |
x_size_ok: |
.check_left: |
or eax, eax |
jl .fix_left_low |
add eax, ecx |
cmp eax, esi |
jg .fix_left_high |
cmp edx,[Screen_Max_Y] ; check y size |
jbe y_size_ok |
mov edx,[Screen_Max_Y] |
mov [edi+WDATA.box.height],edx |
.check_height: |
mov esi, [Screen_Max_Y] |
cmp edx, esi |
ja .fix_height |
y_size_ok: |
.check_top: |
or ebx, ebx |
jl .fix_top_low |
add ebx, edx |
cmp ebx, esi |
jg .fix_top_high |
cmp eax,0 ; check x pos |
jnle @f |
.exit: |
pop esi edx ecx ebx eax |
ret |
.fix_width: |
mov ecx, esi |
mov [edi + WDATA.box.width], esi |
jmp .check_left |
.fix_left_low: |
xor eax,eax |
mov [edi+WDATA.box.left],eax |
jmp x_pos_ok |
@@: |
add eax,ecx |
cmp eax,[Screen_Max_X] |
jbe x_pos_ok |
mov eax,[Screen_Max_X] |
jmp .check_height |
.fix_left_high: |
mov eax, esi |
sub eax,ecx |
mov [edi+WDATA.box.left],eax |
jmp .check_height |
x_pos_ok: |
.fix_height: |
mov edx, esi |
mov [edi + WDATA.box.height], esi |
jmp .check_top |
cmp ebx,0 ; check x pos |
jnle @f |
.fix_top_low: |
xor ebx,ebx |
mov [edi+WDATA.box.top],ebx |
jmp y_pos_ok |
@@: |
add ebx,edx |
cmp ebx,[Screen_Max_Y] |
jbe y_pos_ok |
mov ebx,[Screen_Max_Y] |
jmp .exit |
.fix_top_high: |
mov ebx, esi |
sub ebx,edx |
mov [edi+WDATA.box.top],ebx |
jmp .exit |
y_pos_ok: |
align 4 |
;------------------------------------------------------------------------------ |
sys_window_mouse: ;//////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
push eax |
popad |
mov eax, [timer_ticks] |
cmp [new_window_starting], eax |
jb .exit |
mov byte[MOUSE_BACKGROUND], 0 |
mov byte[DONT_DRAW_MOUSE], 0 |
mov [new_window_starting], eax |
.exit: |
pop eax |
ret |
align 4 |
;------------------------------------------------------------------------------ |
draw_rectangle: ;////////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;> eax = pack[16(left), 16(right)] |
;> ebx = pack[16(top), 16(bottom)] |
;> esi = color |
;------------------------------------------------------------------------------ |
push eax ebx ecx edi |
uglobal |
new_window_starting dd 0 |
endg |
xor edi, edi |
.flags_set: |
push ebx |
sys_window_mouse: |
; set line color |
mov ecx, esi |
push eax |
; draw top border |
rol ebx, 16 |
push ebx |
rol ebx, 16 |
pop bx |
call [draw_line] |
mov eax,[timer_ticks] |
cmp [new_window_starting],eax |
jb swml1 |
; draw bottom border |
mov ebx, [esp - 2] |
pop bx |
call [draw_line] |
mov [MOUSE_BACKGROUND],byte 0 ; no mouse background |
mov [DONT_DRAW_MOUSE],byte 0 ; draw mouse |
pop ebx |
add ebx, 1 * 65536 - 1 |
mov [new_window_starting],eax |
; draw left border |
rol eax, 16 |
push eax |
rol eax, 16 |
pop ax |
call [draw_line] |
swml1: |
; draw right border |
mov eax, [esp - 2] |
pop ax |
call [draw_line] |
pop eax |
pop edi ecx ebx eax |
ret |
.forced: |
push eax ebx ecx edi |
xor edi, edi |
inc edi |
jmp .flags_set |
align 4 |
;------------------------------------------------------------------------------ |
drawwindow_I_caption: ;//////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
push [edx + WDATA.cl_titlebar] |
mov esi, edx |
drawwindow_I_caption: |
mov ecx,[edx+WDATA.cl_titlebar] ; grab bar |
push ecx |
mov esi,edx |
mov edx,[esi+WDATA.box.top] |
add edx,1 |
mov ebx,[esi+WDATA.box.top] |
add ebx,21 |
mov eax,[esi+WDATA.box.top] |
mov eax, edx |
lea ebx, [edx + 21] |
inc edx |
add eax,[esi+WDATA.box.height] |
cmp ebx,eax |
jb .wdsizeok |
jbe @f |
mov ebx,eax |
.wdsizeok: |
push ebx |
.drwi: |
@@: push ebx |
xor edi, edi |
.next_line: |
mov ebx,edx |
shl ebx,16 |
add ebx,edx |
669,126 → 617,79 |
shl eax,16 |
add eax,[esi+WDATA.box.left] |
add eax,[esi+WDATA.box.width] |
sub eax,1 |
push edx |
mov edx,0x80000000 |
dec eax |
mov ecx,[esi+WDATA.cl_titlebar] |
and ecx,edx |
cmp ecx,edx |
jnz .nofa |
mov ecx,[esi+WDATA.cl_titlebar] |
test ecx, 0x80000000 |
jz @f |
sub ecx,0x00040404 |
mov [esi+WDATA.cl_titlebar],ecx |
and ecx,0x00ffffff |
jmp .faj |
.nofa: |
mov ecx,[esi+WDATA.cl_titlebar] |
and ecx,0x00ffffff |
.faj: |
pop edx |
mov edi,0 |
@@: and ecx, 0x00ffffff |
call [draw_line] |
inc edx |
cmp edx,[esp] |
jb .drwi |
jb .next_line |
add esp,4 |
pop ecx |
mov [esi+WDATA.cl_titlebar],ecx |
pop [esi + WDATA.cl_titlebar] |
ret |
align 4 |
;------------------------------------------------------------------------------ |
drawwindow_I: ;//////////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
pushad |
drawwindow_I: |
; window border |
pushad |
or [edx+WDATA.fl_wdrawn], 4 |
mov eax, [edx + WDATA.box.left - 2] |
mov ax, word[edx + WDATA.box.left] |
add ax, word[edx + WDATA.box.width] |
mov ebx, [edx + WDATA.box.top - 2] |
mov bx, word[edx + WDATA.box.top] |
add bx, word[edx + WDATA.box.height] |
mov esi,[edx+WDATA.cl_frames] ; rectangle |
mov eax,[edx+WDATA.box.left] |
shl eax,16 |
add eax,[edx+WDATA.box.left] |
add eax,[edx+WDATA.box.width] |
mov ebx,[edx+WDATA.box.top] |
shl ebx,16 |
add ebx,[edx+WDATA.box.top] |
add ebx,[edx+WDATA.box.height] |
mov esi, [edx + WDATA.cl_frames] |
call draw_rectangle |
and [edx+WDATA.fl_wdrawn], not 4 |
test [edx+WDATA.fl_wdrawn], 2 |
jz @f |
call drawwindowframes2 |
@@: |
; window caption |
call drawwindow_I_caption |
mov edx,[esi+WDATA.box.top] ; inside work area |
; window client area |
; do we need to draw it? |
mov edi, [esi + WDATA.cl_workarea] |
test edi, 0x40000000 |
jnz .exit |
; does client area have a positive size on screen? |
mov edx, [esi + WDATA.box.top] |
add edx,21+5 |
mov ebx,[esi+WDATA.box.top] |
add ebx,[esi+WDATA.box.height] |
cmp edx,ebx |
jg noinside |
jg .exit |
; okay, let's draw it |
mov eax,1 |
mov ebx,21 |
mov ecx,[esi+WDATA.box.width] |
mov edx,[esi+WDATA.box.height] |
mov edi,[esi+WDATA.cl_workarea] |
test edi,0x40000000 |
jnz noinside |
call [drawbar] |
noinside: |
.exit: |
popad |
ret |
draw_rectangle: |
r_eax equ [esp+28] ; x start |
r_ax equ [esp+30] ; x end |
r_ebx equ [esp+16] ; y start |
r_bx equ [esp+18] ; y end |
;esi ; color |
pushad |
mov ecx,esi ; yb,xb -> yb,xe |
mov eax, r_eax |
rol eax, 16 |
mov ebx,r_ebx |
shl ebx,16 |
mov bx,r_ebx |
xor edi, edi |
call [draw_line] |
mov ebx,r_bx ; ye,xb -> ye,xe |
shl ebx,16 |
mov bx,r_bx |
call [draw_line] |
mov ecx,esi ; ya,xa -> ye,xa |
mov eax,r_eax |
shl eax,16 |
mov ax,r_eax |
mov ebx,r_ebx |
shl ebx,16 |
mov bx,r_bx |
mov edi,0 |
call [draw_line] |
mov eax,r_ax ; ya,xe -> ye,xe |
shl eax,16 |
mov ax,r_ax |
call [draw_line] |
popad |
ret |
drawwindow_III_caption: |
mov ecx,[edx+WDATA.cl_titlebar] ; GRAB BAR |
align 4 |
;------------------------------------------------------------------------------ |
drawwindow_III_caption: ;///////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
mov ecx, [edx + WDATA.cl_titlebar] |
push ecx |
mov esi,edx |
mov edx,[esi+WDATA.box.top] |
797,12 → 698,15 |
add ebx,20 |
mov eax,[esi+WDATA.box.top] |
add eax,[esi+WDATA.box.height] |
cmp ebx,eax |
jb .wdsizeok |
jb @f |
mov ebx,eax |
.wdsizeok: |
push ebx |
.drwi: |
@@: push ebx |
xor edi, edi |
.next_line: |
mov ebx,edx |
shl ebx,16 |
add ebx,edx |
813,72 → 717,80 |
add eax,4*65536-4 |
mov ecx,[esi+WDATA.cl_titlebar] |
test ecx,0x40000000 |
jz .nofa |
add ecx,0x040404 |
.nofa: |
test ecx,0x80000000 |
jz .nofa2 |
sub ecx,0x040404 |
.nofa2: |
mov [esi+WDATA.cl_titlebar],ecx |
and ecx,0xffffff |
xor edi, edi |
jz @f |
add ecx, 0x00040404 |
@@: test ecx, 0x80000000 |
jz @f |
sub ecx, 0x00040404 |
@@: mov [esi + WDATA.cl_titlebar], ecx |
and ecx, 0x00ffffff |
call [draw_line] |
inc edx |
cmp edx,[esp] |
jb .drwi |
jb .next_line |
add esp,4 |
pop ecx |
mov [esi+WDATA.cl_titlebar],ecx |
pop [esi + WDATA.cl_titlebar] |
ret |
align 4 |
;------------------------------------------------------------------------------ |
drawwindow_III: ;////////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? <description> |
;------------------------------------------------------------------------------ |
pushad |
drawwindow_III: |
; window border |
pushad |
mov eax, [edx + WDATA.box.left - 2] |
mov ax, word[edx + WDATA.box.left] |
add ax, word[edx + WDATA.box.width] |
mov ebx, [edx + WDATA.box.top - 2] |
mov bx, word[edx + WDATA.box.top] |
add bx, word[edx + WDATA.box.height] |
mov edi,edx ; RECTANGLE |
mov eax,[edi+WDATA.box.left] |
shl eax,16 |
mov ax, word [edi+WDATA.box.left] |
add ax, word [edi+WDATA.box.width] |
mov ebx,[edi+WDATA.box.top] |
shl ebx,16 |
mov bx, word [edi+WDATA.box.top] |
add bx, word [edi+WDATA.box.height] |
mov esi,[edi+WDATA.cl_frames] |
mov esi, [edx + WDATA.cl_frames] |
shr esi,1 |
and esi,0x007f7f7f |
call draw_rectangle |
push esi |
or [edi+WDATA.fl_wdrawn], 4 |
call draw_rectangle |
and [edi+WDATA.fl_wdrawn], not 4 |
test [edi+WDATA.fl_wdrawn], 2 |
jz @f |
call drawwindowframes2 |
@@: |
mov ecx,3 |
dw3l: |
mov esi, [edx + WDATA.cl_frames] |
.next_frame: |
add eax,1*65536-1 |
add ebx,1*65536-1 |
mov esi,[edi+WDATA.cl_frames] |
call draw_rectangle |
dec ecx |
jnz dw3l |
jnz .next_frame |
pop esi |
add eax,1*65536-1 |
add ebx,1*65536-1 |
call draw_rectangle |
; window caption |
call drawwindow_III_caption |
mov edx,[esi+WDATA.box.top] ; WORK AREA |
; window client area |
; do we need to draw it? |
mov edi, [esi + WDATA.cl_workarea] |
test edi, 0x40000000 |
jnz .exit |
; does client area have a positive size on screen? |
mov edx, [esi + WDATA.box.top] |
add edx,21+5 |
mov ebx,[esi+WDATA.box.top] |
add ebx,[esi+WDATA.box.height] |
cmp edx,ebx |
jg noinside2 |
jg .exit |
; okay, let's draw it |
mov eax,5 |
mov ebx,20 |
mov ecx,[esi+WDATA.box.width] |
885,632 → 797,454 |
mov edx,[esi+WDATA.box.height] |
sub ecx,4 |
sub edx,4 |
mov edi,[esi+WDATA.cl_workarea] |
test edi,0x40000000 |
jnz noinside2 |
call [drawbar] |
noinside2: |
.exit: |
popad |
ret |
; activate window |
align 4 |
windowactivate: |
; esi = abs mem position in stack 0xC400+ |
pushad |
; if type of current active window is 3, |
; it must be redrawn |
mov eax, [TASK_COUNT] |
movzx eax, word [WIN_POS + eax*2] |
shl eax, 5 |
add eax, window_data |
mov ebx, [eax + WDATA.cl_workarea] |
and ebx, 0x0f000000 |
cmp ebx, 0x03000000 |
je .set_WDATA_fl_redraw ; for 3 and 4 style |
cmp ebx, 0x04000000 |
je .set_WDATA_fl_redraw |
jmp @f |
.set_WDATA_fl_redraw: |
mov [eax + WDATA.fl_redraw], byte 1 |
@@: |
push esi |
movzx eax, word [esi] ; ax <- process no |
movzx eax, word [WIN_STACK+eax*2] ; ax <- position in window stack |
xor esi, esi ; drop others |
waloop: |
cmp esi, dword [TASK_COUNT] |
jae wacont |
inc esi |
lea edi, [WIN_STACK + esi*2] |
mov bx, [edi] ; position of the current process |
cmp bx, ax |
jbe @f |
dec bx ; upper? => drop! |
mov [edi], bx |
@@: |
jmp waloop |
wacont: |
; set to no 1 |
pop esi ; esi = pointer at 0xC400 |
movzx eax, word [esi] |
mov bx, [TASK_COUNT] ; number of processes |
mov [WIN_STACK+eax*2], bx ; this is the last (and the upper) |
; update on screen -window stack |
xor esi, esi |
waloop2: |
mov edi, [TASK_COUNT] |
cmp esi, edi |
jae wacont2 |
inc esi |
movzx ebx, word [esi*2 + WIN_STACK] |
mov [ebx*2 + WIN_POS], si |
jmp waloop2 |
wacont2: |
mov [KEY_COUNT], byte 0 ; empty keyboard buffer |
mov [BTN_COUNT], byte 0 ; empty button buffer |
mov [MOUSE_SCROLL_H], word 0 ; zero mouse z-index |
mov [MOUSE_SCROLL_V], word 0 ; zero mouse z-index |
popad |
ret |
; check if window is necessary to draw |
checkwindowdraw: |
; edi = position in window_data+ |
mov eax, [edi + WDATA.cl_workarea] |
and eax, 0x0f000000 |
cmp eax, 0x03000000 |
je .return_yes ; window type 3 |
cmp eax, 0x04000000 |
je .return_yes ; window type 4 |
mov esi, edi |
sub esi, window_data |
shr esi, 5 |
; esi = process number |
movzx eax, word [WIN_STACK + esi * 2] ; get value of the curr process |
lea esi, [WIN_POS + eax * 2] ; get address of this process at 0xC400 |
push esi |
.new_check: |
pop esi |
add esi, 2 |
push esi |
mov eax, [TASK_COUNT] |
lea eax, word [WIN_POS + eax * 2] ; number of the upper window |
cmp esi, eax |
ja .all_wnds_to_top |
movzx eax, word [esi] |
shl eax, 5 |
cmp [CURRENT_TASK + eax + TASKDATA.state], byte 9 |
je .new_check ; skip dead windows |
lea esi, [eax+window_data] |
mov ebx, [edi+WDATA.box.top] ; y0 |
mov edx, [edi+WDATA.box.height] |
add edx, ebx ; y0e |
mov ecx, [esi+WDATA.box.top] ; y ; y check |
cmp ecx, edx |
jae .new_check ; y < y0e |
mov eax, [esi+WDATA.box.height] |
add ecx, eax ; ye |
cmp ebx, ecx ; y0 >= ye |
ja .new_check |
mov eax, [edi+WDATA.box.left] ; x0 |
mov ecx, [edi+WDATA.box.width] |
add ecx, eax ; x0e |
mov edx, [esi+WDATA.box.left] ; x ; x check |
cmp edx, ecx |
jae .new_check ; x < x0e |
mov ecx, [esi+WDATA.box.width] |
add edx, ecx |
cmp eax, edx |
ja .new_check |
pop esi |
.return_yes: |
mov ecx,1 ; overlap some window |
ret |
.all_wnds_to_top: |
pop esi |
xor ecx, ecx ; passed all windows to top |
ret |
waredraw: ; if redraw necessary at activate |
pushad |
call checkwindowdraw ; draw window on activation ? |
;------------------------------------------------------------------------------ |
waredraw: ;//////////////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? Activate window, redrawing if necessary |
;------------------------------------------------------------------------------ |
; is it overlapped by another window now? |
push ecx |
call window._.check_window_draw |
test ecx, ecx |
pop ecx |
jz .do_not_draw |
popad |
mov [MOUSE_DOWN], byte 1 ; do draw mouse |
call windowactivate |
; yes it is, activate and update screen buffer |
mov byte[MOUSE_DOWN], 1 |
call window._.window_activate |
; update screen info |
pushad |
mov edi, [TASK_COUNT] ; the last process (number) |
mov edi, [TASK_COUNT] |
movzx esi, word [WIN_POS + edi * 2] |
shl esi, 5 |
add esi, window_data |
; coordinates of the upper window |
mov eax, [esi + WDATA.box.left] ; cx |
mov ebx, [esi + WDATA.box.top] ; cy |
mov ecx, [esi + WDATA.box.width] ; sx |
mov edx, [esi + WDATA.box.height] ; sy |
mov eax, [esi + WDATA.box.left] |
mov ebx, [esi + WDATA.box.top] |
mov ecx, [esi + WDATA.box.width] |
mov edx, [esi + WDATA.box.height] |
add ecx, eax ; ecx = x_end |
add edx, ebx ; edx = y_end |
add ecx, eax |
add edx, ebx |
mov edi, [TASK_COUNT] |
movzx esi, word [WIN_POS + edi * 2] |
call setscreen |
call window._.set_screen |
popad |
mov [edi + WDATA.fl_redraw], 1 ; redraw flag for app |
mov [MOUSE_DOWN],byte 0 ; mouse down checks |
; tell application to redraw itself |
mov [edi + WDATA.fl_redraw], 1 |
mov byte[MOUSE_DOWN], 0 |
ret |
.do_not_draw: |
; no it's not, just activate the window |
call window._.window_activate |
mov byte[MOUSE_DOWN], 0 |
mov byte[MOUSE_BACKGROUND], 0 |
mov byte[DONT_DRAW_MOUSE], 0 |
ret |
popad |
align 4 |
;------------------------------------------------------------------------------ |
minimize_window: ;///////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;> eax = window number on screen |
;------------------------------------------------------------------------------ |
;# corrupts [dl*] |
;------------------------------------------------------------------------------ |
push edi |
pushfd |
cli |
call windowactivate |
mov [MOUSE_DOWN],byte 0 ; mouse down checks |
mov [MOUSE_BACKGROUND],byte 0 ; no mouse background |
mov [DONT_DRAW_MOUSE],byte 0 ; draw mouse |
ret |
; is it already minimized? |
movzx edi, word[WIN_POS + eax * 2] |
shl edi, 5 |
add edi, window_data |
test [edi + WDATA.fl_wstate], WSTATE_MINIMIZED |
jnz .exit |
push eax ebx ecx edx esi |
; eax = window number on screen |
; corrupts registers and [dl*] |
minimize_window: |
movzx eax, word [WIN_POS+eax*2] |
shl eax, 5 |
add eax, window_data |
test [eax+WDATA.fl_wstate], WSTATE_MINIMIZED |
jnz .skip_redrawings |
pushfd |
cli |
or [eax+WDATA.fl_wstate], WSTATE_MINIMIZED |
mov edi, eax |
;call calculatescreen |
; no it's not, let's do that |
or [edi + WDATA.fl_wstate], WSTATE_MINIMIZED |
mov eax, [edi+WDATA.box.left] |
mov [dlx], eax |
mov [draw_limits.left], eax |
mov ecx, eax |
add ecx, [edi+WDATA.box.width] |
mov [dlxe], ecx |
mov [draw_limits.right], ecx |
mov ebx, [edi+WDATA.box.top] |
mov [dly], ebx |
mov [draw_limits.top], ebx |
mov edx, ebx |
add edx, [edi+WDATA.box.height] |
mov [dlye], edx |
mov [draw_limits.bottom], edx |
call calculatescreen |
xor esi, esi |
xor eax, eax |
call redrawscreen |
pop esi edx ecx ebx eax |
.exit: |
popfd |
.skip_redrawings: |
pop edi |
ret |
; eax = window number on screen |
; corrupts registers and [dl*] |
restore_minimized_window: |
align 4 |
;------------------------------------------------------------------------------ |
restore_minimized_window: ;//////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;> eax = window number on screen |
;------------------------------------------------------------------------------ |
;# corrupts [dl*] |
;------------------------------------------------------------------------------ |
pushad |
pushfd |
cli |
; is it already restored? |
movzx esi, word [WIN_POS+eax*2] |
mov edi, esi |
shl edi, 5 |
add edi, window_data |
test [edi+WDATA.fl_wstate], WSTATE_MINIMIZED |
jz .skip_redrawings |
jz .exit |
; no it's not, let's do that |
mov [edi+WDATA.fl_redraw], 1 |
and [edi+WDATA.fl_wstate], not WSTATE_MINIMIZED |
cmp eax, [TASK_COUNT] ; the uppermost window |
jnz .no_uppermost |
mov eax, [edi+WDATA.box.left] |
mov ebp, window._.set_screen |
cmp eax, [TASK_COUNT] |
jz @f |
mov ebp, calculatescreen |
@@: mov eax, [edi + WDATA.box.left] |
mov ebx, [edi+WDATA.box.top] |
mov ecx, eax |
mov edx, ebx |
add ecx, [edi+WDATA.box.width] |
add edx, [edi+WDATA.box.height] |
call setscreen |
jmp .done |
.no_uppermost: |
mov eax, [edi+WDATA.box.left] |
mov ebx, [edi+WDATA.box.top] |
mov ecx, eax |
mov edx, ebx |
add ecx, [edi+WDATA.box.width] |
add edx, [edi+WDATA.box.height] |
call calculatescreen |
.done: |
mov [MOUSE_BACKGROUND],byte 0 ; no mouse under |
.skip_redrawings: |
mov ecx, [edi + WDATA.box.width] |
mov edx, [edi + WDATA.box.height] |
add ecx, eax |
add edx, ebx |
call ebp |
mov byte[MOUSE_BACKGROUND], 0 |
.exit: |
popfd |
popad |
ret |
;iglobal |
; window_moving db 'K : Window - move/resize',13,10,0 |
; window_moved db 'K : Window - done',13,10,0 |
;endg |
; check window touch |
align 4 |
checkwindows: |
;------------------------------------------------------------------------------ |
checkwindows: ;//////////////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? Check for user-initiated window operations |
;------------------------------------------------------------------------------ |
pushad |
; do we have window minimize/restore request? |
cmp [window_minimize], 0 |
je .no_minimizing |
mov eax, [TASK_COUNT] ; the uppermost window |
je .check_for_mouse_buttons_state |
; okay, minimize or restore top-most window and exit |
mov eax, [TASK_COUNT] |
mov bl, 0 |
xchg [window_minimize], bl |
cmp bl, 1 |
jne .restore |
dec bl |
jnz @f |
call minimize_window |
jmp .continue |
.restore: |
call restore_minimized_window |
.continue: |
.no_minimizing: |
jmp .check_for_mouse_buttons_state |
@@: call restore_minimized_window |
cmp [BTN_DOWN],byte 0 ; mouse buttons pressed ? |
.check_for_mouse_buttons_state: |
; do we have any mouse buttons pressed? |
cmp byte[BTN_DOWN], 0 |
jne .mouse_buttons_pressed |
;..................................... start 1/4 : modified by vhanla ................. |
mov [bPressedMouseXY_W],0 |
;..................................... end 1/4 : modified by vhanla ................... |
popad |
ret |
jmp .exit |
.mouse_buttons_pressed: |
;..................................... start 2/4 : modified by vhanla ................. |
uglobal |
bPressedMouseXY_W db 0x0 |
endg |
;..................................... end 2/4 : modified by vhanla ................... |
; yes we do, iterate and ... |
mov esi,[TASK_COUNT] |
inc esi |
;..................................... start 3/4 : modified by vhanla ................. |
cmp [bPressedMouseXY_W],1 |
ja @f |
ja .next_window |
inc [bPressedMouseXY_W] |
jnc @f |
;mov ax,[MOUSE_X] |
;mov [mx],ax |
;mov ax,[MOUSE_Y] |
;mov [my],ax |
mov eax,dword[MOUSE_X] |
mov dword[mx],eax |
@@: |
;..................................... end 3/4 : modified by vhanla ................... |
jnc .next_window |
push dword[MOUSE_X] |
pop dword[mx] |
cwloop: |
.next_window: |
cmp esi,2 |
jb .exit |
dec esi |
movzx edi, word [WIN_POS + esi * 2] ; ebx |
; is that window not minimized? |
movzx edi, word[WIN_POS + esi * 2] |
shl edi, 5 |
add edi, window_data |
; mov edi, ebx |
test [edi + WDATA.fl_wstate], WSTATE_MINIMIZED |
jnz .next_window |
movzx eax, [mx] |
movzx ebx, [my] |
; is the cursor inside screen bounds of that window? |
mov ecx, [edi + WDATA.box.left] |
mov edx, [edi + WDATA.box.top] |
mov eax,ecx |
mov ebx,edx |
test [edi+WDATA.fl_wstate],WSTATE_MINIMIZED |
jnz cwloop |
;..................................... start 4/4 : modified by vhanla ................. |
movzx eax, word [mx]; movzx eax,word[MOUSE_X] |
movzx ebx, word [my]; movzx ebx,word[MOUSE_Y] |
;..................................... endt 4/4 : modified by vhanla .................. |
cmp ecx, eax |
jae cwloop |
cmp edx, ebx |
jae cwloop |
cmp eax, ecx |
jl .next_window |
cmp ebx, edx |
jl .next_window |
add ecx, [edi + WDATA.box.width] |
add edx, [edi + WDATA.box.height] |
cmp eax, ecx |
jae cwloop |
jge .next_window |
cmp ebx, edx |
jae cwloop |
jge .next_window |
pushad |
mov eax, esi |
mov ebx, [TASK_COUNT] |
cmp eax, ebx ; is this window active? |
jz .move_resize_window |
; is that a top-most (which means active) window? |
cmp esi, [TASK_COUNT] |
je .check_for_moving_or_resizing |
; no it's not, did we just press mouse button down above it or was it |
; already pressed before? |
cmp [bPressedMouseXY_W], 1 |
ja .exit_popa |
ja .exit |
; eax = position in windowing stack |
; redraw must ? |
; okay, we just pressed the button, activate this window and exit |
lea esi, [WIN_POS + esi * 2] |
call waredraw |
.exit_popa: |
add esp, 32 |
jmp .exit |
.exit: |
popad |
ret |
.check_for_moving_or_resizing: |
; is that window movable? |
test byte[edi + WDATA.cl_titlebar + 3], 0x01 |
jnz .exit |
.move_resize_window: ; MOVE OR RESIZE WINDOW |
popad |
; Check for user enabled fixed window |
mov edx, [edi + WDATA.cl_titlebar] |
and edx, 0x0f000000 |
cmp edx, 0x01000000 |
jne .window_move_enabled_for_user |
popad |
ret |
.window_move_enabled_for_user: |
; yes it is, is it rolled up? |
test [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP |
jnz .no_resize_2 |
jnz .check_for_cursor_on_caption |
mov [do_resize_from_corner],byte 0 ; resize for skinned window |
mov edx, [edi + WDATA.cl_workarea] |
and edx, 0x0f000000 |
cmp edx, 0x00000000 ;{test for resized} |
je .no_resize_2 |
cmp edx, 0x01000000 ;{test for resized} |
je .no_resize_2 |
cmp edx, 0x04000000 ;{test for resized} |
je .no_resize_2 |
; jb .no_resize_2 ; not type 2 wnd |
; no it's not, can it be resized then? |
mov [do_resize_from_corner], 0 |
mov dl, [edi + WDATA.fl_wstyle] |
and dl, 0x0f |
cmp dl, 0x00 |
je .check_for_cursor_on_caption |
cmp dl, 0x01 |
je .check_for_cursor_on_caption |
cmp dl, 0x04 |
je .check_for_cursor_on_caption |
; are we going to resize it? |
mov edx, [edi + WDATA.box.top] |
add edx, [edi + WDATA.box.height] |
sub edx, 6 ; edx = y_end - 6 |
cmp ebx, edx ; ebx = mouse_y |
jb .no_resize_2 |
mov [do_resize_from_corner],byte 1 |
jmp .continue |
.no_resize_2: |
sub edx, 6 |
cmp ebx, edx |
jl .check_for_cursor_on_caption |
; yes we do, remember that |
mov [do_resize_from_corner], 1 |
jmp .set_move_resize_flag |
.check_for_cursor_on_caption: |
; is the cursor inside window titlebar? |
push eax |
call get_titlebar_height |
call window._.get_titlebar_height |
add eax,[edi + WDATA.box.top] |
cmp ebx,eax |
pop eax |
jae .exit |
jge .exit |
.continue: |
; push esi |
; mov esi, window_moving |
; call sys_msg_board_str |
; pop esi |
mov ecx, [timer_ticks] ; double-click ? |
; calculate duration between two clicks |
mov ecx, [timer_ticks] |
mov edx, ecx |
sub edx, [latest_window_touch] |
mov [latest_window_touch], ecx |
mov [latest_window_touch_delta], edx |
mov cl, [BTN_DOWN] ; save for shade check |
.set_move_resize_flag: |
mov cl, [BTN_DOWN] |
mov [do_resize], cl |
no_emulation_righ_button: |
mov ecx, [edi + WDATA.box.left] |
mov edx, [edi + WDATA.box.top] |
push eax ecx edx |
mov [dlx], ecx ; save for drawlimits |
mov [dly], edx |
mov eax, [edi + WDATA.box.width] |
add ecx, eax |
mov eax, [edi + WDATA.box.height] |
add edx, eax |
mov [dlxe], ecx |
mov [dlye], edx |
pop edx ecx eax |
push ecx edx |
mov [draw_limits.left], ecx |
mov [draw_limits.top], edx |
add ecx, [edi + WDATA.box.width] |
add edx, [edi + WDATA.box.height] |
mov [draw_limits.right], ecx |
mov [draw_limits.bottom], edx |
pop edx ecx |
; calculate window-relative cursor coordinates |
sub eax, ecx |
sub ebx, edx |
mov esi, [MOUSE_X] |
mov [WIN_TEMP_XY], esi |
push dword[MOUSE_X] |
pop dword[WIN_TEMP_XY] |
pushad ; wait for putimages to finish |
; mov ebx,5 |
; call delay_hs |
; save old window coordinates |
push eax |
mov eax,[edi + WDATA.box.left] |
mov [npx],eax |
mov [old_window_pos.left], eax |
mov [new_window_pos.left], eax |
mov eax,[edi + WDATA.box.top] |
mov [npy],eax |
popad |
push eax ; save old coordinates |
mov ax, word [edi + WDATA.box.left] |
mov word [oldc+BOX.left],ax |
mov ax, word [edi + WDATA.box.top] |
mov word [oldc+BOX.top],ax |
mov ax, word [edi + WDATA.box.width] |
mov word [oldc+BOX.width],ax |
mov word [npxe],ax |
mov ax, word [edi + WDATA.box.height] |
mov word [oldc+BOX.height],ax |
mov word [npye],ax |
mov [old_window_pos.top], eax |
mov [new_window_pos.top], eax |
mov eax, [edi + WDATA.box.width] |
mov [old_window_pos.width], eax |
mov [new_window_pos.width], eax |
mov eax, [edi + WDATA.box.height] |
mov [old_window_pos.height], eax |
mov [new_window_pos.height], eax |
pop eax |
call drawwindowframes |
; draw negative moving/sizing frame |
call window._.draw_window_frames |
mov [reposition],0 |
mov [MOUSE_DOWN],byte 1 ; no reaction to mouse up/down |
mov byte[MOUSE_DOWN], 1 |
; move window |
newchm: |
mov [DONT_DRAW_MOUSE],byte 1 |
.next_mouse_state_check: |
; process OS events |
mov byte[DONT_DRAW_MOUSE], 1 |
call checkidle |
call checkVga_N13 |
mov [MOUSE_BACKGROUND],byte 0 |
mov byte[MOUSE_BACKGROUND], 0 |
call [draw_pointer] |
pushad |
call stack_handler |
popad |
; did cursor position change? |
mov esi,[WIN_TEMP_XY] |
cmp esi,[MOUSE_X] |
je cwb |
je .check_for_new_mouse_buttons_state |
mov cx,[MOUSE_X] |
mov dx,[MOUSE_Y] |
sub cx,ax |
sub dx,bx |
; yes it did, calculate window-relative cursor coordinates |
movzx ecx, word[MOUSE_X] |
movzx edx, word[MOUSE_Y] |
sub ecx, eax |
sub edx, ebx |
push ax |
push bx |
push eax ebx |
call drawwindowframes |
; we're going to draw new frame, erasing the old one |
call window._.draw_window_frames |
mov ax,[Screen_Max_X] |
mov bx,[Screen_Max_Y] |
; are we moving it right now? |
cmp [do_resize_from_corner], 0 |
jne .resize_window |
cmp [do_resize_from_corner],1 |
je no_new_position |
; yes we do, check if it's inside the screen area |
mov eax, [Screen_Max_X] |
mov ebx, [Screen_Max_Y] |
mov word [npx],word 0 ; x repos ? |
cmp ax,cx |
jb noreposx |
mov [new_window_pos.left], 0 |
or ecx, ecx |
jle .check_for_new_vert_cursor_pos |
mov [reposition],1 |
sub ax,word [npxe] |
mov word [npx],ax |
cmp ax,cx |
jb noreposx |
mov word [npx],cx |
noreposx: |
sub eax, [new_window_pos.width] |
mov [new_window_pos.left], eax |
cmp ecx, eax |
jge .check_for_new_vert_cursor_pos |
mov [new_window_pos.left], ecx |
mov word [npy],word 0 ; y repos ? |
cmp bx,dx |
jb noreposy |
.check_for_new_vert_cursor_pos: |
mov [new_window_pos.top], 0 |
or edx, edx |
jle .draw_new_window_frame |
mov [reposition],1 |
sub bx,word [npye] |
mov word [npy],bx |
cmp bx,dx |
jb noreposy |
mov word [npy],dx |
noreposy: |
sub ebx, [new_window_pos.height] |
mov [new_window_pos.top], ebx |
cmp edx, ebx |
jge .draw_new_window_frame |
mov [new_window_pos.top], edx |
jmp .draw_new_window_frame |
no_new_position: |
.resize_window: |
push eax ebx edx |
cmp [do_resize_from_corner],0 ; resize from right corner |
je norepos_size |
pushad |
mov edx,edi |
sub edx,window_data |
;shr edx,5 |
;shl edx,8 |
;add edx,0x80000 ; process base at 0x80000+ |
lea edx, [SLOT_BASE + edx*8] |
movzx eax,word [MOUSE_X] |
cmp eax,[edi + WDATA.box.left] |
jb nnepx |
jb .fix_new_vert_size |
sub eax,[edi + WDATA.box.left] |
cmp eax,32 ; [edx+0x90+8] |
jge nnepx2 |
mov eax,32 ; [edx+0x90+8] |
nnepx2: |
mov [npxe],eax |
nnepx: |
cmp eax, 32 |
jge @f |
mov eax, 32 |
@@: mov [new_window_pos.width], eax |
call get_rolledup_height |
.fix_new_vert_size: |
call window._.get_rolledup_height |
mov ebx,eax |
movzx eax,word [MOUSE_Y] |
cmp eax,[edi + WDATA.box.top] |
jb nnepy |
jb .set_reposition_flag |
sub eax,[edi + WDATA.box.top] |
cmp eax,ebx ; [edx+0x90+12] |
jge nnepy2 |
mov eax,ebx ; [edx+0x90+12] |
nnepy2: |
mov [npye],eax |
nnepy: |
cmp eax, ebx |
jge @f |
mov eax, ebx |
@@: mov [new_window_pos.height], eax |
.set_reposition_flag: |
mov [reposition],1 |
popad |
norepos_size: |
pop edx ebx eax |
pop bx |
pop ax |
call drawwindowframes |
.draw_new_window_frame: |
pop ebx eax |
; draw new window moving/sizing frame |
call window._.draw_window_frames |
mov esi,[MOUSE_X] |
mov [WIN_TEMP_XY],esi |
cwb: |
cmp [BTN_DOWN],byte 0 |
jne newchm |
; new position done |
mov [DONT_DRAW_MOUSE],byte 1 |
.check_for_new_mouse_buttons_state: |
; did user release mouse button(s)? |
cmp byte[BTN_DOWN], 0 |
jne .next_mouse_state_check |
; yes he did, moving/sizing is over |
mov byte[DONT_DRAW_MOUSE], 1 |
mov cl,0 |
test [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED |
jnz @f |
jnz .check_other_actions |
mov cl,[reposition] |
call drawwindowframes |
mov eax,[npx] |
; draw negative frame once again to hide it |
call window._.draw_window_frames |
; save new window bounds |
mov eax, [new_window_pos.left] |
mov [edi + WDATA.box.left],eax |
mov eax,[npy] |
mov eax, [new_window_pos.top] |
mov [edi + WDATA.box.top],eax |
mov eax,[npxe] |
mov eax, [new_window_pos.width] |
mov [edi + WDATA.box.width],eax |
mov eax,[npye] |
mov eax, [new_window_pos.height] |
mov [edi + WDATA.box.height],eax |
call set_window_clientbox |
@@: mov [reposition],cl |
cmp [reposition],1 ; save new position and size |
jne no_bounds_save |
cmp cl, 1 |
jne .check_other_actions |
push esi edi ecx |
mov esi,edi |
mov ecx,2 |
1524,44 → 1258,48 |
cld |
rep movsd |
pop ecx edi esi |
no_bounds_save: |
pushad ; WINDOW SHADE/FULLSCREEN |
.check_other_actions: |
mov [reposition], cl |
;{doule click not worked for 4 type window} |
mov edx, [edi + WDATA.cl_workarea] |
and edx, 0x0f000000 |
cmp edx, 0x00000000 |
je no_fullscreen_restore |
cmp edx, 0x01000000 |
je no_fullscreen_restore |
pushad |
cmp [reposition],1 |
je no_window_sizing |
mov dl, [edi + WDATA.fl_wstyle] |
and dl, 0x0f |
cmp dl, 0x00 |
je .check_if_window_fits_screen |
cmp dl, 0x01 |
je .check_if_window_fits_screen |
cmp cl, 1 |
je .no_window_sizing |
mov edx,edi |
sub edx,window_data |
shr edx,5 |
shl edx,8 |
add edx,SLOT_BASE ; process base at 0x80000+ |
add edx, SLOT_BASE |
cmp [do_resize],2 ; window shade ? |
jne no_window_shade |
; did we right-click on titlebar? |
cmp [do_resize], 2 |
jne .check_maximization_request |
; yes we did, toggle normal/rolled up window state |
xor [edi + WDATA.fl_wstate], WSTATE_ROLLEDUP |
mov [reposition],1 |
; calculate and set appropriate window height |
test [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP |
jnz wnd_rolldown |
wnd_rollup: |
or [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP |
call get_rolledup_height |
jmp @f |
wnd_rolldown: |
and [edi+WDATA.fl_wstate],not WSTATE_ROLLEDUP |
mov eax,[edx + APPDATA.saved_box.height] ; 0x90+BOX.height |
jz @f |
call window._.get_rolledup_height |
jmp .set_new_window_height |
@@: mov eax, [edx + APPDATA.saved_box.height] |
test [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED |
jz @f |
jz .set_new_window_height |
mov eax,[screen_workarea.bottom] |
sub eax,[screen_workarea.top] |
@@: mov [edi+WDATA.box.height],eax |
.set_new_window_height: |
mov [edi + WDATA.box.height], eax |
add eax, [edi+WDATA.box.top] |
cmp eax, [Screen_Max_Y] |
jbe @f |
1571,23 → 1309,30 |
@@: call check_window_position |
call set_window_clientbox |
no_window_shade: |
.check_maximization_request: |
; can window change its height? |
push edx |
mov edx, [edi + WDATA.cl_workarea] |
and edx, 0x0f000000 |
cmp edx, 0x04000000 |
mov dl, [edi + WDATA.fl_wstyle] |
and dl, 0x0f |
cmp dl, 0x04 |
pop edx |
je no_fullscreen_restore |
je .check_if_window_fits_screen |
cmp [do_resize],1 ; fullscreen/restore ? |
jne no_fullscreen_restore |
cmp [latest_window_touch_delta],dword 50 |
jg no_fullscreen_restore |
; was it really a maximize/restore request? |
cmp [do_resize], 1 |
jne .check_if_window_fits_screen |
cmp [do_resize_from_corner], 0 |
jne .check_if_window_fits_screen |
cmp [latest_window_touch_delta], 50 |
jg .check_if_window_fits_screen |
; yes is was, toggle normal/maximized window state |
xor [edi + WDATA.fl_wstate], WSTATE_MAXIMIZED |
mov [reposition],1 |
; calculate and set appropriate window bounds |
test [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED |
jnz restore_from_fullscreen |
or [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED |
jz .restore_normal_window_size |
mov eax,[screen_workarea.left] |
mov [edi+WDATA.box.left],eax |
sub eax,[screen_workarea.right] |
1596,16 → 1341,15 |
mov eax,[screen_workarea.top] |
mov [edi+WDATA.box.top],eax |
test [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP |
jnz @f |
jnz .calculate_window_client_area |
sub eax,[screen_workarea.bottom] |
neg eax |
mov [edi+WDATA.box.height],eax |
@@: |
jmp restore_from_fullscreen.clientbox |
restore_from_fullscreen: |
and [edi+WDATA.fl_wstate],not WSTATE_MAXIMIZED |
jmp .calculate_window_client_area |
.restore_normal_window_size: |
push [edi+WDATA.box.height] |
push edi ; restore |
push edi |
lea esi, [edx + APPDATA.saved_box] |
mov ecx,4 |
cld |
1613,22 → 1357,24 |
pop edi |
pop eax |
test [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP |
jz @f |
jz .calculate_window_client_area |
mov [edi+WDATA.box.height],eax |
@@: |
.clientbox: |
.calculate_window_client_area: |
call set_window_clientbox |
no_fullscreen_restore: |
mov eax,[edi+WDATA.box.top] ; check Y inside screen |
.check_if_window_fits_screen: |
; does window fit into screen area? |
mov eax, [edi + WDATA.box.top] |
add eax,[edi+WDATA.box.height] |
cmp eax,[Screen_Max_Y] |
jbe no_window_sizing |
mov eax,[edi+WDATA.box.left] ; check X inside screen |
jbe .no_window_sizing |
mov eax, [edi + WDATA.box.left] |
add eax,[edi+WDATA.box.width] |
cmp eax,[Screen_Max_X] |
jbe no_window_sizing |
jbe .no_window_sizing |
; no it doesn't, fix that |
mov eax,[Screen_Max_X] |
sub eax,[edi+WDATA.box.width] |
mov [edi+WDATA.box.left],eax |
1636,17 → 1382,19 |
sub eax,[edi+WDATA.box.height] |
mov [edi+WDATA.box.top],eax |
call set_window_clientbox |
no_window_sizing: |
.no_window_sizing: |
popad |
; did somethins actually change its place? |
cmp [reposition],0 |
je retwm |
je .reset_vars |
mov [DONT_DRAW_MOUSE],byte 1 ; no mouse |
mov byte[DONT_DRAW_MOUSE], 1 |
push eax ebx ecx edx |
push eax ebx ecx edx |
; recalculate screen buffer at new position |
mov eax,[edi+WDATA.box.left] |
mov ebx,[edi+WDATA.box.top] |
mov ecx,[edi+WDATA.box.width] |
1655,169 → 1403,444 |
add edx,ebx |
call calculatescreen |
mov eax,[oldc+BOX.left] |
mov ebx,[oldc+BOX.top] |
mov ecx,[oldc+BOX.width] |
mov edx,[oldc+BOX.height] |
; recalculate screen buffer at old position |
mov eax, [old_window_pos.left] |
mov ebx, [old_window_pos.top] |
mov ecx, [old_window_pos.width] |
mov edx, [old_window_pos.height] |
add ecx,eax |
add edx,ebx |
call calculatescreen |
pop edx ecx ebx eax |
mov eax,edi |
call redrawscreen |
; tell window to redraw itself |
mov [edi+WDATA.fl_redraw],1 |
mov ecx,100 ; wait to avoid mouse residuals |
waitre2: |
mov [DONT_DRAW_MOUSE],byte 1 |
; wait a bit for window to redraw itself |
mov ecx, 100 |
.next_idle_cycle: |
mov byte[DONT_DRAW_MOUSE], 1 |
call checkidle |
cmp [edi+WDATA.fl_redraw],0 |
jz retwm |
loop waitre2 |
jz .reset_vars |
loop .next_idle_cycle |
retwm: |
.reset_vars: |
mov byte[DONT_DRAW_MOUSE], 0 ; mouse pointer |
mov byte[MOUSE_BACKGROUND], 0 ; no mouse under |
mov byte[MOUSE_DOWN], 0 ; react to mouse up/down |
mov [DONT_DRAW_MOUSE],byte 0 ; mouse pointer |
mov [MOUSE_BACKGROUND],byte 0 ; no mouse under |
mov [MOUSE_DOWN],byte 0 ; react to mouse up/down |
.exit: |
popad |
ret |
; mov esi,window_moved |
; call sys_msg_board_str |
;============================================================================== |
;///// private functions ////////////////////////////////////////////////////// |
;============================================================================== |
popad |
align 4 |
;------------------------------------------------------------------------------ |
window._.get_titlebar_height: ;//////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;> edi = pointer to WDATA |
;------------------------------------------------------------------------------ |
mov al, [edi + WDATA.fl_wstyle] |
and al, 0x0f |
cmp al, 0x03 |
jne @f |
mov eax, [_skinh] |
ret |
@@: mov eax, 21 |
ret |
align 4 |
;------------------------------------------------------------------------------ |
window._.get_rolledup_height: ;//////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;> edi = pointer to WDATA |
;------------------------------------------------------------------------------ |
mov al, [edi + WDATA.fl_wstyle] |
and al, 0x0f |
cmp al, 0x03 |
jb @f |
mov eax, [_skinh] |
add eax, 3 |
ret |
@@: or al, al |
jnz @f |
mov eax, 21 |
ret |
@@: mov eax, 21 + 2 |
ret |
align 4 |
;------------------------------------------------------------------------------ |
window._.set_screen: ;///////////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? Reserve window area in screen buffer |
;------------------------------------------------------------------------------ |
;> eax = left |
;> ebx = top |
;> ecx = right |
;> edx = bottom |
;> esi = process number |
;------------------------------------------------------------------------------ |
virtual at esp |
ff_x dd ? |
ff_y dd ? |
ff_width dd ? |
ff_xsz dd ? |
ff_ysz dd ? |
ff_scale dd ? |
end virtual |
uglobal |
add_window_data dd 0 |
do_resize_from_corner db 0x0 |
reposition db 0x0 |
latest_window_touch dd 0x0 |
latest_window_touch_delta dd 0x0 |
pushad |
do_resize db 0x0 |
cmp esi, 1 |
jz .check_for_shaped_window |
mov edi, esi |
shl edi, 5 |
cmp [window_data + edi + WDATA.box.width], 0 |
jnz .check_for_shaped_window |
cmp [window_data + edi + WDATA.box.height], 0 |
jz .exit |
oldc dd 0x0,0x0,0x0,0x0 |
.check_for_shaped_window: |
mov edi, esi |
shl edi, 8 |
add edi, SLOT_BASE |
cmp [edi + APPDATA.wnd_shape], 0 |
jne .shaped_window |
dlx dd 0x0 |
dly dd 0x0 |
dlxe dd 0x0 |
dlye dd 0x0 |
; get x&y size |
sub ecx, eax |
sub edx, ebx |
inc ecx |
inc edx |
npx dd 0x0 |
npy dd 0x0 |
npxe dd 0x0 |
npye dd 0x0 |
; get WinMap start |
push esi |
mov edi, [Screen_Max_X] |
inc edi |
mov esi, edi |
imul edi, ebx |
add edi, eax |
add edi, [_WinMapAddress] |
pop eax |
mov ah, al |
push ax |
shl eax, 16 |
pop ax |
mpx dd 0x0 |
mpy dd 0x0 |
endg |
.next_line: |
push ecx |
shr ecx, 2 |
rep stosd |
mov ecx, [esp] |
and ecx, 3 |
rep stosb |
pop ecx |
add edi, esi |
sub edi, ecx |
dec edx |
jnz .next_line |
jmp .exit |
; draw negative window frames |
drawwindowframes2: |
pushad |
cli |
jmp drawwindowframes.do |
drawwindowframes: |
pushad |
cli |
.shaped_window: |
; for (y=0; y <= x_size; y++) |
; for (x=0; x <= x_size; x++) |
; if (shape[coord(x,y,scale)]==1) |
; set_pixel(x, y, process_number); |
test [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED |
jnz .ret |
mov eax, [npx] |
cmp eax, [edi+WDATA.box.left] |
jnz .nowndframe |
mov eax, [npxe] |
cmp eax, [edi+WDATA.box.width] |
jnz .nowndframe |
mov eax, [npy] |
cmp eax, [edi+WDATA.box.top] |
jnz .nowndframe |
mov eax, [npye] |
cmp eax, [edi+WDATA.box.height] |
jnz .nowndframe |
xor [edi+WDATA.fl_wdrawn], 2 |
test [edi+WDATA.fl_wdrawn], 4 |
jnz .ret |
sub ecx, eax |
sub edx, ebx |
inc ecx |
inc edx |
.nowndframe: |
.do: |
mov edi, 1 |
mov ecx, 0x01000000 |
mov eax,[npx] |
shl eax,16 |
add eax,[npx] |
add eax,[npxe] |
add eax,65536*1-1 |
mov ebx,[npy] |
shl ebx,16 |
add ebx,[npy] |
call [draw_line] |
push [edi + APPDATA.wnd_shape_scale] ; push scale first -> for loop |
mov eax,[npx] |
shl eax,16 |
add eax,[npx] |
add eax,[npxe] |
add eax,65536*1-1 |
mov ebx,[npy] |
add ebx,[npye] |
shl ebx,16 |
add ebx,[npy] |
add ebx,[npye] |
call [draw_line] |
; get WinMap start -> ebp |
push eax |
mov eax, [Screen_Max_X] ; screen_sx |
inc eax |
imul eax, ebx |
add eax, [esp] |
add eax, [_WinMapAddress] |
mov ebp, eax |
mov eax,[npx] |
shl eax,16 |
add eax,[npx] |
mov ebx,[npy] |
shl ebx,16 |
add ebx,[npy] |
add ebx,[npye] |
call [draw_line] |
mov edi, [edi + APPDATA.wnd_shape] |
pop eax |
mov eax,[npx] |
add eax,[npxe] |
shl eax,16 |
add eax,[npx] |
add eax,[npxe] |
mov ebx,[npy] |
shl ebx,16 |
add ebx,[npy] |
add ebx,[npye] |
call [draw_line] |
; eax = x_start |
; ebx = y_start |
; ecx = x_size |
; edx = y_size |
; esi = process_number |
; edi = &shape |
; [scale] |
push edx ecx ; for loop - x,y size |
.ret: |
sti |
mov ecx, esi |
shl ecx, 5 |
mov edx, [window_data + ecx + WDATA.box.top] |
push [window_data + ecx + WDATA.box.width] ; for loop - width |
mov ecx, [window_data + ecx + WDATA.box.left] |
sub ebx, edx |
sub eax, ecx |
push ebx eax ; for loop - x,y |
add [ff_xsz], eax |
add [ff_ysz], ebx |
mov ebx, [ff_y] |
.ff_new_y: |
mov edx, [ff_x] |
.ff_new_x: |
; -- body -- |
mov ecx, [ff_scale] |
mov eax, [ff_width] |
inc eax |
shr eax, cl |
push ebx edx |
shr ebx, cl |
shr edx, cl |
imul eax, ebx |
add eax, edx |
pop edx ebx |
add eax, edi |
call .read_byte |
test al,al |
jz @f |
mov eax, esi |
mov [ebp], al |
; -- end body -- |
@@: inc ebp |
inc edx |
cmp edx, [ff_xsz] |
jb .ff_new_x |
sub ebp, [ff_xsz] |
add ebp, [ff_x] |
add ebp, [Screen_Max_X] ; screen.x |
inc ebp |
inc ebx |
cmp ebx, [ff_ysz] |
jb .ff_new_y |
add esp, 24 |
.exit: |
popad |
ret |
.read_byte: |
; eax - address |
; esi - slot |
push eax ecx edx esi |
xchg eax, esi |
lea ecx, [esp + 12] |
mov edx, 1 |
call read_process_memory |
pop esi edx ecx eax |
ret |
align 4 |
;------------------------------------------------------------------------------ |
window._.window_activate: ;//////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? Activate window |
;------------------------------------------------------------------------------ |
;> esi = pointer to WIN_POS+ window data |
;------------------------------------------------------------------------------ |
push eax ebx |
random_shaped_window: |
; if type of current active window is 3 or 4, it must be redrawn |
mov ebx, [TASK_COUNT] |
movzx ebx, word[WIN_POS + ebx * 2] |
shl ebx, 5 |
add eax, window_data |
mov al, [window_data + ebx + WDATA.fl_wstyle] |
and al, 0x0f |
cmp al, 0x03 |
je .set_window_redraw_flag |
cmp al, 0x04 |
jne .move_others_down |
; |
; eax = 0 giving address of data area |
; ebx address |
; eax = 1 shape area scale |
; ebx 2^ebx scale |
.set_window_redraw_flag: |
mov [window_data + ebx + WDATA.fl_redraw], 1 |
test eax, eax |
jne rsw_no_address |
mov eax,[current_slot] |
mov [eax+APPDATA.wnd_shape],ebx |
rsw_no_address: |
.move_others_down: |
; ax <- process no |
movzx ebx, word[esi] |
; ax <- position in window stack |
movzx ebx, word[WIN_STACK + ebx * 2] |
cmp eax,1 |
jne rsw_no_scale |
mov eax,[current_slot] |
mov byte [eax+APPDATA.wnd_shape_scale], bl |
rsw_no_scale: |
; drop others |
xor eax, eax |
.next_stack_window: |
cmp eax, [TASK_COUNT] |
jae .move_self_up |
inc eax |
cmp [WIN_STACK + eax * 2], bx |
jbe .next_stack_window |
dec word[WIN_STACK + eax * 2] |
jmp .next_stack_window |
.move_self_up: |
movzx ebx, word[esi] |
; number of processes |
mov ax, [TASK_COUNT] |
; this is the last (and the upper) |
mov [WIN_STACK + ebx * 2], ax |
; update on screen - window stack |
xor eax, eax |
.next_window_pos: |
cmp eax, [TASK_COUNT] |
jae .reset_vars |
inc eax |
movzx ebx, word[WIN_STACK + eax * 2] |
mov [WIN_POS + ebx * 2], ax |
jmp .next_window_pos |
.reset_vars: |
mov byte[KEY_COUNT], 0 |
mov byte[BTN_COUNT], 0 |
mov word[MOUSE_SCROLL_H], 0 |
mov word[MOUSE_SCROLL_V], 0 |
pop ebx eax |
ret |
align 4 |
;------------------------------------------------------------------------------ |
window._.check_window_draw: ;////////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? Check if window is necessary to draw |
;------------------------------------------------------------------------------ |
;> edi = pointer to WDATA |
;------------------------------------------------------------------------------ |
mov cl, [edi + WDATA.fl_wstyle] |
and cl, 0x0f |
cmp cl, 0x03 |
je .exit.redraw ; window type 3 |
cmp cl, 0x04 |
je .exit.redraw ; window type 4 |
push eax ebx edx esi |
mov eax, edi |
sub eax, window_data |
shr eax, 5 |
; esi = process number |
movzx eax, word[WIN_STACK + eax * 2] ; get value of the curr process |
lea esi, [WIN_POS + eax * 2] ; get address of this process at 0xC400 |
.next_window: |
add esi, 2 |
mov eax, [TASK_COUNT] |
lea eax, word[WIN_POS + eax * 2] ; number of the upper window |
cmp esi, eax |
ja .exit.no_redraw |
movzx edx, word[esi] |
shl edx, 5 |
cmp [CURRENT_TASK + edx + TASKDATA.state], TSTATE_FREE |
je .next_window |
mov eax, [edi + WDATA.box.top] |
mov ebx, [edi + WDATA.box.height] |
add ebx, eax |
mov ecx, [window_data + edx + WDATA.box.top] |
cmp ecx, ebx |
jge .next_window |
add ecx, [window_data + edx + WDATA.box.height] |
cmp eax, ecx |
jge .next_window |
mov eax, [edi + WDATA.box.left] |
mov ebx, [edi + WDATA.box.width] |
add ebx, eax |
mov ecx, [window_data + edx + WDATA.box.left] |
cmp ecx, ebx |
jge .next_window |
add ecx, [window_data + edx + WDATA.box.width] |
cmp eax, ecx |
jge .next_window |
pop esi edx ebx eax |
.exit.redraw: |
xor ecx, ecx |
inc ecx |
ret |
.exit.no_redraw: |
pop esi edx ebx eax |
xor ecx, ecx |
ret |
align 4 |
;------------------------------------------------------------------------------ |
window._.draw_window_frames: ;///////////////////////////////////////////////// |
;------------------------------------------------------------------------------ |
;? Draw negative window frames |
;------------------------------------------------------------------------------ |
;> edi = pointer to WDATA |
;------------------------------------------------------------------------------ |
push eax |
cli |
test [edi + WDATA.fl_wstate], WSTATE_MAXIMIZED |
jnz .exit |
mov eax, [new_window_pos.left] |
cmp eax, [edi + WDATA.box.left] |
jnz .draw |
mov eax, [new_window_pos.width] |
cmp eax, [edi + WDATA.box.width] |
jnz .draw |
mov eax, [new_window_pos.top] |
cmp eax, [edi + WDATA.box.top] |
jnz .draw |
mov eax, [new_window_pos.height] |
cmp eax, [edi + WDATA.box.height] |
jnz .draw |
xor [edi + WDATA.fl_wdrawn], 2 |
.draw: |
push ebx esi |
mov eax, [new_window_pos.left - 2] |
mov ax, word[new_window_pos.left] |
add ax, word[new_window_pos.width] |
mov ebx, [new_window_pos.top - 2] |
mov bx, word[new_window_pos.top] |
add bx, word[new_window_pos.height] |
mov esi, 0x01000000 |
call draw_rectangle.forced |
pop esi ebx |
.exit: |
sti |
pop eax |
ret |
.forced: |
push eax |
cli |
jmp .draw |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/hid/keyboard.inc |
---|
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/hid/mousedrv.inc |
---|
51,12 → 51,13 |
draw_mouse_under: |
; return old picture |
cmp [set_hw_cursor], 0 |
jz @F |
cmp [_display.restore_cursor], 0 |
je @F |
pushad |
movzx eax,word [X_UNDER] |
movzx ebx,word [Y_UNDER] |
stdcall [hw_restore], eax, ebx |
stdcall [_display.restore_cursor], eax, ebx |
popad |
ret |
@@: |
97,7 → 98,7 |
save_draw_mouse: |
cmp [set_hw_cursor], 0 |
cmp [_display.move_cursor], 0 |
je .no_hw_cursor |
pushad |
111,8 → 112,8 |
mov ecx, [Screen_Max_X] |
inc ecx |
mul ecx |
movzx edx, byte [display_data+ebx+eax] |
add eax, [_WinMapAddress] |
movzx edx, byte [ebx+eax] |
shl edx, 8 |
mov esi, [edx+SLOT_BASE+APPDATA.cursor] |
119,20 → 120,17 |
cmp esi, [current_cursor] |
je .draw |
; cmp [esi+CURSOR.magic], 'CURS' |
; jne .fail |
push esi |
call [select_hw_cursor] |
call [_display.select_cursor] |
mov [current_cursor], esi |
.draw: |
stdcall [set_hw_cursor], esi |
stdcall [_display.move_cursor], esi |
popad |
ret |
.fail: |
mov ecx, [def_cursor] |
mov [edx+SLOT_BASE+APPDATA.cursor], ecx |
stdcall [set_hw_cursor], ecx ; stdcall: [esp]=ebx,eax |
stdcall [_display.move_cursor], ecx ; stdcall: [esp]=ebx,eax |
popad |
ret |
292,7 → 290,7 |
inc ecx |
imul ecx,ebx |
add ecx,eax |
add ecx, display_data |
add ecx, [_WinMapAddress] |
mov eax, [CURRENT_TASK] |
movzx ebx, byte [ecx] |
cmp eax,ebx |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/hid/set_dtc.inc |
---|
1,6 → 1,6 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;; |
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
17,7 → 17,7 |
; ebx =3 - set alarm-clock ecx - 00SSMMHH |
; out: 0 -Ok 1 -wrong format 2 -battery low |
sys_settime: |
mov ecx,eax |
cli |
mov al,0x0d |
out 0x70,al |
24,130 → 24,132 |
in al,0x71 |
bt ax,7 |
jnc bat_low |
cmp ecx,2 ;day of week |
cmp ebx,2 ;day of week |
jne nosetweek |
test ebx,ebx ;test day of week |
test ecx,ecx ;test day of week |
je wrongtime |
cmp ebx,7 |
cmp ecx,7 |
ja wrongtime |
mov dx,0x70 |
mov edx,0x70 |
call startstopclk |
dec edx |
mov al,6 |
out dx,al |
inc edx |
mov al,bl |
mov al,cl |
out dx,al |
jmp endsettime |
nosetweek: ;set date |
cmp ecx,1 |
cmp ebx,1 |
jne nosetdate |
cmp bl,0x99 ;test year |
cmp cl,0x99 ;test year |
ja wrongtime |
shl ebx,4 |
cmp bl,0x90 |
shl ecx,4 |
cmp cl,0x90 |
ja wrongtime |
cmp bh,0x99 ;test month |
cmp ch,0x99 ;test month |
ja wrongtime |
shr ebx,4 |
test bh,bh |
shr ecx,4 |
test ch,ch |
je wrongtime |
cmp bh,0x12 |
cmp ch,0x12 |
ja wrongtime |
shl ebx,8 |
bswap ebx ;ebx=00YYMMDD |
test bl,bl ;test day |
shl ecx,8 |
bswap ecx ;ebx=00YYMMDD |
test cl,cl ;test day |
je wrongtime |
shl ebx,4 |
cmp bl,0x90 |
shl ecx,4 |
cmp cl,0x90 |
ja wrongtime |
shr ebx,4 |
cmp bh,2 ;February |
shr ecx,4 |
cmp ch,2 ;February |
jne testday |
cmp bl,0x29 |
cmp cl,0x29 |
ja wrongtime |
jmp setdate |
testday: |
cmp bh,8 |
cmp ch,8 |
jb testday1 ;Aug-Dec |
bt bx,8 |
bt cx,8 |
jnc days31 |
jmp days30 |
testday1: |
bt bx,8 ;Jan-Jul ex.Feb |
bt cx,8 ;Jan-Jul ex.Feb |
jnc days30 |
days31: |
cmp bl,0x31 |
cmp cl,0x31 |
ja wrongtime |
jmp setdate |
days30: |
cmp bl,0x30 |
cmp cl,0x30 |
ja wrongtime |
setdate: |
mov dx,0x70 |
mov edx,0x70 |
call startstopclk |
dec edx |
mov al,7 ;set days |
out dx,al |
inc edx |
mov al,bl |
mov al,cl |
out dx,al |
dec edx |
mov al,8 ;set months |
out dx,al |
inc edx |
mov al,bh |
mov al,ch |
out dx,al |
dec edx |
mov al,9 ;set years |
out dx,al |
inc edx |
shr ebx,8 |
mov al,bh |
shr ecx,8 |
mov al,ch |
out dx,al |
jmp endsettime |
nosetdate: ;set time or alarm-clock |
cmp ecx,3 |
cmp ebx,3 |
ja wrongtime |
cmp bl,0x23 |
cmp cl,0x23 |
ja wrongtime |
cmp bh,0x59 |
cmp ch,0x59 |
ja wrongtime |
shl ebx,4 |
cmp bl,0x90 |
shl ecx,4 |
cmp cl,0x90 |
ja wrongtime |
cmp bh,0x92 |
cmp ch,0x92 |
ja wrongtime |
shl ebx,4 |
bswap ebx ;00HHMMSS |
cmp bl,0x59 |
shl ecx,4 |
bswap ecx ;00HHMMSS |
cmp cl,0x59 |
ja wrongtime |
shl ebx,4 |
cmp bl,0x90 |
shl ecx,4 |
cmp cl,0x90 |
ja wrongtime |
shr ebx,4 |
mov dx,0x70 |
shr ecx,4 |
mov edx,0x70 |
call startstopclk |
dec edx |
cmp ecx,3 |
cmp ebx,3 |
je setalarm |
xor eax,eax ;al=0-set seconds |
out dx,al |
inc edx |
mov al,bl |
mov al,cl |
out dx,al |
dec edx |
mov al,2 ;set minutes |
out dx,al |
inc edx |
mov al,bh |
mov al,ch |
out dx,al |
dec edx |
mov al,4 ;set hours |
out dx,al |
inc edx |
shr ebx,8 |
mov al,bh |
shr ecx,8 |
mov al,ch |
out dx,al |
jmp endsettime |
setalarm: |
154,20 → 156,20 |
mov al,1 ;set seconds for al. |
out dx,al |
inc edx |
mov al,bl |
mov al,cl |
out dx,al |
dec edx |
mov al,3 ;set minutes for al. |
out dx,al |
inc edx |
mov al,bh |
mov al,ch |
out dx,al |
dec edx |
mov al,5 ;set hours for al. |
out dx,al |
inc edx |
shr ebx,8 |
mov al,bh |
shr ecx,8 |
mov al,ch |
out dx,al |
dec edx |
mov al,0x0b ;enable irq's |
180,15 → 182,15 |
dec edx |
call startstopclk |
sti |
mov [esp+36],dword 0 |
and [esp+36-4],dword 0 |
ret |
bat_low: |
sti |
mov [esp+36],dword 2 |
mov [esp+36-4],dword 2 |
ret |
wrongtime: |
sti |
mov [esp+36],dword 1 |
mov [esp+36-4],dword 1 |
ret |
startstopclk: |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/init.inc |
---|
114,9 → 114,9 |
mov edx, (OS_BASE/4096) |
jmp .set |
@@: |
cmp edx, (HEAP_BASE+HEAP_MIN_SIZE)/4096 |
cmp edx, (HEAP_BASE-OS_BASE+HEAP_MIN_SIZE)/4096 |
jae .set |
mov edx, (HEAP_BASE+HEAP_MIN_SIZE)/4096 |
mov edx, (HEAP_BASE-OS_BASE+HEAP_MIN_SIZE)/4096 |
.set: |
mov [pg_data.kernel_pages-OS_BASE], edx |
shr edx, 10 |
205,19 → 205,18 |
mov edi, [ebx] |
shr edi, 12 ; edi = first page |
mov eax, edi |
neg eax |
shr edi, 5 |
shl edi, 2 |
add edi, sys_pgmap-OS_BASE |
and eax, 31 |
jz .startok |
sub ecx, eax |
add ecx, eax |
sub ecx, 32 |
jbe .onedword |
push ecx |
mov ecx, eax |
xor eax, eax |
inc eax |
or eax, -1 |
shl eax, cl |
dec eax |
or [edi], eax |
add edi, 4 |
pop ecx |
228,15 → 227,17 |
rep stosd |
pop ecx |
and ecx, 31 |
not eax |
neg eax |
shl eax, cl |
dec eax |
or [edi], eax |
jmp .next |
.onedword: |
add ecx, eax |
add ecx, 32 |
sub ecx, eax |
@@: |
dec eax |
bts [edi], eax |
inc eax |
loop @b |
.next: |
add ebx, 20 |
/kernel/branches/net/kernel.asm |
---|
17,7 → 17,8 |
;; Sergey Semyonov (Serge) |
;; Johnny_B |
;; SPraid (simba) |
;; hidnplayr |
;; Hidnplayr |
;; Alexey Teplov (<Lrz>) |
;; |
;; Data in this file was originally part of MenuetOS project which is |
;; distributed under the terms of GNU GPL. It is modified and redistributed as |
79,6 → 80,7 |
tss0 equ (tss0_l-gdts) |
app_code equ (3+app_code_l-gdts) |
app_data equ (3+app_data_l-gdts) |
app_tls equ (3+tls_data_l-gdts) |
pci_code_sel equ (pci_code_32-gdts) |
pci_data_sel equ (pci_data_32-gdts) |
117,7 → 119,7 |
org 0x0 |
jmp start_of_code |
version db 'Kolibri OS version 0.7.5.0 ',13,10,13,10,0 |
version db 'Kolibri OS version 0.7.7.0+ ',13,10,13,10,0 |
include "boot/bootstr.inc" ; language-independent boot messages |
include "boot/preboot.inc" |
283,12 → 285,13 |
high_code: |
mov ax,os_stack |
mov bx,app_data |
mov cx, app_tls |
mov ss,ax |
add esp, OS_BASE |
mov ds,bx |
mov es,bx |
mov fs,bx |
mov fs, cx |
mov gs,bx |
bt [cpu_caps], CAPS_PGE |
346,14 → 349,20 |
; mov [0xF604],byte 1 ;al |
mov al, [BOOT_VAR+0x901F] ; DMA access |
mov [allow_dma_access], al |
mov al,[BOOT_VAR+0x9000] ; bpp |
movzx eax, byte [BOOT_VAR+0x9000] ; bpp |
mov [ScreenBPP],al |
mov [_display.bpp], eax |
mov [_display.vrefresh], 60 |
mov [_display.disable_mouse], __sys_disable_mouse |
movzx eax,word [BOOT_VAR+0x900A] ; X max |
mov [_display.width], eax |
dec eax |
mov [Screen_Max_X],eax |
mov [screen_workarea.right],eax |
movzx eax,word [BOOT_VAR+0x900C] ; Y max |
mov [_display.height], eax |
dec eax |
mov [Screen_Max_Y],eax |
mov [screen_workarea.bottom],eax |
366,9 → 375,14 |
je @f |
cmp [SCR_MODE],word 0x12 ; VGA 640x480 |
je @f |
mov ax,[BOOT_VAR+0x9001] ; for other modes |
movzx eax, word[BOOT_VAR+0x9001] ; for other modes |
mov [BytesPerScanLine],ax |
mov [_display.pitch], eax |
@@: |
mov eax, [_display.width] |
mul [_display.height] |
mov [_WinMapSize], eax |
mov esi, BOOT_VAR+0x9080 |
movzx ecx, byte [esi-1] |
mov [NumBiosDisks], ecx |
377,7 → 391,7 |
; GRAPHICS ADDRESSES |
mov byte [BOOT_VAR+0x901e],0x0 |
and byte [BOOT_VAR+0x901e],0x0 |
mov eax,[BOOT_VAR+0x9018] |
mov [LFBAddress],eax |
451,6 → 465,16 |
wrmsr |
.noSYSCALL: |
; ----------------------------------------- |
stdcall alloc_page |
stdcall map_page, tss-0xF80, eax, PG_SW |
stdcall alloc_page |
inc eax |
mov [SLOT_BASE+256+APPDATA.io_map], eax |
stdcall map_page, tss+0x80, eax, PG_SW |
stdcall alloc_page |
inc eax |
mov dword [SLOT_BASE+256+APPDATA.io_map+4], eax |
stdcall map_page, tss+0x1080, eax, PG_SW |
; LOAD IDT |
538,14 → 562,18 |
mov [graph_data_l+4],al |
mov [graph_data_l+7],ah |
mov [CURRENT_TASK],dword 1 |
mov [TASK_COUNT],dword 1 |
stdcall kernel_alloc, [_WinMapSize] |
mov [_WinMapAddress], eax |
xor eax,eax |
inc eax |
mov [CURRENT_TASK],eax ;dword 1 |
mov [TASK_COUNT],eax ;dword 1 |
mov [TASK_BASE],dword TASK_DATA |
mov [current_slot], SLOT_BASE+256 |
; set background |
xor eax,eax |
inc eax |
mov [BgrDrawMode],eax |
mov [BgrDataWidth],eax |
mov [BgrDataHeight],eax |
601,6 → 629,7 |
include 'vmodeld.inc' |
;!!!!!!!!!!!!!!!!!!!!!!! |
if 0 |
mov ax,[OS_BASE+0x10000+bx_from_load] |
cmp ax,'r1' ; if using not ram disk, then load librares and parameters {SPraid.simba} |
je no_lib_load |
609,6 → 638,7 |
call load_file_parse_table ; prepare file parse table |
call set_kernel_conf ; configure devices and gui |
no_lib_load: |
end if |
; LOAD FONTS I and II |
628,8 → 658,9 |
mov edx, 0xFFFFFF |
mov ebx, [MEM_AMOUNT] |
shr ebx, 20 |
mov edi, 1 |
xor edi,edi |
mov eax, 0x00040000 |
inc edi |
call display_number_force |
; BUILD SCHEDULER |
646,7 → 677,7 |
mov esi,boot_windefs |
call boot_log |
call setwindowdefaults |
call set_window_defaults |
; SET BACKGROUND DEFAULTS |
686,10 → 717,7 |
add edi, 0x2000-512 |
mov dword [SLOT_BASE+256+APPDATA.fpu_state], edi |
mov dword [SLOT_BASE+256+APPDATA.saved_esp0], edi ; just for case |
mov dword [SLOT_BASE+256+APPDATA.io_map],\ |
(tss._io_map_0-OS_BASE+PG_MAP) |
mov dword [SLOT_BASE+256+APPDATA.io_map+4],\ |
(tss._io_map_1-OS_BASE+PG_MAP) |
; [SLOT_BASE+256+APPDATA.io_map] was set earlier |
mov esi, fpu_data |
mov ecx, 512/4 |
704,17 → 732,19 |
mov dword [SLOT_BASE+256+APPDATA.bk_obj], ebx |
mov dword [SLOT_BASE+256+APPDATA.cur_dir], sysdir_path |
mov dword [SLOT_BASE+256+APPDATA.tls_base], eax |
; task list |
mov [CURRENT_TASK],dword 1 |
mov [TASK_COUNT],dword 1 |
mov dword [TASK_DATA+TASKDATA.mem_start],eax ; process base address |
inc eax |
mov dword [CURRENT_TASK],eax |
mov dword [TASK_COUNT],eax |
mov [current_slot], SLOT_BASE+256 |
mov [TASK_BASE],dword TASK_DATA |
mov [TASK_DATA+TASKDATA.wnd_number], 1 ; on screen number |
mov [TASK_DATA+TASKDATA.pid], 1 ; process id number |
mov [TASK_DATA+TASKDATA.mem_start], 0 ; process base address |
mov byte[TASK_DATA+TASKDATA.wnd_number],al ; on screen number |
mov dword [TASK_DATA+TASKDATA.pid], eax ; process id number |
call init_cursors |
call init_display |
mov eax, [def_cursor] |
mov [SLOT_BASE+APPDATA.cursor],eax |
mov [SLOT_BASE+APPDATA.cursor+256],eax |
750,8 → 780,9 |
movzx ecx, word [boot_y] |
add ecx, (10+17*6) shl 16 - 10 ; 'CPU frequency is ' |
mov edx, 0xFFFFFF |
mov edi, 1 |
xor edi,edi |
mov eax, 0x00040000 |
inc edi |
call display_number_force |
; SET VARIABLES |
797,16 → 828,15 |
;protect io permission map |
mov esi, [default_io_map] |
stdcall map_page,esi,(tss._io_map_0-OS_BASE), PG_MAP |
stdcall map_page,esi,[SLOT_BASE+256+APPDATA.io_map], PG_MAP |
add esi, 0x1000 |
stdcall map_page,esi,(tss._io_map_1-OS_BASE), PG_MAP |
stdcall map_page,esi,[SLOT_BASE+256+APPDATA.io_map+4], PG_MAP |
stdcall map_page,tss._io_map_0,\ |
(tss._io_map_0-OS_BASE), PG_MAP |
[SLOT_BASE+256+APPDATA.io_map], PG_MAP |
stdcall map_page,tss._io_map_1,\ |
(tss._io_map_1-OS_BASE), PG_MAP |
[SLOT_BASE+256+APPDATA.io_map+4], PG_MAP |
; LOAD FIRST APPLICATION |
cli |
816,8 → 846,9 |
mov ebp, vrr_m |
call fs_execute_from_sysdir |
cmp eax,2 ; if vrr_m app found (PID=2) |
je first_app_found |
; cmp eax,2 ; if vrr_m app found (PID=2) |
sub eax,2 |
jz first_app_found |
no_load_vrr_m: |
824,8 → 855,9 |
mov ebp, firstapp |
call fs_execute_from_sysdir |
cmp eax,2 ; continue if a process has been loaded |
je first_app_found |
; cmp eax,2 ; continue if a process has been loaded |
sub eax,2 |
jz first_app_found |
mov esi, boot_failed |
call boot_log |
838,7 → 870,8 |
cli |
;mov [TASK_COUNT],dword 2 |
mov [CURRENT_TASK],dword 1 ; set OS task fisrt |
push 1 |
pop dword [CURRENT_TASK] ; set OS task fisrt |
; SET KEYBOARD PARAMETERS |
mov al, 0xf6 ; reset keyboard, scan enabled |
969,8 → 1002,9 |
mov bx,word [boot_y] |
add [boot_y],dword 10 |
mov ecx,0x80ffffff ; ASCIIZ string with white color |
xor edi,edi |
mov edx,esi |
mov edi,1 |
inc edi |
call dtext |
mov [novesachecksum],1000 |
980,7 → 1014,6 |
ret |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
; ; |
; MAIN OS LOOP START ; |
989,7 → 1022,7 |
align 32 |
osloop: |
call [draw_pointer] |
call checkbuttons |
call check_buttons |
call checkwindows |
; call check_window_move_request |
call checkmisc |
1055,51 → 1088,52 |
reserve_irqs_ports: |
pushad |
mov [irq_owner+4*0], 1 ; timer |
push eax |
xor eax,eax |
inc eax |
mov byte [irq_owner+4*0],al ;1 ; timer |
;mov [irq_owner+4*1], 1 ; keyboard |
mov [irq_owner+4*6], 1 ; floppy diskette |
mov [irq_owner+4*13], 1 ; math co-pros |
mov [irq_owner+4*14], 1 ; ide I |
mov [irq_owner+4*15], 1 ; ide II |
mov byte [irq_owner+4*6],al ;1 ; floppy diskette |
mov byte [irq_owner+4*13],al ;1 ; math co-pros |
mov byte [irq_owner+4*14],al ;1 ; ide I |
mov byte [irq_owner+4*15],al ;1 ; ide II |
pop eax |
; RESERVE PORTS |
mov edi,1 ; 0x00-0x2d |
mov [RESERVED_PORTS],edi |
shl edi,4 |
mov [RESERVED_PORTS+edi+0],dword 1 |
mov [RESERVED_PORTS+edi+4],dword 0x0 |
mov [RESERVED_PORTS+edi+8],dword 0x2d |
push 4 |
pop dword [RESERVED_PORTS] ;,edi |
inc dword [RESERVED_PORTS] ; 0x30-0x4d |
mov edi,[RESERVED_PORTS] |
shl edi,4 |
mov [RESERVED_PORTS+edi+0],dword 1 |
mov [RESERVED_PORTS+edi+4],dword 0x30 |
mov [RESERVED_PORTS+edi+8],dword 0x4d |
push 1 |
pop dword [RESERVED_PORTS+16+0] ;,dword 1 |
and dword [RESERVED_PORTS+16+4],0 ;,dword 0x0 |
mov dword [RESERVED_PORTS+16+8],0x2d ;,dword 0x2d |
inc dword [RESERVED_PORTS] ; 0x50-0xdf |
mov edi,[RESERVED_PORTS] |
shl edi,4 |
mov [RESERVED_PORTS+edi+0],dword 1 |
mov [RESERVED_PORTS+edi+4],dword 0x50 |
mov [RESERVED_PORTS+edi+8],dword 0xdf |
push 1 |
pop dword [RESERVED_PORTS+32+0] ;,dword 1 |
push 0x30 |
pop dword [RESERVED_PORTS+32+4] ;,dword 0x30 |
push 0x4d |
pop dword [RESERVED_PORTS+32+8] ;,dword 0x4d |
inc dword [RESERVED_PORTS] ; 0xe5-0xff |
mov edi,[RESERVED_PORTS] |
shl edi,4 |
mov [RESERVED_PORTS+edi+0],dword 1 |
mov [RESERVED_PORTS+edi+4],dword 0xe5 |
mov [RESERVED_PORTS+edi+8],dword 0xff |
push 1 |
pop dword [RESERVED_PORTS+48+0] ;,dword 1 |
push 0x50 |
pop dword [RESERVED_PORTS+48+4] ;,dword 0x50 |
mov dword [RESERVED_PORTS+48+8],0xdf ;,dword 0xdf |
popad |
push 1 |
pop dword [RESERVED_PORTS+64+0] ;,dword 1 |
mov dword [RESERVED_PORTS+64+4],0xe5 ;,dword 0xe5 |
mov dword [RESERVED_PORTS+64+8],0xff ;,dword 0xff |
ret |
setirqreadports: |
mov [irq12read+0],dword 0x60 + 0x01000000 ; read port 0x60 , byte |
mov [irq12read+4],dword 0 ; end of port list |
and dword [irq12read+4],0 ; end of port list |
; mov [irq12read+4],dword 0 ; end of port list |
;mov [irq04read+0],dword 0x3f8 + 0x01000000 ; read port 0x3f8 , byte |
;mov [irq04read+4],dword 0 ; end of port list |
;mov [irq03read+0],dword 0x2f8 + 0x01000000 ; read port 0x2f8 , byte |
1116,12 → 1150,8 |
mov ecx,0x100 ; flush port 0x60 |
.fl60: in al,0x60 |
loop .fl60 |
mov [MOUSE_BUFF_COUNT],byte 0 ; mouse buffer |
mov [KEY_COUNT],byte 0 ; keyboard buffer |
mov [BTN_COUNT],byte 0 ; button buffer |
; mov [MOUSE_X],dword 100*65536+100 ; mouse x/y |
push eax |
push eax |
mov ax,[BOOT_VAR+0x900c] |
shr ax,1 |
shl eax,16 |
1128,87 → 1158,86 |
mov ax,[BOOT_VAR+0x900A] |
shr ax,1 |
mov [MOUSE_X],eax |
pop eax |
xor eax,eax |
mov [BTN_ADDR],dword BUTTON_INFO ; address of button list |
mov byte [MOUSE_BUFF_COUNT],al ; mouse buffer |
mov byte [KEY_COUNT],al ; keyboard buffer |
mov byte [BTN_COUNT],al ; button buffer |
; mov [MOUSE_X],dword 100*65536+100 ; mouse x/y |
;!! IP 04.02.2005: |
mov byte [DONT_SWITCH], 0 ; change task if possible |
ret |
;* mouse centered - start code- Mario79 |
mouse_centered: |
push eax |
mov eax,[Screen_Max_X] |
shr eax,1 |
mov [MOUSE_X],ax |
mov eax,[Screen_Max_Y] |
shr eax,1 |
mov [MOUSE_Y],ax |
mov byte [DONT_SWITCH],al ; change task if possible |
pop eax |
ret |
;* mouse centered - end code- Mario79 |
align 4 |
;input eax=43,bl-byte of output, ecx - number of port |
sys_outport: |
mov edi,ebx ; separate flag for read / write |
and ebx,65535 |
mov edi,ecx ; separate flag for read / write |
and ecx,65535 |
mov ecx,[RESERVED_PORTS] |
test ecx,ecx |
jne sopl8 |
mov [esp+36],dword 1 |
mov eax,[RESERVED_PORTS] |
test eax,eax |
jnz .sopl8 |
inc eax |
mov [esp+32],eax |
ret |
sopl8: |
.sopl8: |
mov edx,[TASK_BASE] |
mov edx,[edx+0x4] |
and ebx,65535 |
cld |
sopl1: |
;and ecx,65535 |
;cld - set on interrupt 0x40 |
.sopl1: |
mov esi,ecx |
mov esi,eax |
shl esi,4 |
add esi,RESERVED_PORTS |
cmp edx,[esi+0] |
jne sopl2 |
cmp ebx,[esi+4] |
jb sopl2 |
cmp ebx,[esi+8] |
jg sopl2 |
jmp sopl3 |
jne .sopl2 |
cmp ecx,[esi+4] |
jb .sopl2 |
cmp ecx,[esi+8] |
jg .sopl2 |
.sopl3: |
sopl2: |
test edi,0x80000000 ; read ? |
jnz .sopl4 |
dec ecx |
jnz sopl1 |
mov [esp+36],dword 1 |
mov eax,ebx |
mov dx,cx ; write |
out dx,al |
and [esp+32],dword 0 |
ret |
sopl3: |
.sopl2: |
test edi,0x80000000 ; read ? |
jnz sopl4 |
mov dx,bx ; write |
out dx,al |
mov [esp+36],dword 0 |
dec eax |
jnz .sopl1 |
inc eax |
mov [esp+32],eax |
ret |
sopl4: |
mov dx,bx ; read |
.sopl4: |
mov dx,cx ; read |
in al,dx |
and eax,0xff |
mov [esp+36],dword 0 |
mov [esp+24],eax |
and [esp+32],dword 0 |
mov [esp+20],eax |
ret |
display_number: |
;It is not optimization |
mov eax, ebx |
mov ebx, ecx |
mov ecx, edx |
mov edx, esi |
mov esi, edi |
; eax = print type, al=0 -> ebx is number |
; al=1 -> ebx is pointer |
; ah=0 -> display decimal |
1248,8 → 1277,8 |
displnl1: |
sub esp,64 |
cmp ah,0 ; DECIMAL |
jne no_display_desnum |
test ah,ah ; DECIMAL |
jnz no_display_desnum |
shr eax,16 |
and eax,0xC03f |
; and eax,0x3f |
1406,18 → 1435,20 |
; 12 = enable pci access |
mov [esp+36],dword 0 |
cmp eax,1 ; MIDI |
and [esp+32],dword 0 |
dec ebx ; MIDI |
jnz nsyse1 |
cmp ebx,0x100 |
cmp ecx,0x100 |
jb nsyse1 |
mov edx,65535 |
cmp edx,ebx |
mov esi,65535 |
cmp esi,ecx |
jb nsyse1 |
mov [midi_base],bx |
mov word [mididp],bx |
inc bx |
mov word [midisp],bx |
mov [midi_base],cx ;bx |
mov word [mididp],cx ;bx |
inc cx ;bx |
mov word [midisp],cx ;bx |
ret |
iglobal |
1425,70 → 1456,69 |
endg |
nsyse1: |
dec ebx ; KEYBOARD |
jnz nsyse2 |
mov edi,[TASK_BASE] |
mov eax,[edi+TASKDATA.mem_start] |
add eax,edx |
cmp eax,2 ; KEYBOARD |
jnz nsyse2 |
cmp ebx,1 |
dec ecx |
jnz kbnobase |
mov edi,[TASK_BASE] |
add ecx,[edi+TASKDATA.mem_start] |
mov eax,ecx |
mov ebx,keymap |
mov ecx,128 |
call memmove |
ret |
kbnobase: |
cmp ebx,2 |
dec ecx |
jnz kbnoshift |
mov edi,[TASK_BASE] |
add ecx,[edi+TASKDATA.mem_start] |
mov eax,ecx |
mov ebx,keymap_shift |
mov ecx,128 |
call memmove |
ret |
kbnoshift: |
cmp ebx,3 |
jne kbnoalt |
mov edi,[TASK_BASE] |
add ecx,[edi+TASKDATA.mem_start] |
mov eax,ecx |
dec ecx |
jnz kbnoalt |
mov ebx,keymap_alt |
mov ecx,128 |
call memmove |
ret |
kbnoalt: |
cmp ebx,9 |
sub ecx,6 |
jnz kbnocountry |
mov word [keyboard],cx |
mov word [keyboard],dx |
ret |
kbnocountry: |
mov [esp+36],dword 1 |
mov [esp+32],dword 1 |
ret |
nsyse2: |
cmp eax,3 ; CD |
dec ebx ; CD |
jnz nsyse4 |
test ebx,ebx |
test ecx,ecx |
jz nosesl |
cmp ebx, 4 |
cmp ecx, 4 |
ja nosesl |
mov [cd_base],bl |
cmp ebx,1 |
mov [cd_base],cl |
dec ecx |
jnz noprma |
mov [cdbase],0x1f0 |
mov [cdid],0xa0 |
noprma: |
cmp ebx,2 |
dec ecx |
jnz noprsl |
mov [cdbase],0x1f0 |
mov [cdid],0xb0 |
noprsl: |
cmp ebx,3 |
dec ecx |
jnz nosema |
mov [cdbase],0x170 |
mov [cdid],0xa0 |
nosema: |
cmp ebx,4 |
dec ecx |
jnz nosesl |
mov [cdbase],0x170 |
mov [cdid],0xb0 |
1495,55 → 1525,63 |
nosesl: |
ret |
iglobal |
cd_base db 0 |
endg |
nsyse4: |
cmp eax,5 ; SYSTEM LANGUAGE |
sub ebx,2 ; SYSTEM LANGUAGE |
jnz nsyse5 |
mov [syslang],ebx |
mov [syslang],ecx |
ret |
nsyse5: |
cmp eax,7 ; HD BASE |
jne nsyse7 |
test ebx,ebx |
sub ebx,2 ; HD BASE |
jnz nsyse7 |
test ecx,ecx |
jz nosethd |
cmp ebx,4 |
cmp ecx,4 |
ja nosethd |
mov [hd_base],bl |
cmp ebx,1 |
mov [hd_base],cl |
cmp ecx,1 |
jnz noprmahd |
mov [hdbase],0x1f0 |
mov [hdid],0x0 |
mov [hdpos],1 |
and dword [hdid],0x0 |
mov dword [hdpos],ecx |
; call set_FAT32_variables |
noprmahd: |
cmp ebx,2 |
cmp ecx,2 |
jnz noprslhd |
mov [hdbase],0x1f0 |
mov [hdid],0x10 |
mov [hdpos],2 |
mov dword [hdpos],ecx |
; call set_FAT32_variables |
noprslhd: |
cmp ebx,3 |
cmp ecx,3 |
jnz nosemahd |
mov [hdbase],0x170 |
mov [hdid],0x0 |
mov [hdpos],3 |
and dword [hdid],0x0 |
mov dword [hdpos],ecx |
; call set_FAT32_variables |
nosemahd: |
cmp ebx,4 |
cmp ecx,4 |
jnz noseslhd |
mov [hdbase],0x170 |
mov [hdid],0x10 |
mov [hdpos],4 |
mov dword [hdpos],ecx |
; call set_FAT32_variables |
noseslhd: |
call reserve_hd1 |
call reserve_hd_channel |
call free_hd_channel |
mov [hd1_status],0 ; free |
and dword [hd1_status],0 ; free |
nosethd: |
ret |
1553,31 → 1591,33 |
nsyse7: |
cmp eax,8 ; HD PARTITION |
jne nsyse8 |
mov [fat32part],ebx |
; cmp eax,8 ; HD PARTITION |
dec ebx |
jnz nsyse8 |
mov [fat32part],ecx |
; call set_FAT32_variables |
call reserve_hd1 |
call reserve_hd_channel |
call free_hd_channel |
pusha |
; pusha |
call choice_necessity_partition_1 |
popa |
mov [hd1_status],0 ; free |
; popa |
and dword [hd1_status],0 ; free |
ret |
nsyse8: |
cmp eax,11 ; ENABLE LBA READ |
jne no_set_lba_read |
and ebx,1 |
mov [lba_read_enabled],ebx |
; cmp eax,11 ; ENABLE LBA READ |
and ecx,1 |
sub ebx,3 |
jnz no_set_lba_read |
mov [lba_read_enabled],ecx |
ret |
no_set_lba_read: |
cmp eax,12 ; ENABLE PCI ACCESS |
jne no_set_pci_access |
and ebx,1 |
mov [pci_access_enabled],ebx |
; cmp eax,12 ; ENABLE PCI ACCESS |
dec ebx |
jnz no_set_pci_access |
mov [pci_access_enabled],ecx |
ret |
no_set_pci_access: |
1586,7 → 1626,7 |
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
sys_setup_err: |
mov [esp+36],dword -1 |
or [esp+32],dword -1 |
ret |
align 4 |
1601,97 → 1641,109 |
; 8=fat32 partition in hd |
; 9=get hs timer tic |
cmp eax,1 |
jne ngsyse1 |
; cmp eax,1 |
dec ebx |
jnz ngsyse1 |
movzx eax,[midi_base] |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
ngsyse1: |
; cmp eax,2 |
dec ebx |
jnz ngsyse2 |
cmp eax,2 |
jne ngsyse2 |
cmp ebx,1 |
mov edi,[TASK_BASE] |
mov ebx,[edi+TASKDATA.mem_start] |
add ebx,edx |
; cmp ebx,1 |
dec ecx |
jnz kbnobaseret |
mov edi,[TASK_BASE] |
add ecx,[edi+TASKDATA.mem_start] |
mov ebx,ecx |
mov eax,keymap |
mov ecx,128 |
call memmove |
ret |
kbnobaseret: |
cmp ebx,2 |
; cmp ebx,2 |
dec ecx |
jnz kbnoshiftret |
mov edi,[TASK_BASE] |
add ecx,[edi+TASKDATA.mem_start] |
mov ebx,ecx |
mov eax,keymap_shift |
mov ecx,128 |
call memmove |
ret |
kbnoshiftret: |
cmp ebx,3 |
; cmp ebx,3 |
dec ecx |
jne kbnoaltret |
mov edi,[TASK_BASE] |
add ecx,[edi+TASKDATA.mem_start] |
mov ebx,ecx |
mov eax,keymap_alt |
mov ecx,128 |
call memmove |
ret |
kbnoaltret: |
cmp ebx,9 |
; cmp ebx,9 |
sub ecx,6 |
jnz ngsyse2 |
movzx eax,word [keyboard] |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
ngsyse2: |
cmp eax,3 |
; cmp eax,3 |
dec ebx |
jnz ngsyse3 |
movzx eax,[cd_base] |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
ngsyse3: |
cmp eax,5 |
; cmp eax,5 |
sub ebx,2 |
jnz ngsyse5 |
mov eax,[syslang] |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
ngsyse5: |
cmp eax,7 |
; cmp eax,7 |
sub ebx,2 |
jnz ngsyse7 |
movzx eax,[hd_base] |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
ngsyse7: |
cmp eax,8 |
; cmp eax,8 |
dec ebx |
jnz ngsyse8 |
mov eax,[fat32part] |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
ngsyse8: |
cmp eax,9 |
jne ngsyse9 |
; cmp eax,9 |
dec ebx |
jnz ngsyse9 |
mov eax,[timer_ticks] ;[0xfdf0] |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
ngsyse9: |
cmp eax,11 |
; cmp eax,11 |
sub ebx,2 |
jnz ngsyse11 |
mov eax,[lba_read_enabled] |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
ngsyse11: |
cmp eax,12 |
; cmp eax,12 |
dec ebx |
jnz ngsyse12 |
mov eax,[pci_access_enabled] |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
ngsyse12: |
mov [esp+36],dword 1 |
mov [esp+32],dword 1 |
ret |
get_timer_ticks: |
mov eax,[timer_ticks] |
ret |
1716,14 → 1768,14 |
; eax=6 delete cursor ; reserved |
; eax=7 get mouse_z |
cmp eax, 7 |
cmp ebx, 7 |
ja msset |
jmp [mousefn+eax*4] |
jmp [mousefn+ebx*4] |
msscreen: |
mov eax,[MOUSE_X] |
shl eax,16 |
mov ax,[MOUSE_Y] |
mov [esp+36],eax |
mov [esp+36-4],eax |
ret |
mswin: |
mov eax,[MOUSE_X] |
1741,11 → 1793,11 |
rol eax,16 |
sub ax,word[edi+SLOT_BASE+APPDATA.wnd_clientbox.left] |
rol eax,16 |
mov [esp+36],eax |
mov [esp+36-4],eax |
ret |
msbutton: |
movzx eax,byte [BTN_DOWN] |
mov [esp+36],eax |
mov [esp+36-4],eax |
ret |
msz: |
mov edi, [TASK_COUNT] |
1755,32 → 1807,31 |
mov ax,[MOUSE_SCROLL_H] |
shl eax,16 |
mov ax,[MOUSE_SCROLL_V] |
mov [esp+36],eax |
mov [MOUSE_SCROLL_H],word 0 |
mov [MOUSE_SCROLL_V],word 0 |
mov [esp+36-4],eax |
and [MOUSE_SCROLL_H],word 0 |
and [MOUSE_SCROLL_V],word 0 |
ret |
@@: |
mov [esp+36],dword 0 |
ret |
and [esp+36-4],dword 0 |
; ret |
msset: |
ret |
app_load_cursor: |
; add ebx, new_app_base |
cmp ebx, OS_BASE |
cmp ecx, OS_BASE |
jae msset |
stdcall load_cursor, ebx, ecx |
mov [esp+36], eax |
stdcall load_cursor, ecx, edx |
mov [esp+36-4], eax |
ret |
app_set_cursor: |
stdcall set_cursor, ebx |
mov [esp+36], eax |
stdcall set_cursor, ecx |
mov [esp+36-4], eax |
ret |
app_delete_cursor: |
stdcall delete_cursor, ebx |
mov [esp+36], eax |
stdcall delete_cursor, ecx |
mov [esp+36-4], eax |
ret |
is_input: |
1820,11 → 1871,22 |
ret |
setuart: |
align 4 |
sys_midi: |
cmp [mididp],0 |
jnz sm0 |
mov [esp+36],dword 1 |
ret |
sm0: |
and [esp+36],dword 0 |
dec ebx |
jnz smn1 |
; call setuart |
su1: |
call is_output |
cmp al,0 |
test al,al |
jnz su1 |
mov dx,word [midisp] |
mov al,0xff |
1834,7 → 1896,7 |
mov al,0xff |
out dx,al |
call is_input |
cmp al,0 |
test al,al |
jnz su2 |
call get_mpu_in |
cmp al,0xfe |
1841,33 → 1903,14 |
jnz su2 |
su3: |
call is_output |
cmp al,0 |
test al,al |
jnz su3 |
mov dx,word [midisp] |
mov al,0x3f |
out dx,al |
ret |
align 4 |
sys_midi: |
cmp [mididp],0 |
jnz sm0 |
mov [esp+36],dword 1 |
ret |
sm0: |
cmp eax,1 |
mov [esp+36],dword 0 |
jnz smn1 |
call setuart |
ret |
smn1: |
cmp eax,2 |
dec ebx |
jnz smn2 |
sm10: |
call get_mpu_in |
1876,12 → 1919,9 |
jnz sm10 |
mov al,bl |
call put_mpu_out |
ret |
smn2: |
ret |
detect_devices: |
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
;include 'detect/commouse.inc' |
1892,9 → 1932,16 |
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
ret |
sys_end: |
mov ecx, [current_slot] |
mov eax, [ecx+APPDATA.tls_base] |
test eax, eax |
jz @F |
stdcall user_free, eax |
@@: |
mov eax,[TASK_BASE] |
mov [eax+TASKDATA.state], 3 ; terminate this program |
1977,7 → 2024,7 |
cmp edx,[application_table_status] ; clear app table stat |
jne noatsc |
mov [application_table_status],0 |
and [application_table_status],0 |
noatsc: |
noprocessterminate: |
ret |
2000,7 → 2047,7 |
mov ecx,eax |
cli |
call sysfn_terminate |
mov [application_table_status],0 |
and [application_table_status],0 |
sti |
and dword [esp+32],0 |
ret |
2044,7 → 2091,7 |
;!!!!!!!!!!!!!!!!!!!!!!!! |
include 'blkdev/rdsave.inc' |
;!!!!!!!!!!!!!!!!!!!!!!!! |
align 4 |
sysfn_getactive: ; 18.7 = get active window |
mov eax, [TASK_COUNT] |
movzx eax, word [WIN_POS + eax*2] |
2052,13 → 2099,15 |
ret |
sysfn_sound_flag: ; 18.8 = get/set sound_flag |
cmp ecx,1 |
jne nogetsoundflag |
; cmp ecx,1 |
dec ecx |
jnz nogetsoundflag |
movzx eax,byte [sound_flag] ; get sound_flag |
mov [esp+32],eax |
ret |
nogetsoundflag: |
cmp ecx,2 |
; cmp ecx,2 |
dec ecx |
jnz nosoundflag |
xor byte [sound_flag], 1 |
nosoundflag: |
2067,9 → 2116,10 |
sysfn_minimize: ; 18.10 = minimize window |
mov [window_minimize],1 |
ret |
align 4 |
sysfn_getdiskinfo: ; 18.11 = get disk info table |
cmp ecx,1 |
; cmp ecx,1 |
dec ecx |
jnz full_table |
small_table: |
call for_all_tables |
2082,7 → 2132,8 |
mov esi,DRIVE_DATA |
ret |
full_table: |
cmp ecx,2 |
; cmp ecx,2 |
dec ecx |
jnz exit_for_anyone |
call for_all_tables |
mov ecx,16384 |
2112,13 → 2163,29 |
and [esp+32],dword 0 |
ret |
align 4 |
sysfn_centermouse: ; 18.15 = mouse centered |
call mouse_centered |
and [esp+32],dword 0 |
; removed here by <Lrz> |
; call mouse_centered |
;* mouse centered - start code- Mario79 |
;mouse_centered: |
; push eax |
mov eax,[Screen_Max_X] |
shr eax,1 |
mov [MOUSE_X],ax |
mov eax,[Screen_Max_Y] |
shr eax,1 |
mov [MOUSE_Y],ax |
; ret |
;* mouse centered - end code- Mario79 |
xor eax,eax |
and [esp+32],eax |
; pop eax |
ret |
align 4 |
sysfn_mouse_acceleration: ; 18.19 = set/get mouse features |
cmp ecx,0 ; get mouse speed factor |
test ecx,ecx ; get mouse speed factor |
jnz .set_mouse_acceleration |
xor eax,eax |
mov ax,[mouse_speed_factor] |
2125,23 → 2192,27 |
mov [esp+32],eax |
ret |
.set_mouse_acceleration: |
cmp ecx,1 ; set mouse speed factor |
; cmp ecx,1 ; set mouse speed factor |
dec ecx |
jnz .get_mouse_delay |
mov [mouse_speed_factor],dx |
ret |
.get_mouse_delay: |
cmp ecx,2 ; get mouse delay |
; cmp ecx,2 ; get mouse delay |
dec ecx |
jnz .set_mouse_delay |
mov eax,[mouse_delay] |
mov [esp+32],eax |
ret |
.set_mouse_delay: |
cmp ecx,3 ; set mouse delay |
; cmp ecx,3 ; set mouse delay |
dec ecx |
jnz .set_pointer_position |
mov [mouse_delay],edx |
ret |
.set_pointer_position: |
cmp ecx,4 ; set mouse pointer position |
; cmp ecx,4 ; set mouse pointer position |
dec ecx |
jnz .set_mouse_button |
mov [MOUSE_Y],dx ;y |
ror edx,16 |
2149,7 → 2220,8 |
rol edx,16 |
ret |
.set_mouse_button: |
cmp ecx,5 ; set mouse button features |
; cmp ecx,5 ; set mouse button features |
dec ecx |
jnz .end |
mov [BTN_DOWN],dl |
mov [mouse_active],1 |
2217,7 → 2289,7 |
iglobal |
version_inf: |
db 0,7,5,0 ; version 0.7.5.0 |
db 0,7,7,0 ; version 0.7.7.0 |
db UID_KOLIBRI |
dd __REV__ |
version_end: |
2257,10 → 2329,12 |
cmp ebx,1 ; BACKGROUND SIZE |
jnz nosb1 |
cmp ecx,0 |
je sbgrr |
cmp edx,0 |
je sbgrr |
test ecx,ecx |
; cmp ecx,0 |
jz sbgrr |
test edx,edx |
; cmp edx,0 |
jz sbgrr |
@@: |
;;Maxis use atomic bts for mutexes 4.4.2009 |
bts dword [bgrlock], 0 |
2446,6 → 2520,7 |
jnp .err |
push eax |
shr ecx, 12 |
dec ecx |
@@: |
and dword [page_tabs+eax*4], 0 |
mov edx, eax |
2470,8 → 2545,8 |
ret |
force_redraw_background: |
mov [draw_data+32 + RECT.left],dword 0 |
mov [draw_data+32 + RECT.top],dword 0 |
and [draw_data+32 + RECT.left],dword 0 |
and [draw_data+32 + RECT.top],dword 0 |
push eax ebx |
mov eax,[Screen_Max_X] |
mov ebx,[Screen_Max_Y] |
2484,49 → 2559,50 |
align 4 |
sys_getbackground: |
cmp eax,1 ; SIZE |
; cmp eax,1 ; SIZE |
dec ebx |
jnz nogb1 |
mov eax,[BgrDataWidth] |
shl eax,16 |
mov ax,[BgrDataHeight] |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
nogb1: |
cmp eax,2 ; PIXEL |
; cmp eax,2 ; PIXEL |
dec ebx |
jnz nogb2 |
mov eax, [img_background] |
test ebx, ebx |
test ecx, ecx |
jz @f |
cmp eax, static_background_data |
jz .ret |
@@: |
mov ecx, [mem_BACKGROUND] |
add ecx, 4095 |
and ecx, -4096 |
sub ecx, 4 |
cmp ebx, ecx |
mov ebx, [mem_BACKGROUND] |
add ebx, 4095 |
and ebx, -4096 |
sub ebx, 4 |
cmp ecx, ebx |
ja .ret |
mov eax,[ebx+eax] |
mov eax,[ecx+eax] |
and eax, 0xFFFFFF |
mov [esp+36],eax |
mov [esp+32],eax |
.ret: |
ret |
nogb2: |
cmp eax,4 ; TILED / STRETCHED |
; cmp eax,4 ; TILED / STRETCHED |
dec ebx |
dec ebx |
jnz nogb4 |
mov eax,[BgrDrawMode] |
nogb4: |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
align 4 |
sys_getkey: |
2832,9 → 2908,9 |
; cmp eax,0 ; type I - original style |
jne nosyswI |
inc [mouse_pause] |
call [disable_mouse] |
call [_display.disable_mouse] |
call sys_set_window |
call [disable_mouse] |
call [_display.disable_mouse] |
call drawwindow_I |
;dec [mouse_pause] |
;call [draw_pointer] |
2845,9 → 2921,9 |
cmp al,1 ; type II - only reserve area, no draw |
jne nosyswII |
inc [mouse_pause] |
call [disable_mouse] |
call [_display.disable_mouse] |
call sys_set_window |
call [disable_mouse] |
call [_display.disable_mouse] |
call sys_window_mouse |
dec [mouse_pause] |
call [draw_pointer] |
2857,9 → 2933,9 |
cmp al,2 ; type III - new style |
jne nosyswIII |
inc [mouse_pause] |
call [disable_mouse] |
call [_display.disable_mouse] |
call sys_set_window |
call [disable_mouse] |
call [_display.disable_mouse] |
call drawwindow_III |
;dec [mouse_pause] |
;call [draw_pointer] |
2874,9 → 2950,9 |
draw_skin_window: |
inc [mouse_pause] |
call [disable_mouse] |
call [_display.disable_mouse] |
call sys_set_window |
call [disable_mouse] |
call [_display.disable_mouse] |
mov eax, [TASK_COUNT] |
movzx eax, word [WIN_POS + eax*2] |
cmp eax, [CURRENT_TASK] |
2895,7 → 2971,7 |
draw_window_caption: |
inc [mouse_pause] |
call [disable_mouse] |
call [_display.disable_mouse] |
xor eax,eax |
mov edx,[TASK_COUNT] |
3159,8 → 3235,8 |
syscall_windowsettings: |
.set_window_caption: |
dec eax ; subfunction #1 - set window caption |
jnz .get_window_caption |
dec ebx ; subfunction #1 - set window caption |
jnz .exit_fail |
; NOTE: only window owner thread can set its caption, |
; so there's no parameter for PID/TID |
3178,7 → 3254,7 |
; cmp ebx,ecx |
; ja .exit_fail |
mov [edi*8+SLOT_BASE+APPDATA.wnd_caption],ebx |
mov [edi*8+SLOT_BASE+APPDATA.wnd_caption],ecx |
or [edi+window_data+WDATA.fl_wstyle],WSTYLE_HASCAPTION |
call draw_window_caption |
3186,9 → 3262,9 |
xor eax,eax ; eax = 0 (success) |
ret |
.get_window_caption: |
dec eax ; subfunction #2 - get window caption |
jnz .exit_fail |
; .get_window_caption: |
; dec eax ; subfunction #2 - get window caption |
; jnz .exit_fail |
; not implemented yet |
3264,10 → 3340,10 |
pop eax |
add ecx,eax |
add edx,ebx |
mov [dlx],eax ; save for drawlimits |
mov [dly],ebx |
mov [dlxe],ecx |
mov [dlye],edx |
mov [draw_limits.left],eax ; save for drawlimits |
mov [draw_limits.top],ebx |
mov [draw_limits.right],ecx |
mov [draw_limits.bottom],edx |
call calculatescreen |
mov [edi + WDATA.fl_redraw], 1 ; flag the process as redraw |
3313,67 → 3389,76 |
;3 - rdmsr. Counter in edx. (edx:eax) [esi:edi, edx] => [edx:esi, ecx]. Ret in ebx:eax. Block. ok. |
;4 - wrmsr. Counter in edx. (edx:eax) [esi:edi, edx] => [edx:esi, ecx]. Ret in ebx:eax. Block. ok. |
;--------------------------------------------------------------------------------------------- |
sys_sheduler: ;noname & halyavin |
cmp eax,0 |
je shed_counter |
cmp eax,2 |
je perf_control |
cmp eax,3 |
je rdmsr_instr |
cmp eax,4 |
je wrmsr_instr |
cmp eax,1 |
jne not_supported |
call change_task ;delay,0 |
ret |
shed_counter: |
iglobal |
align 4 |
sheduler: |
dd sys_sheduler.00 |
dd change_task |
dd sys_sheduler.02 |
dd sys_sheduler.03 |
dd sys_sheduler.04 |
endg |
sys_sheduler: |
;rewritten by <Lrz> 29.12.2009 |
jmp dword [sheduler+ebx*4] |
;.shed_counter: |
.00: |
mov eax,[context_counter] |
mov [esp+36],eax |
not_supported: |
mov [esp+32],eax |
ret |
perf_control: |
inc eax ;now eax=3 |
cmp ebx,eax |
je cache_disable |
dec eax |
cmp ebx,eax |
je cache_enable |
dec eax |
cmp ebx,eax |
je is_cache_enabled |
dec eax |
cmp ebx,eax |
je modify_pce |
.02: |
;.perf_control: |
inc ebx ;before ebx=2, ebx=3 |
cmp ebx,ecx ;if ecx=3, ebx=3 |
jz cache_disable |
dec ebx ;ebx=2 |
cmp ebx,ecx ; |
jz cache_enable ;if ecx=2 and ebx=2 |
dec ebx ;ebx=1 |
cmp ebx,ecx |
jz is_cache_enabled ;if ecx=1 and ebx=1 |
dec ebx |
test ebx,ecx ;ebx=0 and ecx=0 |
jz modify_pce ;if ecx=0 |
ret |
rdmsr_instr: |
.03: |
;.rdmsr_instr: |
;now counter in ecx |
;(edx:eax) esi:edi => edx:esi |
mov eax,esi |
mov ecx,edx |
rdmsr |
mov [esp+36],eax |
mov [esp+24],edx ;ret in ebx? |
mov [esp+32],eax |
mov [esp+20],edx ;ret in ebx? |
ret |
wrmsr_instr: |
.04: |
;.wrmsr_instr: |
;now counter in ecx |
;(edx:eax) esi:edi => edx:esi |
; Fast Call MSR can't be destroy |
; Íî MSR_AMD_EFER ìîæíî èçìåíÿòü, ò.ê. â ýòîì ðåãèñòðå ëèø |
; âêëþ÷àþòñÿ/âûêëþ÷àþòñÿ ðàñøèðåííûå âîçìîæíîñòè |
cmp ecx, MSR_SYSENTER_CS |
; ® MSR_AMD_EFER ¬®¦® ¨§¬¥ïâì, â.ª. ¢ í⮬ ॣ¨áâॠ«¨è |
; ¢ª«îç îâáï/¢ëª«îç îâáï à áè¨à¥ë¥ ¢®§¬®¦®á⨠|
cmp edx,MSR_SYSENTER_CS |
je @f |
cmp ecx, MSR_SYSENTER_ESP |
cmp edx,MSR_SYSENTER_ESP |
je @f |
cmp ecx, MSR_SYSENTER_EIP |
cmp edx,MSR_SYSENTER_EIP |
je @f |
cmp ecx, MSR_AMD_STAR |
cmp edx,MSR_AMD_STAR |
je @f |
mov eax, esi |
mov ecx,edx |
wrmsr |
; mov [esp + 36], eax |
; mov [esp + 24], edx ;ret in ebx? |
; mov [esp + 32], eax |
; mov [esp + 20], edx ;ret in ebx? |
@@: |
ret |
3395,9 → 3480,9 |
mov ebx,eax |
and eax,01100000000000000000000000000000b |
jz cache_disabled |
mov [esp+36],ebx |
mov [esp+32],ebx |
cache_disabled: |
mov dword [esp+36],eax ;0 |
mov dword [esp+32],eax ;0 |
ret |
modify_pce: |
3407,7 → 3492,7 |
; xor eax,ebx ;invert pce |
bts eax,8 ;pce=cr4[8] |
mov cr4,eax |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
;--------------------------------------------------------------------------------------------- |
3420,7 → 3505,8 |
mov edx,[Screen_Max_X] ; screen x size |
inc edx |
imul edx, ebx |
mov dl, [eax+edx+display_data] ; lea eax, [...] |
add eax, [_WinMapAddress] |
mov dl, [eax+edx] ; lea eax, [...] |
xor ecx, ecx |
mov eax, [CURRENT_TASK] |
3509,7 → 3595,7 |
no_mark_system_shutdown: |
call [disable_mouse] |
call [_display.disable_mouse] |
dec byte [SYS_SHUTDOWN] |
je system_shutdown |
3572,11 → 3658,11 |
add ecx,eax |
add edx,ebx |
mov ecx,[dlye] ; ecx = area y end ebx = window y start |
mov ecx,[draw_limits.bottom] ; ecx = area y end ebx = window y start |
cmp ecx,ebx |
jb ricino |
mov ecx,[dlxe] ; ecx = area x end eax = window x start |
mov ecx,[draw_limits.right] ; ecx = area x end eax = window x start |
cmp ecx,eax |
jb ricino |
3587,11 → 3673,11 |
add ecx, eax |
add edx, ebx |
mov eax,[dly] ; eax = area y start edx = window y end |
mov eax,[draw_limits.top] ; eax = area y start edx = window y end |
cmp edx,eax |
jb ricino |
mov eax,[dlx] ; eax = area x start ecx = window x end |
mov eax,[draw_limits.left] ; eax = area x start ecx = window x end |
cmp ecx,eax |
jb ricino |
3605,22 → 3691,22 |
test al,al |
jz .az |
lea eax,[edi+draw_data-window_data] |
mov ebx,[dlx] |
mov ebx,[draw_limits.left] |
cmp ebx,[eax+RECT.left] |
jae @f |
mov [eax+RECT.left],ebx |
@@: |
mov ebx,[dly] |
mov ebx,[draw_limits.top] |
cmp ebx,[eax+RECT.top] |
jae @f |
mov [eax+RECT.top],ebx |
@@: |
mov ebx,[dlxe] |
mov ebx,[draw_limits.right] |
cmp ebx,[eax+RECT.right] |
jbe @f |
mov [eax+RECT.right],ebx |
@@: |
mov ebx,[dlye] |
mov ebx,[draw_limits.bottom] |
cmp ebx,[eax+RECT.bottom] |
jbe @f |
mov [eax+RECT.bottom],ebx |
3631,13 → 3717,13 |
mov eax,edi |
add eax,draw_data-window_data |
mov ebx,[dlx] ; set limits |
mov ebx,[draw_limits.left] ; set limits |
mov [eax + RECT.left], ebx |
mov ebx,[dly] |
mov ebx,[draw_limits.top] |
mov [eax + RECT.top], ebx |
mov ebx,[dlxe] |
mov ebx,[draw_limits.right] |
mov [eax + RECT.right], ebx |
mov ebx,[dlye] |
mov ebx,[draw_limits.bottom] |
mov [eax + RECT.bottom], ebx |
sub eax,draw_data-window_data |
3667,9 → 3753,10 |
calculatebackground: ; background |
mov edi,display_data ; set os to use all pixels |
mov edi, [_WinMapAddress] ; set os to use all pixels |
mov eax,0x01010101 |
mov ecx,1280*1024 / 4 |
mov ecx, [_WinMapSize] |
shr ecx, 2 |
rep stosd |
mov byte [REDRAW_BACKGROUND], 0 ; do not draw background! |
3745,7 → 3832,7 |
ret |
align 16 ;very often call this subrutine |
memmove: ; memory move in bytes |
; eax = from |
3754,7 → 3841,6 |
test ecx, ecx |
jle .ret |
push esi edi ecx |
mov edi, ebx |
3925,43 → 4011,41 |
set_io_access_rights: |
pushad |
push edi eax |
mov edi, tss._io_map_0 |
; mov ecx,eax |
; and ecx,7 ; offset in byte |
; shr eax,3 ; number of byte |
; add edi,eax |
; mov ebx,1 |
; shl ebx,cl |
cmp ebp,0 ; enable access - ebp = 0 |
jne siar1 |
test ebp,ebp |
; cmp ebp,0 ; enable access - ebp = 0 |
jnz siar1 |
; not ebx |
; and [edi],byte bl |
btr [edi], eax |
popad |
pop eax edi |
ret |
siar1: |
bts [edi], eax |
; or [edi],byte bl ; disable access - ebp = 1 |
popad |
pop eax edi |
ret |
;reserve/free group of ports |
; * eax = 46 - number function |
; * ebx = 0 - reserve, 1 - free |
; * ecx = number start arrea of ports |
; * edx = number end arrea of ports (include last number of port) |
;Return value: |
; * eax = 0 - succesful |
; * eax = 1 - error |
; * The system has reserve this ports: |
; 0..0x2d, 0x30..0x4d, 0x50..0xdf, 0xe5..0xff (include last number of port). |
;destroys eax,ebx, ebp |
r_f_port_area: |
test eax, eax |
test ebx, ebx |
jnz free_port_area |
; je r_port_area |
; jmp free_port_area |
3968,78 → 4052,70 |
; r_port_area: |
pushad |
; pushad |
cmp ebx,ecx ; beginning > end ? |
cmp ecx,edx ; beginning > end ? |
ja rpal1 |
cmp ecx,65536 |
cmp edx,65536 |
jae rpal1 |
mov esi,[RESERVED_PORTS] |
test esi,esi ; no reserved areas ? |
mov eax,[RESERVED_PORTS] |
test eax,eax ; no reserved areas ? |
je rpal2 |
cmp esi,255 ; max reserved |
cmp eax,255 ; max reserved |
jae rpal1 |
rpal3: |
mov edi,esi |
shl edi,4 |
add edi,RESERVED_PORTS |
cmp ebx,[edi+8] |
mov ebx,eax |
shl ebx,4 |
add ebx,RESERVED_PORTS |
cmp ecx,[ebx+8] |
ja rpal4 |
cmp ecx,[edi+4] |
cmp edx,[ebx+4] |
jae rpal1 |
; jb rpal4 |
; jmp rpal1 |
rpal4: |
dec esi |
dec eax |
jnz rpal3 |
jmp rpal2 |
rpal1: |
popad |
mov eax,1 |
; popad |
; mov eax,1 |
xor eax,eax |
inc eax |
ret |
rpal2: |
popad |
; popad |
; enable port access at port IO map |
cli |
pushad ; start enable io map |
cmp ecx,65536 ;16384 |
cmp edx,65536 ;16384 |
jae no_unmask_io ; jge |
mov eax,ebx |
mov eax,ecx |
; push ebp |
xor ebp,ebp ; enable - eax = port |
new_port_access: |
pushad |
xor ebp,ebp ; enable - eax = port |
; pushad |
call set_io_access_rights |
popad |
; popad |
inc eax |
cmp eax,ecx |
cmp eax,edx |
jbe new_port_access |
; pop ebp |
no_unmask_io: |
popad ; end enable io map |
sti |
mov edi,[RESERVED_PORTS] |
add edi,1 |
mov [RESERVED_PORTS],edi |
shl edi,4 |
add edi,RESERVED_PORTS |
mov esi,[TASK_BASE] |
mov esi,[esi+TASKDATA.pid] |
mov [edi],esi |
mov [edi+4],ebx |
mov [edi+8],ecx |
mov eax,[RESERVED_PORTS] |
add eax,1 |
mov [RESERVED_PORTS],eax |
shl eax,4 |
add eax,RESERVED_PORTS |
mov ebx,[TASK_BASE] |
mov ebx,[ebx+TASKDATA.pid] |
mov [eax],ebx |
mov [eax+4],ecx |
mov [eax+8],edx |
xor eax, eax |
ret |
4046,34 → 4122,34 |
free_port_area: |
pushad |
mov esi,[RESERVED_PORTS] ; no reserved areas ? |
test esi,esi |
je frpal2 |
mov edx,[TASK_BASE] |
mov edx,[edx+TASKDATA.pid] |
; pushad |
mov eax,[RESERVED_PORTS] ; no reserved areas ? |
test eax,eax |
jz frpal2 |
mov ebx,[TASK_BASE] |
mov ebx,[ebx+TASKDATA.pid] |
frpal3: |
mov edi,esi |
mov edi,eax |
shl edi,4 |
add edi,RESERVED_PORTS |
cmp edx,[edi] |
cmp ebx,[edi] |
jne frpal4 |
cmp ebx,[edi+4] |
cmp ecx,[edi+4] |
jne frpal4 |
cmp ecx,[edi+8] |
cmp edx,[edi+8] |
jne frpal4 |
jmp frpal1 |
frpal4: |
dec esi |
dec eax |
jnz frpal3 |
frpal2: |
popad |
mov eax,1 |
; popad |
inc eax |
ret |
frpal1: |
push ecx |
mov ecx,256 |
sub ecx,esi |
sub ecx,eax |
shl ecx,4 |
mov esi,edi |
add esi,16 |
4081,36 → 4157,27 |
rep movsb |
dec dword [RESERVED_PORTS] |
popad |
;popad |
; disable port access at port IO map |
pushad ; start disable io map |
cmp ecx,65536 ;16384 |
; pushad ; start disable io map |
pop eax ;start port |
cmp edx,65536 ;16384 |
jge no_mask_io |
mov eax,ebx |
; mov eax,ecx |
xor ebp,ebp |
inc ebp |
new_port_access_disable: |
pushad |
mov ebp,1 ; disable - eax = port |
; pushad |
; mov ebp,1 ; disable - eax = port |
call set_io_access_rights |
popad |
; popad |
inc eax |
cmp eax,ecx |
cmp eax,edx |
jbe new_port_access_disable |
no_mask_io: |
popad ; end disable io map |
; popad ; end disable io map |
xor eax, eax |
ret |
4805,13 → 4872,13 |
push dx ax |
@@: ; wait for empty transmit register |
@@: ; Wait for empty transmit register (yes, this slows down system..) |
mov dx, debug_com_base+5 |
in al, dx |
test al, 1 shl 5 |
jz @r |
mov dx, debug_com_base ; TODO: replace this with variable |
mov dx, debug_com_base ; Output the byte |
mov al, bl |
out dx, al |
4819,7 → 4886,6 |
end if |
mov [msg_board_data+ecx],bl |
inc ecx |
and ecx, 4095 |
4991,7 → 5057,7 |
ret |
no_gs3: |
mov [esp+36],dword -1 |
or [esp+36],dword -1 |
ret |
5019,7 → 5085,7 |
add ebx, [edi+APPDATA.wnd_clientbox.top] |
xor edi, edi ; no force |
; mov edi, 1 |
call [disable_mouse] |
call [_display.disable_mouse] |
jmp [putpixel] |
align 4 |
5093,37 → 5159,39 |
syscall_cdaudio: ; CD |
cmp eax, 4 |
cmp ebx, 4 |
jb .audio |
jz .eject |
cmp eax, 5 |
cmp ebx, 5 |
jnz .ret |
.load: |
call .reserve |
call LoadMedium |
call .free |
ret |
;call .free |
jmp .free |
; ret |
.eject: |
call .reserve |
call clear_CD_cache |
call allow_medium_removal |
call EjectMedium |
call .free |
ret |
; call .free |
jmp .free |
; ret |
.audio: |
call sys_cd_audio |
mov [esp+36],eax |
mov [esp+36-4],eax |
.ret: |
ret |
.reserve: |
call reserve_cd |
mov eax, ebx |
mov eax, ecx |
shr eax, 1 |
and eax, 1 |
inc eax |
mov [ChannelNumber], ax |
mov eax, ebx |
mov eax, ecx |
and eax, 1 |
mov [DiskNumber], al |
call reserve_cd_channel |
5136,7 → 5204,7 |
mov al, [DRIVE_DATA+1] |
shr al, cl |
test al, 2 |
jz .err |
jz .free;.err |
ret |
.free: |
call free_cd_channel |
5144,7 → 5212,7 |
ret |
.err: |
call .free |
pop eax |
; pop eax |
ret |
align 4 |
5171,7 → 5239,7 |
pushad |
inc [mouse_pause] |
; Check of use of the hardware cursor. |
cmp [disable_mouse],__sys_disable_mouse |
cmp [_display.disable_mouse],__sys_disable_mouse |
jne @f |
; Since the test for the coordinates of the mouse should not be used, |
; then use the call [disable_mouse] is not possible! |
5235,7 → 5303,7 |
jnz .start_y |
dec [mouse_pause] |
; Check of use of the hardware cursor. |
cmp [disable_mouse],__sys_disable_mouse |
cmp [_display.disable_mouse],__sys_disable_mouse |
jne @f |
call [draw_pointer] |
@@: |
5289,18 → 5357,24 |
syscall_reserveportarea: ; ReservePortArea and FreePortArea |
call r_f_port_area |
mov [esp+36],eax |
mov [esp+32],eax |
ret |
align 4 |
syscall_threads: ; CreateThreads |
; eax=1 create thread |
; |
; ebx=thread start |
; ecx=thread stack value |
; |
; on return : eax = pid |
call sys_threads |
mov [esp+36],eax |
call new_sys_threads |
mov [esp+32],eax |
ret |
align 4 |
read_from_hd: ; Read from hd - fn not in use |
5334,18 → 5408,33 |
mov [Screen_Max_X], eax |
mov [Screen_Max_Y], edx |
mov [BytesPerScanLine], ecx |
mov [screen_workarea.right],eax |
mov [screen_workarea.bottom], edx |
inc eax |
shl eax, 2 ;32 bpp |
mov [BytesPerScanLine], eax |
push ebx |
push esi |
push edi |
pushad |
stdcall kernel_free, [_WinMapAddress] |
mov eax, [_display.width] |
mul [_display.height] |
mov [_WinMapSize], eax |
stdcall kernel_alloc, eax |
mov [_WinMapAddress], eax |
test eax, eax |
jz .epic_fail |
popad |
call repos_windows |
mov eax, 0 |
mov ebx, 0 |
xor eax, eax |
xor ebx, ebx |
mov ecx, [Screen_Max_X] |
mov edx, [Screen_Max_Y] |
call calculatescreen |
5356,28 → 5445,37 |
popfd |
ret |
.epic_fail: |
hlt ; Houston, we've had a problem |
; --------------- APM --------------------- |
uglobal |
apm_entry dp 0 |
apm_vf dd 0 |
endg |
align 4 |
sys_apm: |
cmp word [apm_vf], 0 ; Check APM BIOS enable |
xor eax,eax |
cmp word [apm_vf], ax ; Check APM BIOS enable |
jne @f |
or [esp + 48], byte 1 ; error |
mov [esp + 36], dword 8 ; 32-bit protected-mode interface not supported |
inc eax |
or dword [esp + 44], eax ; error |
add eax,7 |
mov dword [esp + 32], eax ; 32-bit protected-mode interface not supported |
ret |
@@: |
xchg eax, ecx |
xchg ebx, ecx |
; xchg eax, ecx |
; xchg ebx, ecx |
cmp al, 3 |
cmp dx, 3 |
ja @f |
and [esp + 48], byte 0xfe ; emulate func 0..3 as func 0 |
and [esp + 44], byte 0xfe ; emulate func 0..3 as func 0 |
mov eax, [apm_vf] |
mov [esp + 36], eax |
mov [esp + 32], eax |
shr eax, 16 |
mov [esp + 32], eax |
mov [esp + 28], eax |
ret |
@@: |
5396,17 → 5494,15 |
mov cr3, eax |
pop eax |
mov [esp + 8 ], edi |
mov [esp + 12], esi |
mov [esp + 24], ebx |
mov [esp + 28], edx |
mov [esp + 32], ecx |
mov [esp + 36], eax |
mov [esp + 4 ], edi |
mov [esp + 8], esi |
mov [esp + 20], ebx |
mov [esp + 24], edx |
mov [esp + 28], ecx |
mov [esp + 32], eax |
setc al |
and [esp + 48], byte 0xfe |
or [esp + 48], al |
and [esp + 44], byte 0xfe |
or [esp + 44], al |
ret |
; ----------------------------------------- |
/kernel/branches/net/kernel32.inc |
---|
99,6 → 99,14 |
TASKDATA TASKDATA |
end virtual |
TSTATE_RUNNING = 0 |
TSTATE_RUN_SUSPENDED = 1 |
TSTATE_WAIT_SUSPENDED = 2 |
TSTATE_ZOMBIE = 3 |
TSTATE_TERMINATING = 4 |
TSTATE_WAITING = 5 |
TSTATE_FREE = 9 |
; structures definition |
struc WDATA { |
.box BOX |
109,11 → 117,12 |
.fl_wstate db ? |
.fl_wdrawn db ? |
.fl_redraw db ? |
.sizeof: |
} |
virtual at 0 |
WDATA WDATA |
end virtual |
label WDATA.fl_wstyle byte at 0x13 |
label WDATA.fl_wstyle byte at WDATA.cl_workarea + 3 |
struc APPDATA |
{ |
141,7 → 150,9 |
.wait_begin dd ? ;+92 +++ |
.wait_test dd ? ;+96 +++ |
.wait_param dd ? ;+100 +++ |
db 24 dup(?) ;+104 |
.tls_base dd ? ;+104 |
.dlls_list_ptr dd ? ;+108 |
db 16 dup(?) ;+112 |
.wnd_shape dd ? ;+128 |
.wnd_shape_scale dd ? ;+132 |
/kernel/branches/net/sound/playnote.inc |
---|
143,22 → 143,24 |
;result: |
; al - note |
push eax |
push ebx |
push ecx |
push edx |
push esi |
mov eax,[pidProcessNote] |
call pid_to_slot |
test eax,eax |
jz .failed |
lea ebx,[esp+12] |
mov ecx,1 |
mov edx,[memAdrNote] |
lea ecx,[esp+12] |
mov edx,1 |
mov esi,[memAdrNote] |
inc [memAdrNote] |
call read_process_memory |
.failed: |
pop esi |
pop edx |
pop ecx |
pop ebx |
pop eax |
ret |
;------------------- END CODE ------------------- |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/video/arrow.cur |
---|
Property changes: |
Added: svn:mergeinfo |
/kernel/branches/net/video/cursors.inc |
---|
32,7 → 32,7 |
end virtual |
align 4 |
proc vesa_init_cursor stdcall, dst:dword, src:dword |
proc init_cursor stdcall, dst:dword, src:dword |
locals |
rBase dd ? |
pQuad dd ? |
290,7 → 290,7 |
; ebx= src |
; ecx= flags |
vesa_cursor: |
create_cursor: |
.src equ esp |
.flags equ esp+4 |
.hcursor equ esp+8 |
300,7 → 300,7 |
push ebx |
mov ebx, eax |
mov eax, CURSOR_SIZE |
mov eax, CURSOR.sizeof |
call create_kernel_object |
test eax, eax |
jz .fail |
330,8 → 330,33 |
mov [edi+CURSOR.hot_x], ecx |
mov [edi+CURSOR.hot_y], edx |
stdcall vesa_init_cursor, eax, esi |
stdcall init_cursor, eax, esi |
mov eax, [.hcursor] |
lea eax, [eax+CURSOR.list_next] |
lea edx, [_display.cr_list.next] |
pushfd |
cli |
mov ecx, [edx] |
mov [eax], ecx |
mov [eax+4], edx |
mov [ecx+4], eax |
mov [edx], eax |
popfd |
mov eax, [.hcursor] |
.check_hw: |
cmp [_display.init_cursor], 0 |
je .fail |
push eax |
call [_display.init_cursor] |
add esp, 4 |
mov eax, [.hcursor] |
.fail: |
add esp, 12 |
ret |
346,8 → 371,7 |
mov ecx, 1024 |
cld |
rep movsd |
add esp, 12 |
ret |
jmp .check_hw |
align 4 |
proc load_cursor stdcall, src:dword, flags:dword |
377,7 → 401,7 |
mov eax, [CURRENT_TASK+eax+4] |
mov ebx, [src] |
mov ecx, [flags] |
call [create_cursor] ;eax, ebx, ecx |
call create_cursor ;eax, ebx, ecx |
mov [handle], eax |
cmp word [flags], LOAD_FROM_FILE |
407,8 → 431,6 |
mov esi, [hcursor] |
cmp [esi+CURSOR.magic], 'CURS' |
jne .fail |
; cmp [esi+CURSOR.size], CURSOR_SIZE |
; jne .fail |
mov ebx, [CURRENT_TASK] |
shl ebx, 5 |
443,127 → 465,78 |
align 4 |
select_cursor: |
mov eax, [esp+4] |
mov [_display.cursor], eax |
ret 4 |
align 4 |
proc init_cursors |
proc restore_24 stdcall, x:dword, y:dword |
cmp [SCR_MODE],word 0x13 |
jbe .fail |
push ebx |
test word [SCR_MODE], 0x4000 |
jz .fail |
movzx eax, byte [ScreenBPP] |
mov ebx, [BytesPerScanLine] |
cmp eax, 32 |
jne @F |
sub ebx, 128 |
jmp .init |
@@: |
cmp eax, 24 |
jne .fail |
sub ebx, 96 |
.init: |
mov [cur_def_interl], ebx |
stdcall load_driver, szHwMouse |
mov [hw_cursor], eax |
test eax, eax |
jz .sw_mouse |
stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM |
mov [def_cursor], eax |
ret |
.sw_mouse: |
mov [create_cursor], vesa_cursor |
stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM |
mov [def_cursor], eax |
mov ecx, [Screen_Max_X] |
mov edx, [Screen_Max_Y] |
inc ecx |
inc edx |
mov [scr_width], ecx |
mov [scr_height], edx |
movzx ebx, byte [ScreenBPP] |
cmp ebx, 32 |
jne @F |
mov dword [select_hw_cursor], select_cursor |
mov dword [set_hw_cursor], cursor_32 |
mov dword [hw_restore], restore_32 |
ret |
@@: |
mov dword [select_hw_cursor], select_cursor |
mov dword [set_hw_cursor], cursor_24 |
mov dword [hw_restore], restore_24 |
ret |
.fail: |
xor eax, eax |
mov dword [select_hw_cursor], eax |
mov dword [set_hw_cursor], eax |
mov dword [hw_restore], eax |
ret |
endp |
align 4 |
proc restore_24 stdcall, x:dword, y:dword |
locals |
w dd ? |
endl |
mov edi, [cur_saved_base] |
mov edx, [cur_saved_h] |
mov ebx, [cur_saved_interl] |
mov ebx, [cur_saved_base] |
mov edx, [cur.h] |
test edx, edx |
jz .ret |
push esi |
push edi |
mov esi, cur_saved_data |
mov ecx, [cur.w] |
lea ecx, [ecx+ecx*2] |
push ecx |
@@: |
mov ecx, [cur_saved_w] |
lea ecx, [ecx+ecx*2] |
mov edi, ebx |
add ebx, [BytesPerScanLine] |
mov ecx, [esp] |
rep movsb |
add edi, ebx |
dec edx |
jnz @B |
pop ecx |
pop edi |
pop esi |
.ret: |
pop ebx |
ret |
endp |
align 4 |
proc restore_32 stdcall, x:dword, y:dword |
locals |
w dd ? |
endl |
mov edi, [cur_saved_base] |
mov edx, [cur_saved_h] |
mov ebx, [cur_saved_interl] |
push ebx |
mov ebx, [cur_saved_base] |
mov edx, [cur.h] |
test edx, edx |
jz .ret |
push esi |
push edi |
mov esi, cur_saved_data |
@@: |
mov ecx, [cur_saved_w] |
mov edi, ebx |
add ebx, [BytesPerScanLine] |
mov ecx, [cur.w] |
rep movsd |
add edi, ebx |
dec edx |
jnz @B |
pop edi |
.ret: |
pop esi |
pop ebx |
ret |
endp |
align 4 |
proc cursor_24 stdcall, hcursor:dword, x:dword, y:dword |
proc move_cursor_24 stdcall, hcursor:dword, x:dword, y:dword |
locals |
w dd ? |
h dd ? |
st dd ? |
_dx dd ? |
_dy dd ? |
endl |
575,10 → 548,12 |
xor edx, edx |
sub ecx, [esi+CURSOR.hot_x] |
lea ebx, [ecx+32-1] |
mov [x], ecx |
sets dl |
dec edx |
and ecx, edx ;clip x to 0<=x |
mov [cur.left], ecx |
mov edi, ecx |
sub edi, [x] |
mov [_dx], edi |
585,77 → 560,72 |
xor edx, edx |
sub eax, [esi+CURSOR.hot_y] |
lea edi, [eax+32-1] |
mov [y], eax |
sets dl |
dec edx |
and eax, edx ;clip y to 0<=y |
mov edi, eax |
sub edi, [y] |
mov [_dy], edi |
mov [cur.top], eax |
mov edx, eax |
sub edx, [y] |
mov [_dy], edx |
mul ebx |
lea esi, [ecx+ecx*2] |
add esi, [LFBAddress] |
add esi, eax |
mov [cur_saved_base],esi |
mul dword [BytesPerScanLine] |
lea edx, [LFB_BASE+ecx*3] |
add edx, eax |
mov [cur_saved_base],edx |
mov edi, [scr_width] |
mov edx, [scr_height] |
mov eax, 32 |
sub edi, ecx |
cmp edi, eax |
jng @F |
mov edi, eax |
cmp ebx, [Screen_Max_X] |
jbe @F |
mov ebx, [Screen_Max_X] |
@@: |
sub edi, [_dx] |
sub edx, [y] |
cmp edx, eax |
jng @F |
mov edx, eax |
cmp edi, [Screen_Max_Y] |
jbe @F |
mov edi, [Screen_Max_Y] |
@@: |
sub edx, [_dy] |
mov [cur.right], ebx |
mov [cur.bottom], edi |
mov [w], edi |
mov [h], edx |
mov [cur_saved_w], edi |
mov [cur_saved_h], edx |
sub ebx, [x] |
sub edi, [y] |
inc ebx |
inc edi |
sub eax, edi |
shl eax, 2 ;lea eax, [eax+eax*2] |
lea edi, [edi+edi*2] |
sub ebx, edi |
mov [cur_saved_interl], ebx |
mov [cur.w], ebx |
mov [cur.h], edi |
mov [h], edi |
mov eax, edi |
mov edi, cur_saved_data |
@@: |
mov ecx, [w] |
mov esi, edx |
add edx, [BytesPerScanLine] |
mov ecx, [cur.w] |
lea ecx, [ecx+ecx*2] |
rep movsb |
add esi, ebx |
dec edx |
dec eax |
jnz @B |
;draw cursor |
mov edx, eax |
mov edi, [cur_saved_base] |
mov ebx, [cur_saved_base] |
mov eax, [_dy] |
shl eax, 5 |
add eax, [_dx] |
shl eax, 2 |
mov esi, [hcursor] |
mov esi, [esi+CURSOR.base] |
add esi, eax |
lea edx, [esi+eax*4] |
.row: |
mov ecx, [w] |
mov ecx, [cur.w] |
mov esi, edx |
mov edi, ebx |
add edx, 32*4 |
add ebx, [BytesPerScanLine] |
.pix: |
lodsd |
test eax, 0xFF000000 |
jz @F |
mov word [edi], ax |
mov [edi], ax |
shr eax, 16 |
mov [edi+2],al |
@@: |
663,19 → 633,16 |
dec ecx |
jnz .pix |
add esi, edx |
add edi, ebx |
dec [h] |
jnz .row |
ret |
endp |
align 4 |
proc cursor_32 stdcall, hcursor:dword, x:dword, y:dword |
proc move_cursor_32 stdcall, hcursor:dword, x:dword, y:dword |
locals |
w dd ? |
h dd ? |
st dd ? |
_dx dd ? |
_dy dd ? |
endl |
683,14 → 650,15 |
mov esi, [hcursor] |
mov ecx, [x] |
mov eax, [y] |
mov ebx, [BytesPerScanLine] |
xor edx, edx |
sub ecx, [esi+CURSOR.hot_x] |
lea ebx, [ecx+32-1] |
mov [x], ecx |
sets dl |
dec edx |
and ecx, edx ;clip x to 0<=x |
mov [cur.left], ecx |
mov edi, ecx |
sub edi, [x] |
mov [_dx], edi |
697,69 → 665,65 |
xor edx, edx |
sub eax, [esi+CURSOR.hot_y] |
lea edi, [eax+32-1] |
mov [y], eax |
sets dl |
dec edx |
and eax, edx ;clip y to 0<=y |
mov edi, eax |
sub edi, [y] |
mov [_dy], edi |
mov [cur.top], eax |
mov edx, eax |
sub edx, [y] |
mov [_dy], edx |
mul ebx |
lea esi, [eax+ecx*4] |
add esi, [LFBAddress] |
mov [cur_saved_base],esi |
mul dword [BytesPerScanLine] |
lea edx, [LFB_BASE+eax+ecx*4] |
mov [cur_saved_base],edx |
mov edi, [scr_width] |
mov edx, [scr_height] |
mov eax, 32 |
sub edi, ecx |
cmp edi, eax |
jng @F |
mov edi, eax |
cmp ebx, [Screen_Max_X] |
jbe @F |
mov ebx, [Screen_Max_X] |
@@: |
sub edi, [_dx] |
sub edx, [y] |
cmp edx, eax |
jng @F |
mov edx, eax |
cmp edi, [Screen_Max_Y] |
jbe @F |
mov edi, [Screen_Max_Y] |
@@: |
sub edx, [_dy] |
mov [cur.right], ebx |
mov [cur.bottom], edi |
mov [w], edi |
mov [h], edx |
mov [cur_saved_w], edi |
mov [cur_saved_h], edx |
sub ebx, [x] |
sub edi, [y] |
inc ebx |
inc edi |
sub eax, edi |
shl eax, 2 |
shl edi, 2 |
sub ebx, edi |
mov [cur_saved_interl], ebx |
mov [cur.w], ebx |
mov [cur.h], edi |
mov [h], edi |
mov eax, edi |
mov edi, cur_saved_data |
@@: |
mov ecx, [w] |
mov esi, edx |
add edx, [BytesPerScanLine] |
mov ecx, [cur.w] |
rep movsd |
add esi, ebx |
dec edx |
dec eax |
jnz @B |
;draw cursor |
mov edx, eax |
mov edi, [cur_saved_base] |
mov ebx, [cur_saved_base] |
mov eax, [_dy] |
shl eax, 5 |
add eax, [_dx] |
shl eax, 2 |
mov esi, [hcursor] |
mov esi, [esi+CURSOR.base] |
add esi, eax |
lea edx, [esi+eax*4] |
.row: |
mov ecx, [w] |
mov ecx, [cur.w] |
mov esi, edx |
mov edi, ebx |
add edx, 32*4 |
add ebx, [BytesPerScanLine] |
.pix: |
lodsd |
test eax, 0xFF000000 |
769,14 → 733,74 |
add edi, 4 |
dec ecx |
jnz .pix |
add esi, edx |
add edi, ebx |
dec [h] |
jnz .row |
ret |
endp |
align 4 |
get_display: |
mov eax, _display |
ret |
align 4 |
init_display: |
xor eax, eax |
mov edi, _display |
mov [edi+display_t.init_cursor], eax |
mov [edi+display_t.select_cursor], eax |
mov [edi+display_t.show_cursor], eax |
mov [edi+display_t.move_cursor], eax |
mov [edi+display_t.restore_cursor], eax |
lea ecx, [edi+display_t.cr_list.next] |
mov [edi+display_t.cr_list.next], ecx |
mov [edi+display_t.cr_list.prev], ecx |
cmp [SCR_MODE],word 0x13 |
jbe .fail |
test word [SCR_MODE], 0x4000 |
jz .fail |
mov ebx, restore_32 |
mov ecx, move_cursor_32 |
movzx eax, byte [ScreenBPP] |
cmp eax, 32 |
je @F |
mov ebx, restore_24 |
mov ecx, move_cursor_24 |
cmp eax, 24 |
jne .fail |
@@: |
mov [_display.select_cursor], select_cursor |
mov [_display.move_cursor], ecx |
mov [_display.restore_cursor], ebx |
stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM |
mov [def_cursor], eax |
ret |
.fail: |
xor eax, eax |
mov [_display.select_cursor], eax |
mov [_display.move_cursor], eax |
ret |
align 4 |
def_arrow: |
file 'arrow.cur' |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/video/vesa12.inc |
---|
242,7 → 242,7 |
vesa12_drawbackground: |
call [disable_mouse] |
call [_display.disable_mouse] |
push eax |
push ebx |
258,7 → 258,7 |
mov [imax],eax |
mov eax,[draw_data+32+RECT.left] |
mov ebx,[draw_data+32+RECT.top] |
mov edi,0 ;no force |
xor edi,edi ;no force |
v12dp3: |
327,7 → 327,8 |
mov eax,[Screen_Max_X] |
add eax,1 |
mul ebx |
cmp [eax+esi+WinMapAddress],byte 1 |
add eax, [_WinMapAddress] |
cmp [eax+esi],byte 1 |
jnz v12nbgp |
mov eax,[BytesPerScanLine] |
mov ebx,edi |
386,7 → 387,7 |
vesa12_drawbar: |
call [disable_mouse] |
call [_display.disable_mouse] |
;; mov [novesachecksum],dword 0 |
sub edx,ebx |
494,7 → 495,7 |
sub eax,VGABasePtr |
mov ebx,3 |
div ebx |
add eax,WinMapAddress |
add eax, [_WinMapAddress] |
mov ebx,[CURRENT_TASK] |
cld |
585,7 → 586,7 |
mov eax,edi |
sub eax,VGABasePtr |
shr eax,2 |
add eax,WinMapAddress |
add eax, [_WinMapAddress] |
mov ebx,[CURRENT_TASK] |
cld |
753,7 → 754,7 |
; mov ecx,320*65536+240 |
; mov edx,20*65536+20 |
call [disable_mouse] |
call [_display.disable_mouse] |
mov [novesachecksum],dword 0 |
push esi |
830,7 → 831,7 |
sub edx,VGABasePtr |
mov ebx,3 |
div ebx |
add edx,WinMapAddress |
add edx, [_WinMapAddress] |
mov ebx,[CURRENT_TASK] |
mov bh,[esp+4*3] |
909,7 → 910,7 |
mov edx,edi |
sub edx,VGABasePtr |
shr edx,2 |
add edx,WinMapAddress |
add edx, [_WinMapAddress] |
mov ebx,[CURRENT_TASK] |
mov bh,[esp+4*3] |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/video/vesa20.inc |
---|
28,7 → 28,6 |
;BytesPerScanLine equ 0xfe08 |
;LFBAddress equ 0xfe80 |
;ScreenBPP equ 0xfbf1 |
;WinMapAddress equ 0x460000 |
54,8 → 53,7 |
imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier |
lea edi, [eax+eax*2] ; edi = x*3 |
add edi, ebx ; edi = x*3+(y*y multiplier) |
add edi, [LFBAddress] ; ebx = where pixel is in memory |
mov ecx, [edi] |
mov ecx, [LFB_BASE+edi] |
and ecx, 0xffffff |
ret |
62,8 → 60,7 |
Vesa20_getpixel32: |
imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier |
lea edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier) |
add edi, [LFBAddress] ; ebx = where pixel is in memory |
mov ecx, [edi] |
mov ecx, [LFB_BASE+edi] |
and ecx, 0xffffff |
ret |
106,7 → 103,7 |
vesa20_putimage: |
pushad |
call [disable_mouse] |
call [_display.disable_mouse] |
sub esp, putimg.stack_data |
; save pointer to image |
mov [putimg.pti], ebx |
194,13 → 191,12 |
shr ebx, 3 |
imul eax, ebx |
add edx, eax |
add edx, [LFBAddress] |
; pointer to pixel map |
mov eax, [putimg.abs_cy] |
imul eax, [Screen_Max_X] |
add eax, [putimg.abs_cy] |
add eax, [putimg.abs_cx] |
add eax, WinMapAddress |
add eax, [_WinMapAddress] |
xchg eax, ebp |
; get process number |
mov ebx, [CURRENT_TASK] |
220,9 → 216,9 |
cmp [ebp], bl |
jne .skip |
; mov eax, [esi] ; eax = RRBBGGRR |
mov [edx], ax |
mov [LFB_BASE+edx], ax |
shr eax, 16 |
mov [edx+2], al |
mov [LFB_BASE+edx+2], al |
.skip: |
; add esi, 3 ;[putimg.source_bpp] |
add edx, 3 |
265,7 → 261,7 |
cmp [ebp], bl |
jne .skip |
; mov eax, [esi] ; ecx = RRBBGGRR |
mov [edx], eax |
mov [LFB_BASE+edx], eax |
.skip: |
; add esi, [putimg.source_bpp] |
add edx, 4 |
308,20 → 304,25 |
;;; mov [novesachecksum], dword 0 |
pushad |
cmp [Screen_Max_X], eax |
jb .exit |
cmp [Screen_Max_Y], ebx |
jb .exit |
test edi,1 ; force ? |
jnz .forced |
; not forced: |
push ecx ; save 24th bit in case negative pixel wanted |
call checkpixel |
test ecx,ecx |
pop ecx |
jnz .exit |
push eax |
mov edx,[_display.width] ; screen x size |
imul edx, ebx |
add eax, [_WinMapAddress] |
movzx edx, byte [eax+edx] |
cmp edx, [CURRENT_TASK] |
pop eax |
jne .exit |
.forced: |
cmp [Screen_Max_X], eax |
jb .exit |
cmp [Screen_Max_Y], ebx |
jb .exit |
.ok: |
; check if negation |
test ecx,0x01000000 |
jz .noneg |
342,11 → 343,9 |
imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier |
lea edi, [eax+eax*2] ; edi = x*3 |
mov eax, [esp+32-8+4] |
add edi, [LFBAddress] |
add edi, ebx ; ebx = where to put pixel in memory |
mov [edi], ax |
mov [LFB_BASE+ebx+edi], ax |
shr eax, 16 |
mov [edi+2], al |
mov [LFB_BASE+ebx+edi+2], al |
ret |
357,8 → 356,7 |
imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier |
lea edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier) |
mov eax, [esp+32-8+4] ; eax = color |
add edi, [LFBAddress] ; ebx = where to put pixel in memory |
mov [edi], eax |
mov [LFB_BASE+edi], eax |
ret |
;************************************************* |
378,7 → 376,7 |
align 4 |
__sys_draw_line: |
; inc [mouse_pause] |
call [disable_mouse] |
call [_display.disable_mouse] |
; draw a line |
; eax = HIWORD = x1 |
568,7 → 566,7 |
; edi color |
vesa20_drawbar: |
pushad |
call [disable_mouse] |
call [_display.disable_mouse] |
sub esp, drbar.stack_data |
mov [drbar.color], edi |
sub edx, ebx |
643,13 → 641,12 |
; shr ebx, 3 |
imul eax, ebx |
add edx, eax |
add edx, [LFBAddress] |
; pointer to pixel map |
mov eax, [drbar.abs_cy] |
imul eax, [Screen_Max_X] |
add eax, [drbar.abs_cy] |
add eax, [drbar.abs_cx] |
add eax, WinMapAddress |
add eax, [_WinMapAddress] |
xchg eax, ebp |
; get process number |
mov ebx, [CURRENT_TASK] |
674,8 → 671,9 |
.new_x: |
cmp byte [ebp], bl |
jne .skip |
mov [edx], bh |
mov [edx + 1], ax |
mov [LFB_BASE+edx], bh |
mov [LFB_BASE+edx + 1], ax |
.skip: |
; add pixel |
add edx, 3 |
710,7 → 708,8 |
.new_x: |
cmp byte [ebp], bl |
jne .skip |
mov [edx], eax |
mov [LFB_BASE+edx], eax |
.skip: |
; add pixel |
add edx, 4 |
737,62 → 736,9 |
mov [EGA_counter],1 |
ret |
;voodoodbcplimit: |
; ebp:=(y+Ywin)*(ScreenXSize+1)+(x+Xwin)+AddrBuffer |
; pusha |
; xor edx,edx |
; mov eax,ebp |
; mov ebx,[Screen_Max_X] ; Screen_X_size |
; inc ebx ; +1 |
; sub eax,WinMapAddress ; -AddrBuffer |
; div ebx ; |
; mov ebx,eax ; ebx:=Y |
; mov eax,edx ; eax:=X |
; call cplimit |
; test ecx,ecx |
; jne dbcpl12 |
; popa |
; clc |
; ret |
; dbcpl12: |
; popa |
; stc |
; ret |
;dbcplimit: |
; pusha |
; xor edx,edx |
; mov ebx,[Screen_Max_X] |
; inc ebx |
; sub eax,WinMapAddress |
; div ebx |
; mov ebx,eax |
; mov eax,edx |
; call cplimit |
; test ecx,ecx |
; jne dbcpl1 |
; popa |
; clc |
; ret |
; dbcpl1: |
; popa |
; stc |
; ret |
align 4 |
vesa20_drawbackground_tiled: |
call [disable_mouse] |
call [_display.disable_mouse] |
pushad |
; External loop for all y from start to end |
mov ebx, [draw_data+32+RECT.top] ; y start |
810,10 → 756,11 |
jz @f |
add ebp, eax |
@@: |
add ebp, [LFBAddress] |
add ebp, LFB_BASE |
; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB |
call calculate_edi |
xchg edi, ebp |
add ebp, [_WinMapAddress] |
; Now eax=x, ebx=y, edi->output, ebp=offset in WinMapAddress |
; 2) Calculate offset in background memory block |
push eax |
842,7 → 789,7 |
; esi -> bgr memory, edi -> output |
; ebp = offset in WinMapAddress |
dp3: |
cmp [ebp+WinMapAddress], dl |
cmp [ebp], dl |
jnz nbgp |
movsb |
movsb |
881,7 → 828,7 |
vesa20_drawbackground_stretch: |
call [disable_mouse] |
call [_display.disable_mouse] |
pushad |
; Helper variables |
; calculate 2^32*(BgrDataWidth-1) mod (ScreenWidth-1) |
917,7 → 864,6 |
jz @f |
add ebp, eax |
@@: |
add ebp, [LFBAddress] |
; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB |
call calculate_edi |
xchg edi, ebp |
985,7 → 931,8 |
; qword [esp+28] = 2^32*(BgrDataHeight-1)/(ScreenHeight-1) |
; qword [esp+36] = 2^32*(BgrDataWidth-1)/(ScreenWidth-1) |
sdp3a: |
cmp [ebp+WinMapAddress], byte 1 |
mov eax, [_WinMapAddress] |
cmp [ebp+eax], byte 1 |
jnz snbgp |
mov eax, [bgr_cur_line+esi] |
test ecx, ecx |
993,9 → 940,11 |
mov ebx, [bgr_next_line+esi] |
call [overlapping_of_points_ptr] |
.novert: |
mov [edi], ax |
mov [LFB_BASE+edi], ax |
shr eax, 16 |
mov [edi+2], al |
mov [LFB_BASE+edi+2], al |
snbgp: |
cmp [ScreenBPP], byte 25 |
sbb edi, -4 |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/video/vga.inc |
---|
175,8 → 175,8 |
cld |
m13pix: |
lodsd |
cmp eax,0 |
je .save_pixel |
test eax,eax |
jz .save_pixel |
push eax |
mov ebx,eax |
and eax,(128+64+32) ; blue |
259,8 → 259,8 |
mov cl,8 |
.convert_pixels_to_VGA: |
lodsd ; eax = 24bit colour |
cmp eax,0 |
je .end |
test eax,eax |
jz .end |
rol eax,8 |
mov al,ch |
ror eax,8 |
335,8 → 335,8 |
pushfd |
; edi = address, eax = 24bit colour, ecx = bit no. (modulo 8) |
xor edx,edx |
cmp eax,0 |
je .p13cont |
test eax,eax |
jz .p13cont |
cmp al,85 |
jbe .p13green |
or dl,0x01 |
Property changes: |
Modified: svn:keywords |
-Revision |
\ No newline at end of property |
+Rev |
\ No newline at end of property |
Added: svn:mergeinfo |
/kernel/branches/net/vmodeint.inc |
---|
24,15 → 24,16 |
old_screen_height dd ? |
endg |
cmp eax,13 ; CALL VIDEOMODE DRIVER FUNCTIONS |
jne .no_vmode_drv_access |
; cmp eax,13 ; CALL VIDEOMODE DRIVER FUNCTIONS |
dec ebx |
jnz .no_vmode_drv_access |
pushd [Screen_Max_X] [Screen_Max_Y] |
popd [old_screen_height] [old_screen_width] |
or eax,-1 ; If driver is absent then eax does not change |
call (VMODE_BASE+0x100) ; Entry point of video driver |
mov [esp+36],eax |
mov [esp+24],ebx |
mov [esp+32],ecx |
mov [esp+36-4],eax |
mov [esp+24-4],ebx |
mov [esp+32-4],ecx |
; mov [esp+28],edx |
mov eax,[old_screen_width] |
mov ebx,[old_screen_height] |
46,8 → 47,8 |
sub [screen_workarea.bottom],ebx |
call repos_windows |
mov eax, 0 |
mov ebx, 0 |
xor eax,eax |
xor ebx,ebx |
mov ecx, [Screen_Max_X] |
mov edx, [Screen_Max_Y] |
call calculatescreen |