LittleEndianDataOutput.inc

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

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

; <fold avt.io.LittleEndianDataOutput — родной код>
    if(used avt.io.LittleEndianDataOutput$writeChar$char$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeChar$char$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, char
                    menter      $2
                    loadi_l     data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    mov         word  [r01+$00], r00w
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeShort$int$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeShort$int$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, int
                    menter      $2
                    loadi_l     data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    mov         word  [r01+$00], r00w
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeInt$int$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeInt$int$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, int
                    menter      $2
                    loadi_l     data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    mov         dword [r01+$00], r00d
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeByte2$int2$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeByte2$int2$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, int2
                    menter      $2
                    loadi2_l    data
                    casti2tob2
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovd       dword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeShort2$int2$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeShort2$int2$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, int2
                    menter      $2
                    loadi2_l    data
                    casti2tos2
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovd       dword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeInt2$int2$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeInt2$int2$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, int2
                    menter      $2
                    loadi2_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovq       qword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeByte4$int4$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeByte4$int4$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, int4
                    menter      $2
                    loadi4_l    data
                    casti4tob4
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovd       dword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeShort4$int4$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeShort4$int4$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, int4
                    menter      $2
                    loadi4_l    data
                    casti4tos4
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovq       qword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeInt4$int4$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeInt4$int4$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, int4
                    menter      $2
                    loadi4_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     xword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeByte8$int8$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeByte8$int8$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, int8
                    menter      $2
                    loadi8_l    data
                    casti8tob8
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovq       qword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeShort8$int8$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeShort8$int8$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, int8
                    menter      $2
                    loadi8_l    data
                    casti8tos8
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     xword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeInt8$int8$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeInt8$int8$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, int8
                    menter      $2
                    loadi8_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     yword [r01+$00], ymm0
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeLong$long$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeLong$long$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, long
                    menter      $2
                    loadl_l     data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    mov         qword [r01+$00], r00q
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeLong2$long2$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeLong2$long2$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, long2
                    menter      $2
                    loadl2_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     xword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeLong4$long4$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeLong4$long4$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, long4
                    menter      $2
                    loadl4_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     yword [r01+$00], ymm0
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeLong8$long8$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeLong8$long8$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, long8
                    menter      $2
                    loadl8_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa64   zword [r01+$00], zmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $40
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeFloat$float$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeFloat$float$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, float
                    menter      $2
                    loadf_l     data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovd       dword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeFloat2$float2$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeFloat2$float2$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, float2
                    menter      $2
                    loadf2_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovq       qword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeFloat4$float4$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeFloat4$float4$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, float4
                    menter      $2
                    loadf4_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     xword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeFloat8$float8$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeFloat8$float8$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, float8
                    menter      $2
                    loadf8_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     yword [r01+$00], ymm0
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeDouble$double$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeDouble$double$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, double
                    menter      $2
                    loadd_l     data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovq       qword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeDouble2$double2$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeDouble2$double2$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, double2
                    menter      $2
                    loadd2_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     xword [r01+$00], xmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeDouble4$double4$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeDouble4$double4$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, double4
                    menter      $2
                    loadd4_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     yword [r01+$00], ymm0
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeDouble8$double8$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeDouble8$double8$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, double8
                    menter      $2
                    loadd8_l    data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa64   zword [r01+$00], zmm0
                    loadr_l     this
                    tpushr
                    loadi_g     $40
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.LittleEndianDataOutput$writeReal$real$) ; <fold throws avt.io.IOException>
                    method      avt.io.LittleEndianDataOutput$writeReal$real$, \
                                this, avt.io.LittleEndianDataOutput, \
                                data, real
                    menter      $2
                    loade_l     data
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataOutput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    fstp        tbyte [r01+$00]
                    loadr_l     this
                    tpushr
                    loadi_g     $0a
                    tpushi
                    invvirt     avt.io.LittleEndianDataOutput$writeData$int$
                    mleave
                    eleave
    end if ; </fold>
; </fold>