MSWindowsRuntime.inc

Переключить прокрутку окна
Загрузить этот исходный код

;
 ;  Исходный код среды исполнения ПВТ-ОО.
 ;
 ;  Этот исходный код является частью проекта ПВТ-ОО.
 ;
 ;  Copyright © 2021 Малик Разработчик
 ;
 ;  Это свободная программа: вы можете перераспространять её и/или
 ;  изменять её на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
 ;  в каком она была опубликована Фондом свободного программного обеспечения;
 ;  либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.
 ;
 ;  Эта программа распространяется в надежде, что она может быть полезна,
 ;  но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
 ;  или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЁННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
 ;  общественной лицензии GNU.
 ;
 ;  Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
 ;  вместе с этой программой. Если это не так, см.
 ;  <http://www.gnu.org/licenses/>.
;

; <fold platform.dependent.MSWindowsRuntime (natives)>

    method platform.dependent.MSWindowsRuntime$getHeapIndexOfFreeSpace$long.01d$int$, \
                heapRef, long.01d, \
                blockLength, int  ; returns int <fold >
                menter
                lverify heapRef, TAG_OBJECT
                lverify blockLength, TAG_INT
                mov     r0, [.heapRef]
                lea     r1, [r0+$40]
                add     r1, [r0+long.01d$fldOffset]
                movsxd  r2, [r0+long.01d$fldLength]
                movsxd  r6, [r1+r2*8-$08]
                ; has free descriptors ?
                mov     r0d, r2d
                sub     r0d, r6d
                sub     r0d, $02
                jg      .L.BEG
                mov     r0d, -$01
                jmp     .L.RET
        .L.BEG: ; heap's begin
                cmp     r6d, $00
                jle     .L.END
                mov     r0d, [r1]
                cmp     r0d, [.blockLength]
                jl      .L.MID
                xor     r0d, r0d
                jmp     .L.RET
        .L.MID: ; heap's middle
                cmp     r6d, $01
                jle     .L.END
                mov     r0d, $01
        @@:     mov     r7d, [r1+r0*8-$00]
                sub     r7d, [r1+r0*8-$04]
                sub     r7d, [r1+r0*8-$08]
                cmp     r7d, [.blockLength]
                jge     .L.RET
                inc     r0d
                cmp     r0d, r6d
                jl      @B
        .L.END: ; heap's end
                xor     r7d, r7d
                mov     r0d, r6d
                cmp     r0d, $00
                jle     @F
                mov     r7d, [r1+r6*8-$08]
                add     r7d, [r1+r6*8-$04]
        @@:     lea     r6d, [r2d+$08]
                sub     r6d, r7d
                cmp     r6d, [.blockLength]
                jge     .L.RET
                mov     r0d, -$01
        .L.RET: call    inst$ipush
                mleaved
                eleave
    ; </fold>

    method platform.dependent.MSWindowsRuntime$getHeapIndexOfBlockPointer$long.01d$long$, \
                heapRef, long.01d, \
                blockPointer, long  ; returns int <fold >
                menter
                lverify heapRef, TAG_OBJECT
                lverify blockPointer, TAG_LONG
                mov     r1, [.heapRef]
                lea     r2, [r1+$40]
                add     r2, [r1+long.01d$fldOffset]
                movsxd  r1, [r1+long.01d$fldLength]
                movsxd  r7, [r2+r1*8-$08]
                mov     r0, [r2+r1*8-$10]
                mov     r1, [.blockPointer]
                lea     r7, [r7-$01]
                and     r0, -$1000
                xor     r6, r6
                sub     r1, r0
                shr     r1, $08
        .L.000: lea     r0, [r6+r7]
                sar     r0, $01
                cmp     dword[r2+r0*8], r1d
                je      .L.RET
                jb      @F
                lea     r7, [r0-$01]
                jmp     .L.001
        @@:     lea     r6, [r0+$01]
        .L.001: cmp     r6, r7
                jle     .L.000
                mov     r0d, -$01
        .L.RET: call    inst$ipush
                mleaved
                eleave
    ; </fold>

    method platform.dependent.MSWindowsRuntime$getHeapBlockPointer$long.01d$int$, \
                heapRef, long.01d, \
                blockIndex, int  ; returns long <fold >
                menter
                lverify heapRef, TAG_OBJECT
                lverify blockIndex, TAG_INT
                mov     r1, [.heapRef]
                lea     r0, [r1+$40]
                add     r0, [r1+long.01d$fldOffset]
                movsxd  r1, [r1+long.01d$fldLength]
                mov     r2, [r0+r1*8-$10]
                and     r2, -$1000
                movsxd  r1, [.blockIndex]
                mov     r6, [r0+r1*8]
                mov     r7, r6
                movsxd  r6, r6d
                cmp     r6, $00
                jg      .L.000
                sar     r7, $20
                cmp     r7, $00
                jg      .L.000
                xor     r0, r0
                jmp     .L.RET
        .L.000: shl     r6, $08
                lea     r0, [r2+r6*1]
        .L.RET: call    inst$lpush
                mleaveq
                eleave
    ; </fold>

    method platform.dependent.MSWindowsRuntime$getProgrammeImportRegion$  ; returns long2 <fold >
                menter
                lea     rax, [importBegin]
                call    inst$lpush
                lea     rax, [importEnd]
                call    inst$lpush
                newvectorl2
                mleavex
                eleave
    ; </fold>
; </fold>