hexsha
stringlengths 40
40
| size
int64 6
1.05M
| ext
stringclasses 3
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
232
| max_stars_repo_name
stringlengths 7
106
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
listlengths 1
7
| max_stars_count
int64 1
33.5k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
232
| max_issues_repo_name
stringlengths 7
106
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
listlengths 1
7
| max_issues_count
int64 1
37.5k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
232
| max_forks_repo_name
stringlengths 7
106
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
listlengths 1
7
| max_forks_count
int64 1
12.6k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 6
1.05M
| avg_line_length
float64 1.16
19.7k
| max_line_length
int64 2
938k
| alphanum_fraction
float64 0
1
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0861fc7f2fd129fcdc4829024507453f464d5c69
| 711
|
asm
|
Assembly
|
oeis/000/A000321.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/000/A000321.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/000/A000321.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A000321: H_n(-1/2), where H_n(x) is Hermite polynomial of degree n.
; Submitted by Jamie Morken(s3)
; 1,-1,-1,5,1,-41,31,461,-895,-6481,22591,107029,-604031,-1964665,17669471,37341149,-567425279,-627491489,19919950975,2669742629,-759627879679,652838174519,31251532771999,-59976412450835,-1377594095061119,4256461892701199,64623242860354751,-285959261280817099,-3203695853178339455,19217414484904096999,166596944999439591391,-1319641814093685411331,-9009368775871569254911,93466444877867435580095,501151894329656135244031,-6856870146024641754690491,-28223762457051287712391679
mov $1,2
mov $3,-4
lpb $0
sub $0,1
mov $2,$1
add $2,$1
mul $3,$0
sub $1,$3
sub $1,$2
mov $3,$2
lpe
mov $0,$1
div $0,2
| 39.5
| 475
| 0.779184
|
1f24e09ee6446a8fb1c29a0bc01f70642f50adbf
| 3,603
|
asm
|
Assembly
|
Transynther/x86/_processed/US/_zr_/i3-7100_9_0xca_notsx.log_264_653.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 9
|
2020-08-13T19:41:58.000Z
|
2022-03-30T12:22:51.000Z
|
Transynther/x86/_processed/US/_zr_/i3-7100_9_0xca_notsx.log_264_653.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 1
|
2021-04-29T06:29:35.000Z
|
2021-05-13T21:02:30.000Z
|
Transynther/x86/_processed/US/_zr_/i3-7100_9_0xca_notsx.log_264_653.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 3
|
2020-07-14T17:07:07.000Z
|
2022-03-21T01:12:22.000Z
|
.global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r14
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0x1887f, %rsi
lea addresses_A_ht+0x56bb, %rdi
clflush (%rsi)
nop
nop
nop
xor $63329, %rbp
mov $29, %rcx
rep movsq
nop
and $1943, %rcx
lea addresses_UC_ht+0x1372b, %rsi
lea addresses_normal_ht+0x15c3b, %rdi
nop
inc %r14
mov $29, %rcx
rep movsl
nop
nop
nop
nop
nop
cmp %rcx, %rcx
lea addresses_WT_ht+0x1be5b, %rsi
lea addresses_WT_ht+0x1303b, %rdi
nop
sub $10895, %r14
mov $29, %rcx
rep movsw
nop
cmp $64106, %rbp
lea addresses_normal_ht+0xe76, %rsi
lea addresses_UC_ht+0x1523b, %rdi
nop
nop
nop
nop
nop
cmp $34641, %r13
mov $25, %rcx
rep movsw
nop
nop
cmp %r13, %r13
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r14
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r15
push %r8
push %rbp
push %rdi
push %rdx
// Store
mov $0x4a8954000000063b, %rdx
nop
dec %r11
mov $0x5152535455565758, %r8
movq %r8, (%rdx)
nop
nop
nop
nop
nop
add $43474, %r8
// Load
lea addresses_normal+0xfabb, %r8
nop
nop
nop
nop
nop
xor %r15, %r15
mov (%r8), %ebp
nop
nop
nop
nop
nop
inc %r8
// Load
lea addresses_PSE+0x1f7b, %r15
nop
nop
nop
nop
nop
add $16989, %rdi
mov (%r15), %edx
nop
nop
and $58802, %rdx
// Faulty Load
lea addresses_US+0xaa3b, %r12
nop
xor %r8, %r8
vmovups (%r12), %ymm3
vextracti128 $1, %ymm3, %xmm3
vpextrq $1, %xmm3, %rdi
lea oracles, %r15
and $0xff, %rdi
shlq $12, %rdi
mov (%r15,%rdi,1), %rdi
pop %rdx
pop %rdi
pop %rbp
pop %r8
pop %r15
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_US', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 8, 'NT': False, 'type': 'addresses_NC', 'size': 8, 'AVXalign': False}}
{'src': {'same': False, 'congruent': 7, 'NT': False, 'type': 'addresses_normal', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 5, 'NT': False, 'type': 'addresses_PSE', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_US', 'size': 32, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_UC_ht', 'congruent': 2, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_A_ht', 'congruent': 5, 'same': False}}
{'src': {'type': 'addresses_UC_ht', 'congruent': 2, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_normal_ht', 'congruent': 9, 'same': False}}
{'src': {'type': 'addresses_WT_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WT_ht', 'congruent': 9, 'same': False}}
{'src': {'type': 'addresses_normal_ht', 'congruent': 0, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 11, 'same': False}}
{'00': 264}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
| 24.02
| 791
| 0.657785
|
629bb727edd1d19f73d38fd34cbab9754c691d16
| 527
|
asm
|
Assembly
|
programs/oeis/120/A120743.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/120/A120743.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/120/A120743.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
; A120743: a(n) = (1/2)*(1 + 3*i)^n + (1/2)*(1 - 3*i)^n where i = sqrt(-1).
; 1,-8,-26,28,316,352,-2456,-8432,7696,99712,122464,-752192,-2729024,2063872,31417984,42197248,-229785344,-881543168,534767104,9884965888,14422260736,-70005137408,-284232882176,131585609728,3105500041216,4895143985152,-21264712441856,-91480864735232,29685394948096,974179437248512,1651504925016064,-6438784522452992
add $0,1
mov $1,2
mov $2,1
lpb $0,1
sub $0,1
mul $1,5
mul $2,2
sub $2,$1
add $1,$2
lpe
sub $1,2
div $1,18
mul $1,9
add $1,1
| 29.277778
| 315
| 0.702087
|
6f95e86373764e49231ef36723f5510f78733286
| 6,702
|
asm
|
Assembly
|
Transynther/x86/_processed/AVXALIGN/_ht_zr_un_/i9-9900K_12_0xa0_notsx.log_21829_1579.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 9
|
2020-08-13T19:41:58.000Z
|
2022-03-30T12:22:51.000Z
|
Transynther/x86/_processed/AVXALIGN/_ht_zr_un_/i9-9900K_12_0xa0_notsx.log_21829_1579.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 1
|
2021-04-29T06:29:35.000Z
|
2021-05-13T21:02:30.000Z
|
Transynther/x86/_processed/AVXALIGN/_ht_zr_un_/i9-9900K_12_0xa0_notsx.log_21829_1579.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 3
|
2020-07-14T17:07:07.000Z
|
2022-03-21T01:12:22.000Z
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r12
push %r15
push %r8
push %r9
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0xacd2, %rsi
lea addresses_WC_ht+0x63d2, %rdi
nop
nop
xor $64002, %r15
mov $70, %rcx
rep movsb
nop
nop
xor $42479, %r9
lea addresses_A_ht+0x154d2, %r10
nop
nop
nop
nop
nop
mfence
mov $0x6162636465666768, %rcx
movq %rcx, (%r10)
and $23886, %rsi
lea addresses_UC_ht+0xd88c, %rdi
nop
nop
nop
nop
sub %rsi, %rsi
vmovups (%rdi), %ymm3
vextracti128 $1, %ymm3, %xmm3
vpextrq $1, %xmm3, %r8
and $53047, %rsi
lea addresses_A_ht+0x17a52, %r8
clflush (%r8)
nop
nop
nop
nop
nop
add $60011, %rdi
mov (%r8), %r9d
nop
nop
nop
dec %r9
lea addresses_normal_ht+0xcab2, %rsi
lea addresses_WC_ht+0x100a, %rdi
nop
and $56509, %r15
mov $32, %rcx
rep movsq
nop
nop
nop
nop
sub $35960, %r8
lea addresses_D_ht+0xb4d2, %rcx
nop
nop
nop
inc %rsi
mov (%rcx), %r10w
nop
add $21911, %r10
lea addresses_UC_ht+0x114d2, %rcx
nop
nop
sub %rdi, %rdi
mov $0x6162636465666768, %r8
movq %r8, %xmm3
movups %xmm3, (%rcx)
and %rsi, %rsi
lea addresses_WT_ht+0x1cb52, %r8
nop
sub %rdi, %rdi
and $0xffffffffffffffc0, %r8
movaps (%r8), %xmm3
vpextrq $1, %xmm3, %r15
nop
nop
nop
add $55479, %rsi
lea addresses_WC_ht+0x186d2, %rsi
lea addresses_normal_ht+0x1bcd2, %rdi
nop
nop
nop
nop
cmp %r12, %r12
mov $42, %rcx
rep movsb
nop
nop
nop
nop
nop
add %r8, %r8
lea addresses_UC_ht+0x15362, %rsi
lea addresses_D_ht+0x1a49a, %rdi
nop
nop
nop
nop
and %r9, %r9
mov $16, %rcx
rep movsb
nop
nop
nop
nop
add %r8, %r8
pop %rsi
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r15
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r15
push %r9
push %rax
push %rbx
// Faulty Load
lea addresses_WT+0xccd2, %r13
nop
nop
nop
nop
nop
xor $445, %rbx
vmovaps (%r13), %ymm3
vextracti128 $0, %ymm3, %xmm3
vpextrq $1, %xmm3, %rax
lea oracles, %r13
and $0xff, %rax
shlq $12, %rax
mov (%r13,%rax,1), %rax
pop %rbx
pop %rax
pop %r9
pop %r15
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_WT', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'type': 'addresses_WT', 'AVXalign': True, 'size': 32, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_WC_ht', 'congruent': 10, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 8, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 8, 'NT': False, 'same': True, 'congruent': 10}}
{'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 32, 'NT': False, 'same': False, 'congruent': 1}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 4}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 2, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 3, 'same': False}}
{'src': {'type': 'addresses_D_ht', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 9}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 10}}
{'src': {'type': 'addresses_WT_ht', 'AVXalign': True, 'size': 16, 'NT': False, 'same': False, 'congruent': 6}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WC_ht', 'congruent': 8, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_normal_ht', 'congruent': 9, 'same': False}}
{'src': {'type': 'addresses_UC_ht', 'congruent': 4, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_D_ht', 'congruent': 3, 'same': False}}
{'47': 61, '48': 5112, '44': 1269, '9a': 1, 'ff': 1, '49': 2, '00': 15383}
00 00 00 00 00 00 00 00 48 00 44 48 48 00 00 00 00 00 00 00 00 00 00 00 00 47 44 00 44 00 48 00 00 00 00 48 00 00 48 00 00 48 00 44 48 44 00 00 48 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 48 00 48 48 00 44 00 00 00 00 00 48 44 00 48 00 00 00 48 00 00 00 00 00 00 44 00 00 00 00 00 00 00 00 00 48 00 00 00 00 00 00 00 00 48 00 48 00 00 00 00 44 00 00 00 00 00 00 00 48 48 00 00 48 00 00 00 48 00 00 00 48 00 48 00 00 48 00 00 00 00 00 00 00 00 00 48 00 00 00 00 48 48 00 00 00 48 00 00 48 00 48 00 00 00 00 00 00 48 48 48 00 00 00 44 00 00 00 00 00 48 00 00 48 00 00 00 48 00 00 48 00 48 44 44 00 00 00 00 48 00 00 44 48 00 00 48 48 00 00 00 00 00 00 00 00 48 00 00 00 48 00 00 00 00 48 00 00 00 48 44 00 00 48 00 00 00 00 44 48 48 00 48 48 00 48 00 00 48 00 00 48 00 00 00 00 00 00 00 00 00 00 00 00 00 00 48 00 00 00 00 00 00 48 00 00 00 00 00 00 00 48 00 48 00 00 00 00 00 00 00 00 00 00 48 00 00 00 00 44 00 00 00 00 48 00 00 00 48 48 00 00 00 00 00 00 00 00 00 00 00 00 48 00 00 48 00 00 00 00 00 00 48 00 00 00 00 00 00 00 00 48 48 00 00 48 00 00 00 00 48 00 44 00 00 00 48 00 00 48 48 48 48 00 00 48 48 00 00 00 00 00 00 00 00 48 00 00 00 00 00 00 00 48 48 00 00 00 48 00 00 44 00 44 00 00 00 00 00 48 48 44 00 47 00 00 48 00 00 00 44 00 48 48 00 00 48 48 48 48 00 48 00 00 44 00 00 48 00 44 00 48 00 00 48 00 00 00 00 00 00 00 00 44 00 00 48 00 00 00 00 00 48 00 00 00 48 00 00 48 00 00 48 44 00 00 48 00 00 00 00 44 48 00 00 48 44 00 48 00 00 00 00 00 48 00 00 00 00 00 44 00 00 00 00 00 00 00 00 00 48 44 00 00 00 48 00 00 00 48 00 00 00 48 00 00 00 00 48 00 00 00 00 00 00 48 00 48 00 00 00 48 00 48 48 00 48 00 48 48 00 00 00 00 00 00 00 00 00 48 00 44 00 00 00 00 00 00 00 00 00 48 00 00 48 00 44 00 00 00 00 44 48 00 00 48 00 00 44 00 00 48 48 00 00 47 00 44 00 00 48 00 00 00 00 00 48 00 48 48 00 00 48 00 00 00 44 00 00 00 00 00 00 00 00 00 00 48 00 48 00 00 00 44 00 44 00 00 00 00 48 00 48 00 48 00 00 00 00 00 48 00 48 00 44 00 48 00 00 48 00 44 00 00 00 00 44 00 00 00 48 00 00 48 00 00 48 00 00 00 00 48 00 00 00 44 00 00 00 00 44 48 00 00 48 00 00 48 48 48 00 48 48 48 00 00 00 00 48 00 00 48 00 00 00 00 48 48 00 00 48 00 00 00 48 00 00 00 48 48 00 00 00 48 00 00 48 48 00 00 00 00 48 00 00 48 00 48 00 00 00 48 00 48 48 48 00 44 48 48 00 44 00 00 48 00 48 00 44 00 48 48 00 48 00 00 00 48 48 48 00 00 48 00 44 00 00 00 00 00 00 48 00 00 00 00 00 00 00 00 00 00 00 00 00 48 48 00 00 48 00 00 48 48 00 48 00 48 00 00 44 00 00 00 00 00 00 48 00 00 00 44 48 00 48 48 00 48 00 00 00 48 00 00 00 00 00 00 48 48 00 48 00 00 48 00 00 00 48 48 00 00 48 00 00 00 00 00 48 48 00 00 48 00 00 00 44 00 48 00 00 00 00 48 00 00 00 00 00 48 00 00 00 00 00 00 00 00 00 00 48 00 48 00 48 44 48 00 48 00 00 48 48 48 48 00 00 00 48 48 48 48 00 00 00 00 00 48 00 48 48 00 00 44 00 00 00 00 44 00 44 00 00 00 44 00 44 48 00 00 48 00 48 48 48 00 48 00 00 48 00 00 00 44 00 00 00 00 44 00 00 00 00 48 00 00 48 00 00 00 00 00 00 00 00 44 00 00 00 00 00 48 00 00 00 00 00 00 00 00 44 00
*/
| 36.824176
| 2,999
| 0.658162
|
b5d2af85652bc08ed770751806709bda0f0b12ed
| 3,643
|
asm
|
Assembly
|
lcd_serial.asm
|
pbanaszkiewicz/excercises_ASM_8051
|
651063622c08bab0612b17f3e1a5d8f742075ffb
|
[
"MIT"
] | 1
|
2021-03-18T14:01:31.000Z
|
2021-03-18T14:01:31.000Z
|
lcd_serial.asm
|
pbanaszkiewicz/excercises_ASM_8051
|
651063622c08bab0612b17f3e1a5d8f742075ffb
|
[
"MIT"
] | null | null | null |
lcd_serial.asm
|
pbanaszkiewicz/excercises_ASM_8051
|
651063622c08bab0612b17f3e1a5d8f742075ffb
|
[
"MIT"
] | null | null | null |
.area MAIN(ABS)
; ustawienie pewnych "stałych"
RS .equ P1.0
EN .equ P1.1
DB4 .equ P1.2
DB5 .equ P1.3
DB6 .equ P1.4
DB7 .equ P1.5
DATALINE .equ P1 ; samo "DATA" nie chce się kompilować
.org 0x00
LJMP INIT
.org 0x23
LJMP SERIAL_IRQ
.org 0x30
INIT:
; ustawienia komunikacji szeregowej
MOV PCON, #0x00 ; brak SMOD
MOV SCON, #0x50 ; SETB REN (odbiór), SETB SM1 (tryb 1, transmisja asyn.)
MOV TMOD, #0x20 ; drugi tryb zegara T1 (z przeładowaniem)
MOV TH1, #0xFD ; dla baud=9600
MOV TL1, #0xFD ;
; uruchomienie przerwań (w tym przerwania od portu szereg.) i timerów
SETB EA
SETB ES
SETB TR1
; nie wiadomo czy resetowanie linii ma w tym miejscu jakikolwiek sens
;MOV DATALINE, #0
; 3 razy należy czekać i wysyłać wartość 0x3
LCALL WAIT_LCD
MOV DATALINE, #0b00001100
SETB EN
CLR EN
LCALL WAIT_LCD
MOV DATALINE, #0b00001100
SETB EN
CLR EN
LCALL WAIT_LCD
MOV DATALINE, #0b00001100
SETB EN
CLR EN
; dla pewności jeszcze jedno czekanie
LCALL WAIT_LCD
; Koniec inicjalizacji przez czekanie, następne instrukcje można wykonać
; korzystając z flagi BF (Busy Flag).
; Niestety tryb READ wyświetlacza w laboratorium jest niedostępny, więc
; i tak musimy korzystać z WAIT_LCD.
; ustawienie trybu 4-bitowego (wysłane w trybie 8-bitowym, czyli starszą
; połową bajtu)
MOV DATALINE, #0b00001000
SETB EN
CLR EN
LCALL WAIT_LCD
; tryb funkcji (0x2), ustawienie ilości linii i czcionki
MOV A, #0x20
LCALL WRITE_LCD
LCALL WAIT_LCD
; wyświetlacz włączony (0x0E) lub nie (0x08)
MOV A, #0x0E
LCALL WRITE_LCD
LCALL WAIT_LCD
; czyszczenie wyświetlacza
MOV A, #0x01
LCALL WRITE_LCD
LCALL WAIT_LCD
; ustawienie trybu wprowadzania (inkr. adresu o 1, przesuwanie kursora)
MOV A, #0x06
LCALL WRITE_LCD
LCALL WAIT_LCD
; koniec inicjalizacji LCD ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MAIN:
MOV A, #'H'
LCALL WRITE_CHAR
MOV A, #'e'
LCALL WRITE_CHAR
MOV A, #'l'
LCALL WRITE_CHAR
MOV A, #'l'
LCALL WRITE_CHAR
MOV A, #'o'
LCALL WRITE_CHAR
LOOP:
LJMP LOOP
; oczekiwanie na LCD
WAIT_LCD:
MOV R1, #232
MOV R2, #42
petla3:
petla2:
;petla1:
; DJNZ R0, petla1;
DJNZ R1, petla2;
DJNZ R2, petla3;
RET
; wysłanie dowolnych danych do LCD
WRITE_LCD:
PUSH ACC ; wartość akumulatora przyda się do wysyłania pozostałych 4b
; zmieniamy ustawienie *tylko* DB7-DB4 na 1
ORL DATALINE, #0b00111100
; ustawiamy młodsze 4b na 1
ORL A, #0x0F
; przesuwamy (cyklicznie) akumulator w prawo o dwie pozycje
; dzięki temu zabiegowi najstarsze 4b są na pozycjach bitów 6-2
RR A
RR A
; logiczny AND ustawia tylko bity odpowiadające DB7-DB4
ANL DATALINE, A
SETB EN
CLR EN
; wydaje się, że ten postój jest niepotrzebny
;LCALL WAIT_LCD
POP ACC ; ściągamy zapisaną wartość ze stosu
SWAP A ; dzięki temu starsze 4b zmienione są z młodszymi 4b
; cały proces jest powtórzony
ORL DATALINE, #0b00111100
ORL A, #0x0F
RR A
RR A
ANL DATALINE, A
SETB EN
CLR EN
RET
; wypisanie znaku z akumulatora
WRITE_CHAR:
SETB RS
LCALL WRITE_LCD
LCALL WAIT_LCD
RET
; obsługa portu szeregowego
SERIAL_IRQ:
MOV A, SBUF ; zapisanie przychodzącego bajtu do akumulatora
MOV SBUF, A ; odesłanie tego samego bajtu
CLR RI; zerowanie flagi odbioru
CLR TI; zerowanie flagi nadawania
LCALL WRITE_CHAR ; wyświetlenie znaku na LCD
RETI
| 21.814371
| 77
| 0.652759
|
39e602cf7ebd4d7866b91097c934dce36c41f1ad
| 680
|
asm
|
Assembly
|
oeis/132/A132790.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/132/A132790.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/132/A132790.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A132790: Row sums of triangle A132789.
; Submitted by Jon Maiga
; 1,2,6,18,53,158,486,1550,5109,17298,59799,210048,746983,2682618,9711214,35390422,129710309,477769754,1767525315,6564644688,24467315575,91484660770,343063807931,1289912535908,4861963178643,18367386626558,69533618024841,263748085968060,1002242485086795,3814987038963186,14544637112968702,55534067024531814,212336134707210373,812944050739665322,3116285512087170411,11959798420220191824,45950804393341219063,176733862924445654834,680425372004853707295,2622127042826247922668,10113918592737409761755
mov $1,2
pow $1,$0
seq $0,273526 ; Number of 123-avoiding indecomposable permutations.
add $1,$0
mov $0,$1
sub $0,1
| 61.818182
| 496
| 0.858824
|
a66d64198786ee1373eb5e33263650c4edbaaf21
| 186
|
asm
|
Assembly
|
test/s/ext/float.asm
|
rolf0504/c2verilog
|
835f8453841c9090b7431354bf97f07b4ff92c1f
|
[
"MIT"
] | 252
|
2018-11-09T07:48:20.000Z
|
2022-03-08T04:33:29.000Z
|
test/s/ext/float.asm
|
rolf0504/c2verilog
|
835f8453841c9090b7431354bf97f07b4ff92c1f
|
[
"MIT"
] | 1
|
2019-07-18T20:37:51.000Z
|
2019-07-31T02:20:31.000Z
|
test/s/ext/float.asm
|
rolf0504/c2verilog
|
835f8453841c9090b7431354bf97f07b4ff92c1f
|
[
"MIT"
] | 95
|
2019-01-11T03:32:43.000Z
|
2022-03-19T08:28:18.000Z
|
@main
0;JMP
(C4) 4.0
(PI) 3.14159
(main)
@PI
D=A
@16 // get F(PI)
swi
@18 // putf F
swi
@PI
D=A
@19 // fadd F , PI
swi
@18 // putf F
swi
@C4
D=A
@21 // fmul F, 2
swi
@18 // putf F
swi
| 7.153846
| 18
| 0.537634
|
bdab05e5545c8fcc06035db366059e40c24cc647
| 1,634
|
asm
|
Assembly
|
a500rom.asm
|
franciscozdo/FreeRTOS-Amiga
|
6de616c296b498946fffa50203dbb114c370fe70
|
[
"MIT"
] | 11
|
2020-02-06T08:43:47.000Z
|
2022-03-15T17:39:05.000Z
|
a500rom.asm
|
franciscozdo/FreeRTOS-Amiga
|
6de616c296b498946fffa50203dbb114c370fe70
|
[
"MIT"
] | 11
|
2020-02-26T13:58:50.000Z
|
2021-03-17T07:02:05.000Z
|
a500rom.asm
|
franciscozdo/FreeRTOS-Amiga
|
6de616c296b498946fffa50203dbb114c370fe70
|
[
"MIT"
] | 12
|
2020-04-01T06:43:32.000Z
|
2021-04-18T23:11:08.000Z
|
include 'hardware/custom.i'
include 'hardware/cia.i'
ChipStart equ $400
ChipEnd equ $80000
SlowStart equ $c00000
SlowEnd equ $c80000
; custom chips addresses
custom equ $dff000
ciaa equ $bfe001
ciab equ $bfd000
; A500 kickstart begin address
org $fc0000
Kickstart:
dc.l $400 ; Initial SP
dc.l Entry ; Initial PC
; The ROM is located at $fc0000 but is mapped at $0 after reset shadowing RAM
Entry:
lea ciaa,a6
move.b #3,ciaddra(a6) ; Set port A direction to output for /LED and OVL
move.b #0,ciapra(a6) ; Disable OVL (Memory from $0 onwards available)
InitHW:
move.w #$7fff,d0 ; Make sure DMA and interrupts are disabled
lea custom,a6
move.w d0,intena(a6)
move.w d0,intreq(a6)
move.w d0,dmacon(a6)
Setup:
move.l #(HunkFileEnd-HunkFile),d2
move.l #HunkFile,d3
move.l #BD_SIZE+3*MR_SIZE,a3
sub.l a3,sp
move.l sp,a6
clr.l BD_ENTRY(a6)
clr.l BD_VBR(a6)
clr.w BD_CPUMODEL(a6)
move.w #2,BD_NREGIONS(a6)
lea BD_REGION(a6),a0
move.l #SlowStart,(a0)+
move.l #SlowEnd,(a0)+
move.l #ChipStart,(a0)+
move.l #ChipEnd,(a0)+
clr.l (a0)+
clr.l (a0)+
ROM = 1
include '$(TOPDIR)/bootloader.asm'
HunkFile
incbin '$(PROGRAM).exe'
HunkFileEnd
org $fffff0
dc.w $4718, $4819, $4f1a, $531b
dc.w $541c, $4f1d, $571e, $4e1f
; vim: ft=asm68k:ts=8:sw=8:noet:
| 23.342857
| 81
| 0.546512
|
e9a2b08332d31ff6268e4b187f7069f92919504e
| 1,691
|
asm
|
Assembly
|
programs/oeis/036/A036488.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/036/A036488.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/036/A036488.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
; A036488: Nearest integer to n^(5/2).
; 0,1,6,16,32,56,88,130,181,243,316,401,499,609,733,871,1024,1192,1375,1574,1789,2021,2270,2537,2822,3125,3447,3788,4149,4529,4930,5351,5793,6256,6741,7247,7776,8327,8901,9499,10119,10764,11432,12125,12842,13584,14351,15144,15963,16807,17678,18575,19499,20450,21428,22434,23468,24529,25619,26738,27885,29062,30268,31503,32768,34063,35388,36744,38130,39548,40996,42476,43988,45531,47106,48714,50354,52027,53732,55471,57243,59049,60888,62762,64669,66611,68588,70599,72645,74727,76843,78996,81184,83408,85668,87965,90298,92668,95075,97519,100000,102519,105075,107670,110302,112973,115682,118429,121216,124041,126906,129810,132753,135736,138759,141822,144926,148069,151253,154478,157744,161051,164399,167789,171220,174693,178208,181765,185364,189005,192690,196417,200187,203999,207856,211755,215699,219686,223716,227791,231910,236074,240282,244534,248832,253175,257562,261995,266474,270998,275568,280183,284845,289553,294308,299109,303957,308851,313793,318781,323817,328901,334032,339210,344437,349711,355034,360405,365825,371293,376810,382376,387991,393655,399368,405131,410943,416805,422717,428679,434692,440754,446867,453031,459245,465510,471827,478194,484613,491083,497604,504177,510803,517480,524209,530990,537824,544710,551649,558641,565685,572783,579934,587138,594395,601706,609071,616490,623962,631489,639070,646705,654395,662139,669938,677792,685700,693664,701683,709758,717888,726074,734315,742612,750966,759375,767841,776363,784941,793576,802268,811017,819823,828686,837606,846583,855618,864711,873861,883069,892335,901660,911042,920483,929982,939540,949156,958832,968566,978359
pow $0,5
lpb $0,1
add $1,2
sub $0,$1
trn $0,0
lpe
div $1,2
| 153.727273
| 1,585
| 0.823773
|
5a1a666b9953122c92c9fa91a96a6c1d9f4d0b28
| 113
|
asm
|
Assembly
|
libsrc/stdio_new/error/stdio_error_zc.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | 8
|
2017-01-18T12:02:17.000Z
|
2021-06-12T09:40:28.000Z
|
libsrc/stdio_new/error/stdio_error_zc.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | 1
|
2017-03-06T07:41:56.000Z
|
2017-03-06T07:41:56.000Z
|
libsrc/stdio_new/error/stdio_error_zc.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | 3
|
2017-03-07T03:19:40.000Z
|
2021-09-15T17:59:19.000Z
|
; stdio_error_zc
; 06.2008 aralbrec
PUBLIC stdio_error_zc
pop hl
.stdio_error_zc
ld hl,0
scf
ret
| 8.692308
| 21
| 0.690265
|
9d13f8eaf2e5cfb8a679f8e30ecf31182fb15066
| 707
|
asm
|
Assembly
|
oeis/009/A009759.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/009/A009759.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/009/A009759.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A009759: Expansion of (3 - 21*x + 4*x^2)/((x-1)*(x^2 - 6*x + 1)).
; Submitted by Jamie Morken(s1.)
; -3,0,17,116,693,4056,23657,137900,803757,4684656,27304193,159140516,927538917,5406093000,31509019097,183648021596,1070379110493,6238626641376,36361380737777,211929657785300,1235216565974037,7199369738058936,41961001862379593,244566641436218636,1425438846754932237,8308066439093374800,48422959787805316577,282229692287738524676,1644955193938625831493,9587501471344016464296,55880053634125472954297,325692820333408821261500,1898276868366327454614717,11063968389864555906426816
lpb $0
sub $0,1
add $2,$1
add $1,$2
add $1,$2
add $1,1
add $2,$1
lpe
mov $0,$1
mul $0,2
sub $2,1
add $0,$2
sub $0,2
| 39.277778
| 476
| 0.78925
|
8909771dfa4e38654e9a7e655a45db5ac1fa8297
| 624
|
asm
|
Assembly
|
libsrc/graphics/unused/sprite.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 8
|
2017-01-18T12:02:17.000Z
|
2021-06-12T09:40:28.000Z
|
libsrc/graphics/unused/sprite.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 1
|
2017-03-06T07:41:56.000Z
|
2017-03-06T07:41:56.000Z
|
libsrc/graphics/unused/sprite.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 3
|
2017-03-07T03:19:40.000Z
|
2021-09-15T17:59:19.000Z
|
;
; Print using 8x8 font to the Map
;
;
; $Id: sprite.asm,v 1.3 2016-07-14 17:44:17 pauloscustodio Exp $
;
PUBLIC sprite
EXTERN swapgfxbk
EXTERN base_graphics
;Print a 16x16 sprite to the screen - sprites stored as characters..
;Entry: hl=sprite address
; d=y
; e=x
;Each map row consists of 256 bytes, each character is unique so can just
;copy..
.sprite
call swapgfxbk
ex de,hl
ld a,l
sla a
sla a
sla a
ld l,a
ld bc,(base_graphics)
add hl,bc
ex de,hl
;hl=sprite, de=map address
ld bc,16
ldir
ex de,hl
ld bc,256-16
add hl,bc
ex de,hl
ld bc,16
ldir
call swapgfxbk
ret
| 13.565217
| 73
| 0.663462
|
28d1bc180e5125d84ab86e4ecd36df5946a809fe
| 9,085
|
asm
|
Assembly
|
Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca.log_970_908.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 9
|
2020-08-13T19:41:58.000Z
|
2022-03-30T12:22:51.000Z
|
Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca.log_970_908.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 1
|
2021-04-29T06:29:35.000Z
|
2021-05-13T21:02:30.000Z
|
Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca.log_970_908.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 3
|
2020-07-14T17:07:07.000Z
|
2022-03-21T01:12:22.000Z
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r12
push %r14
push %r15
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x313a, %r15
nop
dec %r14
mov $0x6162636465666768, %rdi
movq %rdi, %xmm2
and $0xffffffffffffffc0, %r15
movaps %xmm2, (%r15)
nop
nop
nop
nop
nop
sub %rcx, %rcx
lea addresses_A_ht+0x3b46, %r12
clflush (%r12)
nop
nop
nop
add %r10, %r10
mov (%r12), %r11d
nop
nop
and %r12, %r12
lea addresses_WC_ht+0x16c4c, %r14
nop
nop
nop
xor %rcx, %rcx
vmovups (%r14), %ymm0
vextracti128 $1, %ymm0, %xmm0
vpextrq $1, %xmm0, %r10
xor $23967, %r10
lea addresses_WT_ht+0x19de, %r10
nop
nop
nop
nop
inc %rcx
movl $0x61626364, (%r10)
nop
nop
sub %r14, %r14
lea addresses_UC_ht+0xa25c, %rsi
lea addresses_UC_ht+0x224c, %rdi
clflush (%rdi)
nop
nop
nop
nop
nop
inc %r11
mov $110, %rcx
rep movsl
nop
nop
nop
dec %r10
lea addresses_A_ht+0xd44c, %rsi
nop
nop
sub $3847, %r11
mov $0x6162636465666768, %r10
movq %r10, %xmm4
vmovups %ymm4, (%rsi)
add %r11, %r11
lea addresses_UC_ht+0x1b44c, %rsi
lea addresses_normal_ht+0x15c4c, %rdi
clflush (%rdi)
nop
nop
nop
nop
sub $56377, %r12
mov $84, %rcx
rep movsl
nop
nop
nop
add $59551, %rdi
lea addresses_UC_ht+0x1558c, %rsi
lea addresses_UC_ht+0xc28b, %rdi
add %r14, %r14
mov $51, %rcx
rep movsb
nop
nop
nop
nop
nop
add $14042, %r15
lea addresses_WT_ht+0xe11c, %r15
nop
nop
add %r12, %r12
movw $0x6162, (%r15)
nop
nop
nop
nop
nop
cmp $61593, %r11
lea addresses_D_ht+0x718c, %r11
nop
nop
nop
add %rsi, %rsi
movw $0x6162, (%r11)
nop
nop
nop
nop
xor $46282, %r15
lea addresses_D_ht+0xfac4, %rsi
nop
xor %r15, %r15
mov $0x6162636465666768, %r12
movq %r12, %xmm3
and $0xffffffffffffffc0, %rsi
movaps %xmm3, (%rsi)
nop
nop
nop
nop
nop
sub $54113, %r10
lea addresses_WT_ht+0x2e4c, %r11
nop
nop
nop
nop
xor %rcx, %rcx
movw $0x6162, (%r11)
nop
nop
xor %rdi, %rdi
lea addresses_normal_ht+0x1aa4c, %r15
inc %r11
vmovups (%r15), %ymm2
vextracti128 $1, %ymm2, %xmm2
vpextrq $1, %xmm2, %rsi
nop
nop
nop
nop
nop
inc %r12
pop %rsi
pop %rdi
pop %rcx
pop %r15
pop %r14
pop %r12
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r12
push %r14
push %r9
push %rdx
push %rsi
// Store
lea addresses_A+0x4f9c, %r11
clflush (%r11)
nop
nop
nop
nop
nop
add %r10, %r10
movb $0x51, (%r11)
cmp %r9, %r9
// Store
mov $0x307d4e0000000d4c, %r14
nop
nop
nop
nop
nop
cmp $42432, %r12
movb $0x51, (%r14)
nop
and %r10, %r10
// Load
lea addresses_normal+0x1fd24, %r11
nop
nop
nop
nop
xor %r12, %r12
mov (%r11), %r9w
nop
nop
nop
nop
nop
inc %rdx
// Store
lea addresses_A+0x624c, %r11
nop
nop
add %rdx, %rdx
mov $0x5152535455565758, %r10
movq %r10, (%r11)
nop
xor $56129, %rdx
// Store
lea addresses_WT+0x115c4, %r10
nop
nop
sub $25786, %r14
mov $0x5152535455565758, %r12
movq %r12, (%r10)
nop
nop
nop
nop
nop
sub $38947, %r9
// Store
lea addresses_normal+0x1c84c, %rsi
nop
nop
nop
nop
nop
and %r12, %r12
mov $0x5152535455565758, %r10
movq %r10, (%rsi)
nop
nop
inc %rsi
// Store
lea addresses_D+0x1decc, %r10
clflush (%r10)
nop
xor $35069, %rsi
movw $0x5152, (%r10)
nop
nop
sub $567, %r9
// Faulty Load
lea addresses_normal+0x144c, %r14
nop
nop
nop
sub %rsi, %rsi
mov (%r14), %r12
lea oracles, %rdx
and $0xff, %r12
shlq $12, %r12
mov (%rdx,%r12,1), %r12
pop %rsi
pop %rdx
pop %r9
pop %r14
pop %r12
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_normal', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 1, 'NT': False, 'type': 'addresses_A', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 1, 'NT': False, 'type': 'addresses_NC', 'same': False, 'AVXalign': False, 'congruent': 8}}
{'OP': 'LOAD', 'src': {'size': 2, 'NT': False, 'type': 'addresses_normal', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_A', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_WT', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_normal', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'STOR', 'dst': {'size': 2, 'NT': False, 'type': 'addresses_D', 'same': False, 'AVXalign': False, 'congruent': 5}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_normal', 'same': True, 'AVXalign': False, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': True, 'congruent': 1}}
{'OP': 'LOAD', 'src': {'size': 4, 'NT': True, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 1}}
{'OP': 'LOAD', 'src': {'size': 32, 'NT': False, 'type': 'addresses_WC_ht', 'same': False, 'AVXalign': False, 'congruent': 10}}
{'OP': 'STOR', 'dst': {'size': 4, 'NT': False, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 1}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 4}, 'dst': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 9}}
{'OP': 'STOR', 'dst': {'size': 32, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 9}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 11}, 'dst': {'same': False, 'type': 'addresses_normal_ht', 'congruent': 5}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 6}, 'dst': {'same': False, 'type': 'addresses_UC_ht', 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 2, 'NT': False, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 2, 'NT': False, 'type': 'addresses_D_ht', 'same': False, 'AVXalign': False, 'congruent': 6}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_D_ht', 'same': False, 'AVXalign': True, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'size': 2, 'NT': True, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': True, 'congruent': 7}}
{'OP': 'LOAD', 'src': {'size': 32, 'NT': False, 'type': 'addresses_normal_ht', 'same': False, 'AVXalign': False, 'congruent': 8}}
{'34': 970}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
| 28.933121
| 2,909
| 0.654375
|
f21cef16b60742a1c32fe0d17869bd39444f79c9
| 541
|
asm
|
Assembly
|
oeis/029/A029656.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/029/A029656.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/029/A029656.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A029656: Numbers in the (2,1)-Pascal triangle A029653 that are different from 1.
; Submitted by Christian Krause
; 2,2,3,2,5,4,2,7,9,5,2,9,16,14,6,2,11,25,30,20,7,2,13,36,55,50,27,8,2,15,49,91,105,77,35,9,2,17,64,140,196,182,112,44,10,2,19,81,204,336,378,294,156,54,11,2,21,100,285,540,714,672,450,210,65,12,2,23,121,385,825,1254,1386,1122,660,275,77,13,2,25,144,506,1210,2079,2640,2508,1782,935,352,90,14,2,27,169,650,1716,3289,4719,5148,4290
mov $1,1
lpb $0
add $2,1
sub $0,$2
add $1,1
lpe
bin $1,$0
bin $2,$0
add $2,$1
mov $0,$2
| 36.066667
| 330
| 0.674677
|
bf153d60945624e5157cefe0ce2a1a0326c04435
| 2,307
|
asm
|
Assembly
|
savefile/maps/232D_PathOfPointless_Fun.asm
|
stranck/fools2018-1
|
1c506b17343fcdfa708aafaf8e596153e2c63254
|
[
"MIT"
] | 35
|
2018-04-01T06:55:28.000Z
|
2021-05-09T19:09:42.000Z
|
savefile/maps/232D_PathOfPointless_Fun.asm
|
stranck/fools2018-1
|
1c506b17343fcdfa708aafaf8e596153e2c63254
|
[
"MIT"
] | 4
|
2018-04-01T15:32:55.000Z
|
2019-02-23T20:46:49.000Z
|
savefile/maps/232D_PathOfPointless_Fun.asm
|
stranck/fools2018-1
|
1c506b17343fcdfa708aafaf8e596153e2c63254
|
[
"MIT"
] | 12
|
2018-04-01T15:48:09.000Z
|
2021-01-27T10:22:33.000Z
|
SECTION "Map_232D_Fun", ROM0[$B800]
Map_232D_Fun_Header:
hdr_tileset 0
hdr_dimensions 5, 11
hdr_pointers_a Map_232D_Fun_Blocks, Map_232D_Fun_TextPointers
hdr_pointers_b Map_232D_Fun_Script, Map_232D_Fun_Objects
hdr_pointers_c Map_232D_Fun_InitScript, Map_232D_Fun_RAMScript
hdr_palette $06
hdr_music MUSIC_ROUTES1, AUDIO_1
hdr_connection NORTH, $223A, 9, 10
hdr_connection SOUTH, $0000, 0, 0
hdr_connection WEST, $2435, 18, 12
hdr_connection EAST, $0000, 0, 0
Map_232D_Fun_Objects:
hdr_border $0f
hdr_warp_count 0
hdr_sign_count 1
hdr_signpost 7, 5, $03
hdr_object_count 2
hdr_object SPRITE_BUG_CATCHER, 7, 13, STAY, NONE, $02
hdr_object SPRITE_YOUNG_BOY, 4, 4, STAY, NONE, $01
Map_232D_Fun_RAMScript:
rs_write_3 $c6f6, $0f, $31, $0f
rs_write_3 $c701, $0f, $31, $0f
rs_fill_byte $7b
rs_fill_3 $c761
rs_fill_3 $c76c
rs_end
Map_232D_Fun_Blocks:
db $0f,$31,$0f,$0f,$0f
db $0f,$31,$0a,$0a,$0f
db $0f,$31,$31,$08,$0f
db $0f,$0a,$0a,$31,$0f
db $0f,$66,$6d,$31,$6e
db $0f,$66,$0f,$31,$6e
db $0f,$66,$6d,$0a,$6e
db $0f,$66,$0f,$6f,$0f
db $90,$7b,$0f,$0f,$0f
db $90,$7b,$0f,$0f,$0f
db $0f,$0f,$0f,$0f,$0f
Map_232D_Fun_TextPointers:
dw Map_232D_Fun_TX1
dw Map_232D_Fun_TX3
dw Map_232D_Fun_TX2
Map_232D_Fun_InitScript:
ret
Map_232D_Fun_Script:
ret
Map_232D_Fun_TX1:
TX_ASM
jp EnhancedTextOnly
text "I heard they've just started"
next "building a road here."
para "For now however, this path"
next "really seems to serve"
cont "no real purpose."
done
Map_232D_Fun_TX2:
TX_ASM
jp EnhancedTextOnly
text "Western - Eastern"
next "Glitchland Pass"
para "In construction"
done
Map_232D_Fun_TX3:
TX_ASM
jp EnhancedTextOnly
text "Some progress was made"
next "towards building that path."
cont "It's about time."
para "Also, someone seems to live"
next "on the other side of that"
cont "small river."
para "But I haven't seen him in a"
next "while. I'm kind of worried."
para "Just kidding. Who cares"
next "about that guy?"
done
| 26.215909
| 71
| 0.634157
|
46bd37efa4ce67138aa4599fed270b396625a0d1
| 563
|
asm
|
Assembly
|
oeis/315/A315202.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/315/A315202.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/315/A315202.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A315202: Coordination sequence Gal.6.194.6 where G.u.t.v denotes the coordination sequence for a vertex of type v in tiling number t in the Galebach list of u-uniform tilings.
; Submitted by Jamie Morken(s4)
; 1,6,10,14,20,24,28,32,38,42,46,52,58,62,66,72,76,80,84,90,94,98,104,110,114,118,124,128,132,136,142,146,150,156,162,166,170,176,180,184,188,194,198,202,208,214,218,222,228,232
mov $1,1
mov $4,$0
mov $5,$0
lpb $0
mov $0,4
mul $0,$4
mul $4,10
mov $2,$4
mod $2,11
add $0,$2
div $0,11
mov $1,$0
lpe
mov $3,$5
mul $3,4
add $1,$3
add $0,$1
| 25.590909
| 177
| 0.666075
|
efd4e7373342076cf33f3078bd9ebfa791de4efd
| 1,267
|
asm
|
Assembly
|
src/Main.asm
|
MrCerealGuy/65816-Mandelbrot-SNES
|
c145fd05f6ce515aec483c8bc10442d83c71e69a
|
[
"MIT"
] | 1
|
2018-11-06T06:19:45.000Z
|
2018-11-06T06:19:45.000Z
|
src/Main.asm
|
MrCerealGuy/65816-Mandelbrot-SNES
|
c145fd05f6ce515aec483c8bc10442d83c71e69a
|
[
"MIT"
] | null | null | null |
src/Main.asm
|
MrCerealGuy/65816-Mandelbrot-SNES
|
c145fd05f6ce515aec483c8bc10442d83c71e69a
|
[
"MIT"
] | null | null | null |
;------------------------------------------------------------------------
;-
;- Mandelbrot set for 65816 processor (SNES)
;-
;- Andreas Zahnleiter <a.zahnleiter@gmx.d>
;-
;------------------------------------------------------------------------
;=== Include MemoryMap, VectorTable, HeaderInfo ===
.INCLUDE "inc/Main.inc"
;=== Include Library Routines & Macros ===
.INCLUDE "src/InitSNES.asm"
.INCLUDE "src/LoadGraphics.asm"
.INCLUDE "src/2Input.asm"
.INCLUDE "src/Strings.asm"
.INCLUDE "src/QuickSetup.asm"
;=== Global Variables ===
.ENUM $80
var1 db
var2 db
.ENDE
;==============================================================================
; main
;==============================================================================
.BANK 0 SLOT 0
.ORG 0
.SECTION "MainCode"
Main:
InitializeSNES
jsr QuickSetup ; set VRAM, the video mode, background and character pointers,
; and turn on the screen
jsr JoyInit ;setup joypads and enable NMI
PrintString "\n -= Mandelbrot set =-"
PrintString "\n\n by Andreas Zahnleiter"
PrintString "\n\n"
forever:
wai ;wait for next frame
;do whatever you feel like here
;let's print the current frame number
SetCursorPos 20, 10
ldy #FrameNum
PrintString "Frame num = %d "
jmp forever
.ENDS
| 21.474576
| 79
| 0.528808
|
1c6e33081597dbc1fe5af2e7342266bf2e6825f1
| 282
|
asm
|
Assembly
|
test/a32offs.asm
|
bitwiseworks/nasm-os2
|
ef78e4ee1ca3220ac3b60a61b084a693b8032ab6
|
[
"BSD-2-Clause"
] | 3
|
2015-03-21T07:35:15.000Z
|
2018-01-12T01:24:02.000Z
|
3rdParties/src/nasm/nasm-2.15.02/test/a32offs.asm
|
blue3k/StormForge
|
1557e699a673ae9adcc8f987868139f601ec0887
|
[
"Apache-2.0"
] | 1
|
2020-03-26T19:58:54.000Z
|
2020-04-24T08:58:04.000Z
|
test/a32offs.asm
|
bitwiseworks/nasm-os2
|
ef78e4ee1ca3220ac3b60a61b084a693b8032ab6
|
[
"BSD-2-Clause"
] | 5
|
2015-03-21T07:35:21.000Z
|
2021-01-14T10:54:46.000Z
|
;Testname=unoptimized; Arguments=-O0 -fbin -oa32offs.bin; Files=a32offs.bin stdout stderr
;Testname=optimized; Arguments=-Ox -fbin -oa32offs.bin; Files=a32offs.bin stdout stderr
bits 16
foo: a32 loop foo
bar: loop bar, ecx
bits 32
baz: a16 loop baz
qux: loop qux, cx
| 28.2
| 90
| 0.72695
|
14bafd3034559fa00325a3de6ffbcf2015447445
| 751
|
asm
|
Assembly
|
oeis/289/A289211.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/289/A289211.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/289/A289211.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A289211: a(n) = n! * Laguerre(n,-5).
; Submitted by Jamie Morken(s2)
; 1,6,47,446,4929,61870,866695,13373190,224995745,4094022230,80031878175,1671426609550,37116087808225,872797202471550,21656891639499575,565266064058561750,15476777687220818625,443409439715399299750,13263588837009155407375,413406072686595153990750,13401711628049881673530625,451116305815656495386108750,15743427851181513960506214375,568831100544297954258434083750,21250943895028472736330784950625,819904256418021906109004355093750,32632798425016431281897503291109375
mov $2,1
mov $3,$0
mov $4,1
lpb $3
mul $1,$3
mul $4,$3
add $1,$4
mul $1,$3
mul $2,5
cmp $4,0
add $5,$4
mov $6,$5
cmp $6,0
add $5,$6
div $1,$5
add $2,$1
sub $3,1
div $4,$5
lpe
mov $0,$2
| 30.04
| 465
| 0.76964
|
5717153bea8c3180125adbf8ebfdd237262e4c1b
| 649
|
asm
|
Assembly
|
src/test/resources/data/generationtests/sjasmplus-test3.asm
|
cpcitor/mdlz80optimizer
|
75070d984e1f08474e6d397c7e0eb66d8be0c432
|
[
"Apache-2.0"
] | 36
|
2020-06-29T06:52:26.000Z
|
2022-02-10T19:41:58.000Z
|
src/test/resources/data/generationtests/sjasmplus-test3.asm
|
cpcitor/mdlz80optimizer
|
75070d984e1f08474e6d397c7e0eb66d8be0c432
|
[
"Apache-2.0"
] | 39
|
2020-07-02T18:19:34.000Z
|
2022-03-27T18:08:54.000Z
|
src/test/resources/data/generationtests/sjasmplus-test3.asm
|
cpcitor/mdlz80optimizer
|
75070d984e1f08474e6d397c7e0eb66d8be0c432
|
[
"Apache-2.0"
] | 7
|
2020-07-02T06:00:05.000Z
|
2021-11-28T17:31:13.000Z
|
; Test case encountered when parsing aplib
DEFINE FasterGetBit
IFDEF FasterGetBit
MACRO GET_BIT
add a : call z,ReloadByte
ENDM
ELSE
MACRO GET_BIT
call GetOneBit
ENDM
ENDIF
@Decompress: ld a,128
CASE0: ldi
MainLoop: GET_BIT : jr nc,CASE0
GET_BIT : jr nc,CASE10
ld bc,%11100000
GET_BIT : jr nc,CASE110
CASE110:
CASE10:
NoLWM
bit 7,l : jr nz,.Add0
.Add2 inc bc
.Add1 inc bc
.Add0 exa
loop:
jr loop
IFNDEF FasterGetBit
GetOneBit: add a : ret nz
ENDIF
ReloadByte: ld a,(hl) : inc hl
rla : ret
| 18.027778
| 42
| 0.571649
|
41965d0ef1a6be23c2c85d2f0a5a4210af4bb6fc
| 618
|
asm
|
Assembly
|
EasySafe/utility/instrumentation_callbacks/minwinasm.asm
|
ALEHACKsp/EasySafe
|
0a1d84485430868cecde08df384d57be4caf8be4
|
[
"MIT"
] | 1
|
2021-12-15T02:43:57.000Z
|
2021-12-15T02:43:57.000Z
|
EasySafe/utility/instrumentation_callbacks/minwinasm.asm
|
SteepCheat/EasySafe
|
0a1d84485430868cecde08df384d57be4caf8be4
|
[
"MIT"
] | null | null | null |
EasySafe/utility/instrumentation_callbacks/minwinasm.asm
|
SteepCheat/EasySafe
|
0a1d84485430868cecde08df384d57be4caf8be4
|
[
"MIT"
] | 1
|
2021-12-15T22:10:28.000Z
|
2021-12-15T22:10:28.000Z
|
include ksamd64.inc
EXTERN SysHook:NEAR
.data
value qword ?
.code
medium PROC
; https://docs.microsoft.com/en-us/cpp/build/caller-callee-saved-registers
push rax ; return value
push rcx
push RBX
push RBP
push RDI
push RSI
push RSP
push r10
push r11
push R12
push R13
push R14
push R15
; without this it crashes :)
sub rsp, 1000h
mov rdx, rax
mov rcx, r10
call SysHook
mov QWORD PTR [value], rax
add rsp, 1000h
pop R15
pop R14
pop R13
pop R12
pop R11
pop R10
pop RSP
pop RSI
pop RDI
pop RBP
pop RBX
pop rcx
pop rax
mov rax, qword ptr [value]
jmp R10
medium ENDP
END
| 12.117647
| 75
| 0.694175
|
28f63e69ca7aaafa3ac18e754ab8d6f5cc0d8f2e
| 422
|
asm
|
Assembly
|
oeis/037/A037637.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/037/A037637.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/037/A037637.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A037637: Base 9 digits are, in order, the first n terms of the periodic sequence with initial period 2,1,3.
; Submitted by Christian Krause
; 2,19,174,1568,14113,127020,1143182,10288639,92597754,833379788,7500418093,67503762840,607533865562,5467804790059,49210243110534,442892187994808,3986029691953273
mov $2,1
lpb $0
sub $0,1
add $1,$2
add $1,1
mul $1,9
add $2,8
mod $2,3
lpe
add $1,$2
mov $0,$1
add $0,1
| 24.823529
| 162
| 0.734597
|
8aa7a116ec241e87a20cbf2b5cb707c326b242ec
| 432
|
asm
|
Assembly
|
oeis/050/A050182.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/050/A050182.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/050/A050182.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A050182: a(n) = T(2*n+4, n), array T as in A051168 (a count of Lyndon words).
; Submitted by Jon Maiga
; 0,1,3,12,40,143,497,1768,6288,22610,81686,297160,1086384,3991995,14732005,54587280,202995232,757398510,2834502346,10637507400,40023606896,150946230006,570534474698,2160865067312,8199711007200
mov $1,$0
add $0,2
seq $1,51197 ; T(2n+4,n), array T as in A050186; a count of aperiodic binary words.
div $1,$0
mov $0,$1
div $0,2
| 39.272727
| 193
| 0.740741
|
8449c8865859ab0a93cb89e9be8f108a45900db0
| 834
|
asm
|
Assembly
|
programs/oeis/141/A141960.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/141/A141960.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/141/A141960.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A141960: Primes congruent to 19 mod 27.
; 19,73,127,181,397,613,829,883,937,991,1153,1423,1531,1693,1747,1801,2017,2179,2287,2341,2503,2557,2719,3259,3313,3529,3583,3637,3691,3853,3907,4177,4231,4339,4447,4663,4933,4987,5419,5527,5581,5689,5743,5851,6067,6121,6229,6337,6553,6607,6661,6823,7039,7309,7417,7687,7741,8011,8389,8443,8713,8821,8929,9091,9199,9631,9739,9901,10009,10333,10657,10711,11197,11251,11467,11953,12007,12277,12547,12601,12763,12979,13033,13249,13411,13627,13681,13789,14221,14437,14653,14869,14923,15031,15139,15193,15679,15733,15787,16057
mov $2,$0
add $2,1
pow $2,2
lpb $2
add $1,18
sub $2,1
mov $3,$1
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
add $1,9
mov $4,$0
max $4,0
cmp $4,$0
mul $2,$4
lpe
div $1,2
sub $1,22
mul $1,2
add $1,37
mov $0,$1
| 34.75
| 521
| 0.720624
|
f77ebf5be1a3ff61f08cc3d62221967e86c10b7f
| 947
|
asm
|
Assembly
|
Source/Test/Case/HookSetFail/OneByteFunction.asm
|
samuelgr/Hookshot
|
cf6e0fa6c273fcac087e0c0a97097433736e72ab
|
[
"BSD-3-Clause"
] | 4
|
2021-01-10T22:25:31.000Z
|
2022-01-11T16:55:25.000Z
|
Source/Test/Case/HookSetFail/OneByteFunction.asm
|
samuelgr/Hookshot
|
cf6e0fa6c273fcac087e0c0a97097433736e72ab
|
[
"BSD-3-Clause"
] | 2
|
2021-01-11T11:23:47.000Z
|
2021-05-12T05:26:30.000Z
|
Source/Test/Case/HookSetFail/OneByteFunction.asm
|
samuelgr/Hookshot
|
cf6e0fa6c273fcac087e0c0a97097433736e72ab
|
[
"BSD-3-Clause"
] | 2
|
2020-10-02T03:07:50.000Z
|
2021-12-29T14:42:25.000Z
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Hookshot
; General-purpose library for injecting DLLs and hooking function calls.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Authored by Samuel Grossman
; Copyright (c) 2019-2021
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
INCLUDE TestDefinitions.inc
; Tests Hookshot with a single-byte function.
; Because this function consists of only a single byte, it is too short for Hookshot to hook successfully.
; Some 0 bytes need to be added afterwards to avoid Hookshot finding any valid padding.
_TEXT SEGMENT
BEGIN_HOOKSHOT_TEST_FUNCTION OneByteFunction_Test
ret
REPEAT 8
BYTE 0
ENDM
END_HOOKSHOT_TEST_FUNCTION OneByteFunction_Test
_TEXT ENDS
END
| 28.69697
| 106
| 0.488912
|
dabf9c40bcd8dd94c3aff8e07612de33953a693b
| 343
|
asm
|
Assembly
|
programs/oeis/080/A080169.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/080/A080169.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/080/A080169.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A080169: Numbers that are cubes of primes of the form 4k+1 (A002144).
; 125,2197,4913,24389,50653,68921,148877,226981,389017,704969,912673,1030301,1295029,1442897,2571353,3307949,3869893,5177717,5929741,7189057,7645373,12008989,12649337,13997521,16974593,19465109,21253933
seq $0,2144 ; Pythagorean primes: primes of form 4*k + 1.
pow $0,3
| 57.166667
| 202
| 0.793003
|
b3b20f4ac6eae2d5f384193d1c1c1f4f3faef671
| 676
|
asm
|
Assembly
|
oeis/081/A081115.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/081/A081115.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/081/A081115.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A081115: (p^2 - 1)/12 where p > 3 runs through the primes.
; Submitted by Christian Krause
; 2,4,10,14,24,30,44,70,80,114,140,154,184,234,290,310,374,420,444,520,574,660,784,850,884,954,990,1064,1344,1430,1564,1610,1850,1900,2054,2214,2324,2494,2670,2730,3040,3104,3234,3300,3710,4144,4294,4370,4524,4760,4840,5250,5504,5764,6030,6120,6394,6580,6674,7154,7854,8060,8164,8374,9130,9464,10034,10150,10384,10740,11224,11594,11970,12224,12610,13134,13400,13940,14630,14770,15480,15624,16060,16354,16800,17404,17710,17864,18174,19120,19764,20090,20750,21084,21590,22620,22794,24390,24934,25854
seq $0,173064 ; a(n) = prime(n) - 5.
add $0,7
mul $0,4
sub $0,8
pow $0,2
div $0,192
| 61.454545
| 497
| 0.75
|
f884e93ebb9383c5b293199790ab396190daea8a
| 695
|
asm
|
Assembly
|
oeis/105/A105038.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/105/A105038.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/105/A105038.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A105038: Nonnegative n such that 6*n^2 + 6*n + 1 is a square.
; Submitted by Jamie Morken(s1)
; 0,4,44,440,4360,43164,427284,4229680,41869520,414465524,4102785724,40613391720,402031131480,3979697923084,39394948099364,389969783070560,3860302882606240,38213059042991844,378270287547312204,3744489816430130200,37066627876753989800,366921788951109767804,3632151261634343688244,35954590827392327114640,355913757012288927458160,3523182979295496947466964,34875916035942680547211484,345235977380131308524647880,3417483857765370404699267320,33829602600273572738468025324,334878542144970356979980985924
lpb $0
sub $0,1
mov $1,$3
mul $1,8
add $2,1
add $2,$1
add $3,$2
lpe
mov $0,$3
mul $0,4
| 46.333333
| 498
| 0.833094
|
48834bd980566631a79a512c9bf613b8806feaa9
| 1,212
|
asm
|
Assembly
|
src/examples/blackScreen.asm
|
digitsensitive/c64
|
47b0aa02910c26f49bae967f573466b94143ec74
|
[
"Unlicense"
] | 2
|
2020-12-04T23:25:20.000Z
|
2021-11-04T21:56:37.000Z
|
src/examples/blackScreen.asm
|
digitsensitive/c64
|
47b0aa02910c26f49bae967f573466b94143ec74
|
[
"Unlicense"
] | null | null | null |
src/examples/blackScreen.asm
|
digitsensitive/c64
|
47b0aa02910c26f49bae967f573466b94143ec74
|
[
"Unlicense"
] | 1
|
2022-02-02T12:14:56.000Z
|
2022-02-02T12:14:56.000Z
|
; ==========================================================
; COMMODORE 64 - Examples in 6502 Assembly language
; © Digitsensitive; digit.sensitivee@gmail.com
; How to clear the screen to black
; ==========================================================
.include "src/include/constants.asm"
; ----------------------------------------------------------
; Main Loop
; ----------------------------------------------------------
*=$02a7 ; sys 679
init ldx #$00
stx $d020 ; Border color register
stx $d021 ; Background color
clear lda #$20 ; spacebar screen code
sta $0400,x ; fill four areas of screen with 256 spacebar characters
sta $0500,x
sta $0600,x
sta $06e8,x
lda #$00 ; set foreground to black in Color Ram
sta $d800,x
sta $d900,x
sta $da00,x
sta $dae8,x
inx
bne clear ; bne = branch on not equal
; did x turn to zero already?
; if yes -> stop loop
; if no -> continue loop
rts
| 34.628571
| 88
| 0.382838
|
ac83e0f5320b0f72e7a7e782b6d5d51cecbf49d6
| 2,160
|
asm
|
Assembly
|
asm/fpga_bootloader.asm
|
FKD13/RCPU
|
1f27246494f60eaa2432470b2d218bb3f63578c7
|
[
"MIT"
] | 17
|
2017-07-26T13:08:34.000Z
|
2022-02-19T20:44:02.000Z
|
asm/fpga_bootloader.asm
|
FKD13/RCPU
|
1f27246494f60eaa2432470b2d218bb3f63578c7
|
[
"MIT"
] | 4
|
2017-10-12T20:56:39.000Z
|
2020-05-04T09:19:44.000Z
|
asm/fpga_bootloader.asm
|
FKD13/RCPU
|
1f27246494f60eaa2432470b2d218bb3f63578c7
|
[
"MIT"
] | 4
|
2017-10-16T16:24:16.000Z
|
2022-03-21T19:07:06.000Z
|
.text
.global main:
; (blocking) reads one char from uart to the D register
; pollutes A, B, C, D
; needs 1 stack space
uart_read_char:
; push address of misc.in (which contains if uart is writeable/readable), and read option
LDV B, (0b110)
PSH B
SYS
; pop read value in B
POP B
; get second-to-last bit: AND with 2
LDV A, 2
AND A, B
; if A now contains 2, that means we can read from uart
LDV C, uart_read_char:
LDV B, 2
; if A == 0, then A < B and we will retry
JLT B, C
; read from uart to D register
LDV A, (0b1010)
PSH A
SYS
POP D
RET
; (blocking) write the D register to uart
; pollutes A, B, C
; needs 2 stack space
uart_send_char:
LDV B, (0b110)
PSH B
SYS
; pop read value in B
POP B
; get last bit: AND with 1
LDV A, 1
AND A, B
; if A now contains 1, that means we can write to uart
LDV C, uart_send_char:
LDV B, 1
; if A == 0, then A < B and we will retry
JLT B, C
; else write to uart
PSH D
LDV A, (0b1001)
PSH A
SYS
RET
; blocking, reads two chars from uart into a 16-bit value into the D register
; the first character is the most significant byte, the second character the least
; pollutes A, B, C, D
read_16_bits_from_uart:
LDV A, uart_read_char:
CAL A
; D contains the first 8 bits of the address, shift it and push it onto the stack
LSH D, 7
LSH D, 1
PSH D
LDV A, uart_read_char:
CAL A
; D now contains the last 8 bits of the address
POP C
; C now contains the first 8 bits of the address
OR D, C
; now D contains the full address
RET
main:
; send a single '>'
LDV A, uart_send_char:
LDV D, 62
CAL A
LDV A, read_16_bits_from_uart:
CAL A
; push the address onto the stack
PSH D
LDV A, read_16_bits_from_uart:
CAL A
; the value to load is now in the D register
POP C
LDP C, D
; The first ever instruction will be a jump to main
; this makes it easy to transfer control flow to the now-loaded program:
; you just need to overwrite the jump in address 0 with a jump to your loaded program
JMP 0
| 22.5
| 91
| 0.638426
|
d0ca85dd508de5a89d4c03920b370348c7b6c995
| 274
|
asm
|
Assembly
|
libsrc/fcntl/spectrum/zxbasdrv/zx_hardcopy.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
libsrc/fcntl/spectrum/zxbasdrv/zx_hardcopy.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
libsrc/fcntl/spectrum/zxbasdrv/zx_hardcopy.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
;
; Just enter BASIC at the "Hardcopy" line
;
; Stefano - 12/7/2006
;
; void zx_hardcopy()
;
; $Id: zx_hardcopy.asm,v 1.4 2015/01/19 01:32:43 pauloscustodio Exp $
PUBLIC zx_hardcopy
EXTERN zx_goto
.zx_hardcopy
ld hl,7800 ; BASIC routine for "hardcopy"
jp zx_goto
| 14.421053
| 69
| 0.69708
|
cc51ab6bbe17f328860bf200e62760e2c14b820b
| 185
|
asm
|
Assembly
|
data/pokemon/dex_entries/snorunt.asm
|
AtmaBuster/pokeplat-gen2
|
fa83b2e75575949b8f72cb2c48f7a1042e97f70f
|
[
"blessing"
] | 6
|
2021-06-19T06:41:19.000Z
|
2022-02-15T17:12:33.000Z
|
data/pokemon/dex_entries/snorunt.asm
|
AtmaBuster/pokeplat-gen2-old
|
01e42c55db5408d72d89133dc84a46c699d849ad
|
[
"blessing"
] | null | null | null |
data/pokemon/dex_entries/snorunt.asm
|
AtmaBuster/pokeplat-gen2-old
|
01e42c55db5408d72d89133dc84a46c699d849ad
|
[
"blessing"
] | 3
|
2021-01-15T18:45:40.000Z
|
2021-10-16T03:35:27.000Z
|
db "SNOW HAT@" ; species name
db "It's said that if"
next "they appear at"
next "midnight, they'll"
page "cause heavy snow."
next "They eat snow and"
next "ice to survive.@"
| 18.5
| 30
| 0.654054
|
90b44b77d92e46ed11a10a7b59687bc88675b9e1
| 471
|
asm
|
Assembly
|
programs/oeis/186/A186389.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/186/A186389.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/186/A186389.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A186389: Adjusted joint rank sequence of (f(i)) and (g(j)) with f(i) after g(j) when f(i)=g(j), where f(i)=6i and g(j)=j(j+1)/2 (triangular number). Complement of A186390.
; 4,6,8,10,12,14,15,17,18,20,22,23,25,26,27,29,30,32,33,35,36,37,39,40,41,43,44,45,47,48,49,51,52,53,55,56,57,58,60,61,62,63,65,66,67,69,70,71,72,74,75,76,77,78,80,81,82,83,85,86,87,88,90,91,92
mov $2,$0
add $0,1
mul $0,6
seq $0,2024 ; n appears n times; a(n) = floor(sqrt(2n) + 1/2).
add $0,$2
| 52.333333
| 193
| 0.63482
|
65a0d9bc9fb713d47e229ae933c876e9cf81d945
| 1,144
|
asm
|
Assembly
|
libsrc/_DEVELOPMENT/stdio/z80/asm_fsetpos_unlocked.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
libsrc/_DEVELOPMENT/stdio/z80/asm_fsetpos_unlocked.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
libsrc/_DEVELOPMENT/stdio/z80/asm_fsetpos_unlocked.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
; ===============================================================
; Jan 2014
; ===============================================================
;
; int fsetpos_unlocked(FILE *stream, const fpos_t *pos)
;
; Set the file position of stream according to pos.
;
; ===============================================================
SECTION code_stdio
PUBLIC asm_fsetpos_unlocked
PUBLIC asm0_fsetpos_unlocked
EXTERN STDIO_SEEK_SET
EXTERN asm0_fseek_unlocked
asm_fsetpos_unlocked:
; enter : ix = FILE *
; hl = fpos_t *pos
;
; exit : ix = FILE *
;
; success
;
; hl = 0
; carry reset
;
; fail
;
; hl = -1
; carry set
;
; uses : all except ix
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF __CLIB_OPT_STDIO & $01
EXTERN __stdio_verify_valid
call __stdio_verify_valid
ret c
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
asm0_fsetpos_unlocked:
ld e,(hl)
inc hl
ld d,(hl)
inc hl
ld a,(hl)
inc hl
ld h,(hl)
ld l,a
ex de,hl ; dehl = file position
ld c,STDIO_SEEK_SET
jp asm0_fseek_unlocked
| 17.6
| 65
| 0.442308
|
a449ede0d2d0e621ca94f086254e7ef8bdaf2b85
| 392
|
asm
|
Assembly
|
programs/oeis/187/A187881.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/187/A187881.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/187/A187881.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
; A187881: Triangle read by rows: the n-th column consists of n n's followed by 0's.
; 1,0,2,0,2,3,0,0,3,4,0,0,3,4,5,0,0,0,4,5,6,0,0,0,4,5,6,7,0,0,0,0,5,6,7,8,0,0,0,0,5,6,7,8,9,0,0,0,0,0,6,7,8,9,10,0,0,0,0,0,6,7,8,9,10,11
mul $0,3
add $0,3
mov $1,4
mov $4,1
lpb $0,2
add $1,$0
sub $0,$4
add $2,1
add $4,1
lpb $2
trn $2,$0
add $4,2
lpe
add $0,1
mul $1,$2
lpe
div $1,3
| 18.666667
| 136
| 0.538265
|
305e620ccce149b74edf1439a0f273f384e82a2a
| 576
|
asm
|
Assembly
|
programs/oeis/120/A120194.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/120/A120194.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/120/A120194.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A120194: a(n) = ceiling( Sum_{i=1..n-1} a(i)/8 ), a(1)=1.
; 1,1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,4,4,5,5,6,7,8,9,10,11,12,14,16,18,20,22,25,28,32,36,40,45,51,57,64,72,81,91,103,116,130,146,165,185,208,234,264,297,334,376,423,475,535,602,677,762,857,964,1084,1220,1372,1544
mov $3,$0
mov $5,2
lpb $5
mov $0,$3
sub $5,1
add $0,$5
trn $0,1
seq $0,279079 ; Maximum starting value of X such that repeated replacement of X with X-ceiling(X/9) requires n steps to reach 0.
add $0,1
mov $2,$5
mul $2,$0
add $1,$2
mov $4,$0
lpe
min $3,1
mul $3,$4
sub $1,$3
mov $0,$1
| 26.181818
| 209
| 0.609375
|
41c078e198335022c8de403c702f493a6d880192
| 743
|
asm
|
Assembly
|
16bit with mul/16bit_Multiplication.asm
|
Shivaakriti/Basic_Assembly_Program
|
9b60c062484c8c6a3d26f8ba9753a46ea2d4b7d1
|
[
"Unlicense"
] | null | null | null |
16bit with mul/16bit_Multiplication.asm
|
Shivaakriti/Basic_Assembly_Program
|
9b60c062484c8c6a3d26f8ba9753a46ea2d4b7d1
|
[
"Unlicense"
] | null | null | null |
16bit with mul/16bit_Multiplication.asm
|
Shivaakriti/Basic_Assembly_Program
|
9b60c062484c8c6a3d26f8ba9753a46ea2d4b7d1
|
[
"Unlicense"
] | null | null | null |
/*
* MUL16BIT1.asm
*
* Created: 29-08-2016 19:30:40
* Author: Administrator
*/
.INCLUDE "M128DEF.INC"
.CSEG
.ORG 0x0100
LDI R16,$55 ;LOADING THE VALUES
LDI R17,$55 ;IN R117,R16
LDI R18,$11 ;AND
LDI R19,$55 ;R19,R18
MUL R19,R17 ;PERFORMING MULTIPLICATION HENCEFORTH
MOV R20,R0
MOV R21,R1
MUL R16,R19
MOV R22,R0
MOV R23,R1
MUL R17,R18
MOV R24,R0
MOV R25,R1
MUL R18,R16
MOV R26,R0
MOV R27,R1 ;DONE WITH MULTIPLICATION
ADD R21,R22 ;ADDING THE APPROPRIATE REGISTERS
ADC R23,R25 ;FOR GETTING THE SOLUTION IN
ADD R21,R24 ;R25 R23 R21 R20
ADC R23,R26
BRCC NEXT
INC R27
NEXT:MOV R22,R23
MOV R23,R27
CLR R0
CLR R1
CLR R24
CLR R25
CLR R26
CLR R27
END: RJMP END ;END LOOP
| 18.575
| 54
| 0.660834
|
1d5446bc229ac3f04a695721552c129f63d73df8
| 1,038
|
asm
|
Assembly
|
libsrc/c128/invdc.asm
|
andydansby/z88dk-mk2
|
51c15f1387293809c496f5eaf7b196f8a0e9b66b
|
[
"ClArtistic"
] | 1
|
2020-09-15T08:35:49.000Z
|
2020-09-15T08:35:49.000Z
|
libsrc/c128/invdc.asm
|
andydansby/z88dk-MK2
|
51c15f1387293809c496f5eaf7b196f8a0e9b66b
|
[
"ClArtistic"
] | null | null | null |
libsrc/c128/invdc.asm
|
andydansby/z88dk-MK2
|
51c15f1387293809c496f5eaf7b196f8a0e9b66b
|
[
"ClArtistic"
] | null | null | null |
;
;Based on the SG C Tools 1.7
;(C) 1993 Steve Goldsmith
;
;$Id: invdc.asm,v 1.1 2008/06/23 17:34:33 stefano Exp $
;
;get vdc register
XLIB invdc
invdc:
;pop de ;return address
;pop hl ;vdc register to set
;push hl
;push de
; __FASTCALL__, so vdc register to set is in HL already
ld a,l
ld bc,0d600h ;vdc status port
out (c),a ;set reg to read
test7:
in a,(c) ;repeat
bit 7,a ; test bit 7
jr z,test7 ;until bit 7 high
inc bc ;vdc data register
in l,(c) ;get data
ld h,0
ret
;uchar invdc(uchar RegNum)
;{
; outp(vdcStatusReg,RegNum); /* internal vdc register to read */
; while ((inp(vdcStatusReg) & 0x80) == 0x00); /* wait for status bit to be set */
; return(inp(vdcDataReg)); /* read register */
;}
| 27.315789
| 82
| 0.461464
|
684e836b3b05d97485cb9e7598427ead0b5a630d
| 2,315
|
asm
|
Assembly
|
DEF CON CTF Qualifier 2018/ELF Crumble/3.asm
|
p-g-krish/CTF-Writeups
|
05ad6a9ecbc19ceb8890f4581dfee36f16d164aa
|
[
"MIT"
] | 51
|
2018-06-26T09:49:42.000Z
|
2019-09-14T00:06:35.000Z
|
DEF CON CTF Qualifier 2018/ELF Crumble/3.asm
|
p-g-krish/CTF-Writeups
|
05ad6a9ecbc19ceb8890f4581dfee36f16d164aa
|
[
"MIT"
] | 1
|
2018-06-29T18:40:59.000Z
|
2018-07-09T20:29:41.000Z
|
DEF CON CTF Qualifier 2018/ELF Crumble/3.asm
|
p-g-krish/CTF-Writeups
|
05ad6a9ecbc19ceb8890f4581dfee36f16d164aa
|
[
"MIT"
] | 22
|
2019-10-03T14:52:43.000Z
|
2022-01-17T08:55:10.000Z
|
00000000 89C8 mov eax,ecx
00000002 8B4004 mov eax,[eax+0x4]
00000005 8945C4 mov [ebp-0x3c],eax
00000008 65A114000000 mov eax,[gs:0x14]
0000000E 8945E4 mov [ebp-0x1c],eax
00000011 31C0 xor eax,eax
00000013 C745CD44696420 mov dword [ebp-0x33],0x20646944
0000001A C745D1596F7520 mov dword [ebp-0x2f],0x20756f59
00000021 C745D546696E44 mov dword [ebp-0x2b],0x446e6946
00000028 C745D920746865 mov dword [ebp-0x27],0x65687420
0000002F C745DD20476C55 mov dword [ebp-0x23],0x556c4720
00000036 66C745E1653F mov word [ebp-0x1f],0x3f65
0000003C C645E300 mov byte [ebp-0x1d],0x0
00000040 C745C801000000 mov dword [ebp-0x38],0x1
00000047 83EC0C sub esp,byte +0xc
0000004A 8D45CD lea eax,[ebp-0x33]
0000004D 50 push eax
0000004E E854FFFFFF call 0xffffffa7
00000053 83C410 add esp,byte +0x10
00000056 0FB645E1 movzx eax,byte [ebp-0x1f]
0000005A 0FBEC8 movsx ecx,al
0000005D 0FB645CD movzx eax,byte [ebp-0x33]
00000061 0FBEF8 movsx edi,al
00000064 0FB645D8 movzx eax,byte [ebp-0x28]
00000068 0FBEC0 movsx eax,al
0000006B 8945C0 mov [ebp-0x40],eax
0000006E 0FB645D8 movzx eax,byte [ebp-0x28]
00000072 0FBED0 movsx edx,al
00000075 8955BC mov [ebp-0x44],edx
00000078 0FB645D8 movzx eax,byte [ebp-0x28]
0000007C 0FBEF0 movsx esi,al
0000007F 8975B8 mov [ebp-0x48],esi
00000082 0FB645CE movzx eax,byte [ebp-0x32]
00000086 0FBEF0 movsx esi,al
00000089 0FB645E1 movzx eax,byte [ebp-0x1f]
0000008D 0FBED0 movsx edx,al
00000090 0FB645D5 movzx eax,byte [ebp-0x2b]
00000094 0FBEC0 movsx eax,al
00000097 83EC0C sub esp,byte +0xc
0000009A 51 push ecx
0000009B 57 push edi
0000009C FF75C0 push dword [ebp-0x40]
0000009F FF75BC push dword [ebp-0x44]
000000A2 FF75B8 push dword [ebp-0x48]
000000A5 56 push esi
000000A6 52 push edx
000000A7 50 push eax
000000A8 8D83B0E9FFFF lea eax,[ebx-0x1650]
000000AE 50 push eax
| 46.3
| 59
| 0.62203
|
ec9fc7bda52d336366bc4d879e6d685d652e0ed2
| 4,637
|
asm
|
Assembly
|
third_party/codecs/xvidcore/src/plugins/x86_asm/plugin_ssim-a.asm
|
Narflex/sagetv
|
76cb5755e54fd3b01d2bb708a8a72af0aa1533f1
|
[
"Apache-2.0"
] | 292
|
2015-08-10T18:34:55.000Z
|
2022-01-26T00:38:45.000Z
|
third_party/codecs/xvidcore/src/plugins/x86_asm/plugin_ssim-a.asm
|
Narflex/sagetv
|
76cb5755e54fd3b01d2bb708a8a72af0aa1533f1
|
[
"Apache-2.0"
] | 366
|
2015-08-10T18:21:02.000Z
|
2022-01-22T20:03:41.000Z
|
third_party/codecs/xvidcore/src/plugins/x86_asm/plugin_ssim-a.asm
|
Narflex/sagetv
|
76cb5755e54fd3b01d2bb708a8a72af0aa1533f1
|
[
"Apache-2.0"
] | 227
|
2015-08-10T22:24:29.000Z
|
2022-02-25T19:16:21.000Z
|
;/****************************************************************************
; *
; * XVID MPEG-4 VIDEO CODEC
; * - optimized SSIM routines -
; *
; * Copyright(C) 2006 Johannes Reinhardt <johannes.reinhardt@gmx.de>
; *
; * This program is free software; you can redistribute it and/or modify it
; * under the terms of the GNU General Public License as published by
; * the Free Software Foundation; either version 2 of the License, or
; * (at your option) any later version.
; *
; * This program is distributed in the hope that it will be useful,
; * but WITHOUT ANY WARRANTY; without even the implied warranty of
; * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; * GNU General Public License for more details.
; *
; * You should have received a copy of the GNU General Public License
; * along with this program; if not, write to the Free Software
; * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
; *
; *
; ***************************************************************************/
BITS 32
%include "nasm.inc"
%macro ACC_ROW 2
movq %1,[ TMP0]
movq %2,[TMP0+TMP1]
psadbw %1,mm0
psadbw %2,mm0
lea TMP0, [TMP0+2*TMP1]
paddw %1, %2
%endmacro
%macro CONSIM_1x8_SSE2 0
movdqu xmm0,[TMP0]
movdqu xmm1,[TMP1]
;unpack to words
punpcklbw xmm0,xmm2
punpcklbw xmm1,xmm2
movaps xmm3,xmm0
movaps xmm4,xmm1
pmaddwd xmm0,xmm0;orig
pmaddwd xmm1,xmm1;comp
pmaddwd xmm3,xmm4;corr
paddd xmm5,xmm0
paddd xmm6,xmm1
paddd xmm7,xmm3
%endmacro
%macro CONSIM_1x8_MMX 0
movq mm0,[TMP0];orig
movq mm1,[TMP1];comp
;unpack low half of qw to words
punpcklbw mm0,mm2
punpcklbw mm1,mm2
movq mm3,mm0
pmaddwd mm3,mm0
paddd mm5,mm3;
movq mm4,mm1
pmaddwd mm4,mm1
paddd mm6,mm4;
pmaddwd mm1,mm0
paddd mm7,mm1
movq mm0,[TMP0];orig
movq mm1,[TMP1];comp
;unpack high half of qw to words
punpckhbw mm0,mm2
punpckhbw mm1,mm2
movq mm3,mm0
pmaddwd mm3,mm0
paddd mm5,mm3;
movq mm4,mm1
pmaddwd mm4,mm1
paddd mm6,mm4;
pmaddwd mm1,mm0
paddd mm7,mm1
%endmacro
%macro CONSIM_WRITEOUT 3
mov eax,prm4d;lumo
mul eax; lumo^2
add eax, 32
shr eax, 6; 64*lum0^2
movd TMP0d,%1
sub TMP0d, eax
mov TMP1,prm6; pdevo
mov dword [TMP1],TMP0d
mov eax,prm5d ;lumc
mul eax; lumc^2
add eax, 32
shr eax, 6; 64*lumc^2
movd TMP0d,%2
sub TMP0d, eax
mov TMP1,prm7; pdevc
mov dword [TMP1],TMP0d
mov eax,prm4d;lumo
mul prm5d; lumo*lumc, should fit in _EAX
add eax, 32
shr eax, 6; 64*lumo*lumc
movd TMP0d,%3
sub TMP0d, eax
mov TMP1,prm8; pcorr
mov dword [TMP1],TMP0d
%endmacro
TEXT
cglobal lum_8x8_mmx
cglobal consim_sse2
cglobal consim_mmx
;int lum_8x8_c(uint8_t* ptr, uint32_t stride)
ALIGN SECTION_ALIGN
lum_8x8_mmx:
mov TMP0, prm1 ;ptr
mov TMP1, prm2 ;stride
pxor mm0,mm0
ACC_ROW mm1, mm2
ACC_ROW mm3, mm4
ACC_ROW mm5, mm6
ACC_ROW mm7, mm4
paddw mm1, mm3
paddw mm5, mm7
paddw mm1, mm5
movd eax,mm1
ret
ENDFUNC
ALIGN SECTION_ALIGN
consim_sse2:
PUSH_XMM6_XMM7
mov TMP0,prm1 ;ptro
mov TMP1,prm2 ;ptrc
mov _EAX, prm3 ;stride
pxor xmm2,xmm2;null vektor
pxor xmm5,xmm5;devo
pxor xmm6,xmm6;devc
pxor xmm7,xmm7;corr
CONSIM_1x8_SSE2
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_SSE2
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_SSE2
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_SSE2
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_SSE2
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_SSE2
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_SSE2
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_SSE2
;accumulate xmm5-7
pshufd xmm0, xmm5, 0x0E
paddd xmm5, xmm0
pshufd xmm0, xmm5, 0x01
paddd xmm5, xmm0
pshufd xmm1, xmm6, 0x0E
paddd xmm6, xmm1
pshufd xmm1, xmm6, 0x01
paddd xmm6, xmm1
pshufd xmm2, xmm7, 0x0E
paddd xmm7, xmm2
pshufd xmm2, xmm7, 0x01
paddd xmm7, xmm2
CONSIM_WRITEOUT xmm5,xmm6,xmm7
POP_XMM6_XMM7
ret
ENDFUNC
ALIGN SECTION_ALIGN
consim_mmx:
mov TMP0,prm1 ;ptro
mov TMP1,prm2 ;ptrc
mov _EAX,prm3;stride
pxor mm2,mm2;null
pxor mm5,mm5;devo
pxor mm6,mm6;devc
pxor mm7,mm7;corr
CONSIM_1x8_MMX
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_MMX
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_MMX
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_MMX
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_MMX
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_MMX
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_MMX
add TMP0,_EAX
add TMP1,_EAX
CONSIM_1x8_MMX
movq mm0,mm5
psrlq mm0,32
paddd mm5,mm0
movq mm1,mm6
psrlq mm1,32
paddd mm6,mm1
movq mm2,mm7
psrlq mm2,32
paddd mm7,mm2
CONSIM_WRITEOUT mm5,mm6,mm7
ret
ENDFUNC
NON_EXEC_STACK
| 17.237918
| 78
| 0.689023
|
feeba5f04f97b7ab818d62f5a052a7cbf53cec45
| 1,199
|
asm
|
Assembly
|
asm/loop.asm
|
dspinellis/effective-debugging
|
8a1faae5028d382a59b71073450a8634e10fc972
|
[
"Apache-2.0"
] | 36
|
2016-01-30T02:48:17.000Z
|
2022-01-04T21:22:38.000Z
|
asm/loop.asm
|
salewski/effective-debugging
|
8a1faae5028d382a59b71073450a8634e10fc972
|
[
"Apache-2.0"
] | 20
|
2016-12-16T11:03:56.000Z
|
2017-06-21T15:54:06.000Z
|
asm/loop.asm
|
salewski/effective-debugging
|
8a1faae5028d382a59b71073450a8634e10fc972
|
[
"Apache-2.0"
] | 14
|
2016-02-25T11:46:24.000Z
|
2021-06-12T10:34:51.000Z
|
_DATA SEGMENT ; Data area
$SG2748 DB '%d', 0aH, 00H ; printf format string
_DATA ENDS
PUBLIC _main ; Export main
EXTRN _printf:PROC ; Import printf
_TEXT SEGMENT ; Code area
_i$ = -4 ; Stack offset where i is stored
_main PROC
push ebp ; Function entry boilerplate
mov ebp, esp
push ecx
mov DWORD PTR _i$[ebp], 0 ; i = 0
jmp SHORT $LN3@main ; Jump to loop's end
$LN2@main: ; Loop's top label
mov eax, DWORD PTR _i$[ebp] ; Get i into register eax
add eax, 1 ; Increment by one
mov DWORD PTR _i$[ebp], eax ; Store eax back to i
$LN3@main: ; Loop's end label
cmp DWORD PTR _i$[ebp], 10 ; Compare i to 10
jge SHORT $LN1@main ; If greater or equal
; terminate loop
mov ecx, DWORD PTR _i$[ebp] ; Get i into register ecx
push ecx ; Push ecx as argument to printf
push OFFSET $SG2748 ; Push printf format string
; argument
call _printf ; Call printf
add esp, 8 ; Free pushed printf arguments
jmp SHORT $LN2@main ; Jump to loop's top
$LN1@main: ; Loop's exit label
xor eax, eax ; Zero eax as main's return value
mov esp, ebp ; Function exit boilerplate
pop ebp
ret 0
_main ENDP
_TEXT ENDS
END
| 30.74359
| 55
| 0.655546
|
51268659760b99fb55e8a1ec78d891bb7cf00c6c
| 60,363
|
asm
|
Assembly
|
stat.asm
|
adrianna157/CS444-Lab5-Mutexes
|
a6d4d67cae45b5f37ce4b26d17636659d9e5b58b
|
[
"MIT-0"
] | null | null | null |
stat.asm
|
adrianna157/CS444-Lab5-Mutexes
|
a6d4d67cae45b5f37ce4b26d17636659d9e5b58b
|
[
"MIT-0"
] | null | null | null |
stat.asm
|
adrianna157/CS444-Lab5-Mutexes
|
a6d4d67cae45b5f37ce4b26d17636659d9e5b58b
|
[
"MIT-0"
] | null | null | null |
_stat: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
return ftype;
}
int
main(int argc, char *argv[])
{
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 57 push %edi
4: 56 push %esi
5: 53 push %ebx
int i;
int res;
struct stat st;
for (i = 1; i < argc; i++) {
6: bb 01 00 00 00 mov $0x1,%ebx
{
b: 83 e4 f0 and $0xfffffff0,%esp
e: 83 ec 50 sub $0x50,%esp
11: 8b 75 0c mov 0xc(%ebp),%esi
for (i = 1; i < argc; i++) {
14: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
18: 7f 63 jg 7d <main+0x7d>
1a: e9 98 00 00 00 jmp b7 <main+0xb7>
1f: 90 nop
res = stat(argv[i], &st);
if (res < 0) {
printf(2, "stat failed on file: %s\n", argv[i]);
}
else {
printf(1, "name: %s\n type: %s\n links: %d\n inode: %u\n size: %d\n"
20: 0f bf 44 24 3c movswl 0x3c(%esp),%eax
25: 8b 4c 24 4c mov 0x4c(%esp),%ecx
29: 8b 54 24 44 mov 0x44(%esp),%edx
2d: 0f bf 7c 24 48 movswl 0x48(%esp),%edi
32: 89 04 24 mov %eax,(%esp)
35: 89 4c 24 28 mov %ecx,0x28(%esp)
39: 89 54 24 2c mov %edx,0x2c(%esp)
3d: e8 7e 00 00 00 call c0 <filetype>
42: 8b 4c 24 28 mov 0x28(%esp),%ecx
46: 8b 54 24 2c mov 0x2c(%esp),%edx
4a: 89 7c 24 10 mov %edi,0x10(%esp)
4e: 89 4c 24 18 mov %ecx,0x18(%esp)
52: 89 54 24 14 mov %edx,0x14(%esp)
56: 89 44 24 0c mov %eax,0xc(%esp)
5a: 8b 04 9e mov (%esi,%ebx,4),%eax
for (i = 1; i < argc; i++) {
5d: 83 c3 01 add $0x1,%ebx
printf(1, "name: %s\n type: %s\n links: %d\n inode: %u\n size: %d\n"
60: c7 44 24 04 a8 0b 00 movl $0xba8,0x4(%esp)
67: 00
68: c7 04 24 01 00 00 00 movl $0x1,(%esp)
6f: 89 44 24 08 mov %eax,0x8(%esp)
73: e8 d8 04 00 00 call 550 <printf>
for (i = 1; i < argc; i++) {
78: 3b 5d 08 cmp 0x8(%ebp),%ebx
7b: 74 3a je b7 <main+0xb7>
res = stat(argv[i], &st);
7d: 8d 44 24 3c lea 0x3c(%esp),%eax
81: 89 44 24 04 mov %eax,0x4(%esp)
85: 8b 04 9e mov (%esi,%ebx,4),%eax
88: 89 04 24 mov %eax,(%esp)
8b: e8 60 02 00 00 call 2f0 <stat>
if (res < 0) {
90: 85 c0 test %eax,%eax
92: 79 8c jns 20 <main+0x20>
printf(2, "stat failed on file: %s\n", argv[i]);
94: 8b 04 9e mov (%esi,%ebx,4),%eax
for (i = 1; i < argc; i++) {
97: 83 c3 01 add $0x1,%ebx
printf(2, "stat failed on file: %s\n", argv[i]);
9a: c7 44 24 04 8c 0b 00 movl $0xb8c,0x4(%esp)
a1: 00
a2: c7 04 24 02 00 00 00 movl $0x2,(%esp)
a9: 89 44 24 08 mov %eax,0x8(%esp)
ad: e8 9e 04 00 00 call 550 <printf>
for (i = 1; i < argc; i++) {
b2: 3b 5d 08 cmp 0x8(%ebp),%ebx
b5: 75 c6 jne 7d <main+0x7d>
, argv[i], filetype(st.type), st.nlink, st.ino, st.size);
}
}
exit();
b7: e8 e6 02 00 00 call 3a2 <exit>
bc: 66 90 xchg %ax,%ax
be: 66 90 xchg %ax,%ax
000000c0 <filetype>:
{
c0: 55 push %ebp
c1: 89 e5 mov %esp,%ebp
c3: 53 push %ebx
c4: 83 ec 14 sub $0x14,%esp
c7: 8b 5d 08 mov 0x8(%ebp),%ebx
memset(ftype, 0, sizeof(ftype));
ca: c7 44 24 08 14 00 00 movl $0x14,0x8(%esp)
d1: 00
d2: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
d9: 00
da: c7 04 24 b4 10 00 00 movl $0x10b4,(%esp)
e1: e8 4a 01 00 00 call 230 <memset>
switch (sttype) {
e6: 83 fb 02 cmp $0x2,%ebx
e9: 74 6d je 158 <filetype+0x98>
eb: 83 fb 03 cmp $0x3,%ebx
ee: 74 48 je 138 <filetype+0x78>
f0: 83 fb 01 cmp $0x1,%ebx
f3: 74 23 je 118 <filetype+0x58>
strcpy(ftype, "unknown file type");
f5: c7 44 24 04 7a 0b 00 movl $0xb7a,0x4(%esp)
fc: 00
fd: c7 04 24 b4 10 00 00 movl $0x10b4,(%esp)
104: e8 77 00 00 00 call 180 <strcpy>
}
109: 83 c4 14 add $0x14,%esp
10c: b8 b4 10 00 00 mov $0x10b4,%eax
111: 5b pop %ebx
112: 5d pop %ebp
113: c3 ret
114: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
strcpy(ftype, "directory");
118: c7 44 24 04 5c 0b 00 movl $0xb5c,0x4(%esp)
11f: 00
120: c7 04 24 b4 10 00 00 movl $0x10b4,(%esp)
127: e8 54 00 00 00 call 180 <strcpy>
}
12c: 83 c4 14 add $0x14,%esp
12f: b8 b4 10 00 00 mov $0x10b4,%eax
134: 5b pop %ebx
135: 5d pop %ebp
136: c3 ret
137: 90 nop
strcpy(ftype, "device");
138: c7 44 24 04 73 0b 00 movl $0xb73,0x4(%esp)
13f: 00
140: c7 04 24 b4 10 00 00 movl $0x10b4,(%esp)
147: e8 34 00 00 00 call 180 <strcpy>
}
14c: 83 c4 14 add $0x14,%esp
14f: b8 b4 10 00 00 mov $0x10b4,%eax
154: 5b pop %ebx
155: 5d pop %ebp
156: c3 ret
157: 90 nop
strcpy(ftype, "regular file");
158: c7 44 24 04 66 0b 00 movl $0xb66,0x4(%esp)
15f: 00
160: c7 04 24 b4 10 00 00 movl $0x10b4,(%esp)
167: e8 14 00 00 00 call 180 <strcpy>
}
16c: 83 c4 14 add $0x14,%esp
16f: b8 b4 10 00 00 mov $0x10b4,%eax
174: 5b pop %ebx
175: 5d pop %ebp
176: c3 ret
177: 66 90 xchg %ax,%ax
179: 66 90 xchg %ax,%ax
17b: 66 90 xchg %ax,%ax
17d: 66 90 xchg %ax,%ax
17f: 90 nop
00000180 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, const char *t)
{
180: 55 push %ebp
181: 89 e5 mov %esp,%ebp
183: 8b 45 08 mov 0x8(%ebp),%eax
186: 8b 4d 0c mov 0xc(%ebp),%ecx
189: 53 push %ebx
char *os;
os = s;
while((*s++ = *t++) != 0)
18a: 89 c2 mov %eax,%edx
18c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
190: 83 c1 01 add $0x1,%ecx
193: 0f b6 59 ff movzbl -0x1(%ecx),%ebx
197: 83 c2 01 add $0x1,%edx
19a: 84 db test %bl,%bl
19c: 88 5a ff mov %bl,-0x1(%edx)
19f: 75 ef jne 190 <strcpy+0x10>
;
return os;
}
1a1: 5b pop %ebx
1a2: 5d pop %ebp
1a3: c3 ret
1a4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1aa: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
000001b0 <strcmp>:
int
strcmp(const char *p, const char *q)
{
1b0: 55 push %ebp
1b1: 89 e5 mov %esp,%ebp
1b3: 8b 55 08 mov 0x8(%ebp),%edx
1b6: 53 push %ebx
1b7: 8b 4d 0c mov 0xc(%ebp),%ecx
while(*p && *p == *q)
1ba: 0f b6 02 movzbl (%edx),%eax
1bd: 84 c0 test %al,%al
1bf: 74 2d je 1ee <strcmp+0x3e>
1c1: 0f b6 19 movzbl (%ecx),%ebx
1c4: 38 d8 cmp %bl,%al
1c6: 74 0e je 1d6 <strcmp+0x26>
1c8: eb 2b jmp 1f5 <strcmp+0x45>
1ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1d0: 38 c8 cmp %cl,%al
1d2: 75 15 jne 1e9 <strcmp+0x39>
p++, q++;
1d4: 89 d9 mov %ebx,%ecx
1d6: 83 c2 01 add $0x1,%edx
while(*p && *p == *q)
1d9: 0f b6 02 movzbl (%edx),%eax
p++, q++;
1dc: 8d 59 01 lea 0x1(%ecx),%ebx
while(*p && *p == *q)
1df: 0f b6 49 01 movzbl 0x1(%ecx),%ecx
1e3: 84 c0 test %al,%al
1e5: 75 e9 jne 1d0 <strcmp+0x20>
1e7: 31 c0 xor %eax,%eax
return (uchar)*p - (uchar)*q;
1e9: 29 c8 sub %ecx,%eax
}
1eb: 5b pop %ebx
1ec: 5d pop %ebp
1ed: c3 ret
1ee: 0f b6 09 movzbl (%ecx),%ecx
while(*p && *p == *q)
1f1: 31 c0 xor %eax,%eax
1f3: eb f4 jmp 1e9 <strcmp+0x39>
1f5: 0f b6 cb movzbl %bl,%ecx
1f8: eb ef jmp 1e9 <strcmp+0x39>
1fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000200 <strlen>:
uint
strlen(const char *s)
{
200: 55 push %ebp
201: 89 e5 mov %esp,%ebp
203: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
206: 80 39 00 cmpb $0x0,(%ecx)
209: 74 12 je 21d <strlen+0x1d>
20b: 31 d2 xor %edx,%edx
20d: 8d 76 00 lea 0x0(%esi),%esi
210: 83 c2 01 add $0x1,%edx
213: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
217: 89 d0 mov %edx,%eax
219: 75 f5 jne 210 <strlen+0x10>
;
return n;
}
21b: 5d pop %ebp
21c: c3 ret
for(n = 0; s[n]; n++)
21d: 31 c0 xor %eax,%eax
}
21f: 5d pop %ebp
220: c3 ret
221: eb 0d jmp 230 <memset>
223: 90 nop
224: 90 nop
225: 90 nop
226: 90 nop
227: 90 nop
228: 90 nop
229: 90 nop
22a: 90 nop
22b: 90 nop
22c: 90 nop
22d: 90 nop
22e: 90 nop
22f: 90 nop
00000230 <memset>:
void*
memset(void *dst, int c, uint n)
{
230: 55 push %ebp
231: 89 e5 mov %esp,%ebp
233: 8b 55 08 mov 0x8(%ebp),%edx
236: 57 push %edi
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
237: 8b 4d 10 mov 0x10(%ebp),%ecx
23a: 8b 45 0c mov 0xc(%ebp),%eax
23d: 89 d7 mov %edx,%edi
23f: fc cld
240: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
242: 89 d0 mov %edx,%eax
244: 5f pop %edi
245: 5d pop %ebp
246: c3 ret
247: 89 f6 mov %esi,%esi
249: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000250 <strchr>:
char*
strchr(const char *s, char c)
{
250: 55 push %ebp
251: 89 e5 mov %esp,%ebp
253: 8b 45 08 mov 0x8(%ebp),%eax
256: 53 push %ebx
257: 8b 55 0c mov 0xc(%ebp),%edx
for(; *s; s++)
25a: 0f b6 18 movzbl (%eax),%ebx
25d: 84 db test %bl,%bl
25f: 74 1d je 27e <strchr+0x2e>
if(*s == c)
261: 38 d3 cmp %dl,%bl
263: 89 d1 mov %edx,%ecx
265: 75 0d jne 274 <strchr+0x24>
267: eb 17 jmp 280 <strchr+0x30>
269: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
270: 38 ca cmp %cl,%dl
272: 74 0c je 280 <strchr+0x30>
for(; *s; s++)
274: 83 c0 01 add $0x1,%eax
277: 0f b6 10 movzbl (%eax),%edx
27a: 84 d2 test %dl,%dl
27c: 75 f2 jne 270 <strchr+0x20>
return (char*)s;
return 0;
27e: 31 c0 xor %eax,%eax
}
280: 5b pop %ebx
281: 5d pop %ebp
282: c3 ret
283: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
289: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000290 <gets>:
char*
gets(char *buf, int max)
{
290: 55 push %ebp
291: 89 e5 mov %esp,%ebp
293: 57 push %edi
294: 56 push %esi
int i, cc;
char c;
for(i=0; i+1 < max; ){
295: 31 f6 xor %esi,%esi
{
297: 53 push %ebx
298: 83 ec 2c sub $0x2c,%esp
cc = read(0, &c, 1);
29b: 8d 7d e7 lea -0x19(%ebp),%edi
for(i=0; i+1 < max; ){
29e: eb 31 jmp 2d1 <gets+0x41>
cc = read(0, &c, 1);
2a0: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
2a7: 00
2a8: 89 7c 24 04 mov %edi,0x4(%esp)
2ac: c7 04 24 00 00 00 00 movl $0x0,(%esp)
2b3: e8 02 01 00 00 call 3ba <read>
if(cc < 1)
2b8: 85 c0 test %eax,%eax
2ba: 7e 1d jle 2d9 <gets+0x49>
break;
buf[i++] = c;
2bc: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
for(i=0; i+1 < max; ){
2c0: 89 de mov %ebx,%esi
buf[i++] = c;
2c2: 8b 55 08 mov 0x8(%ebp),%edx
if(c == '\n' || c == '\r')
2c5: 3c 0d cmp $0xd,%al
buf[i++] = c;
2c7: 88 44 1a ff mov %al,-0x1(%edx,%ebx,1)
if(c == '\n' || c == '\r')
2cb: 74 0c je 2d9 <gets+0x49>
2cd: 3c 0a cmp $0xa,%al
2cf: 74 08 je 2d9 <gets+0x49>
for(i=0; i+1 < max; ){
2d1: 8d 5e 01 lea 0x1(%esi),%ebx
2d4: 3b 5d 0c cmp 0xc(%ebp),%ebx
2d7: 7c c7 jl 2a0 <gets+0x10>
break;
}
buf[i] = '\0';
2d9: 8b 45 08 mov 0x8(%ebp),%eax
2dc: c6 04 30 00 movb $0x0,(%eax,%esi,1)
return buf;
}
2e0: 83 c4 2c add $0x2c,%esp
2e3: 5b pop %ebx
2e4: 5e pop %esi
2e5: 5f pop %edi
2e6: 5d pop %ebp
2e7: c3 ret
2e8: 90 nop
2e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000002f0 <stat>:
int
stat(const char *n, struct stat *st)
{
2f0: 55 push %ebp
2f1: 89 e5 mov %esp,%ebp
2f3: 56 push %esi
2f4: 53 push %ebx
2f5: 83 ec 10 sub $0x10,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
2f8: 8b 45 08 mov 0x8(%ebp),%eax
2fb: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
302: 00
303: 89 04 24 mov %eax,(%esp)
306: e8 d7 00 00 00 call 3e2 <open>
if(fd < 0)
30b: 85 c0 test %eax,%eax
fd = open(n, O_RDONLY);
30d: 89 c3 mov %eax,%ebx
if(fd < 0)
30f: 78 27 js 338 <stat+0x48>
return -1;
r = fstat(fd, st);
311: 8b 45 0c mov 0xc(%ebp),%eax
314: 89 1c 24 mov %ebx,(%esp)
317: 89 44 24 04 mov %eax,0x4(%esp)
31b: e8 da 00 00 00 call 3fa <fstat>
close(fd);
320: 89 1c 24 mov %ebx,(%esp)
r = fstat(fd, st);
323: 89 c6 mov %eax,%esi
close(fd);
325: e8 a0 00 00 00 call 3ca <close>
return r;
32a: 89 f0 mov %esi,%eax
}
32c: 83 c4 10 add $0x10,%esp
32f: 5b pop %ebx
330: 5e pop %esi
331: 5d pop %ebp
332: c3 ret
333: 90 nop
334: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
338: b8 ff ff ff ff mov $0xffffffff,%eax
33d: eb ed jmp 32c <stat+0x3c>
33f: 90 nop
00000340 <atoi>:
int
atoi(const char *s)
{
340: 55 push %ebp
341: 89 e5 mov %esp,%ebp
343: 8b 4d 08 mov 0x8(%ebp),%ecx
346: 53 push %ebx
int n;
n = 0;
while('0' <= *s && *s <= '9')
347: 0f be 11 movsbl (%ecx),%edx
34a: 8d 42 d0 lea -0x30(%edx),%eax
34d: 3c 09 cmp $0x9,%al
n = 0;
34f: b8 00 00 00 00 mov $0x0,%eax
while('0' <= *s && *s <= '9')
354: 77 17 ja 36d <atoi+0x2d>
356: 66 90 xchg %ax,%ax
n = n*10 + *s++ - '0';
358: 83 c1 01 add $0x1,%ecx
35b: 8d 04 80 lea (%eax,%eax,4),%eax
35e: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
while('0' <= *s && *s <= '9')
362: 0f be 11 movsbl (%ecx),%edx
365: 8d 5a d0 lea -0x30(%edx),%ebx
368: 80 fb 09 cmp $0x9,%bl
36b: 76 eb jbe 358 <atoi+0x18>
return n;
}
36d: 5b pop %ebx
36e: 5d pop %ebp
36f: c3 ret
00000370 <memmove>:
void*
memmove(void *vdst, const void *vsrc, int n)
{
370: 55 push %ebp
char *dst;
const char *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
371: 31 d2 xor %edx,%edx
{
373: 89 e5 mov %esp,%ebp
375: 56 push %esi
376: 8b 45 08 mov 0x8(%ebp),%eax
379: 53 push %ebx
37a: 8b 5d 10 mov 0x10(%ebp),%ebx
37d: 8b 75 0c mov 0xc(%ebp),%esi
while(n-- > 0)
380: 85 db test %ebx,%ebx
382: 7e 12 jle 396 <memmove+0x26>
384: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*dst++ = *src++;
388: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
38c: 88 0c 10 mov %cl,(%eax,%edx,1)
38f: 83 c2 01 add $0x1,%edx
while(n-- > 0)
392: 39 da cmp %ebx,%edx
394: 75 f2 jne 388 <memmove+0x18>
return vdst;
}
396: 5b pop %ebx
397: 5e pop %esi
398: 5d pop %ebp
399: c3 ret
0000039a <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
39a: b8 01 00 00 00 mov $0x1,%eax
39f: cd 40 int $0x40
3a1: c3 ret
000003a2 <exit>:
SYSCALL(exit)
3a2: b8 02 00 00 00 mov $0x2,%eax
3a7: cd 40 int $0x40
3a9: c3 ret
000003aa <wait>:
SYSCALL(wait)
3aa: b8 03 00 00 00 mov $0x3,%eax
3af: cd 40 int $0x40
3b1: c3 ret
000003b2 <pipe>:
SYSCALL(pipe)
3b2: b8 04 00 00 00 mov $0x4,%eax
3b7: cd 40 int $0x40
3b9: c3 ret
000003ba <read>:
SYSCALL(read)
3ba: b8 05 00 00 00 mov $0x5,%eax
3bf: cd 40 int $0x40
3c1: c3 ret
000003c2 <write>:
SYSCALL(write)
3c2: b8 10 00 00 00 mov $0x10,%eax
3c7: cd 40 int $0x40
3c9: c3 ret
000003ca <close>:
SYSCALL(close)
3ca: b8 15 00 00 00 mov $0x15,%eax
3cf: cd 40 int $0x40
3d1: c3 ret
000003d2 <kill>:
SYSCALL(kill)
3d2: b8 06 00 00 00 mov $0x6,%eax
3d7: cd 40 int $0x40
3d9: c3 ret
000003da <exec>:
SYSCALL(exec)
3da: b8 07 00 00 00 mov $0x7,%eax
3df: cd 40 int $0x40
3e1: c3 ret
000003e2 <open>:
SYSCALL(open)
3e2: b8 0f 00 00 00 mov $0xf,%eax
3e7: cd 40 int $0x40
3e9: c3 ret
000003ea <mknod>:
SYSCALL(mknod)
3ea: b8 11 00 00 00 mov $0x11,%eax
3ef: cd 40 int $0x40
3f1: c3 ret
000003f2 <unlink>:
SYSCALL(unlink)
3f2: b8 12 00 00 00 mov $0x12,%eax
3f7: cd 40 int $0x40
3f9: c3 ret
000003fa <fstat>:
SYSCALL(fstat)
3fa: b8 08 00 00 00 mov $0x8,%eax
3ff: cd 40 int $0x40
401: c3 ret
00000402 <link>:
SYSCALL(link)
402: b8 13 00 00 00 mov $0x13,%eax
407: cd 40 int $0x40
409: c3 ret
0000040a <mkdir>:
SYSCALL(mkdir)
40a: b8 14 00 00 00 mov $0x14,%eax
40f: cd 40 int $0x40
411: c3 ret
00000412 <chdir>:
SYSCALL(chdir)
412: b8 09 00 00 00 mov $0x9,%eax
417: cd 40 int $0x40
419: c3 ret
0000041a <dup>:
SYSCALL(dup)
41a: b8 0a 00 00 00 mov $0xa,%eax
41f: cd 40 int $0x40
421: c3 ret
00000422 <getpid>:
SYSCALL(getpid)
422: b8 0b 00 00 00 mov $0xb,%eax
427: cd 40 int $0x40
429: c3 ret
0000042a <sbrk>:
SYSCALL(sbrk)
42a: b8 0c 00 00 00 mov $0xc,%eax
42f: cd 40 int $0x40
431: c3 ret
00000432 <sleep>:
SYSCALL(sleep)
432: b8 0d 00 00 00 mov $0xd,%eax
437: cd 40 int $0x40
439: c3 ret
0000043a <uptime>:
SYSCALL(uptime)
43a: b8 0e 00 00 00 mov $0xe,%eax
43f: cd 40 int $0x40
441: c3 ret
00000442 <getppid>:
#ifdef GETPPID
SYSCALL(getppid)
442: b8 16 00 00 00 mov $0x16,%eax
447: cd 40 int $0x40
449: c3 ret
0000044a <cps>:
#endif // GETPPID
#ifdef CPS
SYSCALL(cps)
44a: b8 17 00 00 00 mov $0x17,%eax
44f: cd 40 int $0x40
451: c3 ret
00000452 <halt>:
#endif // CPS
#ifdef HALT
SYSCALL(halt)
452: b8 18 00 00 00 mov $0x18,%eax
457: cd 40 int $0x40
459: c3 ret
0000045a <kdebug>:
#endif // HALT
#ifdef KDEBUG
SYSCALL(kdebug)
45a: b8 19 00 00 00 mov $0x19,%eax
45f: cd 40 int $0x40
461: c3 ret
00000462 <va2pa>:
#endif // KDEBUG
#ifdef VA2PA
SYSCALL(va2pa)
462: b8 1a 00 00 00 mov $0x1a,%eax
467: cd 40 int $0x40
469: c3 ret
0000046a <kthread_create>:
#endif // VA2PA
#ifdef KTHREADS
SYSCALL(kthread_create)
46a: b8 1b 00 00 00 mov $0x1b,%eax
46f: cd 40 int $0x40
471: c3 ret
00000472 <kthread_join>:
SYSCALL(kthread_join)
472: b8 1c 00 00 00 mov $0x1c,%eax
477: cd 40 int $0x40
479: c3 ret
0000047a <kthread_exit>:
SYSCALL(kthread_exit)
47a: b8 1d 00 00 00 mov $0x1d,%eax
47f: cd 40 int $0x40
481: c3 ret
00000482 <kthread_self>:
#endif // KTHREADS
#ifdef BENNY_MOOTEX
SYSCALL(kthread_self)
482: b8 1e 00 00 00 mov $0x1e,%eax
487: cd 40 int $0x40
489: c3 ret
0000048a <kthread_yield>:
SYSCALL(kthread_yield)
48a: b8 1f 00 00 00 mov $0x1f,%eax
48f: cd 40 int $0x40
491: c3 ret
00000492 <kthread_cpu_count>:
SYSCALL(kthread_cpu_count)
492: b8 20 00 00 00 mov $0x20,%eax
497: cd 40 int $0x40
499: c3 ret
0000049a <kthread_thread_count>:
SYSCALL(kthread_thread_count)
49a: b8 21 00 00 00 mov $0x21,%eax
49f: cd 40 int $0x40
4a1: c3 ret
4a2: 66 90 xchg %ax,%ax
4a4: 66 90 xchg %ax,%ax
4a6: 66 90 xchg %ax,%ax
4a8: 66 90 xchg %ax,%ax
4aa: 66 90 xchg %ax,%ax
4ac: 66 90 xchg %ax,%ax
4ae: 66 90 xchg %ax,%ax
000004b0 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
4b0: 55 push %ebp
4b1: 89 e5 mov %esp,%ebp
4b3: 57 push %edi
4b4: 56 push %esi
4b5: 89 c6 mov %eax,%esi
4b7: 53 push %ebx
4b8: 83 ec 4c sub $0x4c,%esp
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
4bb: 8b 5d 08 mov 0x8(%ebp),%ebx
4be: 85 db test %ebx,%ebx
4c0: 74 09 je 4cb <printint+0x1b>
4c2: 89 d0 mov %edx,%eax
4c4: c1 e8 1f shr $0x1f,%eax
4c7: 84 c0 test %al,%al
4c9: 75 75 jne 540 <printint+0x90>
neg = 1;
x = -xx;
} else {
x = xx;
4cb: 89 d0 mov %edx,%eax
neg = 0;
4cd: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
4d4: 89 75 c0 mov %esi,-0x40(%ebp)
}
i = 0;
4d7: 31 ff xor %edi,%edi
4d9: 89 ce mov %ecx,%esi
4db: 8d 5d d7 lea -0x29(%ebp),%ebx
4de: eb 02 jmp 4e2 <printint+0x32>
do{
buf[i++] = digits[x % base];
4e0: 89 cf mov %ecx,%edi
4e2: 31 d2 xor %edx,%edx
4e4: f7 f6 div %esi
4e6: 8d 4f 01 lea 0x1(%edi),%ecx
4e9: 0f b6 92 e7 0b 00 00 movzbl 0xbe7(%edx),%edx
}while((x /= base) != 0);
4f0: 85 c0 test %eax,%eax
buf[i++] = digits[x % base];
4f2: 88 14 0b mov %dl,(%ebx,%ecx,1)
}while((x /= base) != 0);
4f5: 75 e9 jne 4e0 <printint+0x30>
if(neg)
4f7: 8b 55 c4 mov -0x3c(%ebp),%edx
buf[i++] = digits[x % base];
4fa: 89 c8 mov %ecx,%eax
4fc: 8b 75 c0 mov -0x40(%ebp),%esi
if(neg)
4ff: 85 d2 test %edx,%edx
501: 74 08 je 50b <printint+0x5b>
buf[i++] = '-';
503: 8d 4f 02 lea 0x2(%edi),%ecx
506: c6 44 05 d8 2d movb $0x2d,-0x28(%ebp,%eax,1)
while(--i >= 0)
50b: 8d 79 ff lea -0x1(%ecx),%edi
50e: 66 90 xchg %ax,%ax
510: 0f b6 44 3d d8 movzbl -0x28(%ebp,%edi,1),%eax
515: 83 ef 01 sub $0x1,%edi
write(fd, &c, 1);
518: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
51f: 00
520: 89 5c 24 04 mov %ebx,0x4(%esp)
524: 89 34 24 mov %esi,(%esp)
527: 88 45 d7 mov %al,-0x29(%ebp)
52a: e8 93 fe ff ff call 3c2 <write>
while(--i >= 0)
52f: 83 ff ff cmp $0xffffffff,%edi
532: 75 dc jne 510 <printint+0x60>
putc(fd, buf[i]);
}
534: 83 c4 4c add $0x4c,%esp
537: 5b pop %ebx
538: 5e pop %esi
539: 5f pop %edi
53a: 5d pop %ebp
53b: c3 ret
53c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
x = -xx;
540: 89 d0 mov %edx,%eax
542: f7 d8 neg %eax
neg = 1;
544: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
54b: eb 87 jmp 4d4 <printint+0x24>
54d: 8d 76 00 lea 0x0(%esi),%esi
00000550 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, const char *fmt, ...)
{
550: 55 push %ebp
551: 89 e5 mov %esp,%ebp
553: 57 push %edi
char *s;
int c, i, state;
uint *ap;
state = 0;
554: 31 ff xor %edi,%edi
{
556: 56 push %esi
557: 53 push %ebx
558: 83 ec 3c sub $0x3c,%esp
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
55b: 8b 5d 0c mov 0xc(%ebp),%ebx
ap = (uint*)(void*)&fmt + 1;
55e: 8d 45 10 lea 0x10(%ebp),%eax
{
561: 8b 75 08 mov 0x8(%ebp),%esi
ap = (uint*)(void*)&fmt + 1;
564: 89 45 d4 mov %eax,-0x2c(%ebp)
for(i = 0; fmt[i]; i++){
567: 0f b6 13 movzbl (%ebx),%edx
56a: 83 c3 01 add $0x1,%ebx
56d: 84 d2 test %dl,%dl
56f: 75 39 jne 5aa <printf+0x5a>
571: e9 ca 00 00 00 jmp 640 <printf+0xf0>
576: 66 90 xchg %ax,%ax
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
578: 83 fa 25 cmp $0x25,%edx
57b: 0f 84 c7 00 00 00 je 648 <printf+0xf8>
write(fd, &c, 1);
581: 8d 45 e0 lea -0x20(%ebp),%eax
584: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
58b: 00
58c: 89 44 24 04 mov %eax,0x4(%esp)
590: 89 34 24 mov %esi,(%esp)
state = '%';
} else {
putc(fd, c);
593: 88 55 e0 mov %dl,-0x20(%ebp)
write(fd, &c, 1);
596: e8 27 fe ff ff call 3c2 <write>
59b: 83 c3 01 add $0x1,%ebx
for(i = 0; fmt[i]; i++){
59e: 0f b6 53 ff movzbl -0x1(%ebx),%edx
5a2: 84 d2 test %dl,%dl
5a4: 0f 84 96 00 00 00 je 640 <printf+0xf0>
if(state == 0){
5aa: 85 ff test %edi,%edi
c = fmt[i] & 0xff;
5ac: 0f be c2 movsbl %dl,%eax
if(state == 0){
5af: 74 c7 je 578 <printf+0x28>
}
} else if(state == '%'){
5b1: 83 ff 25 cmp $0x25,%edi
5b4: 75 e5 jne 59b <printf+0x4b>
if(c == 'd' || c == 'u'){
5b6: 83 fa 75 cmp $0x75,%edx
5b9: 0f 84 99 00 00 00 je 658 <printf+0x108>
5bf: 83 fa 64 cmp $0x64,%edx
5c2: 0f 84 90 00 00 00 je 658 <printf+0x108>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
5c8: 25 f7 00 00 00 and $0xf7,%eax
5cd: 83 f8 70 cmp $0x70,%eax
5d0: 0f 84 aa 00 00 00 je 680 <printf+0x130>
putc(fd, '0');
putc(fd, 'x');
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
5d6: 83 fa 73 cmp $0x73,%edx
5d9: 0f 84 e9 00 00 00 je 6c8 <printf+0x178>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
5df: 83 fa 63 cmp $0x63,%edx
5e2: 0f 84 2b 01 00 00 je 713 <printf+0x1c3>
putc(fd, *ap);
ap++;
} else if(c == '%'){
5e8: 83 fa 25 cmp $0x25,%edx
5eb: 0f 84 4f 01 00 00 je 740 <printf+0x1f0>
write(fd, &c, 1);
5f1: 8d 45 e6 lea -0x1a(%ebp),%eax
5f4: 83 c3 01 add $0x1,%ebx
5f7: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
5fe: 00
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
5ff: 31 ff xor %edi,%edi
write(fd, &c, 1);
601: 89 44 24 04 mov %eax,0x4(%esp)
605: 89 34 24 mov %esi,(%esp)
608: 89 55 d0 mov %edx,-0x30(%ebp)
60b: c6 45 e6 25 movb $0x25,-0x1a(%ebp)
60f: e8 ae fd ff ff call 3c2 <write>
putc(fd, c);
614: 8b 55 d0 mov -0x30(%ebp),%edx
write(fd, &c, 1);
617: 8d 45 e7 lea -0x19(%ebp),%eax
61a: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
621: 00
622: 89 44 24 04 mov %eax,0x4(%esp)
626: 89 34 24 mov %esi,(%esp)
putc(fd, c);
629: 88 55 e7 mov %dl,-0x19(%ebp)
write(fd, &c, 1);
62c: e8 91 fd ff ff call 3c2 <write>
for(i = 0; fmt[i]; i++){
631: 0f b6 53 ff movzbl -0x1(%ebx),%edx
635: 84 d2 test %dl,%dl
637: 0f 85 6d ff ff ff jne 5aa <printf+0x5a>
63d: 8d 76 00 lea 0x0(%esi),%esi
}
}
}
640: 83 c4 3c add $0x3c,%esp
643: 5b pop %ebx
644: 5e pop %esi
645: 5f pop %edi
646: 5d pop %ebp
647: c3 ret
state = '%';
648: bf 25 00 00 00 mov $0x25,%edi
64d: e9 49 ff ff ff jmp 59b <printf+0x4b>
652: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
printint(fd, *ap, 10, 1);
658: c7 04 24 01 00 00 00 movl $0x1,(%esp)
65f: b9 0a 00 00 00 mov $0xa,%ecx
printint(fd, *ap, 16, 0);
664: 8b 45 d4 mov -0x2c(%ebp),%eax
state = 0;
667: 31 ff xor %edi,%edi
printint(fd, *ap, 16, 0);
669: 8b 10 mov (%eax),%edx
66b: 89 f0 mov %esi,%eax
66d: e8 3e fe ff ff call 4b0 <printint>
ap++;
672: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
676: e9 20 ff ff ff jmp 59b <printf+0x4b>
67b: 90 nop
67c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
write(fd, &c, 1);
680: 8d 45 e1 lea -0x1f(%ebp),%eax
683: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
68a: 00
68b: 89 44 24 04 mov %eax,0x4(%esp)
68f: 89 34 24 mov %esi,(%esp)
692: c6 45 e1 30 movb $0x30,-0x1f(%ebp)
696: e8 27 fd ff ff call 3c2 <write>
69b: 8d 45 e2 lea -0x1e(%ebp),%eax
69e: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
6a5: 00
6a6: 89 44 24 04 mov %eax,0x4(%esp)
6aa: 89 34 24 mov %esi,(%esp)
6ad: c6 45 e2 78 movb $0x78,-0x1e(%ebp)
6b1: e8 0c fd ff ff call 3c2 <write>
printint(fd, *ap, 16, 0);
6b6: b9 10 00 00 00 mov $0x10,%ecx
6bb: c7 04 24 00 00 00 00 movl $0x0,(%esp)
6c2: eb a0 jmp 664 <printf+0x114>
6c4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
s = (char*)*ap;
6c8: 8b 45 d4 mov -0x2c(%ebp),%eax
ap++;
6cb: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
s = (char*)*ap;
6cf: 8b 38 mov (%eax),%edi
s = "(null)";
6d1: b8 e0 0b 00 00 mov $0xbe0,%eax
6d6: 85 ff test %edi,%edi
6d8: 0f 44 f8 cmove %eax,%edi
while(*s != 0){
6db: 0f b6 07 movzbl (%edi),%eax
6de: 84 c0 test %al,%al
6e0: 74 2a je 70c <printf+0x1bc>
6e2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
6e8: 88 45 e3 mov %al,-0x1d(%ebp)
write(fd, &c, 1);
6eb: 8d 45 e3 lea -0x1d(%ebp),%eax
s++;
6ee: 83 c7 01 add $0x1,%edi
write(fd, &c, 1);
6f1: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
6f8: 00
6f9: 89 44 24 04 mov %eax,0x4(%esp)
6fd: 89 34 24 mov %esi,(%esp)
700: e8 bd fc ff ff call 3c2 <write>
while(*s != 0){
705: 0f b6 07 movzbl (%edi),%eax
708: 84 c0 test %al,%al
70a: 75 dc jne 6e8 <printf+0x198>
state = 0;
70c: 31 ff xor %edi,%edi
70e: e9 88 fe ff ff jmp 59b <printf+0x4b>
putc(fd, *ap);
713: 8b 45 d4 mov -0x2c(%ebp),%eax
state = 0;
716: 31 ff xor %edi,%edi
putc(fd, *ap);
718: 8b 00 mov (%eax),%eax
write(fd, &c, 1);
71a: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
721: 00
722: 89 34 24 mov %esi,(%esp)
putc(fd, *ap);
725: 88 45 e4 mov %al,-0x1c(%ebp)
write(fd, &c, 1);
728: 8d 45 e4 lea -0x1c(%ebp),%eax
72b: 89 44 24 04 mov %eax,0x4(%esp)
72f: e8 8e fc ff ff call 3c2 <write>
ap++;
734: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
738: e9 5e fe ff ff jmp 59b <printf+0x4b>
73d: 8d 76 00 lea 0x0(%esi),%esi
write(fd, &c, 1);
740: 8d 45 e5 lea -0x1b(%ebp),%eax
state = 0;
743: 31 ff xor %edi,%edi
write(fd, &c, 1);
745: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
74c: 00
74d: 89 44 24 04 mov %eax,0x4(%esp)
751: 89 34 24 mov %esi,(%esp)
754: c6 45 e5 25 movb $0x25,-0x1b(%ebp)
758: e8 65 fc ff ff call 3c2 <write>
75d: e9 39 fe ff ff jmp 59b <printf+0x4b>
762: 66 90 xchg %ax,%ax
764: 66 90 xchg %ax,%ax
766: 66 90 xchg %ax,%ax
768: 66 90 xchg %ax,%ax
76a: 66 90 xchg %ax,%ax
76c: 66 90 xchg %ax,%ax
76e: 66 90 xchg %ax,%ax
00000770 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
770: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
771: a1 c8 10 00 00 mov 0x10c8,%eax
{
776: 89 e5 mov %esp,%ebp
778: 57 push %edi
779: 56 push %esi
77a: 53 push %ebx
77b: 8b 5d 08 mov 0x8(%ebp),%ebx
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
77e: 8b 08 mov (%eax),%ecx
bp = (Header*)ap - 1;
780: 8d 53 f8 lea -0x8(%ebx),%edx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
783: 39 d0 cmp %edx,%eax
785: 72 11 jb 798 <free+0x28>
787: 90 nop
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
788: 39 c8 cmp %ecx,%eax
78a: 72 04 jb 790 <free+0x20>
78c: 39 ca cmp %ecx,%edx
78e: 72 10 jb 7a0 <free+0x30>
790: 89 c8 mov %ecx,%eax
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
792: 39 d0 cmp %edx,%eax
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
794: 8b 08 mov (%eax),%ecx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
796: 73 f0 jae 788 <free+0x18>
798: 39 ca cmp %ecx,%edx
79a: 72 04 jb 7a0 <free+0x30>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
79c: 39 c8 cmp %ecx,%eax
79e: 72 f0 jb 790 <free+0x20>
break;
if(bp + bp->s.size == p->s.ptr){
7a0: 8b 73 fc mov -0x4(%ebx),%esi
7a3: 8d 3c f2 lea (%edx,%esi,8),%edi
7a6: 39 cf cmp %ecx,%edi
7a8: 74 1e je 7c8 <free+0x58>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
7aa: 89 4b f8 mov %ecx,-0x8(%ebx)
if(p + p->s.size == bp){
7ad: 8b 48 04 mov 0x4(%eax),%ecx
7b0: 8d 34 c8 lea (%eax,%ecx,8),%esi
7b3: 39 f2 cmp %esi,%edx
7b5: 74 28 je 7df <free+0x6f>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
7b7: 89 10 mov %edx,(%eax)
freep = p;
7b9: a3 c8 10 00 00 mov %eax,0x10c8
}
7be: 5b pop %ebx
7bf: 5e pop %esi
7c0: 5f pop %edi
7c1: 5d pop %ebp
7c2: c3 ret
7c3: 90 nop
7c4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
bp->s.size += p->s.ptr->s.size;
7c8: 03 71 04 add 0x4(%ecx),%esi
7cb: 89 73 fc mov %esi,-0x4(%ebx)
bp->s.ptr = p->s.ptr->s.ptr;
7ce: 8b 08 mov (%eax),%ecx
7d0: 8b 09 mov (%ecx),%ecx
7d2: 89 4b f8 mov %ecx,-0x8(%ebx)
if(p + p->s.size == bp){
7d5: 8b 48 04 mov 0x4(%eax),%ecx
7d8: 8d 34 c8 lea (%eax,%ecx,8),%esi
7db: 39 f2 cmp %esi,%edx
7dd: 75 d8 jne 7b7 <free+0x47>
p->s.size += bp->s.size;
7df: 03 4b fc add -0x4(%ebx),%ecx
freep = p;
7e2: a3 c8 10 00 00 mov %eax,0x10c8
p->s.size += bp->s.size;
7e7: 89 48 04 mov %ecx,0x4(%eax)
p->s.ptr = bp->s.ptr;
7ea: 8b 53 f8 mov -0x8(%ebx),%edx
7ed: 89 10 mov %edx,(%eax)
}
7ef: 5b pop %ebx
7f0: 5e pop %esi
7f1: 5f pop %edi
7f2: 5d pop %ebp
7f3: c3 ret
7f4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
7fa: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000800 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
800: 55 push %ebp
801: 89 e5 mov %esp,%ebp
803: 57 push %edi
804: 56 push %esi
805: 53 push %ebx
806: 83 ec 1c sub $0x1c,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
809: 8b 45 08 mov 0x8(%ebp),%eax
if((prevp = freep) == 0){
80c: 8b 1d c8 10 00 00 mov 0x10c8,%ebx
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
812: 8d 48 07 lea 0x7(%eax),%ecx
815: c1 e9 03 shr $0x3,%ecx
if((prevp = freep) == 0){
818: 85 db test %ebx,%ebx
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
81a: 8d 71 01 lea 0x1(%ecx),%esi
if((prevp = freep) == 0){
81d: 0f 84 9b 00 00 00 je 8be <malloc+0xbe>
823: 8b 13 mov (%ebx),%edx
825: 8b 7a 04 mov 0x4(%edx),%edi
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
828: 39 fe cmp %edi,%esi
82a: 76 64 jbe 890 <malloc+0x90>
82c: 8d 04 f5 00 00 00 00 lea 0x0(,%esi,8),%eax
if(nu < 4096)
833: bb 00 80 00 00 mov $0x8000,%ebx
838: 89 45 e4 mov %eax,-0x1c(%ebp)
83b: eb 0e jmp 84b <malloc+0x4b>
83d: 8d 76 00 lea 0x0(%esi),%esi
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
840: 8b 02 mov (%edx),%eax
if(p->s.size >= nunits){
842: 8b 78 04 mov 0x4(%eax),%edi
845: 39 fe cmp %edi,%esi
847: 76 4f jbe 898 <malloc+0x98>
849: 89 c2 mov %eax,%edx
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
84b: 3b 15 c8 10 00 00 cmp 0x10c8,%edx
851: 75 ed jne 840 <malloc+0x40>
if(nu < 4096)
853: 8b 45 e4 mov -0x1c(%ebp),%eax
856: 81 fe 00 10 00 00 cmp $0x1000,%esi
85c: bf 00 10 00 00 mov $0x1000,%edi
861: 0f 43 fe cmovae %esi,%edi
864: 0f 42 c3 cmovb %ebx,%eax
p = sbrk(nu * sizeof(Header));
867: 89 04 24 mov %eax,(%esp)
86a: e8 bb fb ff ff call 42a <sbrk>
if(p == (char*)-1)
86f: 83 f8 ff cmp $0xffffffff,%eax
872: 74 18 je 88c <malloc+0x8c>
hp->s.size = nu;
874: 89 78 04 mov %edi,0x4(%eax)
free((void*)(hp + 1));
877: 83 c0 08 add $0x8,%eax
87a: 89 04 24 mov %eax,(%esp)
87d: e8 ee fe ff ff call 770 <free>
return freep;
882: 8b 15 c8 10 00 00 mov 0x10c8,%edx
if((p = morecore(nunits)) == 0)
888: 85 d2 test %edx,%edx
88a: 75 b4 jne 840 <malloc+0x40>
return 0;
88c: 31 c0 xor %eax,%eax
88e: eb 20 jmp 8b0 <malloc+0xb0>
if(p->s.size >= nunits){
890: 89 d0 mov %edx,%eax
892: 89 da mov %ebx,%edx
894: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(p->s.size == nunits)
898: 39 fe cmp %edi,%esi
89a: 74 1c je 8b8 <malloc+0xb8>
p->s.size -= nunits;
89c: 29 f7 sub %esi,%edi
89e: 89 78 04 mov %edi,0x4(%eax)
p += p->s.size;
8a1: 8d 04 f8 lea (%eax,%edi,8),%eax
p->s.size = nunits;
8a4: 89 70 04 mov %esi,0x4(%eax)
freep = prevp;
8a7: 89 15 c8 10 00 00 mov %edx,0x10c8
return (void*)(p + 1);
8ad: 83 c0 08 add $0x8,%eax
}
}
8b0: 83 c4 1c add $0x1c,%esp
8b3: 5b pop %ebx
8b4: 5e pop %esi
8b5: 5f pop %edi
8b6: 5d pop %ebp
8b7: c3 ret
prevp->s.ptr = p->s.ptr;
8b8: 8b 08 mov (%eax),%ecx
8ba: 89 0a mov %ecx,(%edx)
8bc: eb e9 jmp 8a7 <malloc+0xa7>
base.s.ptr = freep = prevp = &base;
8be: c7 05 c8 10 00 00 cc movl $0x10cc,0x10c8
8c5: 10 00 00
base.s.size = 0;
8c8: ba cc 10 00 00 mov $0x10cc,%edx
base.s.ptr = freep = prevp = &base;
8cd: c7 05 cc 10 00 00 cc movl $0x10cc,0x10cc
8d4: 10 00 00
base.s.size = 0;
8d7: c7 05 d0 10 00 00 00 movl $0x0,0x10d0
8de: 00 00 00
8e1: e9 46 ff ff ff jmp 82c <malloc+0x2c>
8e6: 66 90 xchg %ax,%ax
8e8: 66 90 xchg %ax,%ax
8ea: 66 90 xchg %ax,%ax
8ec: 66 90 xchg %ax,%ax
8ee: 66 90 xchg %ax,%ax
000008f0 <benny_thread_create>:
static struct benny_thread_s *bt_new(void);
int
benny_thread_create(benny_thread_t *abt, void (*func)(void*), void *arg_ptr)
{
8f0: 55 push %ebp
8f1: 89 e5 mov %esp,%ebp
8f3: 56 push %esi
8f4: 53 push %ebx
8f5: 83 ec 10 sub $0x10,%esp
}
static struct benny_thread_s *
bt_new(void)
{
struct benny_thread_s *bt = malloc(sizeof(struct benny_thread_s));
8f8: c7 04 24 0c 00 00 00 movl $0xc,(%esp)
8ff: e8 fc fe ff ff call 800 <malloc>
if (bt == NULL) {
904: 85 c0 test %eax,%eax
struct benny_thread_s *bt = malloc(sizeof(struct benny_thread_s));
906: 89 c6 mov %eax,%esi
if (bt == NULL) {
908: 74 66 je 970 <benny_thread_create+0x80>
// allocate 2 pages worth of memory and then make sure the
// beginning address used for the stack is page alligned.
// we want it page alligned so that we don't generate a
// page fault by accessing the stack for a thread.
bt->bt_stack = bt->mem_stack = malloc(PGSIZE * 2);
90a: c7 04 24 00 20 00 00 movl $0x2000,(%esp)
911: e8 ea fe ff ff call 800 <malloc>
if (bt->bt_stack == NULL) {
916: 85 c0 test %eax,%eax
bt->bt_stack = bt->mem_stack = malloc(PGSIZE * 2);
918: 89 c3 mov %eax,%ebx
91a: 89 46 08 mov %eax,0x8(%esi)
91d: 89 46 04 mov %eax,0x4(%esi)
if (bt->bt_stack == NULL) {
920: 74 5d je 97f <benny_thread_create+0x8f>
free(bt);
return NULL;
}
if (((uint) bt->bt_stack) % PGSIZE != 0) {
922: 25 ff 0f 00 00 and $0xfff,%eax
927: 75 37 jne 960 <benny_thread_create+0x70>
// allign the thread stack to a page boundary
bt->bt_stack += (PGSIZE - ((uint) bt->bt_stack) % PGSIZE);
}
bt->bid = -1;
929: c7 06 ff ff ff ff movl $0xffffffff,(%esi)
bt->bid = kthread_create(func, arg_ptr, bt->bt_stack);
92f: 8b 45 10 mov 0x10(%ebp),%eax
932: 89 5c 24 08 mov %ebx,0x8(%esp)
936: 89 44 24 04 mov %eax,0x4(%esp)
93a: 8b 45 0c mov 0xc(%ebp),%eax
93d: 89 04 24 mov %eax,(%esp)
940: e8 25 fb ff ff call 46a <kthread_create>
if (bt->bid != 0) {
945: 85 c0 test %eax,%eax
bt->bid = kthread_create(func, arg_ptr, bt->bt_stack);
947: 89 06 mov %eax,(%esi)
if (bt->bid != 0) {
949: 74 2d je 978 <benny_thread_create+0x88>
*abt = (benny_thread_t) bt;
94b: 8b 45 08 mov 0x8(%ebp),%eax
94e: 89 30 mov %esi,(%eax)
result = 0;
950: 31 c0 xor %eax,%eax
}
952: 83 c4 10 add $0x10,%esp
955: 5b pop %ebx
956: 5e pop %esi
957: 5d pop %ebp
958: c3 ret
959: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
bt->bt_stack += (PGSIZE - ((uint) bt->bt_stack) % PGSIZE);
960: 29 c3 sub %eax,%ebx
962: 81 c3 00 10 00 00 add $0x1000,%ebx
968: 89 5e 04 mov %ebx,0x4(%esi)
96b: eb bc jmp 929 <benny_thread_create+0x39>
96d: 8d 76 00 lea 0x0(%esi),%esi
970: 8b 1d 04 00 00 00 mov 0x4,%ebx
976: eb b7 jmp 92f <benny_thread_create+0x3f>
int result = -1;
978: b8 ff ff ff ff mov $0xffffffff,%eax
97d: eb d3 jmp 952 <benny_thread_create+0x62>
free(bt);
97f: 89 34 24 mov %esi,(%esp)
return NULL;
982: 31 f6 xor %esi,%esi
free(bt);
984: e8 e7 fd ff ff call 770 <free>
989: 8b 5b 04 mov 0x4(%ebx),%ebx
98c: eb a1 jmp 92f <benny_thread_create+0x3f>
98e: 66 90 xchg %ax,%ax
00000990 <benny_thread_bid>:
{
990: 55 push %ebp
991: 89 e5 mov %esp,%ebp
return bt->bid;
993: 8b 45 08 mov 0x8(%ebp),%eax
}
996: 5d pop %ebp
return bt->bid;
997: 8b 00 mov (%eax),%eax
}
999: c3 ret
99a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
000009a0 <benny_thread_join>:
{
9a0: 55 push %ebp
9a1: 89 e5 mov %esp,%ebp
9a3: 53 push %ebx
9a4: 83 ec 14 sub $0x14,%esp
9a7: 8b 5d 08 mov 0x8(%ebp),%ebx
retVal = kthread_join(bt->bid);
9aa: 8b 03 mov (%ebx),%eax
9ac: 89 04 24 mov %eax,(%esp)
9af: e8 be fa ff ff call 472 <kthread_join>
if (retVal == 0) {
9b4: 85 c0 test %eax,%eax
9b6: 75 27 jne 9df <benny_thread_join+0x3f>
free(bt->mem_stack);
9b8: 8b 53 08 mov 0x8(%ebx),%edx
9bb: 89 45 f4 mov %eax,-0xc(%ebp)
9be: 89 14 24 mov %edx,(%esp)
9c1: e8 aa fd ff ff call 770 <free>
bt->bt_stack = bt->mem_stack = NULL;
9c6: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
9cd: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
free(bt);
9d4: 89 1c 24 mov %ebx,(%esp)
9d7: e8 94 fd ff ff call 770 <free>
9dc: 8b 45 f4 mov -0xc(%ebp),%eax
}
9df: 83 c4 14 add $0x14,%esp
9e2: 5b pop %ebx
9e3: 5d pop %ebp
9e4: c3 ret
9e5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
9e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000009f0 <benny_thread_exit>:
{
9f0: 55 push %ebp
9f1: 89 e5 mov %esp,%ebp
}
9f3: 5d pop %ebp
return kthread_exit(exitValue);
9f4: e9 81 fa ff ff jmp 47a <kthread_exit>
9f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000a00 <benny_mootex_init>:
}
# ifdef BENNY_MOOTEX
int
benny_mootex_init(benny_mootex_t *benny_mootex)
{
a00: 55 push %ebp
a01: 89 e5 mov %esp,%ebp
a03: 8b 45 08 mov 0x8(%ebp),%eax
benny_mootex->locked = 0;
a06: c7 00 00 00 00 00 movl $0x0,(%eax)
benny_mootex->bid = -1;
a0c: c7 40 04 ff ff ff ff movl $0xffffffff,0x4(%eax)
return 0;
}
a13: 31 c0 xor %eax,%eax
a15: 5d pop %ebp
a16: c3 ret
a17: 89 f6 mov %esi,%esi
a19: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000a20 <benny_mootex_yieldlock>:
int
benny_mootex_yieldlock(benny_mootex_t *benny_mootex)
{
a20: 55 push %ebp
xchg(volatile uint *addr, uint newval)
{
uint result;
// The + in "+m" denotes a read-modify-write operand.
asm volatile("lock; xchgl %0, %1" :
a21: b8 01 00 00 00 mov $0x1,%eax
a26: 89 e5 mov %esp,%ebp
a28: 56 push %esi
a29: 53 push %ebx
a2a: 8b 5d 08 mov 0x8(%ebp),%ebx
a2d: f0 87 03 lock xchg %eax,(%ebx)
// #error this is the call to lock the mootex that will yield in a
// #error loop until the lock is acquired.
while(xchg(&benny_mootex->locked, 1) != 0){
a30: 85 c0 test %eax,%eax
a32: be 01 00 00 00 mov $0x1,%esi
a37: 74 15 je a4e <benny_mootex_yieldlock+0x2e>
a39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
benny_yield(void)
{
// # error This just gives up the rest of this scheduled time slice to
// # error another process/thread.
return kthread_yield();
a40: e8 45 fa ff ff call 48a <kthread_yield>
a45: 89 f0 mov %esi,%eax
a47: f0 87 03 lock xchg %eax,(%ebx)
while(xchg(&benny_mootex->locked, 1) != 0){
a4a: 85 c0 test %eax,%eax
a4c: 75 f2 jne a40 <benny_mootex_yieldlock+0x20>
return kthread_self();
a4e: e8 2f fa ff ff call 482 <kthread_self>
benny_mootex->bid = benny_self();
a53: 89 43 04 mov %eax,0x4(%ebx)
}
a56: 31 c0 xor %eax,%eax
a58: 5b pop %ebx
a59: 5e pop %esi
a5a: 5d pop %ebp
a5b: c3 ret
a5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000a60 <benny_mootex_spinlock>:
{
a60: 55 push %ebp
a61: ba 01 00 00 00 mov $0x1,%edx
a66: 89 e5 mov %esp,%ebp
a68: 53 push %ebx
a69: 83 ec 04 sub $0x4,%esp
a6c: 8b 5d 08 mov 0x8(%ebp),%ebx
a6f: 90 nop
a70: 89 d0 mov %edx,%eax
a72: f0 87 03 lock xchg %eax,(%ebx)
while(xchg(&benny_mootex->locked, 1) != 0){
a75: 85 c0 test %eax,%eax
a77: 75 f7 jne a70 <benny_mootex_spinlock+0x10>
return kthread_self();
a79: e8 04 fa ff ff call 482 <kthread_self>
benny_mootex->bid = benny_self();
a7e: 89 43 04 mov %eax,0x4(%ebx)
}
a81: 83 c4 04 add $0x4,%esp
a84: 31 c0 xor %eax,%eax
a86: 5b pop %ebx
a87: 5d pop %ebp
a88: c3 ret
a89: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000a90 <benny_mootex_unlock>:
{
a90: 55 push %ebp
a91: 89 e5 mov %esp,%ebp
a93: 53 push %ebx
a94: 83 ec 04 sub $0x4,%esp
a97: 8b 5d 08 mov 0x8(%ebp),%ebx
return kthread_self();
a9a: e8 e3 f9 ff ff call 482 <kthread_self>
if(tid == benny_mootex->bid){
a9f: 39 43 04 cmp %eax,0x4(%ebx)
aa2: 75 1c jne ac0 <benny_mootex_unlock+0x30>
__sync_synchronize();
aa4: 0f ae f0 mfence
return 0;
aa7: 31 c0 xor %eax,%eax
benny_mootex->bid = -1;
aa9: c7 43 04 ff ff ff ff movl $0xffffffff,0x4(%ebx)
__sync_lock_release(&benny_mootex->locked);
ab0: c7 03 00 00 00 00 movl $0x0,(%ebx)
}
ab6: 83 c4 04 add $0x4,%esp
ab9: 5b pop %ebx
aba: 5d pop %ebp
abb: c3 ret
abc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
ac0: 83 c4 04 add $0x4,%esp
return -1;
ac3: b8 ff ff ff ff mov $0xffffffff,%eax
}
ac8: 5b pop %ebx
ac9: 5d pop %ebp
aca: c3 ret
acb: 90 nop
acc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000ad0 <benny_mootex_trylock>:
{
ad0: 55 push %ebp
ad1: b8 01 00 00 00 mov $0x1,%eax
ad6: 89 e5 mov %esp,%ebp
ad8: 53 push %ebx
ad9: 83 ec 04 sub $0x4,%esp
adc: 8b 5d 08 mov 0x8(%ebp),%ebx
adf: f0 87 03 lock xchg %eax,(%ebx)
if(xchg(&benny_mootex->locked, 1) != 0){
ae2: 85 c0 test %eax,%eax
ae4: 75 08 jne aee <benny_mootex_trylock+0x1e>
int tid = kthread_self();
ae6: e8 97 f9 ff ff call 482 <kthread_self>
benny_mootex->bid = tid;
aeb: 89 43 04 mov %eax,0x4(%ebx)
}
aee: 83 c4 04 add $0x4,%esp
af1: b8 ff ff ff ff mov $0xffffffff,%eax
af6: 5b pop %ebx
af7: 5d pop %ebp
af8: c3 ret
af9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000b00 <benny_mootex_wholock>:
{
b00: 55 push %ebp
b01: 89 e5 mov %esp,%ebp
return benny_mootex->bid;
b03: 8b 45 08 mov 0x8(%ebp),%eax
}
b06: 5d pop %ebp
return benny_mootex->bid;
b07: 8b 40 04 mov 0x4(%eax),%eax
}
b0a: c3 ret
b0b: 90 nop
b0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000b10 <benny_mootex_islocked>:
{
b10: 55 push %ebp
b11: 89 e5 mov %esp,%ebp
return benny_mootex->locked;
b13: 8b 45 08 mov 0x8(%ebp),%eax
}
b16: 5d pop %ebp
return benny_mootex->locked;
b17: 8b 00 mov (%eax),%eax
}
b19: c3 ret
b1a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000b20 <benny_self>:
{
b20: 55 push %ebp
b21: 89 e5 mov %esp,%ebp
}
b23: 5d pop %ebp
return kthread_self();
b24: e9 59 f9 ff ff jmp 482 <kthread_self>
b29: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000b30 <benny_yield>:
{
b30: 55 push %ebp
b31: 89 e5 mov %esp,%ebp
}
b33: 5d pop %ebp
return kthread_yield();
b34: e9 51 f9 ff ff jmp 48a <kthread_yield>
b39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000b40 <benny_cpu_count>:
int
benny_cpu_count(void)
{
b40: 55 push %ebp
b41: 89 e5 mov %esp,%ebp
// # error call the kthread_cpu_count() function.
// kthread_cpu_count();
return kthread_cpu_count();
}
b43: 5d pop %ebp
return kthread_cpu_count();
b44: e9 49 f9 ff ff jmp 492 <kthread_cpu_count>
b49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000b50 <benny_thread_count>:
int
benny_thread_count(void)
{
b50: 55 push %ebp
b51: 89 e5 mov %esp,%ebp
// # error call the kthread_thread_count() function.
// kthread_thread_count()
return kthread_thread_count();
}
b53: 5d pop %ebp
return kthread_thread_count();
b54: e9 41 f9 ff ff jmp 49a <kthread_thread_count>
| 34.180634
| 84
| 0.437917
|
56596579eb6717f61305dcf28c050d658881ef0e
| 2,686
|
asm
|
Assembly
|
DiOS/io.asm
|
diniremix/NaOS
|
3c63475749593418280d688930393006fc88f459
|
[
"MIT"
] | null | null | null |
DiOS/io.asm
|
diniremix/NaOS
|
3c63475749593418280d688930393006fc88f459
|
[
"MIT"
] | null | null | null |
DiOS/io.asm
|
diniremix/NaOS
|
3c63475749593418280d688930393006fc88f459
|
[
"MIT"
] | null | null | null |
;controlada Ok (ver si el getstring deja borrar mas atras de donde empezo)
;# Funcion PutChar #########################################################
;# Descripcion:
;# Pone un caracter en la posicion del cursor
;# Parametros:
;# AL -> Caracter a mostrar
;# Retorno:
;# Ninguno
;# Nota:
;# Hacerlo sin la Bios
;###########################################################################
putChar:
push ax ; guardamos...
mov ah,0eh ; funcion putChar de la Bios
int 10h ; interrupcion de video
pop ax ; recuperamos
ret ; return
;# Funcion putString #######################################################
;# Descripcion:
;# Pone la cadena en la posicion del cursor
;# Parametros:
;# SI -> cadena a mostrar terminada en 0
;# Retorno:
;# Ninguno
;# Nota:
;# -
;###########################################################################
putString:
push ax ; ponemos en la pila los valores que modificamos
push si
.l1:
mov al,[si] ; cargamos el caracter
cmp al,0 ; nos fijamos si es el terminador
jz .fin ; si es el terminador terminamos
call putChar ; ponemos el caracter
inc si ; SI++
jmp .l1 ; de nuevo...
.fin:
pop si ; recuperamos los valores
pop ax
ret ; return
;# Funcion getChar #########################################################
;# Descripcion:
;# obtiene un caracter y lo retira del buffer
;# Parametros:
;# -
;# Retorno:
;# AH -> scancode
;# AL -> ASCII
;# Nota:
;# Hacerlo sin la BIOS
;###########################################################################
getChar:
mov ah,0 ; getkey de la bios
int 16h ; int de teclado
call putChar ; lo mostramos
ret
;# Funcion GetString #######################################################
;# Descripcion:
;# obtiene una cadena hasta que se presiona enter
;# Parametros:
;# CX -> cantidad de caracteres maxima a leer
;# ES:DI -> donde poner la cadena
;# Retorno:
;# DI -> la cadena
;# Nota:
;# -
;###########################################################################
getString:
push cx
push ax ; guardamos...
push di
push si
mov si,di
.l1:
cmp cx,0
jz .fin
mov ah,0 ; getkey de la bios
int 16h ; int de teclado
dec cx
cmp al,0xd ; es enter?
jz .fin ; si es terminamos
cmp al,0x8 ; es backSpace?
jz .bs ; lo tratamos
call putChar
mov [di],al ; si no, ponemos el carater
inc di ; DI++
jmp .l1 ; de nuevo
.bs:
cmp si,di ; si llego al primer caracter
je .l1 ; pide el que sigue
call putChar
dec di ; si no, DI--
jmp .l1 ; pide el que sigue
.fin:
mov byte [di],0 ; ponemos el terminador de cadena
mov al,13 ; bajamos a la linea siguiente
call putChar
mov al,10
call putChar
pop si
pop di
pop ax ; restauramos...
pop cx
ret
| 22.383333
| 76
| 0.532018
|
17920f6b394b8d11f08680479878a2d00e3cff3a
| 885
|
asm
|
Assembly
|
util.asm
|
adkennan/BurgerMayhem
|
0c80704b73f9ddf17924a377aa37062504bddb1c
|
[
"BSD-3-Clause"
] | null | null | null |
util.asm
|
adkennan/BurgerMayhem
|
0c80704b73f9ddf17924a377aa37062504bddb1c
|
[
"BSD-3-Clause"
] | null | null | null |
util.asm
|
adkennan/BurgerMayhem
|
0c80704b73f9ddf17924a377aa37062504bddb1c
|
[
"BSD-3-Clause"
] | null | null | null |
WRITE_HEX
sta LINE_VAL
stx LINE_NUM
pha
tya
pha
txa
pha
ldx LINE_NUM
lda #<SCREEN_0
sta LINE_PTR_LO
lda #>SCREEN_0
sta LINE_PTR_HI
@loop
clc
adc #$28
sta LINE_PTR_LO
bcc @got_line
inc LINE_PTR_HI
@got_line
dex
bne @loop
lda LINE_VAL
ldy #1
jsr SHOW_DIGIT
lda LINE_VAL
ror
ror
ror
ror
ldy #0
jsr SHOW_DIGIT
pla
tax
pla
tay
pla
rts
SHOW_DIGIT
pha
and #$0f
cmp #$0a
bcc @show
clc
adc #1
@show
sta (LINE_PTR_LO),y
pla
rts
SET_BIT
tay
lda NUM_FLAG,y
rts
| 14.047619
| 27
| 0.39435
|
38673bb792c8b61b0066c6b1efe78f82548d1b57
| 575
|
asm
|
Assembly
|
libsrc/_DEVELOPMENT/arch/zx/display/z80/asm_zx_aaddr2cx.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 640
|
2017-01-14T23:33:45.000Z
|
2022-03-30T11:28:42.000Z
|
libsrc/_DEVELOPMENT/arch/zx/display/z80/asm_zx_aaddr2cx.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 1,600
|
2017-01-15T16:12:02.000Z
|
2022-03-31T12:11:12.000Z
|
libsrc/_DEVELOPMENT/arch/zx/display/z80/asm_zx_aaddr2cx.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 215
|
2017-01-17T10:43:03.000Z
|
2022-03-23T17:25:02.000Z
|
; ===============================================================
; Jun 2007
; ===============================================================
;
; uchar zx_aaddr2cx(void *attraddr)
;
; Attribute address to character x coordinate.
;
; ===============================================================
SECTION code_clib
SECTION code_arch
PUBLIC asm_zx_aaddr2cx
asm_zx_aaddr2cx:
; enter : hl = valid attribute address
;
; exit : l = character x coordinate of attr square
;
; uses : af, l
ld a,l
and $1f
ld l,a
IF __SCCZ80
ld h,0
ENDIF
ret
| 16.911765
| 65
| 0.431304
|
d38a9f206ded66cbfd5c266b95d17c5cb414cef6
| 433
|
asm
|
Assembly
|
oeis/136/A136675.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/136/A136675.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/136/A136675.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A136675: Numerator of Sum_{k=1..n} (-1)^(k+1)/k^3.
; Submitted by Christian Krause
; 1,7,197,1549,195353,194353,66879079,533875007,14436577189,14420574181,19209787242911,19197460851911,42198121495296467,6025866788581781,6027847576222613,48209723660000029,236907853607882606477
mov $1,1
lpb $0
mov $2,$0
sub $0,1
add $2,1
pow $2,3
mul $3,$2
mul $3,-1
add $3,$1
mul $1,$2
lpe
sub $1,$3
gcd $3,$1
div $1,$3
mov $0,$1
| 21.65
| 193
| 0.699769
|
79ce52e4e8acc01ba3f937dd7cdfc4dfe33ab719
| 206
|
asm
|
Assembly
|
stone/testcases/cmp.asm
|
yutopp/sekki
|
28d848ff2f0a4205032a8722e755176bafde0b04
|
[
"BSL-1.0"
] | 6
|
2019-09-14T16:01:18.000Z
|
2021-05-07T12:09:34.000Z
|
stone/testcases/cmp.asm
|
yutopp/sekki
|
28d848ff2f0a4205032a8722e755176bafde0b04
|
[
"BSL-1.0"
] | null | null | null |
stone/testcases/cmp.asm
|
yutopp/sekki
|
28d848ff2f0a4205032a8722e755176bafde0b04
|
[
"BSL-1.0"
] | null | null | null |
bits 64
cmp cl, 0x0
cmp rcx, [rbp-32]
cmp dl, al
cmp rax, 0xff
cmp rax, 8
cmp rax, 0xffffffff
cmp rcx, rsi
cmp rax, -1
cmp rax,0x80
cmp al, byte [rbp-0x20]
| 13.733333
| 27
| 0.519417
|
acc57a838d0b3b5d8e1bc86d9c6990d32ae71c17
| 7,386
|
asm
|
Assembly
|
Transynther/x86/_processed/NONE/_st_/i7-7700_9_0x48.log_21829_1911.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 9
|
2020-08-13T19:41:58.000Z
|
2022-03-30T12:22:51.000Z
|
Transynther/x86/_processed/NONE/_st_/i7-7700_9_0x48.log_21829_1911.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 1
|
2021-04-29T06:29:35.000Z
|
2021-05-13T21:02:30.000Z
|
Transynther/x86/_processed/NONE/_st_/i7-7700_9_0x48.log_21829_1911.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 3
|
2020-07-14T17:07:07.000Z
|
2022-03-21T01:12:22.000Z
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r9
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_WT_ht+0x1b27c, %rsi
lea addresses_UC_ht+0x1724c, %rdi
inc %rbx
mov $91, %rcx
rep movsw
inc %rbx
lea addresses_normal_ht+0x1979, %rsi
lea addresses_UC_ht+0x1d42c, %rdi
clflush (%rsi)
nop
nop
nop
nop
sub %r11, %r11
mov $117, %rcx
rep movsq
nop
nop
nop
inc %rbx
lea addresses_D_ht+0x516c, %rsi
lea addresses_A_ht+0x588e, %rdi
nop
nop
xor %r10, %r10
mov $36, %rcx
rep movsw
and %rcx, %rcx
lea addresses_WT_ht+0x17233, %rdi
nop
nop
nop
nop
and %r11, %r11
movw $0x6162, (%rdi)
nop
nop
nop
nop
and %rdi, %rdi
lea addresses_D_ht+0x5e6c, %rsi
lea addresses_UC_ht+0x96c, %rdi
nop
and %r9, %r9
mov $112, %rcx
rep movsl
nop
nop
nop
sub %rbx, %rbx
lea addresses_UC_ht+0x1b36c, %rsi
lea addresses_UC_ht+0x1bd2c, %rdi
nop
nop
nop
nop
xor $31932, %r9
mov $88, %rcx
rep movsw
nop
nop
nop
nop
cmp %r9, %r9
lea addresses_WC_ht+0x1cda4, %rsi
lea addresses_WC_ht+0x11665, %rdi
nop
nop
nop
nop
nop
dec %r11
mov $66, %rcx
rep movsw
nop
nop
sub $40711, %rcx
lea addresses_WC_ht+0x11d6c, %r11
nop
nop
and $61805, %rcx
movups (%r11), %xmm6
vpextrq $1, %xmm6, %r9
nop
nop
and %r10, %r10
lea addresses_D_ht+0x1ecc2, %rsi
lea addresses_D_ht+0xab5c, %rdi
nop
inc %rbx
mov $73, %rcx
rep movsq
nop
nop
sub $24275, %r11
lea addresses_UC_ht+0x129fc, %rsi
lea addresses_normal_ht+0x59a3, %rdi
nop
cmp %r11, %r11
mov $118, %rcx
rep movsb
nop
sub %rbx, %rbx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %r9
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %r14
push %r9
push %rbp
push %rdi
push %rsi
// Store
mov $0xef8, %r14
nop
nop
nop
nop
dec %rbp
mov $0x5152535455565758, %r12
movq %r12, %xmm0
vmovups %ymm0, (%r14)
nop
nop
nop
nop
nop
xor %r12, %r12
// Store
mov $0xd6c, %r9
clflush (%r9)
nop
nop
nop
add $17596, %rbp
movw $0x5152, (%r9)
nop
nop
nop
and %rbp, %rbp
// Store
lea addresses_normal+0x1396c, %r9
cmp %r10, %r10
movl $0x51525354, (%r9)
nop
nop
nop
nop
cmp $62765, %rsi
// Faulty Load
lea addresses_A+0x15d6c, %rbp
nop
nop
nop
nop
nop
sub %rdi, %rdi
movb (%rbp), %r12b
lea oracles, %r10
and $0xff, %r12
shlq $12, %r12
mov (%r10,%r12,1), %r12
pop %rsi
pop %rdi
pop %rbp
pop %r9
pop %r14
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_A', 'AVXalign': False, 'congruent': 0, 'size': 2, 'same': True, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_P', 'AVXalign': False, 'congruent': 2, 'size': 32, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_P', 'AVXalign': False, 'congruent': 8, 'size': 2, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal', 'AVXalign': False, 'congruent': 10, 'size': 4, 'same': False, 'NT': True}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_A', 'AVXalign': False, 'congruent': 0, 'size': 1, 'same': True, 'NT': False}}
<gen_prepare_buffer>
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 4, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 0, 'same': True}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 6, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 7, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'AVXalign': False, 'congruent': 0, 'size': 2, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 6, 'same': True}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 9, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 9, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 5, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WC_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 0, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'AVXalign': False, 'congruent': 9, 'size': 16, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 4, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 0, 'same': False}}
{'52': 21829}
52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52 52
*/
| 34.036866
| 2,999
| 0.658272
|
ab96b831617097b880e8f032e95829405bcb9776
| 58,463
|
asm
|
Assembly
|
vp9/encoder/arm/neon/vp9_dct_32x32_neon_asm.asm
|
ittiamvpx/libvpx
|
2d6523dcbf71745297c603489bf37ba264f93caa
|
[
"BSD-3-Clause"
] | 14
|
2015-01-31T16:24:27.000Z
|
2021-04-26T16:32:45.000Z
|
vp9/encoder/arm/neon/vp9_dct_32x32_neon_asm.asm
|
ittiamvpx/libvpx
|
2d6523dcbf71745297c603489bf37ba264f93caa
|
[
"BSD-3-Clause"
] | 1
|
2015-11-23T00:18:08.000Z
|
2018-06-13T14:58:49.000Z
|
vp9/encoder/arm/neon/vp9_dct_32x32_neon_asm.asm
|
ittiamvpx/libvpx
|
2d6523dcbf71745297c603489bf37ba264f93caa
|
[
"BSD-3-Clause"
] | 7
|
2015-11-01T10:06:14.000Z
|
2020-10-30T11:10:39.000Z
|
;
; Copyright (c) 2013 The WebM project authors. All Rights Reserved.
;
; Use of this source code is governed by a BSD-style license
; that can be found in the LICENSE file in the root of the source
; tree. An additional intellectual property rights grant can be found
; in the file PATENTS. All contributing project authors may
; be found in the AUTHORS file in the root of the source tree.
;
;TODO(cd): adjust these constant to be able to use vqdmulh for faster
; dct_const_round_shift(a * b) within butterfly calculations.
cospi_1_64 EQU 16364
cospi_2_64 EQU 16305
cospi_3_64 EQU 16207
cospi_4_64 EQU 16069
cospi_5_64 EQU 15893
cospi_6_64 EQU 15679
cospi_7_64 EQU 15426
cospi_8_64 EQU 15137
cospi_9_64 EQU 14811
cospi_10_64 EQU 14449
cospi_11_64 EQU 14053
cospi_12_64 EQU 13623
cospi_13_64 EQU 13160
cospi_14_64 EQU 12665
cospi_15_64 EQU 12140
cospi_16_64 EQU 11585
cospi_17_64 EQU 11003
cospi_18_64 EQU 10394
cospi_19_64 EQU 9760
cospi_20_64 EQU 9102
cospi_21_64 EQU 8423
cospi_22_64 EQU 7723
cospi_23_64 EQU 7005
cospi_24_64 EQU 6270
cospi_25_64 EQU 5520
cospi_26_64 EQU 4756
cospi_27_64 EQU 3981
cospi_28_64 EQU 3196
cospi_29_64 EQU 2404
cospi_30_64 EQU 1606
cospi_31_64 EQU 804
EXPORT |vp9_fdct32x32_rd_neon|
ARM
REQUIRE8
PRESERVE8
AREA ||.text||, CODE, READONLY, ALIGN=2
AREA Block, CODE, READONLY
; --------------------------------------------------------------------------
; Load the named constant
; Load the specified constant as 16 bit signed value into neon register
; $dst : neon register to load constant into
; $const : name of the constant to load
; $tmp : arm register to use as temporary register
MACRO
GET_CONST $dst, $const, $tmp
; Generate the scalar constant
mov $tmp, #$const & 0xFF00
add $tmp, #$const & 0x00FF
; Copy the constant to neon register
vdup.s16 $dst, $tmp
MEND
;--------------------------------------------------------------------------
; Halve values
; Halves the given two values, with rounding
; $reg1 : neon register containing 1st value to be halved
; $reg2 : neon register containing 2nd value to be halved
; $tmp1 : Scratch register 1
; $tmp2 : Scratch register 2
; None of the input arguments will be preserved
MACRO
HALF_ROUND_SHIFT $reg1, $reg2, $tmp1, $tmp2
;output = (input + 1 + (input < 0)) >> 2;
; Get the sign bit of both registers
vshr.u16 $tmp1, $reg1, #15
vshr.u16 $tmp2, $reg2, #15
; Add the sign bit, also move 1
vadd.s16 $reg1, $reg1, $tmp1
vmov.s16 $tmp1, #1
vadd.s16 $reg2, $reg2, $tmp2
; Add 1 to both registers
vadd.s16 $reg1, $reg1, $tmp1
vadd.s16 $reg2, $reg2, $tmp1
; Right shift by 2
vshr.s16 $reg1, $reg1, #2
vshr.s16 $reg2, $reg2, #2
MEND
;--------------------------------------------------------------------------
; Load Values, transpose and write back
; Loads two 8x8 blocks, transpose each one and write to memory
; $src1 : address to load first 8x8 matrix from
; $src2 : address to load second 8x8 matrix from
; $dst1 : address to write first 8x8 matrix to
; $dst2 : address to write second 8x8 matrix to
; Assumes a stride of 64 for both src and dst
; Overwrites neon registers q0-q15
; None of the input arguments except $strd will be preserved
MACRO
TRANSPOSE_TWO_8x8 $src1, $src2, $dst1, $dst2, $strd
vld1.s16 {q8}, [$src2],$strd
vld1.s16 {q0}, [$src1],$strd
vld1.s16 {q9}, [$src2],$strd
vld1.s16 {q1}, [$src1],$strd
vld1.s16 {q10}, [$src2],$strd
vld1.s16 {q2}, [$src1],$strd
vld1.s16 {q11}, [$src2],$strd
vld1.s16 {q3}, [$src1],$strd
vld1.s16 {q12}, [$src2],$strd
vld1.s16 {q4}, [$src1],$strd
vld1.s16 {q13}, [$src2],$strd
vld1.s16 {q5}, [$src1],$strd
vld1.s16 {q14}, [$src2],$strd
vld1.s16 {q6}, [$src1],$strd
vld1.s16 {q15}, [$src2],$strd
vld1.s16 {q7}, [$src1],$strd
; transpose the two 8x8 16bit data matrices.
vswp d17, d24
vswp d23, d30
vswp d21, d28
vswp d19, d26
vswp d1, d8
vswp d7, d14
vswp d5, d12
vswp d3, d10
vtrn.32 q8, q10
vtrn.32 q9, q11
vtrn.32 q12, q14
vtrn.32 q13, q15
vtrn.32 q0, q2
vtrn.32 q1, q3
vtrn.32 q4, q6
vtrn.32 q5, q7
vtrn.16 q8, q9
vtrn.16 q10, q11
vtrn.16 q12, q13
vtrn.16 q14, q15
vtrn.16 q0, q1
vtrn.16 q2, q3
vtrn.16 q4, q5
vtrn.16 q6, q7
vst1.s16 {q8}, [$dst2],$strd
vst1.s16 {q0}, [$dst1],$strd
vst1.s16 {q9}, [$dst2],$strd
vst1.s16 {q1}, [$dst1],$strd
vst1.s16 {q10}, [$dst2],$strd
vst1.s16 {q2}, [$dst1],$strd
vst1.s16 {q11}, [$dst2],$strd
vst1.s16 {q3}, [$dst1],$strd
vst1.s16 {q12}, [$dst2],$strd
vst1.s16 {q4}, [$dst1],$strd
vst1.s16 {q13}, [$dst2],$strd
vst1.s16 {q5}, [$dst1],$strd
vst1.s16 {q14}, [$dst2],$strd
vst1.s16 {q6}, [$dst1],$strd
vst1.s16 {q15}, [$dst2],$strd
vst1.s16 {q7}, [$dst1],$strd
MEND
; --------------------------------------------------------------------------
; Load from intermediate buffer
; Loads a particular row from intermediate buffer
; $row_1 : Row no. from which first data is to be loaded
; $row_2 : Row no. from which second data is to be loaded
; $dst_1 : Register to store data from $row_1
; $dst_2 : Register to store data from $row_2
; Assumes r3, contains the address of the buffer
MACRO
LOAD_FROM_INTERMEDIATE $row_1, $row_2, $dst_1, $dst_2
;Load first value
add r3, #($row_1 * 16)
vld1.s16 {$dst_1},[r3]
;Load Second value
add r3, #($row_2 - $row_1) * 16
vld1.s16 {$dst_2},[r3]
;Restore pointer
sub r3, #($row_2 * 16)
MEND
; --------------------------------------------------------------------------
; Store to intermediate buffer
; Store two registers to specified rows of intermediate buffer
; $row_1 : Row no. to which first data is to be stored
; $row_2 : Row no. to which second data is to be stored
; $src_1 : Source register for $row_1
; $src_2 : Source register for $row_2
; Assumes r3, contains the address of the buffer
MACRO
STORE_TO_INTERMEDIATE $row_1, $row_2, $src_1, $src_2
; address calculation with proper stride and loading
add r3, #($row_1 * 16)
vst1.s16 {$src_1},[r3]
add r3, #($row_2 - $row_1) * 16
vst1.s16 {$src_2},[r3]
sub r3, #($row_2 * 16)
MEND
; --------------------------------------------------------------------------
; Store to output_buffer
; Store a particular register to output buffer
; $row1 : Column to which first data is to the stored
; $row2 : Column to which second data is to be stored
; $src1 : Register to store data for $row1
; $src2 : Register to store data for $row2
; $sub_band1 : sub_band no. corresponding to $row1
; $sub_band2 : sub_band no. corresponding to $row2
; For explanation of sub_bands, see Memory layout
; Assumes r1, contains the address of the buffer
MACRO
STORE_TO_OUTPUT $row1, $row2, $src1, $src2, $sub_band1, $sub_band2
;check for pass 0
cmp r5, #1
;Store first value
addeq r1, #($row1 * 64)
addne r1, #($sub_band1 * 16 + ($row1 - $sub_band1 * 8) * 64)
vst1.s16 {$src1},[r1]
;Store second value
addeq r1, #($row2 - $row1) * 64
addne r1, #($sub_band2 * 16 + ($row2 - $sub_band2 * 8) * 64) - ($sub_band1 * 16 + ($row1 - $sub_band1 * 8) * 64)
vst1.s16 {$src2},[r1]
;Store pointer
subeq r1, #($row2 * 64)
subne r1, #($sub_band2 * 16 + ($row2 - $sub_band2 * 8) * 64)
MEND
;---------------------------------------------------------------------------
; Computes butterfly. Cosine/Sine coefficient multiplications are not needed
; Computes butterfly of two registers
; $reg1 : Source register for Butterfly
; $reg2 : Source & destination register for butterfly
; $reg3 : destination register for butterfly
;
; $reg3 = $reg1 - $reg2
; $reg2 = $reg1 + $reg2
MACRO
DO_BUTTERFLY_NO_COEFFS $reg1, $reg2, $reg3
vsub.s16 $reg3, $reg1, $reg2
vadd.s16 $reg2, $reg1, $reg2
MEND
;---------------------------------------------------------------------------
; Computes butterfly. Cosine/Sine coefficients is symmetric/same
; Computes butterfly of 4 registers
; $src1 : Source register for butterfly (64 bit)
; $src2 : Source register for butterfly (64 bit)
; $src3 : Source & destination register for Butterfly (64 bit)
; $src4 : Source & destination register for butterfly (64 bit)
; $scal : Scaling value (64 bit)
; $dst1 : Source register for Butterfly (64 bit)
; $dst2 : Source register for butterfly (64 bit)
; $tmp2,$tmp3 : temporary registers (128 bit)
;
; Ssrc3 = ($src1 + $src2) * scal >> 14 (rounded)
; Ssrc4 = ($src3 + $src4) * scal >> 14 (rounded)
; Sdst1 = ($src1 - $src2) * scal >> 14 (rounded)
; Sdst2 = ($src3 - $src4) * scal >> 14 (rounded)
MACRO
DO_BUTTERFLY_SYMMETRIC_COEFFS $src1, $src2, $src3, $src4, $scal, $dst1, $dst2, $tmp2, $tmp3
;Butterfly for $src1 $src3
vaddl.s16 $tmp3, $src1, $src3
vsubl.s16 $tmp2, $src1, $src3
vmul.s32 $tmp3, $tmp3, $scal
vmul.s32 $tmp2, $tmp2, $scal
vrshrn.s32 $src3, $tmp3, #14
vrshrn.s32 $dst1, $tmp2, #14
;Butterfly for $src2 $src4
vaddl.s16 $tmp3, $src2, $src4
vsubl.s16 $tmp2, $src2, $src4
vmul.s32 $tmp3, $tmp3, $scal
vmul.s32 $tmp2, $tmp2, $scal
vrshrn.s32 $src4, $tmp3, #14
vrshrn.s32 $dst2, $tmp2, #14
MEND
;---------------------------------------------------------------------------
; Computes butterfly. Cosine/Sine coefficients are unique
; Computes butterfly of 4 registers
; $reg1 : Source and destination for Butterfly (64 bit)
; $reg2 : Source and destination for butterfly (64 bit)
; $reg3 : Source and destination for Butterfly (64 bit)
; $reg4 : Source and destination for butterfly (64 bit)
; $scal1 : Scaling value 1 (64 bit)
; $scal2 : Scaling value 2 (64 bit)
; $tmp1, $tmp2, $tmp3 : temporary registers (128 bit)
;
; Sreg1 = ( $reg1 * $scal1 + $reg2 * $scal2) >> 14 (rounded)
; Sreg2 = ( $reg3 * $scal1 + $reg4 * $scal2) >> 14 (rounded)
; Sreg3 = (-$reg1 * $scal2 + $reg2 * $scal1) >> 14 (rounded)
; Sreg4 = (-$reg3 * $scal2 + $reg4 * $scal1) >> 14 (rounded)
MACRO
DO_BUTTERFLY_STD $reg1, $reg2, $reg3, $reg4, $scal1, $scal2, $tmp1, $tmp2, $tmp3
vmull.s16 $tmp1, $reg1, $scal1
vmull.s16 $tmp2, $reg3, $scal2
vadd.s32 $tmp3, $tmp1, $tmp2
vmull.s16 $tmp1, $reg1, $scal2
vmull.s16 $tmp2, $reg3, $scal1
vsub.s32 $tmp2, $tmp2, $tmp1
vrshrn.s32 $reg1, $tmp3, #14
vrshrn.s32 $reg3, $tmp2, #14
vmull.s16 $tmp1, $reg2, $scal1
vmull.s16 $tmp2, $reg4, $scal2
vadd.s32 $tmp3, $tmp1, $tmp2
vmull.s16 $tmp1, $reg2, $scal2
vmull.s16 $tmp2, $reg4, $scal1
vsub.s32 $tmp2, $tmp2, $tmp1
vrshrn.s32 $reg2, $tmp3, #14
vrshrn.s32 $reg4, $tmp2, #14
MEND
; --------------------------------------------------------------------------
; Memory layout
; --------------------------------------------------------------------------
; We use 3 buffers, input, output and intermediate buffer
;
; Input buffer
; Input buffer will be a 32x32 buffer with a stride
; Input buffer is used only in first pass, values are just read from it.
;
; Output buffer
; Output buffer will be a 32x32 buffer
; Output buffer will be used to write outputs in both the passes,
; hence in the second pass it will be used as the input buffer too.
; The structure of reading and writing into output buffer are different
; in different passes.
; In first pass, one 32x8 band is processed at a time. The macros
; for loading and storing will use the row numbers directly to load.
; In second pass, one 8x32 band is processed at a time. The input is
; organized in columns and hence it will have to transposed before
; processing. For the ease of transpose, the 8x32 band is further
; divided into four 8x8 sub-bands. Hence
; - sub-band 0 will correspond to output[0] to output[7]
; - sub-band 1 will correspond to output[8] to output[15]
; - sub-band 2 will correspond to output[16] to output[23]
; - sub-band 3 will correspond to output[24] to output[31]
;
; intermediate buffer
; intermediate buffer is the scratch buffer, with size of 32x8
;void vp9_fdct32x32_rd_c(const int16_t *input, tran_low_t *out, int stride) {
;
; r0 int16_t *input,
; r1 tran_low_t *out,
; r2 int stride
; loop counters
; r4 band loop counter
; r5 pass loop counter
; r8 sub-band loop counter
;Scratch
; r6 scratch
; r7 scratch
; r9 scratch
; r10 scratch
|vp9_fdct32x32_rd_neon| PROC
; This function does dct32x32 transform.
;
; This 2-D transform is done by performing a 1-D transform in two passes
; The 1-D transform is always performed on columns
; - In the first pass the data is used as is.
; - In the second pass the input is transposed first and then used for
; transforms
; - The final output is transposed again
;
; Each pass is composed of 4 loops, with each iteration processing 32x8 band
; In each iteration the processing is done in blocks A, B, C and D.
; Block A corresponds to row 0-3
; Block B corresponds to row 4-7
; Block C corresponds to row 8-15
; Block D corresponds to row 16-31
push {r4-r11}
vpush {d8-d15}
; Double the stride to accommodate 16 bit input
lsl r2, r2, #1
; Initialize a negative input stride
neg r9, r2
;Decrement stack by 512 -> 32x16 for temporary space
sub sp, #512
; r5 = 1 : Column transform pass 1
; r5 = 0 : Row transform pass 2
mov r5, #1
dct32_pass_loop
; Each pass processes a band size 32x8 once, hence 4 such bands
mov r4, #4
dct32_bands_loop
; Set up intermediate buffer, sp-8*32
mov r3, sp
; if first pass
cmp r5, #1
; Get address of 31st row in current 32x8 band
addeq r6, r0, r2, lsl #5
subeq r6, r6, r2
; Get pointer to 4th 8x8 sub-band of current 8x32 band
addne r6, r0, #48
; Get address of last row of intermediate buffer of size 8x32 ->16*31
add r7, r3, #496
; The transpose is done for a sub-band of 2 8x8 coefficients at a time hence
; we need 2 passes
mov r8, #2
dct32_subband_pair_loop
; Load two 8x8 sub bands. The matrices must be complementary
; if coeff i is in a matrix 31-i should be in other. Load first one
; into q0-q7 and the second one into q15-q8. There is an input stride too
vld1.s16 {q15}, [r6], r9
vld1.s16 {q0}, [r0], r2
vld1.s16 {q14}, [r6], r9
vld1.s16 {q1}, [r0], r2
vld1.s16 {q13}, [r6], r9
vld1.s16 {q2}, [r0], r2
vld1.s16 {q12}, [r6], r9
vld1.s16 {q3}, [r0], r2
vld1.s16 {q11}, [r6], r9
vld1.s16 {q4}, [r0], r2
vld1.s16 {q10}, [r6], r9
vld1.s16 {q5}, [r0], r2
vld1.s16 {q9}, [r6], r9
vld1.s16 {q6}, [r0], r2
vld1.s16 {q8}, [r6], r9
vld1.s16 {q7}, [r0], r2
; In the first pass we need to scale coeffs by 4
cmp r5, #1
bne no_pass1_preprocess
;temp_in[j] = input[j * stride + i]* 4;
vshl.s16 q0, q0, #2
vshl.s16 q1, q1, #2
vshl.s16 q2, q2, #2
vshl.s16 q3, q3, #2
vshl.s16 q4, q4, #2
vshl.s16 q5, q5, #2
vshl.s16 q6, q6, #2
vshl.s16 q7, q7, #2
vshl.s16 q8, q8, #2
vshl.s16 q9, q9, #2
vshl.s16 q10, q10, #2
vshl.s16 q11, q11, #2
vshl.s16 q12, q12, #2
vshl.s16 q13, q13, #2
vshl.s16 q14, q14, #2
vshl.s16 q15, q15, #2
no_pass1_preprocess
; In the second pass, we need to transpose the coefficents and
; adjust the magnitude as below
;output[j * 32 + i] = (temp_out[j] + 1 + (temp_out[j] > 0)) >> 2;
cmp r5, #0
beq pass2_preprocess
back_from_pass2_preprocess
; --------------------------------------------------------------------------
; STAGE 1, BLOCK A, B, C and D : 0-31
; --------------------------------------------------------------------------
; 1) Transposition of 32x8 block if its pass 2
; 2) First stage computation of 32x8/8x32 block
; 3) storing of this 32x8 coeffs into intermediate buffer
; Get stride of intermediate buffer
mov r10, #16
; Get neg stride of intermediate buffer
mov r11, #-16
;step[0] = input[0] + input[(32 - 1)]
;step[31] = -input[31] + input[(32 - 32)];
; Since we do not have registers to use as tmp storage
; hence we will use bit twiddling for this butterfly
; a = a + b
; b = a - 2b
vadd.s16 q0, q0, q15
vshl.s16 q15, q15, #1
vsub.s16 q15, q0, q15
vst1.s16 {q15}, [r7], r11
vst1.s16 {q0}, [r3], r10
; From here on use the DO_BUTTERFLY_NO_COEFFS and store to intermediate buffer
; --------------------------------------------------------------------------
;step[1] = input[1] + input[(32 - 2)];
;step[30] = -input[30] + input[(32 - 31)];
DO_BUTTERFLY_NO_COEFFS q1, q14, q15
vst1.s16 {q15}, [r7], r11
vst1.s16 {q14}, [r3], r10
;step[2] = input[2] + input[(32 - 3)];
;step[29] = -input[29] + input[(32 - 30)];
DO_BUTTERFLY_NO_COEFFS q2, q13, q1
vst1.s16 {q1}, [r7], r11
vst1.s16 {q13}, [r3], r10
;step[3] = input[3] + input[(32 - 4)];
;step[28] = -input[28] + input[(32 - 29)];
DO_BUTTERFLY_NO_COEFFS q3, q12, q2
vst1.s16 {q2}, [r7], r11
vst1.s16 {q12}, [r3], r10
;step[4] = input[4] + input[(32 - 5)];
;step[27] = -input[27] + input[(32 - 28)];
DO_BUTTERFLY_NO_COEFFS q4, q11, q3
vst1.s16 {q3}, [r7], r11
vst1.s16 {q11}, [r3], r10
;step[5] = input[5] + input[(32 - 6)];
;step[26] = -input[26] + input[(32 - 27)];
DO_BUTTERFLY_NO_COEFFS q5, q10, q4
vst1.s16 {q4}, [r7], r11
vst1.s16 {q10}, [r3], r10
;step[6] = input[6] + input[(32 - 7)];
;step[25] = -input[25] + input[(32 - 26)];
DO_BUTTERFLY_NO_COEFFS q6, q9, q5
vst1.s16 {q5}, [r7], r11
vst1.s16 {q9}, [r3], r10
;step[7] = input[7] + input[(32 - 8)];
;step[24] = -input[24] + input[(32 - 25)];
DO_BUTTERFLY_NO_COEFFS q7, q8, q6
vst1.s16 {q6}, [r7], r11
vst1.s16 {q8}, [r3], r10
; No need to correct r3, r7 and r1, both point to correct location
cmp r5, #1
; For first pass we need to read 17th row next, hence no need to correct
; input pointer
; For second pass, again we will be at start of 17th row, but we need to be
; at the 8th element of 1st row, hence subtract stride*8 - 16
subne r0, r0, r2, lsl #3
addne r0, r0, #16
; Go to next 32-i block
addne r6, r0, #16
; Update the subband loop counter
subs r8, #1
bne dct32_subband_pair_loop
; Restore the pointer for intermediate buffer
sub r3, #256 ;Sub 16(num rows)*16(stride)
; --------------------------------------------------------------------------
; STAGE 2, BLOCK A, B, C : 0-15
; --------------------------------------------------------------------------
; 1) Load coeffs 1-16 in i, 16-i format
; 2) Store the subtracted coeffs in butterfly (corresponding to BLOCK C)
; 3) Don't store the added coeffs, keep them in registers so that we can
; process block A and B together without memory access
; Load step[0]-step[5], step[10]-step[15]
LOAD_FROM_INTERMEDIATE 0, 15, q0, q1
LOAD_FROM_INTERMEDIATE 1, 14, q2, q3
LOAD_FROM_INTERMEDIATE 2, 13, q4, q5
LOAD_FROM_INTERMEDIATE 3, 12, q6, q7
LOAD_FROM_INTERMEDIATE 4, 11, q8, q9
LOAD_FROM_INTERMEDIATE 5, 10, q10, q11
;output[0] = step[0] + step[16 - 1];
;output[15] = -step[15] + step[16 - 16];
DO_BUTTERFLY_NO_COEFFS q0, q1, q15
;output[1] = step[1] + step[16 - 2];
;output[14] = -step[14] + step[16 - 15];
DO_BUTTERFLY_NO_COEFFS q2, q3, q14
;output[2] = step[2] + step[16 - 3];
;output[13] = -step[13] + step[16 - 14];
DO_BUTTERFLY_NO_COEFFS q4, q5, q13
;output[3] = step[3] + step[16 - 4];
;output[12] = -step[12] + step[16 - 13];
DO_BUTTERFLY_NO_COEFFS q6, q7, q12
; Store subtracted coeffs (corresponding to BLOCK C)
STORE_TO_INTERMEDIATE 15, 14, q15, q14
STORE_TO_INTERMEDIATE 13, 12, q13, q12
; Load step[4],step[5],step[10],step[11]
LOAD_FROM_INTERMEDIATE 6, 9, q12, q13
LOAD_FROM_INTERMEDIATE 7, 8, q14, q15
;output[4] = step[4] + step[16 - 5];
;output[11] = -step[11] + step[16 - 12];
DO_BUTTERFLY_NO_COEFFS q8, q9, q0
;output[5] = step[5] + step[16 - 6];
;output[10] = -step[10] + step[16 - 11];
DO_BUTTERFLY_NO_COEFFS q10, q11, q2
;output[6] = step[6] + step[16 - 7];
;output[9] = -step[9] + step[16 - 10];
DO_BUTTERFLY_NO_COEFFS q12, q13, q4
;output[7] = step[7] + step[16 - 8];
;output[7] = step[7] + step[16 - 8];
DO_BUTTERFLY_NO_COEFFS q14, q15, q6
; Store subtracted coeffs (corresponding to BLOCK C)
STORE_TO_INTERMEDIATE 11, 10, q0, q2
STORE_TO_INTERMEDIATE 9, 8, q4, q6
; In the second pass, we need to halve the value between the stages
cmp r5, #0
beq round_shift_block_ABC
back_from_round_shift_block_ABC
; --------------------------------------------------------------------------
; STAGE 3 BLOCK A, B : 0-7
; --------------------------------------------------------------------------
;step[0] = output[0] + output[(8 - 1)];
;step[7] = -output[7]+ output[(8 - 8)];
DO_BUTTERFLY_NO_COEFFS q1, q15, q0
;step[1] = output[1] + output[(8 - 2)];
;step[6] = output[6] + output[(8 - 7)];
DO_BUTTERFLY_NO_COEFFS q3, q13, q2
;step[2] = output[2] + output[(8 - 3)];
;step[5] = -output[5] + output[(8 - 6)];
DO_BUTTERFLY_NO_COEFFS q5, q11, q4
;step[3] = output[3] + output[(8 - 4)];
;step[4] = -output[4] + output[(8 - 5)];
DO_BUTTERFLY_NO_COEFFS q7, q9, q6
; --------------------------------------------------------------------------
; STAGE 4 BLOCK A : 0-3
; --------------------------------------------------------------------------
;output[0] = step[0] + step[3];
;output[3] = -step[3] + step[0];
DO_BUTTERFLY_NO_COEFFS q15, q9, q8
;output[1] = step[1] + step[2];
;output[2] = -step[2] + step[1];
DO_BUTTERFLY_NO_COEFFS q13, q11, q10
; --------------------------------------------------------------------------
; STAGE 4 BLOCK B : 4-7
; --------------------------------------------------------------------------
;output[5] = dct_32_round((-step[5] + step[6]) * cospi_16_64);
;output[6] = dct_32_round(( step[6] + step[5]) * cospi_16_64);
GET_CONST d26, cospi_16_64, r6
vmovl.s16 q13, d26
DO_BUTTERFLY_SYMMETRIC_COEFFS d4, d5, d8, d9, q13, d28, d29, q7, q5
; --------------------------------------------------------------------------
; STAGE 5 BLOCK A : 0-3
; --------------------------------------------------------------------------
;step[0] = dct_32_round(( output[0] + output[1]) * cospi_16_64);
;step[1] = dct_32_round((-output[1] + output[0]) * cospi_16_64);
GET_CONST d26, cospi_16_64, r6
vmovl.s16 q13, d26
DO_BUTTERFLY_SYMMETRIC_COEFFS d18, d19, d22, d23, q13, d6, d7, q7, q2
;step[2] = dct_32_round(output[2] * cospi_24_64 + output[3] * cospi_8_64);
;step[2] = dct_32_round(output[2] * cospi_24_64 + output[3] * cospi_8_64);
GET_CONST d4, cospi_24_64,r6
GET_CONST d5, cospi_8_64,r6
DO_BUTTERFLY_STD d20, d21, d16, d17, d4, d5, q5, q7, q9
; --------------------------------------------------------------------------
; STAGE 5 BLOCK B : 4-7
; --------------------------------------------------------------------------
;step[4] = output[4] + output[5];
;step[5] = -output[5] + output[4];
DO_BUTTERFLY_NO_COEFFS q6, q14, q2
;step[6] = -output[6] + output[7];
;step[7] = output[7] + output[6];
;step[6] -> q5, step[7] -> q4
DO_BUTTERFLY_NO_COEFFS q0, q4, q5
; --------------------------------------------------------------------------
; STORE OUTPUT BLOCK A : 0-3
; --------------------------------------------------------------------------
STORE_TO_OUTPUT 0, 16, q11, q3, 0,2
STORE_TO_OUTPUT 8, 24, q10, q8, 1,3
; --------------------------------------------------------------------------
; STAGE 6 BLOCK B : 4-7
; --------------------------------------------------------------------------
;output[4] = dct_32_round(step[4] * cospi_28_64 +step[7] * cospi_4_64);
;output[7] = dct_32_round(step[7] * cospi_28_64 +step[4] * -cospi_4_64);
GET_CONST d2, cospi_28_64, r6
GET_CONST d3, cospi_4_64, r6
DO_BUTTERFLY_STD d28, d29, d8, d9, d2, d3, q11, q7, q9
;output[5] = dct_32_round(step[5] * cospi_12_64 + step[6] * cospi_20_64);
;output[6] = dct_32_round(step[6] * cospi_12_64 + step[5] * -cospi_20_64);
GET_CONST d6, cospi_12_64, r6
GET_CONST d7, cospi_20_64, r6
DO_BUTTERFLY_STD d4, d5, d10, d11, d6, d7, q11, q7, q9
; --------------------------------------------------------------------------
; STORE OUTPUT BLOCK B : 4-7
; --------------------------------------------------------------------------
STORE_TO_OUTPUT 4, 28, q14, q4, 0, 3
STORE_TO_OUTPUT 20, 12, q2, q5, 2, 1
; --------------------------------------------------------------------------
; STAGE 3 BLOCK C : 8-15
; --------------------------------------------------------------------------
LOAD_FROM_INTERMEDIATE 10, 13, q1, q0
LOAD_FROM_INTERMEDIATE 11, 12, q4, q3
;step[10] = dct_32_round((-output[10] + output[13]) * cospi_16_64);
;step[13] = dct_32_round(( output[13] + output[10]) * cospi_16_64);
GET_CONST d28, cospi_16_64, r6
vmovl.s16 q14, d28
;step[10] -> q2, step[13] -> q1
DO_BUTTERFLY_SYMMETRIC_COEFFS d0, d1, d2, d3, q14, d4, d5, q15, q5
;step[11] = dct_32_round((-output[11] + output[12]) * cospi_16_64);
;step[12] = dct_32_round(( output[12] + output[11]) * cospi_16_64);
;step[11] -> q5, step[12] -> q4
DO_BUTTERFLY_SYMMETRIC_COEFFS d6, d7, d8, d9, q14, d10, d11, q15, q0
; --------------------------------------------------------------------------
; STAGE 4 BLOCK C: 8-15
; --------------------------------------------------------------------------
LOAD_FROM_INTERMEDIATE 8, 9, q6, q7
LOAD_FROM_INTERMEDIATE 14, 15, q8, q9
;output[8] = step[8] + step[11];
;output[11] = -step[11] + step[8];
DO_BUTTERFLY_NO_COEFFS q6, q5, q15
;output[9] = step[9] + step[10];
;output[10] = -step[10] + step[9];
DO_BUTTERFLY_NO_COEFFS q7, q2, q14
;output[12] = -step[12] + step[15];
;output[15] = step[15] + step[12];
DO_BUTTERFLY_NO_COEFFS q9, q4, q13
;output[13] = -step[13] + step[14];
;output[14] = step[14] + step[13];
DO_BUTTERFLY_NO_COEFFS q8 , q1, q12
; --------------------------------------------------------------------------
; STAGE 5 BLOCK C: 8-15
; --------------------------------------------------------------------------
;step[9] = dct_32_round(output[9] * -cospi_8_64 +
; output[14] * cospi_24_64 );
;step[14] = dct_32_round(output[14] * cospi_8_64 +
; output[9] * cospi_24_64 );
;step[14] -> q2, step[9] -> q1
GET_CONST d0, cospi_24_64, r6
GET_CONST d1, cospi_8_64, r6
DO_BUTTERFLY_STD d4, d5, d2, d3, d0, d1, q6, q7, q9
;step[10] = dct_32_round(output[10] * -cospi_24_64 +
; output[13] * -cospi_8_64 );
;step[13] = dct_32_round(output[13] * cospi_24_64 +
; output[10] * -cospi_8_64 );
;step[10] -> q12, step[13] -> q14
GET_CONST d0, -cospi_24_64, r6
GET_CONST d1, -cospi_8_64 , r6
DO_BUTTERFLY_STD d24, d25, d28, d29, d1, d0, q6, q7, q9
; --------------------------------------------------------------------------
; STAGE 6 BLOCK C: 8-15
; --------------------------------------------------------------------------
;output[8] = step[8] + step[9];
;output[9] = -step[9] + step[8];
DO_BUTTERFLY_NO_COEFFS q5, q1, q0
;output[10] = -step[10] + step[11];
;output[11] = step[11] + step[10];
;output[10] -> q3, output[11] -> q12
DO_BUTTERFLY_NO_COEFFS q15, q12, q3
;output[12] = step[12] + step[13];
;output[13] = -step[13] + step[12];
DO_BUTTERFLY_NO_COEFFS q13, q14, q5
;output[14] = -step[14] + step[15];
;output[15] = step[15] + step[14];
DO_BUTTERFLY_NO_COEFFS q4, q2, q6
; --------------------------------------------------------------------------
; STAGE 7 BLOCK C: 8-15
; --------------------------------------------------------------------------
;step[8] = dct_32_round(output[8] * cospi_30_64 +
; output[15] * cospi_2_64);
;step[15] = dct_32_round(output[15] * cospi_30_64 +
; output[8] * -cospi_2_64);
GET_CONST d8, cospi_30_64, r6
GET_CONST d9, cospi_2_64, r6
DO_BUTTERFLY_STD d2, d3, d4, d5, d8, d9, q7, q8, q9
;step[9] = dct_32_round(output[9] * cospi_14_64 +
; output[14] * cospi_18_64);
;step[14] = dct_32_round(output[14] * cospi_14_64 +
; output[9] * -cospi_18_64);
GET_CONST d8, cospi_14_64, r6
GET_CONST d9, cospi_18_64, r6
DO_BUTTERFLY_STD d0, d1, d12, d13, d8, d9, q7, q8, q9
;step[10] = dct_32_round(output[10] * cospi_22_64 +
; output[13] * cospi_10_64 );
;step[13] = dct_32_round(output[13] * cospi_22_64 +
; output[10] * -cospi_10_64);
GET_CONST d8, cospi_22_64, r6
GET_CONST d9, cospi_10_64, r6
DO_BUTTERFLY_STD d6, d7, d10, d11, d8, d9, q7, q8, q9
;step[11] = dct_32_round(output[11] * cospi_6_64 +
; output[12] * cospi_26_64 );
;step[12] = dct_32_round(output[12] * cospi_6_64 +
; output[11] * -cospi_26_64);
GET_CONST d8, cospi_6_64, r6
GET_CONST d9, cospi_26_64, r6
DO_BUTTERFLY_STD d24, d25, d28, d29, d8, d9, q7, q8, q9
; --------------------------------------------------------------------------
; STORE OUTPUT BLOCK C: 8-15
; --------------------------------------------------------------------------
STORE_TO_OUTPUT 2, 30, q1, q2, 0, 3 ;Store step[8], step[15]
STORE_TO_OUTPUT 18, 14, q0, q6, 2, 1 ;Store step[9], step[14]
STORE_TO_OUTPUT 10, 22, q3, q5, 1, 2 ;Store step[10], step[13]
STORE_TO_OUTPUT 26, 6, q12, q14, 3, 0 ;Store step[11], step[12]
; --------------------------------------------------------------------------
; STAGE 2 BLOCK D: 16-31
; --------------------------------------------------------------------------
LOAD_FROM_INTERMEDIATE 20, 27, q0, q7
LOAD_FROM_INTERMEDIATE 21, 26, q1, q6
LOAD_FROM_INTERMEDIATE 22, 25, q2, q5
LOAD_FROM_INTERMEDIATE 23, 24, q3, q4
GET_CONST d30, cospi_16_64, r6
vmovl.s16 q15, d30
;output[20] = dct_32_round((-step[20] + step[27]) * cospi_16_64);
;output[27] = dct_32_round(( step[27] + step[20]) * cospi_16_64);
DO_BUTTERFLY_SYMMETRIC_COEFFS d14, d15, d0, d1, q15, d16, d17, q14, q13
;output[21] = dct_32_round((-step[21] + step[26]) * cospi_16_64);
;output[26] = dct_32_round(( step[26] + step[21]) * cospi_16_64);
DO_BUTTERFLY_SYMMETRIC_COEFFS d12, d13, d2, d3, q15, d18, d19, q14, q13
;output[22] = dct_32_round((-step[22] + step[25]) * cospi_16_64);
;output[26] = dct_32_round(( step[26] + step[21]) * cospi_16_64);
DO_BUTTERFLY_SYMMETRIC_COEFFS d10, d11, d4, d5, q15, d20, d21, q14, q13
;output[23] = dct_32_round((-step[23] + step[24]) * cospi_16_64);
;output[24] = dct_32_round(( step[24] + step[23]) * cospi_16_64);
DO_BUTTERFLY_SYMMETRIC_COEFFS d8, d9, d6, d7, q15, d22, d23, q14, q13
cmp r5, #0
; If second pass, we will do the half round shift here for BLOCK D : 16-31
beq round_shift_block_D
back_from_round_shift_block_D
; --------------------------------------------------------------------------
; STAGE 3 BLOCK D: 16-31
; --------------------------------------------------------------------------
LOAD_FROM_INTERMEDIATE 16, 17, q4, q5
LOAD_FROM_INTERMEDIATE 18, 19, q6, q7
;step[16] = output[16] + output[23];
;step[23] = -output[23] + output[16];
DO_BUTTERFLY_NO_COEFFS q4, q11, q15
;step[17] = output[17] + output[22];
;step[22] = -output[22] + output[17];
DO_BUTTERFLY_NO_COEFFS q5, q10, q14
;step[18] = output[18] + output[21];
;step[21] = -output[21] + output[18];
DO_BUTTERFLY_NO_COEFFS q6, q9, q13
;step[19] = output[19] + output[20];
;step[20] = -output[20] + output[19];
DO_BUTTERFLY_NO_COEFFS q7, q8, q12
; Store columns not needed for next stage into mem
STORE_TO_INTERMEDIATE 16, 17, q11, q10
STORE_TO_INTERMEDIATE 22, 23, q14, q15
LOAD_FROM_INTERMEDIATE 31, 30, q4, q5
LOAD_FROM_INTERMEDIATE 28, 29, q6, q7
;step[24] = -output[24] + output[31];
;step[31] = output[31] + output[24];
DO_BUTTERFLY_NO_COEFFS q4, q3, q10
;step[25] = -output[25] + output[30];
;step[30] = output[30] + output[25];
DO_BUTTERFLY_NO_COEFFS q5, q2, q11
;step[26] = -output[26] + output[29];
;step[29] = output[29] + output[26];
DO_BUTTERFLY_NO_COEFFS q7, q1, q14
;step[27] = -output[27] + output[28];
;step[28] = output[28] + output[27];
DO_BUTTERFLY_NO_COEFFS q6, q0, q15
;Store colums not needed for next stage into mem
STORE_TO_INTERMEDIATE 30, 31, q2, q3
STORE_TO_INTERMEDIATE 24, 25, q10, q11
; --------------------------------------------------------------------------
; STAGE 4 BLOCK D: 16-31
; --------------------------------------------------------------------------
GET_CONST d4, cospi_24_64, r6
GET_CONST d5, cospi_8_64, r6
;output[18] = dct_32_round(step[18] * -cospi_8_64 + step[29] * cospi_24_64);
;output[29] = dct_32_round(step[29] * cospi_8_64 + step[18] * cospi_24_64);
DO_BUTTERFLY_STD d18, d19, d2, d3, d4, d5, q6, q7, q10
;18 -> q1, 29->q9
;output[19] = dct_32_round(step[19] * -cospi_8_64 + step[28] * cospi_24_64);
;output[28] = dct_32_round(step[28] * cospi_8_64 + step[19] * cospi_24_64);
DO_BUTTERFLY_STD d16, d17, d0, d1, d4, d5, q6, q7, q10
; 28 -> q8, 19 -> q0
vneg.s16 d4, d4
vneg.s16 d5, d5
;output[20] = dct_32_round(step[20] * -cospi_24_64 +
; step[27] * -cospi_8_64 );
;output[27] = dct_32_round(step[27] * cospi_24_64 +
; step[20] * -cospi_8_64 );
;output[20] -> q15, output[27] -> q12
DO_BUTTERFLY_STD d30, d31, d24, d25, d5, d4, q6, q7, q10
;output[21] = dct_32_round(step[21] * -cospi_24_64 +
; step[26] * -cospi_8_64 );
;output[26] = dct_32_round(step[26] * cospi_24_64 +
; step[21] * -cospi_8_64 );
;output[21] -> q14, output[26] -> q13
DO_BUTTERFLY_STD d28, d29, d26, d27, d5, d4, q6, q7, q10
STORE_TO_INTERMEDIATE 20, 21, q15, q14
STORE_TO_INTERMEDIATE 26, 27, q13, q12
; --------------------------------------------------------------------------
; STAGE 5 BLOCK D PART 1: 16-19 28-31
; --------------------------------------------------------------------------
LOAD_FROM_INTERMEDIATE 16,17,q4,q5
LOAD_FROM_INTERMEDIATE 30,31,q6,q7
;step[16] = output[16] + output[19];
;step[19] = -output[19] + output[16];
DO_BUTTERFLY_NO_COEFFS q4, q0, q11
;step[17] = output[17] + output[18];
;step[17] = output[17] + output[18];
DO_BUTTERFLY_NO_COEFFS q5, q1, q10
;step[28] = -output[28] + output[31];
;step[31] = output[31] + output[28];
;step[31] -> q8, step[28] -> q4
DO_BUTTERFLY_NO_COEFFS q7, q8, q4
;step[29] = -output[29] + output[30];
;step[30] = output[30] + output[29];
;step[30] -> q9, step[29] -> q5
DO_BUTTERFLY_NO_COEFFS q6, q9, q5
; --------------------------------------------------------------------------
; STAGE 6 BLOCK D PART 1 : 16-19,28-31
; --------------------------------------------------------------------------
;output[17] = dct_32_round(step[17] * -cospi_4_64 +
; step[30] * cospi_28_64 );
;output[30] = dct_32_round(step[30] * cospi_4_64 +
; step[17] * cospi_28_64 );
;output[17] -> q9, output[30] -> q1
GET_CONST d13, cospi_4_64, r6
GET_CONST d12, cospi_28_64, r6
DO_BUTTERFLY_STD d2, d3, d18, d19, d12, d13, q14, q15, q7
;output[18] = dct_32_round(step[18] * -cospi_28_64 +
; step[29] * -cospi_4_64);
;output[29] = dct_32_round(step[29] * cospi_28_64 +
; step[18] * -cospi_4_64);
GET_CONST d12, -cospi_4_64, r6
GET_CONST d13, -cospi_28_64, r6
DO_BUTTERFLY_STD d10, d11, d20, d21, d12, d13, q14, q15, q7
; --------------------------------------------------------------------------
; STAGE 7 BLOCK D PART 1 : 16-19,28-31
; --------------------------------------------------------------------------
;step[16] = output[16] + output[17];
;step[17] = -output[17] + output[16];
DO_BUTTERFLY_NO_COEFFS q0, q9, q15
;step[18] = -output[18] + output[19];
;step[19] = output[19] + output[18];
;step[18] -> q14, step[19] -> q5
DO_BUTTERFLY_NO_COEFFS q11, q5, q14
;step[28] = output[28] + output[29];
;step[29] = -output[29] + output[28];
DO_BUTTERFLY_NO_COEFFS q4, q10, q7
;step[30] = -output[30] + output[31];
;step[31] = output[31] + output[30];
;step[31] -> q1, step[30] -> q12
DO_BUTTERFLY_NO_COEFFS q8, q1, q12
; --------------------------------------------------------------------------
; STAGE 8 BLOCK D PART 1 : 16-19,28-31
; --------------------------------------------------------------------------
;output[1] = dct_32_round(step[16] * cospi_31_64 +
; step[31] * cospi_1_64 );
;output[31] = dct_32_round(step[31] * cospi_31_64 +
; step[16] * -cospi_1_64 );
GET_CONST d0, cospi_31_64, r6
GET_CONST d1, cospi_1_64, r6
DO_BUTTERFLY_STD d18, d19, d2, d3, d0, d1, q2, q3, q11
;output[17] = dct_32_round(step[17] * cospi_15_64 +
; step[30] * cospi_17_64 );
;output[15] = dct_32_round(step[30] * cospi_15_64 +
; step[17] * -cospi_17_64)
GET_CONST d0, cospi_15_64, r6
GET_CONST d1, cospi_17_64, r6
DO_BUTTERFLY_STD d30, d31, d24, d25, d0, d1, q2, q3, q11
;output[9] = dct_32_round(step[18] * cospi_23_64 +
; step[29] * cospi_9_64 );
;output[23] = dct_32_round(step[29] * cospi_23_64 +
; step[18] * -cospi_9_64 );
GET_CONST d0, cospi_23_64, r6
GET_CONST d1, cospi_9_64, r6
DO_BUTTERFLY_STD d28, d29, d14, d15, d0, d1, q2, q3, q11
;output[25] = dct_32_round(step[19] * cospi_7_64 +
; step[28] * cospi_25_64 );
;output[7] = dct_32_round(step[28] * cospi_7_64 +
; step[19] * -cospi_25_64);
GET_CONST d0, cospi_7_64, r6
GET_CONST d1, cospi_25_64, r6
DO_BUTTERFLY_STD d10, d11, d20, d21, d0, d1, q2, q3, q11
; --------------------------------------------------------------------------
; STORE OUTPUT BLOCK D PART 1 : 16-19,28-31
; --------------------------------------------------------------------------
STORE_TO_OUTPUT 1, 31, q9, q1, 0, 3 ;Store 16,31
STORE_TO_OUTPUT 17, 15, q15, q12, 2, 1 ;Store 17,30
STORE_TO_OUTPUT 9, 23, q14, q7, 1, 2 ;Store 18,29
STORE_TO_OUTPUT 25, 7, q5, q10, 3, 0 ;Store 19,28
; --------------------------------------------------------------------------
; STAGE 5 BLOCK D PART 2 : 16-19,28-31
; --------------------------------------------------------------------------
LOAD_FROM_INTERMEDIATE 20, 21, q0, q1 ;load 20 21
LOAD_FROM_INTERMEDIATE 22, 23, q2, q3 ;load 22 23
LOAD_FROM_INTERMEDIATE 24, 25, q4, q5 ;load 24 25
LOAD_FROM_INTERMEDIATE 26, 27, q6, q7 ;load 26 27
;step[20] = -output[20] + output[23];
;step[23] = output[23] + output[20];
;step[20] -> q0, step[23] -> q10
DO_BUTTERFLY_NO_COEFFS q3, q0, q10
;step[21] = -output[21] + output[22];
;step[22] = output[22] + output[21];
;step[22] -> q1, step[21] -> q11
DO_BUTTERFLY_NO_COEFFS q2, q1, q11
;step[24] = output[24] + output[27];
;step[27] = -output[27] + output[24];
DO_BUTTERFLY_NO_COEFFS q4, q7, q3
;step[25] = output[25] + output[26];
;step[26] = -output[26] + output[25];
DO_BUTTERFLY_NO_COEFFS q5, q6, q2
; --------------------------------------------------------------------------
; STAGE 6 BLOCK D PART 2 : 20-27
; --------------------------------------------------------------------------
;output[21] = dct_32_round(step[21] * -cospi_20_64 +
; step[26] * cospi_12_64);
;output[26] = dct_32_round(step[26] * cospi_20_64 +
; step[21] * cospi_12_64);
;output[26] -> q11, output[21] -> q2
GET_CONST d31, cospi_20_64, r6
GET_CONST d30, cospi_12_64, r6
DO_BUTTERFLY_STD d22, d23, d4, d5, d30, d31, q14, q13, q12
;output[22] = dct_32_round(step[22] * -cospi_12_64 +
; step[25] * -cospi_20_64);
;output[25] = dct_32_round(step[25] * cospi_12_64 +
; step[22] * -cospi_20_64);
;output[22] -> q6, output[25] -> q1
GET_CONST d31, -cospi_20_64, r6
GET_CONST d30, -cospi_12_64, r6
DO_BUTTERFLY_STD d12, d13, d2, d3, d31, d30, q14, q13, q12
; --------------------------------------------------------------------------
; STAGE 7 BLOCK D PART 2 : 20-27
; --------------------------------------------------------------------------
;step[20] = output[20] + output[21];
;step[21] = -output[21] + output[20];
DO_BUTTERFLY_NO_COEFFS q10, q2, q4
;step[22] = -output[22] + output[23];
;step[23] = output[23] + output[22];
;step[23] -> q6, step[22] -> q5
DO_BUTTERFLY_NO_COEFFS q0, q6, q5
;step[24] = output[24] + output[25];
;step[25] = -output[25] + output[24];
DO_BUTTERFLY_NO_COEFFS q7, q1, q8
;step[26] = -output[26] + output[27];
;step[27] = output[27] + output[26];
;step[27] -> q1, step[26] -> q9
DO_BUTTERFLY_NO_COEFFS q3, q11, q9
; --------------------------------------------------------------------------
; STAGE 8 BLOCK D PART 2 : 20-27
; --------------------------------------------------------------------------
;output[5] = dct_32_round(step[20] * cospi_27_64 +
; step[27] * cospi_5_64 );
;output[27] = dct_32_round(step[27] * cospi_27_64 +
; step[20] * -cospi_5_64 );
GET_CONST d0, cospi_27_64, r6
GET_CONST d1, cospi_5_64, r6
DO_BUTTERFLY_STD d4, d5, d22, d23, d0, d1, q10, q3, q12
;output[21] = dct_32_round(step[21] * cospi_11_64 +
; step[26] * cospi_21_64 );
;output[11] = dct_32_round(step[26] * cospi_11_64 +
; step[21] *-cospi_21_64 );
GET_CONST d0, cospi_11_64, r6
GET_CONST d1, cospi_21_64, r6
DO_BUTTERFLY_STD d8, d9, d18, d19, d0, d1, q10, q3, q12
;output[13] = dct_32_round(step[22] * cospi_19_64 +
; step[25] * cospi_13_64 );
;output[19] = dct_32_round(step[25] * cospi_19_64 +
; step[22] *-cospi_13_64 );
GET_CONST d0, cospi_19_64, r6
GET_CONST d1, cospi_13_64, r6
DO_BUTTERFLY_STD d10, d11, d16, d17, d0,d1, q10, q3, q12
;output[29] = dct_32_round(step[23] * cospi_3_64 +
; step[24] * cospi_29_64 );
;output[3] = dct_32_round(step[24] * cospi_3_64 +
; step[23] * -cospi_29_64 );
GET_CONST d0, cospi_3_64, r6
GET_CONST d1, cospi_29_64, r6
DO_BUTTERFLY_STD d12, d13, d2, d3, d0, d1, q10, q3, q12
; --------------------------------------------------------------------------
; STORE OUTPUT BLOCK D PART 2 : 20-27
; --------------------------------------------------------------------------
STORE_TO_OUTPUT 5, 27, q2, q11, 0, 3 ;Store 20,27
STORE_TO_OUTPUT 21, 11, q4, q9, 2, 1 ;Store 21,26
STORE_TO_OUTPUT 13, 19, q5, q8, 1, 2 ;Store 22,25
STORE_TO_OUTPUT 29, 3, q6, q1, 3, 0 ;Store 23,24
; Done with band loop, now adjust pointers
cmp r5, #1
; For pass 1, we will need to go back 16 rows and forward by 8 columns
subeq r0, r0, r2, lsl #4 ;-16*input_stride+16
addeq r0, #16
; Move to next 8x32 block, add 16 since output pointer is restores every
; time in pass 1
addeq r1, #16
; If pass 2 get to next 8x32 block
addne r1, #512 ;Output stride *16
; Input and output are same in pass 2
movne r0, r1
; Update band loop cntr
subs r4, #1
bne dct32_bands_loop
; Update test count
sub r5, #1
; Update pointers for pass2
; At the end of first pass, we will be at the end of first row, so get back
sub r1, #64
; Set 2nd stage input as 1st stage output
mov r0, r1
; Set output stride as input stride
mov r2, #64
; In pass 2 we will read 32 colums in a single row, hence both
; strides are positive
mov r9, #64
cmp r5, #-1
bne dct32_pass_loop
; Now transpose each 8x8 matrices
; We have output in r1 with a stride of 64, so Get r1 back to origin
; Output pointer will be at the position 32*64(last row), we already
; subtracted 64 for pass loop update hence subtract 32*64 - 64
sub r1, #1984
; use r2,r3 as src pointers,
; r2 for block i r3 fro block i+1
; use r4 r5 as corresponding output pointers
; Address of block 0 for input
mov r2, r1
; Address of block 1 for input
add r3, r1, #16
; Address of block 0 for output
mov r4, r2
; Address of block 1 for output
mov r5, r3
; Stride of output
mov r9, #64
mov r10, #1
; We need to process 16 blocks, hece loop cntr 8
mov r6, #8
transpose_final
TRANSPOSE_TWO_8x8 r2, r3, r4, r5, r9
; update loop counter
sub r6, #1
and r7, r6, r10
; Check odd or even
cmp r7, #0
; If even, it means the end of 8x32 block
; then move to next b8x32 block
addeq r1, #480
; else just move 2 blocks forward
addne r1, #32
mov r2, r1
add r3, r1, #16
mov r4, r2
mov r5, r3
; Check loop counter
cmp r6, #0
bne transpose_final
;Restore SP
add sp, #512
vpop {d8-d15}
pop {r4-r11}
bx lr
ENDP ; |vp9_fdct32x32_rd_neon|
pass2_preprocess
; transpose the two 8x8 16bit data matrices.
vswp d31, d22
vswp d25, d16
vswp d27, d18
vswp d29, d20
vswp d1, d8
vswp d7, d14
vswp d5, d12
vswp d3, d10
vtrn.32 q15, q13
vtrn.32 q14, q12
vtrn.32 q11, q9
vtrn.32 q10, q8
vtrn.32 q0, q2
vtrn.32 q1, q3
vtrn.32 q4, q6
vtrn.32 q5, q7
vtrn.16 q15, q14
vtrn.16 q13, q12
vtrn.16 q11, q10
vtrn.16 q9 , q8
vtrn.16 q0, q1
vtrn.16 q2, q3
vtrn.16 q4, q5
vtrn.16 q6, q7
vswp q15, q8
vswp q14, q9
vswp q13, q10
vswp q12, q11
; Since all 16 registers are full, store to temporary space
; so that we have some registers to be used as temporary
STORE_TO_INTERMEDIATE 0, 1, q14, q15
;output[j * 32 + i] = (temp_out[j] + 1 + (temp_out[j] > 0)) >> 2;
vshr.u16 q14, q0, #15
vsub.s16 q0, q0, q14
vrshr.s16 q0, q0, #2
vshr.u16 q15, q1, #15
vsub.s16 q1, q1, q15
vrshr.s16 q1, q1, #2
vshr.u16 q14, q2, #15
vsub.s16 q2, q2, q14
vrshr.s16 q2, q2, #2
vshr.u16 q15, q3, #15
vsub.s16 q3, q3, q15
vrshr.s16 q3, q3, #2
vshr.u16 q14, q4, #15
vsub.s16 q4, q4, q14
vrshr.s16 q4, q4, #2
vshr.u16 q15, q5, #15
vsub.s16 q5, q5, q15
vrshr.s16 q5, q5, #2
vshr.u16 q14, q6, #15
vsub.s16 q6, q6, q14
vrshr.s16 q6, q6, #2
vshr.u16 q15, q7, #15
vsub.s16 q7, q7, q15
vrshr.s16 q7, q7, #2
vshr.u16 q14, q8, #15
vsub.s16 q8, q8, q14
vrshr.s16 q8, q8, #2
vshr.u16 q15, q9, #15
vsub.s16 q9, q9, q15
vrshr.s16 q9, q9, #2
; Store again so that we can process column 0 and column 1 too
STORE_TO_INTERMEDIATE 2, 3, q8 ,q9
vshr.u16 q14, q10, #15
vsub.s16 q10, q10, q14
vrshr.s16 q10, q10, #2
vshr.u16 q15, q11, #15
vsub.s16 q11, q11, q15
vrshr.s16 q11, q11, #2
vshr.u16 q14, q12, #15
vsub.s16 q12, q12, q14
vrshr.s16 q12, q12, #2
vshr.u16 q15, q13, #15
vsub.s16 q13, q13, q15
vrshr.s16 q13, q13, #2
; restore column 0 and column 1
LOAD_FROM_INTERMEDIATE 0, 1, q14, q15
vshr.u16 q8, q14, #15
vsub.s16 q14, q14, q8
vrshr.s16 q14, q14, #2
vshr.u16 q9, q15, #15
vsub.s16 q15, q15, q9
vrshr.s16 q15, q15, #2
; restore column 8 column 9
LOAD_FROM_INTERMEDIATE 2, 3, q8, q9
b back_from_pass2_preprocess
; Half round blocks
; Does half_round_shift for blocks A, B, and C
; Touches q0 - q15
round_shift_block_ABC
;half_round_shift(output[11]);
;half_round_shift(output[10]);
HALF_ROUND_SHIFT q0, q2, q12, q14
;half_round_shift(output[9]);
;half_round_shift(output[8]);
HALF_ROUND_SHIFT q4, q6, q12, q14
; Store column 11 and column 10
STORE_TO_INTERMEDIATE 11, 10, q0, q2
; Store column 9 and column 8
STORE_TO_INTERMEDIATE 9, 8, q4, q6
; load column 15 and column 14
LOAD_FROM_INTERMEDIATE 15, 14, q0, q2
; load column 13 and column 12
LOAD_FROM_INTERMEDIATE 13, 12, q4, q6
;half_round_shift(output[0]);
;half_round_shift(output[4]);
HALF_ROUND_SHIFT q1, q9, q12, q14
;half_round_shift(output[1]);
;half_round_shift(output[5]);
HALF_ROUND_SHIFT q3, q11, q12, q14
;half_round_shift(output[2]);
;half_round_shift(output[6]);
HALF_ROUND_SHIFT q5, q13, q12, q14
;half_round_shift(output[3]);
;half_round_shift(output[7]);
HALF_ROUND_SHIFT q7, q15, q12, q14
;half_round_shift(output[15]);
;half_round_shift(output[14]);
HALF_ROUND_SHIFT q0, q2, q12, q14
;half_round_shift(output[13]);
;half_round_shift(output[12]);
HALF_ROUND_SHIFT q4, q6, q12, q14
; Store column 15 and column 14
STORE_TO_INTERMEDIATE 15, 14, q0, q2
; Store column 13 and column 12
STORE_TO_INTERMEDIATE 13, 12, q4, q6
b back_from_round_shift_block_ABC
; Does half_round_shift for blocks A B and C
; Touches q0 - q15
round_shift_block_D
;half_round_shift(output[27]);
;half_round_shift(output[26]);
HALF_ROUND_SHIFT q0, q1, q14, q15
;half_round_shift(output[25]);
;half_round_shift(output[24]);
HALF_ROUND_SHIFT q2, q3, q14, q15
;half_round_shift(output[23]);
;half_round_shift(output[22]);
HALF_ROUND_SHIFT q8, q9, q14, q15
;half_round_shift(output[20]);
;half_round_shift(output[21]);
HALF_ROUND_SHIFT q10, q11, q14, q15
LOAD_FROM_INTERMEDIATE 16, 17, q4, q5
LOAD_FROM_INTERMEDIATE 18, 19, q6, q7
;half_round_shift(output[16]);
;half_round_shift(output[17]);
HALF_ROUND_SHIFT q4, q5 ,q14, q15
;half_round_shift(output[18]);
;half_round_shift(output[19]);
HALF_ROUND_SHIFT q6, q7 ,q14, q15
STORE_TO_INTERMEDIATE 16, 17, q4, q5
STORE_TO_INTERMEDIATE 18, 19, q6, q7
LOAD_FROM_INTERMEDIATE 28, 29, q4, q5
LOAD_FROM_INTERMEDIATE 30, 31, q6, q7
;half_round_shift(output[28]);
;half_round_shift(output[29]);
HALF_ROUND_SHIFT q4, q5 ,q14, q15
;half_round_shift(output[30]);
;half_round_shift(output[31]);
HALF_ROUND_SHIFT q6, q7, q14, q15
STORE_TO_INTERMEDIATE 28, 29, q4, q5
STORE_TO_INTERMEDIATE 30, 31, q6, q7
b back_from_round_shift_block_D
END
| 41.287429
| 168
| 0.485196
|
3adf4b705e7a25d1072a93ebb8ad543394a076cc
| 556
|
asm
|
Assembly
|
oeis/258/A258807.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/258/A258807.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/258/A258807.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A258807: a(n) = n^5 - 1.
; 0,31,242,1023,3124,7775,16806,32767,59048,99999,161050,248831,371292,537823,759374,1048575,1419856,1889567,2476098,3199999,4084100,5153631,6436342,7962623,9765624,11881375,14348906,17210367,20511148,24299999,28629150,33554431,39135392,45435423,52521874,60466175,69343956,79235167,90224198,102399999,115856200,130691231,147008442,164916223,184528124,205962975,229345006,254803967,282475248,312499999,345025250,380204031,418195492,459165023,503284374,550731775,601692056,656356767,714924298,777599999
add $0,1
pow $0,5
sub $0,1
| 79.428571
| 500
| 0.838129
|
89f71febfad33326a3b1ecd9a170b6abe19b2fa0
| 1,025
|
asm
|
Assembly
|
programs/oeis/047/A047226.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/047/A047226.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/047/A047226.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
; A047226: Numbers that are congruent to {0, 1, 2, 3, 4} mod 6; a(n)=floor(6(n-1)/5).
; 0,1,2,3,4,6,7,8,9,10,12,13,14,15,16,18,19,20,21,22,24,25,26,27,28,30,31,32,33,34,36,37,38,39,40,42,43,44,45,46,48,49,50,51,52,54,55,56,57,58,60,61,62,63,64,66,67,68,69,70,72,73,74,75,76,78,79,80,81,82,84,85,86,87,88,90,91,92,93,94,96,97,98,99,100,102,103,104,105,106,108,109,110,111,112,114,115,116,117,118,120,121,122,123,124,126,127,128,129,130,132,133,134,135,136,138,139,140,141,142,144,145,146,147,148,150,151,152,153,154,156,157,158,159,160,162,163,164,165,166,168,169,170,171,172,174,175,176,177,178,180,181,182,183,184,186,187,188,189,190,192,193,194,195,196,198,199,200,201,202,204,205,206,207,208,210,211,212,213,214,216,217,218,219,220,222,223,224,225,226,228,229,230,231,232,234,235,236,237,238,240,241,242,243,244,246,247,248,249,250,252,253,254,255,256,258,259,260,261,262,264,265,266,267,268,270,271,272,273,274,276,277,278,279,280,282,283,284,285,286,288,289,290,291,292,294,295,296,297,298
mov $1,$0
div $0,5
add $1,$0
| 146.428571
| 908
| 0.706341
|
9c48da65cbea0917bb919d49f292b11fbf47a8c8
| 50,668
|
asm
|
Assembly
|
user/kalloctest.asm
|
eric-qian-d/TCP
|
76e62ad0ece99d6881879e59500f18eb2756c3e4
|
[
"MIT-0"
] | null | null | null |
user/kalloctest.asm
|
eric-qian-d/TCP
|
76e62ad0ece99d6881879e59500f18eb2756c3e4
|
[
"MIT-0"
] | null | null | null |
user/kalloctest.asm
|
eric-qian-d/TCP
|
76e62ad0ece99d6881879e59500f18eb2756c3e4
|
[
"MIT-0"
] | null | null | null |
user/_kalloctest: file format elf64-littleriscv
Disassembly of section .text:
0000000000000000 <test0>:
test1();
exit(0);
}
void test0()
{
0: 7179 addi sp,sp,-48
2: f406 sd ra,40(sp)
4: f022 sd s0,32(sp)
6: ec26 sd s1,24(sp)
8: e84a sd s2,16(sp)
a: e44e sd s3,8(sp)
c: 1800 addi s0,sp,48
void *a, *a1;
int n = 0;
printf("start test0\n");
e: 00001517 auipc a0,0x1
12: a7250513 addi a0,a0,-1422 # a80 <malloc+0xea>
16: 00001097 auipc ra,0x1
1a: 8c2080e7 jalr -1854(ra) # 8d8 <printf>
ntas(0);
1e: 4501 li a0,0
20: 00000097 auipc ra,0x0
24: 5d8080e7 jalr 1496(ra) # 5f8 <ntas>
for(int i = 0; i < NCHILD; i++){
int pid = fork();
28: 00000097 auipc ra,0x0
2c: 520080e7 jalr 1312(ra) # 548 <fork>
if(pid < 0){
30: 06054363 bltz a0,96 <test0+0x96>
printf("fork failed");
exit(-1);
}
if(pid == 0){
34: cd35 beqz a0,b0 <test0+0xb0>
int pid = fork();
36: 00000097 auipc ra,0x0
3a: 512080e7 jalr 1298(ra) # 548 <fork>
if(pid < 0){
3e: 04054c63 bltz a0,96 <test0+0x96>
if(pid == 0){
42: c53d beqz a0,b0 <test0+0xb0>
exit(-1);
}
}
for(int i = 0; i < NCHILD; i++){
wait(0);
44: 4501 li a0,0
46: 00000097 auipc ra,0x0
4a: 512080e7 jalr 1298(ra) # 558 <wait>
4e: 4501 li a0,0
50: 00000097 auipc ra,0x0
54: 508080e7 jalr 1288(ra) # 558 <wait>
}
printf("test0 results:\n");
58: 00001517 auipc a0,0x1
5c: a5850513 addi a0,a0,-1448 # ab0 <malloc+0x11a>
60: 00001097 auipc ra,0x1
64: 878080e7 jalr -1928(ra) # 8d8 <printf>
n = ntas(1);
68: 4505 li a0,1
6a: 00000097 auipc ra,0x0
6e: 58e080e7 jalr 1422(ra) # 5f8 <ntas>
if(n < 10)
72: 47a5 li a5,9
74: 08a7c863 blt a5,a0,104 <test0+0x104>
printf("test0 OK\n");
78: 00001517 auipc a0,0x1
7c: a4850513 addi a0,a0,-1464 # ac0 <malloc+0x12a>
80: 00001097 auipc ra,0x1
84: 858080e7 jalr -1960(ra) # 8d8 <printf>
else
printf("test0 FAIL\n");
}
88: 70a2 ld ra,40(sp)
8a: 7402 ld s0,32(sp)
8c: 64e2 ld s1,24(sp)
8e: 6942 ld s2,16(sp)
90: 69a2 ld s3,8(sp)
92: 6145 addi sp,sp,48
94: 8082 ret
printf("fork failed");
96: 00001517 auipc a0,0x1
9a: 9fa50513 addi a0,a0,-1542 # a90 <malloc+0xfa>
9e: 00001097 auipc ra,0x1
a2: 83a080e7 jalr -1990(ra) # 8d8 <printf>
exit(-1);
a6: 557d li a0,-1
a8: 00000097 auipc ra,0x0
ac: 4a8080e7 jalr 1192(ra) # 550 <exit>
{
b0: 6961 lui s2,0x18
b2: 6a090913 addi s2,s2,1696 # 186a0 <__global_pointer$+0x172f7>
*(int *)(a+4) = 1;
b6: 4985 li s3,1
a = sbrk(4096);
b8: 6505 lui a0,0x1
ba: 00000097 auipc ra,0x0
be: 51e080e7 jalr 1310(ra) # 5d8 <sbrk>
c2: 84aa mv s1,a0
*(int *)(a+4) = 1;
c4: 01352223 sw s3,4(a0) # 1004 <__BSS_END__+0x43c>
a1 = sbrk(-4096);
c8: 757d lui a0,0xfffff
ca: 00000097 auipc ra,0x0
ce: 50e080e7 jalr 1294(ra) # 5d8 <sbrk>
if (a1 != a + 4096) {
d2: 6785 lui a5,0x1
d4: 94be add s1,s1,a5
d6: 00951a63 bne a0,s1,ea <test0+0xea>
for(i = 0; i < N; i++) {
da: 397d addiw s2,s2,-1
dc: fc091ee3 bnez s2,b8 <test0+0xb8>
exit(-1);
e0: 557d li a0,-1
e2: 00000097 auipc ra,0x0
e6: 46e080e7 jalr 1134(ra) # 550 <exit>
printf("wrong sbrk\n");
ea: 00001517 auipc a0,0x1
ee: 9b650513 addi a0,a0,-1610 # aa0 <malloc+0x10a>
f2: 00000097 auipc ra,0x0
f6: 7e6080e7 jalr 2022(ra) # 8d8 <printf>
exit(-1);
fa: 557d li a0,-1
fc: 00000097 auipc ra,0x0
100: 454080e7 jalr 1108(ra) # 550 <exit>
printf("test0 FAIL\n");
104: 00001517 auipc a0,0x1
108: 9cc50513 addi a0,a0,-1588 # ad0 <malloc+0x13a>
10c: 00000097 auipc ra,0x0
110: 7cc080e7 jalr 1996(ra) # 8d8 <printf>
}
114: bf95 j 88 <test0+0x88>
0000000000000116 <test1>:
// Run system out of memory and count tot memory allocated
void test1()
{
116: 715d addi sp,sp,-80
118: e486 sd ra,72(sp)
11a: e0a2 sd s0,64(sp)
11c: fc26 sd s1,56(sp)
11e: f84a sd s2,48(sp)
120: f44e sd s3,40(sp)
122: 0880 addi s0,sp,80
void *a;
int pipes[NCHILD];
int tot = 0;
char buf[1];
printf("start test1\n");
124: 00001517 auipc a0,0x1
128: 9bc50513 addi a0,a0,-1604 # ae0 <malloc+0x14a>
12c: 00000097 auipc ra,0x0
130: 7ac080e7 jalr 1964(ra) # 8d8 <printf>
for(int i = 0; i < NCHILD; i++){
134: fc840913 addi s2,s0,-56
int fds[2];
if(pipe(fds) != 0){
138: fb840513 addi a0,s0,-72
13c: 00000097 auipc ra,0x0
140: 424080e7 jalr 1060(ra) # 560 <pipe>
144: 84aa mv s1,a0
146: e905 bnez a0,176 <test1+0x60>
printf("pipe() failed\n");
exit(-1);
}
int pid = fork();
148: 00000097 auipc ra,0x0
14c: 400080e7 jalr 1024(ra) # 548 <fork>
if(pid < 0){
150: 04054063 bltz a0,190 <test1+0x7a>
printf("fork failed");
exit(-1);
}
if(pid == 0){
154: c939 beqz a0,1aa <test1+0x94>
exit(-1);
}
}
exit(0);
} else {
close(fds[1]);
156: fbc42503 lw a0,-68(s0)
15a: 00000097 auipc ra,0x0
15e: 41e080e7 jalr 1054(ra) # 578 <close>
pipes[i] = fds[0];
162: fb842783 lw a5,-72(s0)
166: 00f92023 sw a5,0(s2)
for(int i = 0; i < NCHILD; i++){
16a: 0911 addi s2,s2,4
16c: fd040793 addi a5,s0,-48
170: fd2794e3 bne a5,s2,138 <test1+0x22>
174: a85d j 22a <test1+0x114>
printf("pipe() failed\n");
176: 00001517 auipc a0,0x1
17a: 97a50513 addi a0,a0,-1670 # af0 <malloc+0x15a>
17e: 00000097 auipc ra,0x0
182: 75a080e7 jalr 1882(ra) # 8d8 <printf>
exit(-1);
186: 557d li a0,-1
188: 00000097 auipc ra,0x0
18c: 3c8080e7 jalr 968(ra) # 550 <exit>
printf("fork failed");
190: 00001517 auipc a0,0x1
194: 90050513 addi a0,a0,-1792 # a90 <malloc+0xfa>
198: 00000097 auipc ra,0x0
19c: 740080e7 jalr 1856(ra) # 8d8 <printf>
exit(-1);
1a0: 557d li a0,-1
1a2: 00000097 auipc ra,0x0
1a6: 3ae080e7 jalr 942(ra) # 550 <exit>
close(fds[0]);
1aa: fb842503 lw a0,-72(s0)
1ae: 00000097 auipc ra,0x0
1b2: 3ca080e7 jalr 970(ra) # 578 <close>
1b6: 64e1 lui s1,0x18
1b8: 6a048493 addi s1,s1,1696 # 186a0 <__global_pointer$+0x172f7>
*(int *)(a+4) = 1;
1bc: 4905 li s2,1
if (write(fds[1], "x", 1) != 1) {
1be: 00001997 auipc s3,0x1
1c2: 94298993 addi s3,s3,-1726 # b00 <malloc+0x16a>
a = sbrk(PGSIZE);
1c6: 6505 lui a0,0x1
1c8: 00000097 auipc ra,0x0
1cc: 410080e7 jalr 1040(ra) # 5d8 <sbrk>
*(int *)(a+4) = 1;
1d0: 01252223 sw s2,4(a0) # 1004 <__BSS_END__+0x43c>
if (write(fds[1], "x", 1) != 1) {
1d4: 864a mv a2,s2
1d6: 85ce mv a1,s3
1d8: fbc42503 lw a0,-68(s0)
1dc: 00000097 auipc ra,0x0
1e0: 394080e7 jalr 916(ra) # 570 <write>
1e4: 01251963 bne a0,s2,1f6 <test1+0xe0>
for(i = 0; i < N; i++) {
1e8: 34fd addiw s1,s1,-1
1ea: fcf1 bnez s1,1c6 <test1+0xb0>
exit(0);
1ec: 4501 li a0,0
1ee: 00000097 auipc ra,0x0
1f2: 362080e7 jalr 866(ra) # 550 <exit>
printf("write failed");
1f6: 00001517 auipc a0,0x1
1fa: 91250513 addi a0,a0,-1774 # b08 <malloc+0x172>
1fe: 00000097 auipc ra,0x0
202: 6da080e7 jalr 1754(ra) # 8d8 <printf>
exit(-1);
206: 557d li a0,-1
208: 00000097 auipc ra,0x0
20c: 348080e7 jalr 840(ra) # 550 <exit>
int stop = 0;
while (!stop) {
stop = 1;
for(int i = 0; i < NCHILD; i++){
if (read(pipes[i], buf, 1) == 1) {
tot += 1;
210: 2485 addiw s1,s1,1
if (read(pipes[i], buf, 1) == 1) {
212: 4605 li a2,1
214: fc040593 addi a1,s0,-64
218: fcc42503 lw a0,-52(s0)
21c: 00000097 auipc ra,0x0
220: 34c080e7 jalr 844(ra) # 568 <read>
224: 4785 li a5,1
226: 02f50a63 beq a0,a5,25a <test1+0x144>
22a: 4605 li a2,1
22c: fc040593 addi a1,s0,-64
230: fc842503 lw a0,-56(s0)
234: 00000097 auipc ra,0x0
238: 334080e7 jalr 820(ra) # 568 <read>
23c: 4785 li a5,1
23e: fcf509e3 beq a0,a5,210 <test1+0xfa>
242: 4605 li a2,1
244: fc040593 addi a1,s0,-64
248: fcc42503 lw a0,-52(s0)
24c: 00000097 auipc ra,0x0
250: 31c080e7 jalr 796(ra) # 568 <read>
254: 4785 li a5,1
256: 02f51163 bne a0,a5,278 <test1+0x162>
tot += 1;
25a: 2485 addiw s1,s1,1
while (!stop) {
25c: b7f9 j 22a <test1+0x114>
}
}
int n = (PHYSTOP-KERNBASE)/PGSIZE;
printf("total allocated number of pages: %d (out of %d)\n", tot, n);
if(n - tot > 1000) {
printf("test1 FAILED: cannot allocate enough memory");
25e: 00001517 auipc a0,0x1
262: 8ba50513 addi a0,a0,-1862 # b18 <malloc+0x182>
266: 00000097 auipc ra,0x0
26a: 672080e7 jalr 1650(ra) # 8d8 <printf>
exit(-1);
26e: 557d li a0,-1
270: 00000097 auipc ra,0x0
274: 2e0080e7 jalr 736(ra) # 550 <exit>
printf("total allocated number of pages: %d (out of %d)\n", tot, n);
278: 6621 lui a2,0x8
27a: 85a6 mv a1,s1
27c: 00001517 auipc a0,0x1
280: 8dc50513 addi a0,a0,-1828 # b58 <malloc+0x1c2>
284: 00000097 auipc ra,0x0
288: 654080e7 jalr 1620(ra) # 8d8 <printf>
if(n - tot > 1000) {
28c: 67a1 lui a5,0x8
28e: 409784bb subw s1,a5,s1
292: 3e800793 li a5,1000
296: fc97c4e3 blt a5,s1,25e <test1+0x148>
}
printf("test1 OK\n");
29a: 00001517 auipc a0,0x1
29e: 8ae50513 addi a0,a0,-1874 # b48 <malloc+0x1b2>
2a2: 00000097 auipc ra,0x0
2a6: 636080e7 jalr 1590(ra) # 8d8 <printf>
}
2aa: 60a6 ld ra,72(sp)
2ac: 6406 ld s0,64(sp)
2ae: 74e2 ld s1,56(sp)
2b0: 7942 ld s2,48(sp)
2b2: 79a2 ld s3,40(sp)
2b4: 6161 addi sp,sp,80
2b6: 8082 ret
00000000000002b8 <main>:
{
2b8: 1141 addi sp,sp,-16
2ba: e406 sd ra,8(sp)
2bc: e022 sd s0,0(sp)
2be: 0800 addi s0,sp,16
test0();
2c0: 00000097 auipc ra,0x0
2c4: d40080e7 jalr -704(ra) # 0 <test0>
test1();
2c8: 00000097 auipc ra,0x0
2cc: e4e080e7 jalr -434(ra) # 116 <test1>
exit(0);
2d0: 4501 li a0,0
2d2: 00000097 auipc ra,0x0
2d6: 27e080e7 jalr 638(ra) # 550 <exit>
00000000000002da <strcpy>:
#include "kernel/fcntl.h"
#include "user/user.h"
char*
strcpy(char *s, const char *t)
{
2da: 1141 addi sp,sp,-16
2dc: e422 sd s0,8(sp)
2de: 0800 addi s0,sp,16
char *os;
os = s;
while((*s++ = *t++) != 0)
2e0: 87aa mv a5,a0
2e2: 0585 addi a1,a1,1
2e4: 0785 addi a5,a5,1
2e6: fff5c703 lbu a4,-1(a1)
2ea: fee78fa3 sb a4,-1(a5) # 7fff <__global_pointer$+0x6c56>
2ee: fb75 bnez a4,2e2 <strcpy+0x8>
;
return os;
}
2f0: 6422 ld s0,8(sp)
2f2: 0141 addi sp,sp,16
2f4: 8082 ret
00000000000002f6 <strcmp>:
int
strcmp(const char *p, const char *q)
{
2f6: 1141 addi sp,sp,-16
2f8: e422 sd s0,8(sp)
2fa: 0800 addi s0,sp,16
while(*p && *p == *q)
2fc: 00054783 lbu a5,0(a0)
300: cb91 beqz a5,314 <strcmp+0x1e>
302: 0005c703 lbu a4,0(a1)
306: 00f71763 bne a4,a5,314 <strcmp+0x1e>
p++, q++;
30a: 0505 addi a0,a0,1
30c: 0585 addi a1,a1,1
while(*p && *p == *q)
30e: 00054783 lbu a5,0(a0)
312: fbe5 bnez a5,302 <strcmp+0xc>
return (uchar)*p - (uchar)*q;
314: 0005c503 lbu a0,0(a1)
}
318: 40a7853b subw a0,a5,a0
31c: 6422 ld s0,8(sp)
31e: 0141 addi sp,sp,16
320: 8082 ret
0000000000000322 <strlen>:
uint
strlen(const char *s)
{
322: 1141 addi sp,sp,-16
324: e422 sd s0,8(sp)
326: 0800 addi s0,sp,16
int n;
for(n = 0; s[n]; n++)
328: 00054783 lbu a5,0(a0)
32c: cf91 beqz a5,348 <strlen+0x26>
32e: 0505 addi a0,a0,1
330: 87aa mv a5,a0
332: 4685 li a3,1
334: 9e89 subw a3,a3,a0
336: 00f6853b addw a0,a3,a5
33a: 0785 addi a5,a5,1
33c: fff7c703 lbu a4,-1(a5)
340: fb7d bnez a4,336 <strlen+0x14>
;
return n;
}
342: 6422 ld s0,8(sp)
344: 0141 addi sp,sp,16
346: 8082 ret
for(n = 0; s[n]; n++)
348: 4501 li a0,0
34a: bfe5 j 342 <strlen+0x20>
000000000000034c <memset>:
void*
memset(void *dst, int c, uint n)
{
34c: 1141 addi sp,sp,-16
34e: e422 sd s0,8(sp)
350: 0800 addi s0,sp,16
char *cdst = (char *) dst;
int i;
for(i = 0; i < n; i++){
352: ce09 beqz a2,36c <memset+0x20>
354: 87aa mv a5,a0
356: fff6071b addiw a4,a2,-1
35a: 1702 slli a4,a4,0x20
35c: 9301 srli a4,a4,0x20
35e: 0705 addi a4,a4,1
360: 972a add a4,a4,a0
cdst[i] = c;
362: 00b78023 sb a1,0(a5)
for(i = 0; i < n; i++){
366: 0785 addi a5,a5,1
368: fee79de3 bne a5,a4,362 <memset+0x16>
}
return dst;
}
36c: 6422 ld s0,8(sp)
36e: 0141 addi sp,sp,16
370: 8082 ret
0000000000000372 <strchr>:
char*
strchr(const char *s, char c)
{
372: 1141 addi sp,sp,-16
374: e422 sd s0,8(sp)
376: 0800 addi s0,sp,16
for(; *s; s++)
378: 00054783 lbu a5,0(a0)
37c: cb99 beqz a5,392 <strchr+0x20>
if(*s == c)
37e: 00f58763 beq a1,a5,38c <strchr+0x1a>
for(; *s; s++)
382: 0505 addi a0,a0,1
384: 00054783 lbu a5,0(a0)
388: fbfd bnez a5,37e <strchr+0xc>
return (char*)s;
return 0;
38a: 4501 li a0,0
}
38c: 6422 ld s0,8(sp)
38e: 0141 addi sp,sp,16
390: 8082 ret
return 0;
392: 4501 li a0,0
394: bfe5 j 38c <strchr+0x1a>
0000000000000396 <gets>:
char*
gets(char *buf, int max)
{
396: 711d addi sp,sp,-96
398: ec86 sd ra,88(sp)
39a: e8a2 sd s0,80(sp)
39c: e4a6 sd s1,72(sp)
39e: e0ca sd s2,64(sp)
3a0: fc4e sd s3,56(sp)
3a2: f852 sd s4,48(sp)
3a4: f456 sd s5,40(sp)
3a6: f05a sd s6,32(sp)
3a8: ec5e sd s7,24(sp)
3aa: 1080 addi s0,sp,96
3ac: 8baa mv s7,a0
3ae: 8a2e mv s4,a1
int i, cc;
char c;
for(i=0; i+1 < max; ){
3b0: 892a mv s2,a0
3b2: 4481 li s1,0
cc = read(0, &c, 1);
if(cc < 1)
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
3b4: 4aa9 li s5,10
3b6: 4b35 li s6,13
for(i=0; i+1 < max; ){
3b8: 89a6 mv s3,s1
3ba: 2485 addiw s1,s1,1
3bc: 0344d863 bge s1,s4,3ec <gets+0x56>
cc = read(0, &c, 1);
3c0: 4605 li a2,1
3c2: faf40593 addi a1,s0,-81
3c6: 4501 li a0,0
3c8: 00000097 auipc ra,0x0
3cc: 1a0080e7 jalr 416(ra) # 568 <read>
if(cc < 1)
3d0: 00a05e63 blez a0,3ec <gets+0x56>
buf[i++] = c;
3d4: faf44783 lbu a5,-81(s0)
3d8: 00f90023 sb a5,0(s2)
if(c == '\n' || c == '\r')
3dc: 01578763 beq a5,s5,3ea <gets+0x54>
3e0: 0905 addi s2,s2,1
3e2: fd679be3 bne a5,s6,3b8 <gets+0x22>
for(i=0; i+1 < max; ){
3e6: 89a6 mv s3,s1
3e8: a011 j 3ec <gets+0x56>
3ea: 89a6 mv s3,s1
break;
}
buf[i] = '\0';
3ec: 99de add s3,s3,s7
3ee: 00098023 sb zero,0(s3)
return buf;
}
3f2: 855e mv a0,s7
3f4: 60e6 ld ra,88(sp)
3f6: 6446 ld s0,80(sp)
3f8: 64a6 ld s1,72(sp)
3fa: 6906 ld s2,64(sp)
3fc: 79e2 ld s3,56(sp)
3fe: 7a42 ld s4,48(sp)
400: 7aa2 ld s5,40(sp)
402: 7b02 ld s6,32(sp)
404: 6be2 ld s7,24(sp)
406: 6125 addi sp,sp,96
408: 8082 ret
000000000000040a <stat>:
int
stat(const char *n, struct stat *st)
{
40a: 1101 addi sp,sp,-32
40c: ec06 sd ra,24(sp)
40e: e822 sd s0,16(sp)
410: e426 sd s1,8(sp)
412: e04a sd s2,0(sp)
414: 1000 addi s0,sp,32
416: 892e mv s2,a1
int fd;
int r;
fd = open(n, O_RDONLY);
418: 4581 li a1,0
41a: 00000097 auipc ra,0x0
41e: 176080e7 jalr 374(ra) # 590 <open>
if(fd < 0)
422: 02054563 bltz a0,44c <stat+0x42>
426: 84aa mv s1,a0
return -1;
r = fstat(fd, st);
428: 85ca mv a1,s2
42a: 00000097 auipc ra,0x0
42e: 17e080e7 jalr 382(ra) # 5a8 <fstat>
432: 892a mv s2,a0
close(fd);
434: 8526 mv a0,s1
436: 00000097 auipc ra,0x0
43a: 142080e7 jalr 322(ra) # 578 <close>
return r;
}
43e: 854a mv a0,s2
440: 60e2 ld ra,24(sp)
442: 6442 ld s0,16(sp)
444: 64a2 ld s1,8(sp)
446: 6902 ld s2,0(sp)
448: 6105 addi sp,sp,32
44a: 8082 ret
return -1;
44c: 597d li s2,-1
44e: bfc5 j 43e <stat+0x34>
0000000000000450 <atoi>:
int
atoi(const char *s)
{
450: 1141 addi sp,sp,-16
452: e422 sd s0,8(sp)
454: 0800 addi s0,sp,16
int n;
n = 0;
while('0' <= *s && *s <= '9')
456: 00054603 lbu a2,0(a0)
45a: fd06079b addiw a5,a2,-48
45e: 0ff7f793 andi a5,a5,255
462: 4725 li a4,9
464: 02f76963 bltu a4,a5,496 <atoi+0x46>
468: 86aa mv a3,a0
n = 0;
46a: 4501 li a0,0
while('0' <= *s && *s <= '9')
46c: 45a5 li a1,9
n = n*10 + *s++ - '0';
46e: 0685 addi a3,a3,1
470: 0025179b slliw a5,a0,0x2
474: 9fa9 addw a5,a5,a0
476: 0017979b slliw a5,a5,0x1
47a: 9fb1 addw a5,a5,a2
47c: fd07851b addiw a0,a5,-48
while('0' <= *s && *s <= '9')
480: 0006c603 lbu a2,0(a3)
484: fd06071b addiw a4,a2,-48
488: 0ff77713 andi a4,a4,255
48c: fee5f1e3 bgeu a1,a4,46e <atoi+0x1e>
return n;
}
490: 6422 ld s0,8(sp)
492: 0141 addi sp,sp,16
494: 8082 ret
n = 0;
496: 4501 li a0,0
498: bfe5 j 490 <atoi+0x40>
000000000000049a <memmove>:
void*
memmove(void *vdst, const void *vsrc, int n)
{
49a: 1141 addi sp,sp,-16
49c: e422 sd s0,8(sp)
49e: 0800 addi s0,sp,16
char *dst;
const char *src;
dst = vdst;
src = vsrc;
if (src > dst) {
4a0: 02b57663 bgeu a0,a1,4cc <memmove+0x32>
while(n-- > 0)
4a4: 02c05163 blez a2,4c6 <memmove+0x2c>
4a8: fff6079b addiw a5,a2,-1
4ac: 1782 slli a5,a5,0x20
4ae: 9381 srli a5,a5,0x20
4b0: 0785 addi a5,a5,1
4b2: 97aa add a5,a5,a0
dst = vdst;
4b4: 872a mv a4,a0
*dst++ = *src++;
4b6: 0585 addi a1,a1,1
4b8: 0705 addi a4,a4,1
4ba: fff5c683 lbu a3,-1(a1)
4be: fed70fa3 sb a3,-1(a4)
while(n-- > 0)
4c2: fee79ae3 bne a5,a4,4b6 <memmove+0x1c>
src += n;
while(n-- > 0)
*--dst = *--src;
}
return vdst;
}
4c6: 6422 ld s0,8(sp)
4c8: 0141 addi sp,sp,16
4ca: 8082 ret
dst += n;
4cc: 00c50733 add a4,a0,a2
src += n;
4d0: 95b2 add a1,a1,a2
while(n-- > 0)
4d2: fec05ae3 blez a2,4c6 <memmove+0x2c>
4d6: fff6079b addiw a5,a2,-1
4da: 1782 slli a5,a5,0x20
4dc: 9381 srli a5,a5,0x20
4de: fff7c793 not a5,a5
4e2: 97ba add a5,a5,a4
*--dst = *--src;
4e4: 15fd addi a1,a1,-1
4e6: 177d addi a4,a4,-1
4e8: 0005c683 lbu a3,0(a1)
4ec: 00d70023 sb a3,0(a4)
while(n-- > 0)
4f0: fee79ae3 bne a5,a4,4e4 <memmove+0x4a>
4f4: bfc9 j 4c6 <memmove+0x2c>
00000000000004f6 <memcmp>:
int
memcmp(const void *s1, const void *s2, uint n)
{
4f6: 1141 addi sp,sp,-16
4f8: e422 sd s0,8(sp)
4fa: 0800 addi s0,sp,16
const char *p1 = s1, *p2 = s2;
while (n-- > 0) {
4fc: ca05 beqz a2,52c <memcmp+0x36>
4fe: fff6069b addiw a3,a2,-1
502: 1682 slli a3,a3,0x20
504: 9281 srli a3,a3,0x20
506: 0685 addi a3,a3,1
508: 96aa add a3,a3,a0
if (*p1 != *p2) {
50a: 00054783 lbu a5,0(a0)
50e: 0005c703 lbu a4,0(a1)
512: 00e79863 bne a5,a4,522 <memcmp+0x2c>
return *p1 - *p2;
}
p1++;
516: 0505 addi a0,a0,1
p2++;
518: 0585 addi a1,a1,1
while (n-- > 0) {
51a: fed518e3 bne a0,a3,50a <memcmp+0x14>
}
return 0;
51e: 4501 li a0,0
520: a019 j 526 <memcmp+0x30>
return *p1 - *p2;
522: 40e7853b subw a0,a5,a4
}
526: 6422 ld s0,8(sp)
528: 0141 addi sp,sp,16
52a: 8082 ret
return 0;
52c: 4501 li a0,0
52e: bfe5 j 526 <memcmp+0x30>
0000000000000530 <memcpy>:
void *
memcpy(void *dst, const void *src, uint n)
{
530: 1141 addi sp,sp,-16
532: e406 sd ra,8(sp)
534: e022 sd s0,0(sp)
536: 0800 addi s0,sp,16
return memmove(dst, src, n);
538: 00000097 auipc ra,0x0
53c: f62080e7 jalr -158(ra) # 49a <memmove>
}
540: 60a2 ld ra,8(sp)
542: 6402 ld s0,0(sp)
544: 0141 addi sp,sp,16
546: 8082 ret
0000000000000548 <fork>:
# generated by usys.pl - do not edit
#include "kernel/syscall.h"
.global fork
fork:
li a7, SYS_fork
548: 4885 li a7,1
ecall
54a: 00000073 ecall
ret
54e: 8082 ret
0000000000000550 <exit>:
.global exit
exit:
li a7, SYS_exit
550: 4889 li a7,2
ecall
552: 00000073 ecall
ret
556: 8082 ret
0000000000000558 <wait>:
.global wait
wait:
li a7, SYS_wait
558: 488d li a7,3
ecall
55a: 00000073 ecall
ret
55e: 8082 ret
0000000000000560 <pipe>:
.global pipe
pipe:
li a7, SYS_pipe
560: 4891 li a7,4
ecall
562: 00000073 ecall
ret
566: 8082 ret
0000000000000568 <read>:
.global read
read:
li a7, SYS_read
568: 4895 li a7,5
ecall
56a: 00000073 ecall
ret
56e: 8082 ret
0000000000000570 <write>:
.global write
write:
li a7, SYS_write
570: 48c1 li a7,16
ecall
572: 00000073 ecall
ret
576: 8082 ret
0000000000000578 <close>:
.global close
close:
li a7, SYS_close
578: 48d5 li a7,21
ecall
57a: 00000073 ecall
ret
57e: 8082 ret
0000000000000580 <kill>:
.global kill
kill:
li a7, SYS_kill
580: 4899 li a7,6
ecall
582: 00000073 ecall
ret
586: 8082 ret
0000000000000588 <exec>:
.global exec
exec:
li a7, SYS_exec
588: 489d li a7,7
ecall
58a: 00000073 ecall
ret
58e: 8082 ret
0000000000000590 <open>:
.global open
open:
li a7, SYS_open
590: 48bd li a7,15
ecall
592: 00000073 ecall
ret
596: 8082 ret
0000000000000598 <mknod>:
.global mknod
mknod:
li a7, SYS_mknod
598: 48c5 li a7,17
ecall
59a: 00000073 ecall
ret
59e: 8082 ret
00000000000005a0 <unlink>:
.global unlink
unlink:
li a7, SYS_unlink
5a0: 48c9 li a7,18
ecall
5a2: 00000073 ecall
ret
5a6: 8082 ret
00000000000005a8 <fstat>:
.global fstat
fstat:
li a7, SYS_fstat
5a8: 48a1 li a7,8
ecall
5aa: 00000073 ecall
ret
5ae: 8082 ret
00000000000005b0 <link>:
.global link
link:
li a7, SYS_link
5b0: 48cd li a7,19
ecall
5b2: 00000073 ecall
ret
5b6: 8082 ret
00000000000005b8 <mkdir>:
.global mkdir
mkdir:
li a7, SYS_mkdir
5b8: 48d1 li a7,20
ecall
5ba: 00000073 ecall
ret
5be: 8082 ret
00000000000005c0 <chdir>:
.global chdir
chdir:
li a7, SYS_chdir
5c0: 48a5 li a7,9
ecall
5c2: 00000073 ecall
ret
5c6: 8082 ret
00000000000005c8 <dup>:
.global dup
dup:
li a7, SYS_dup
5c8: 48a9 li a7,10
ecall
5ca: 00000073 ecall
ret
5ce: 8082 ret
00000000000005d0 <getpid>:
.global getpid
getpid:
li a7, SYS_getpid
5d0: 48ad li a7,11
ecall
5d2: 00000073 ecall
ret
5d6: 8082 ret
00000000000005d8 <sbrk>:
.global sbrk
sbrk:
li a7, SYS_sbrk
5d8: 48b1 li a7,12
ecall
5da: 00000073 ecall
ret
5de: 8082 ret
00000000000005e0 <sleep>:
.global sleep
sleep:
li a7, SYS_sleep
5e0: 48b5 li a7,13
ecall
5e2: 00000073 ecall
ret
5e6: 8082 ret
00000000000005e8 <uptime>:
.global uptime
uptime:
li a7, SYS_uptime
5e8: 48b9 li a7,14
ecall
5ea: 00000073 ecall
ret
5ee: 8082 ret
00000000000005f0 <connect>:
.global connect
connect:
li a7, SYS_connect
5f0: 48d9 li a7,22
ecall
5f2: 00000073 ecall
ret
5f6: 8082 ret
00000000000005f8 <ntas>:
.global ntas
ntas:
li a7, SYS_ntas
5f8: 48dd li a7,23
ecall
5fa: 00000073 ecall
ret
5fe: 8082 ret
0000000000000600 <putc>:
static char digits[] = "0123456789ABCDEF";
static void
putc(int fd, char c)
{
600: 1101 addi sp,sp,-32
602: ec06 sd ra,24(sp)
604: e822 sd s0,16(sp)
606: 1000 addi s0,sp,32
608: feb407a3 sb a1,-17(s0)
write(fd, &c, 1);
60c: 4605 li a2,1
60e: fef40593 addi a1,s0,-17
612: 00000097 auipc ra,0x0
616: f5e080e7 jalr -162(ra) # 570 <write>
}
61a: 60e2 ld ra,24(sp)
61c: 6442 ld s0,16(sp)
61e: 6105 addi sp,sp,32
620: 8082 ret
0000000000000622 <printint>:
static void
printint(int fd, int xx, int base, int sgn)
{
622: 7139 addi sp,sp,-64
624: fc06 sd ra,56(sp)
626: f822 sd s0,48(sp)
628: f426 sd s1,40(sp)
62a: f04a sd s2,32(sp)
62c: ec4e sd s3,24(sp)
62e: 0080 addi s0,sp,64
630: 84aa mv s1,a0
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
632: c299 beqz a3,638 <printint+0x16>
634: 0805c863 bltz a1,6c4 <printint+0xa2>
neg = 1;
x = -xx;
} else {
x = xx;
638: 2581 sext.w a1,a1
neg = 0;
63a: 4881 li a7,0
63c: fc040693 addi a3,s0,-64
}
i = 0;
640: 4701 li a4,0
do{
buf[i++] = digits[x % base];
642: 2601 sext.w a2,a2
644: 00000517 auipc a0,0x0
648: 55450513 addi a0,a0,1364 # b98 <digits>
64c: 883a mv a6,a4
64e: 2705 addiw a4,a4,1
650: 02c5f7bb remuw a5,a1,a2
654: 1782 slli a5,a5,0x20
656: 9381 srli a5,a5,0x20
658: 97aa add a5,a5,a0
65a: 0007c783 lbu a5,0(a5)
65e: 00f68023 sb a5,0(a3)
}while((x /= base) != 0);
662: 0005879b sext.w a5,a1
666: 02c5d5bb divuw a1,a1,a2
66a: 0685 addi a3,a3,1
66c: fec7f0e3 bgeu a5,a2,64c <printint+0x2a>
if(neg)
670: 00088b63 beqz a7,686 <printint+0x64>
buf[i++] = '-';
674: fd040793 addi a5,s0,-48
678: 973e add a4,a4,a5
67a: 02d00793 li a5,45
67e: fef70823 sb a5,-16(a4)
682: 0028071b addiw a4,a6,2
while(--i >= 0)
686: 02e05863 blez a4,6b6 <printint+0x94>
68a: fc040793 addi a5,s0,-64
68e: 00e78933 add s2,a5,a4
692: fff78993 addi s3,a5,-1
696: 99ba add s3,s3,a4
698: 377d addiw a4,a4,-1
69a: 1702 slli a4,a4,0x20
69c: 9301 srli a4,a4,0x20
69e: 40e989b3 sub s3,s3,a4
putc(fd, buf[i]);
6a2: fff94583 lbu a1,-1(s2)
6a6: 8526 mv a0,s1
6a8: 00000097 auipc ra,0x0
6ac: f58080e7 jalr -168(ra) # 600 <putc>
while(--i >= 0)
6b0: 197d addi s2,s2,-1
6b2: ff3918e3 bne s2,s3,6a2 <printint+0x80>
}
6b6: 70e2 ld ra,56(sp)
6b8: 7442 ld s0,48(sp)
6ba: 74a2 ld s1,40(sp)
6bc: 7902 ld s2,32(sp)
6be: 69e2 ld s3,24(sp)
6c0: 6121 addi sp,sp,64
6c2: 8082 ret
x = -xx;
6c4: 40b005bb negw a1,a1
neg = 1;
6c8: 4885 li a7,1
x = -xx;
6ca: bf8d j 63c <printint+0x1a>
00000000000006cc <vprintf>:
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
vprintf(int fd, const char *fmt, va_list ap)
{
6cc: 7119 addi sp,sp,-128
6ce: fc86 sd ra,120(sp)
6d0: f8a2 sd s0,112(sp)
6d2: f4a6 sd s1,104(sp)
6d4: f0ca sd s2,96(sp)
6d6: ecce sd s3,88(sp)
6d8: e8d2 sd s4,80(sp)
6da: e4d6 sd s5,72(sp)
6dc: e0da sd s6,64(sp)
6de: fc5e sd s7,56(sp)
6e0: f862 sd s8,48(sp)
6e2: f466 sd s9,40(sp)
6e4: f06a sd s10,32(sp)
6e6: ec6e sd s11,24(sp)
6e8: 0100 addi s0,sp,128
char *s;
int c, i, state;
state = 0;
for(i = 0; fmt[i]; i++){
6ea: 0005c903 lbu s2,0(a1)
6ee: 18090f63 beqz s2,88c <vprintf+0x1c0>
6f2: 8aaa mv s5,a0
6f4: 8b32 mv s6,a2
6f6: 00158493 addi s1,a1,1
state = 0;
6fa: 4981 li s3,0
if(c == '%'){
state = '%';
} else {
putc(fd, c);
}
} else if(state == '%'){
6fc: 02500a13 li s4,37
if(c == 'd'){
700: 06400c13 li s8,100
printint(fd, va_arg(ap, int), 10, 1);
} else if(c == 'l') {
704: 06c00c93 li s9,108
printint(fd, va_arg(ap, uint64), 10, 0);
} else if(c == 'x') {
708: 07800d13 li s10,120
printint(fd, va_arg(ap, int), 16, 0);
} else if(c == 'p') {
70c: 07000d93 li s11,112
putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
710: 00000b97 auipc s7,0x0
714: 488b8b93 addi s7,s7,1160 # b98 <digits>
718: a839 j 736 <vprintf+0x6a>
putc(fd, c);
71a: 85ca mv a1,s2
71c: 8556 mv a0,s5
71e: 00000097 auipc ra,0x0
722: ee2080e7 jalr -286(ra) # 600 <putc>
726: a019 j 72c <vprintf+0x60>
} else if(state == '%'){
728: 01498f63 beq s3,s4,746 <vprintf+0x7a>
for(i = 0; fmt[i]; i++){
72c: 0485 addi s1,s1,1
72e: fff4c903 lbu s2,-1(s1)
732: 14090d63 beqz s2,88c <vprintf+0x1c0>
c = fmt[i] & 0xff;
736: 0009079b sext.w a5,s2
if(state == 0){
73a: fe0997e3 bnez s3,728 <vprintf+0x5c>
if(c == '%'){
73e: fd479ee3 bne a5,s4,71a <vprintf+0x4e>
state = '%';
742: 89be mv s3,a5
744: b7e5 j 72c <vprintf+0x60>
if(c == 'd'){
746: 05878063 beq a5,s8,786 <vprintf+0xba>
} else if(c == 'l') {
74a: 05978c63 beq a5,s9,7a2 <vprintf+0xd6>
} else if(c == 'x') {
74e: 07a78863 beq a5,s10,7be <vprintf+0xf2>
} else if(c == 'p') {
752: 09b78463 beq a5,s11,7da <vprintf+0x10e>
printptr(fd, va_arg(ap, uint64));
} else if(c == 's'){
756: 07300713 li a4,115
75a: 0ce78663 beq a5,a4,826 <vprintf+0x15a>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
75e: 06300713 li a4,99
762: 0ee78e63 beq a5,a4,85e <vprintf+0x192>
putc(fd, va_arg(ap, uint));
} else if(c == '%'){
766: 11478863 beq a5,s4,876 <vprintf+0x1aa>
putc(fd, c);
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
76a: 85d2 mv a1,s4
76c: 8556 mv a0,s5
76e: 00000097 auipc ra,0x0
772: e92080e7 jalr -366(ra) # 600 <putc>
putc(fd, c);
776: 85ca mv a1,s2
778: 8556 mv a0,s5
77a: 00000097 auipc ra,0x0
77e: e86080e7 jalr -378(ra) # 600 <putc>
}
state = 0;
782: 4981 li s3,0
784: b765 j 72c <vprintf+0x60>
printint(fd, va_arg(ap, int), 10, 1);
786: 008b0913 addi s2,s6,8
78a: 4685 li a3,1
78c: 4629 li a2,10
78e: 000b2583 lw a1,0(s6)
792: 8556 mv a0,s5
794: 00000097 auipc ra,0x0
798: e8e080e7 jalr -370(ra) # 622 <printint>
79c: 8b4a mv s6,s2
state = 0;
79e: 4981 li s3,0
7a0: b771 j 72c <vprintf+0x60>
printint(fd, va_arg(ap, uint64), 10, 0);
7a2: 008b0913 addi s2,s6,8
7a6: 4681 li a3,0
7a8: 4629 li a2,10
7aa: 000b2583 lw a1,0(s6)
7ae: 8556 mv a0,s5
7b0: 00000097 auipc ra,0x0
7b4: e72080e7 jalr -398(ra) # 622 <printint>
7b8: 8b4a mv s6,s2
state = 0;
7ba: 4981 li s3,0
7bc: bf85 j 72c <vprintf+0x60>
printint(fd, va_arg(ap, int), 16, 0);
7be: 008b0913 addi s2,s6,8
7c2: 4681 li a3,0
7c4: 4641 li a2,16
7c6: 000b2583 lw a1,0(s6)
7ca: 8556 mv a0,s5
7cc: 00000097 auipc ra,0x0
7d0: e56080e7 jalr -426(ra) # 622 <printint>
7d4: 8b4a mv s6,s2
state = 0;
7d6: 4981 li s3,0
7d8: bf91 j 72c <vprintf+0x60>
printptr(fd, va_arg(ap, uint64));
7da: 008b0793 addi a5,s6,8
7de: f8f43423 sd a5,-120(s0)
7e2: 000b3983 ld s3,0(s6)
putc(fd, '0');
7e6: 03000593 li a1,48
7ea: 8556 mv a0,s5
7ec: 00000097 auipc ra,0x0
7f0: e14080e7 jalr -492(ra) # 600 <putc>
putc(fd, 'x');
7f4: 85ea mv a1,s10
7f6: 8556 mv a0,s5
7f8: 00000097 auipc ra,0x0
7fc: e08080e7 jalr -504(ra) # 600 <putc>
800: 4941 li s2,16
putc(fd, digits[x >> (sizeof(uint64) * 8 - 4)]);
802: 03c9d793 srli a5,s3,0x3c
806: 97de add a5,a5,s7
808: 0007c583 lbu a1,0(a5)
80c: 8556 mv a0,s5
80e: 00000097 auipc ra,0x0
812: df2080e7 jalr -526(ra) # 600 <putc>
for (i = 0; i < (sizeof(uint64) * 2); i++, x <<= 4)
816: 0992 slli s3,s3,0x4
818: 397d addiw s2,s2,-1
81a: fe0914e3 bnez s2,802 <vprintf+0x136>
printptr(fd, va_arg(ap, uint64));
81e: f8843b03 ld s6,-120(s0)
state = 0;
822: 4981 li s3,0
824: b721 j 72c <vprintf+0x60>
s = va_arg(ap, char*);
826: 008b0993 addi s3,s6,8
82a: 000b3903 ld s2,0(s6)
if(s == 0)
82e: 02090163 beqz s2,850 <vprintf+0x184>
while(*s != 0){
832: 00094583 lbu a1,0(s2)
836: c9a1 beqz a1,886 <vprintf+0x1ba>
putc(fd, *s);
838: 8556 mv a0,s5
83a: 00000097 auipc ra,0x0
83e: dc6080e7 jalr -570(ra) # 600 <putc>
s++;
842: 0905 addi s2,s2,1
while(*s != 0){
844: 00094583 lbu a1,0(s2)
848: f9e5 bnez a1,838 <vprintf+0x16c>
s = va_arg(ap, char*);
84a: 8b4e mv s6,s3
state = 0;
84c: 4981 li s3,0
84e: bdf9 j 72c <vprintf+0x60>
s = "(null)";
850: 00000917 auipc s2,0x0
854: 34090913 addi s2,s2,832 # b90 <malloc+0x1fa>
while(*s != 0){
858: 02800593 li a1,40
85c: bff1 j 838 <vprintf+0x16c>
putc(fd, va_arg(ap, uint));
85e: 008b0913 addi s2,s6,8
862: 000b4583 lbu a1,0(s6)
866: 8556 mv a0,s5
868: 00000097 auipc ra,0x0
86c: d98080e7 jalr -616(ra) # 600 <putc>
870: 8b4a mv s6,s2
state = 0;
872: 4981 li s3,0
874: bd65 j 72c <vprintf+0x60>
putc(fd, c);
876: 85d2 mv a1,s4
878: 8556 mv a0,s5
87a: 00000097 auipc ra,0x0
87e: d86080e7 jalr -634(ra) # 600 <putc>
state = 0;
882: 4981 li s3,0
884: b565 j 72c <vprintf+0x60>
s = va_arg(ap, char*);
886: 8b4e mv s6,s3
state = 0;
888: 4981 li s3,0
88a: b54d j 72c <vprintf+0x60>
}
}
}
88c: 70e6 ld ra,120(sp)
88e: 7446 ld s0,112(sp)
890: 74a6 ld s1,104(sp)
892: 7906 ld s2,96(sp)
894: 69e6 ld s3,88(sp)
896: 6a46 ld s4,80(sp)
898: 6aa6 ld s5,72(sp)
89a: 6b06 ld s6,64(sp)
89c: 7be2 ld s7,56(sp)
89e: 7c42 ld s8,48(sp)
8a0: 7ca2 ld s9,40(sp)
8a2: 7d02 ld s10,32(sp)
8a4: 6de2 ld s11,24(sp)
8a6: 6109 addi sp,sp,128
8a8: 8082 ret
00000000000008aa <fprintf>:
void
fprintf(int fd, const char *fmt, ...)
{
8aa: 715d addi sp,sp,-80
8ac: ec06 sd ra,24(sp)
8ae: e822 sd s0,16(sp)
8b0: 1000 addi s0,sp,32
8b2: e010 sd a2,0(s0)
8b4: e414 sd a3,8(s0)
8b6: e818 sd a4,16(s0)
8b8: ec1c sd a5,24(s0)
8ba: 03043023 sd a6,32(s0)
8be: 03143423 sd a7,40(s0)
va_list ap;
va_start(ap, fmt);
8c2: fe843423 sd s0,-24(s0)
vprintf(fd, fmt, ap);
8c6: 8622 mv a2,s0
8c8: 00000097 auipc ra,0x0
8cc: e04080e7 jalr -508(ra) # 6cc <vprintf>
}
8d0: 60e2 ld ra,24(sp)
8d2: 6442 ld s0,16(sp)
8d4: 6161 addi sp,sp,80
8d6: 8082 ret
00000000000008d8 <printf>:
void
printf(const char *fmt, ...)
{
8d8: 711d addi sp,sp,-96
8da: ec06 sd ra,24(sp)
8dc: e822 sd s0,16(sp)
8de: 1000 addi s0,sp,32
8e0: e40c sd a1,8(s0)
8e2: e810 sd a2,16(s0)
8e4: ec14 sd a3,24(s0)
8e6: f018 sd a4,32(s0)
8e8: f41c sd a5,40(s0)
8ea: 03043823 sd a6,48(s0)
8ee: 03143c23 sd a7,56(s0)
va_list ap;
va_start(ap, fmt);
8f2: 00840613 addi a2,s0,8
8f6: fec43423 sd a2,-24(s0)
vprintf(1, fmt, ap);
8fa: 85aa mv a1,a0
8fc: 4505 li a0,1
8fe: 00000097 auipc ra,0x0
902: dce080e7 jalr -562(ra) # 6cc <vprintf>
}
906: 60e2 ld ra,24(sp)
908: 6442 ld s0,16(sp)
90a: 6125 addi sp,sp,96
90c: 8082 ret
000000000000090e <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
90e: 1141 addi sp,sp,-16
910: e422 sd s0,8(sp)
912: 0800 addi s0,sp,16
Header *bp, *p;
bp = (Header*)ap - 1;
914: ff050693 addi a3,a0,-16
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
918: 00000797 auipc a5,0x0
91c: 2987b783 ld a5,664(a5) # bb0 <freep>
920: a805 j 950 <free+0x42>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
bp->s.size += p->s.ptr->s.size;
922: 4618 lw a4,8(a2)
924: 9db9 addw a1,a1,a4
926: feb52c23 sw a1,-8(a0)
bp->s.ptr = p->s.ptr->s.ptr;
92a: 6398 ld a4,0(a5)
92c: 6318 ld a4,0(a4)
92e: fee53823 sd a4,-16(a0)
932: a091 j 976 <free+0x68>
} else
bp->s.ptr = p->s.ptr;
if(p + p->s.size == bp){
p->s.size += bp->s.size;
934: ff852703 lw a4,-8(a0)
938: 9e39 addw a2,a2,a4
93a: c790 sw a2,8(a5)
p->s.ptr = bp->s.ptr;
93c: ff053703 ld a4,-16(a0)
940: e398 sd a4,0(a5)
942: a099 j 988 <free+0x7a>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
944: 6398 ld a4,0(a5)
946: 00e7e463 bltu a5,a4,94e <free+0x40>
94a: 00e6ea63 bltu a3,a4,95e <free+0x50>
{
94e: 87ba mv a5,a4
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
950: fed7fae3 bgeu a5,a3,944 <free+0x36>
954: 6398 ld a4,0(a5)
956: 00e6e463 bltu a3,a4,95e <free+0x50>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
95a: fee7eae3 bltu a5,a4,94e <free+0x40>
if(bp + bp->s.size == p->s.ptr){
95e: ff852583 lw a1,-8(a0)
962: 6390 ld a2,0(a5)
964: 02059713 slli a4,a1,0x20
968: 9301 srli a4,a4,0x20
96a: 0712 slli a4,a4,0x4
96c: 9736 add a4,a4,a3
96e: fae60ae3 beq a2,a4,922 <free+0x14>
bp->s.ptr = p->s.ptr;
972: fec53823 sd a2,-16(a0)
if(p + p->s.size == bp){
976: 4790 lw a2,8(a5)
978: 02061713 slli a4,a2,0x20
97c: 9301 srli a4,a4,0x20
97e: 0712 slli a4,a4,0x4
980: 973e add a4,a4,a5
982: fae689e3 beq a3,a4,934 <free+0x26>
} else
p->s.ptr = bp;
986: e394 sd a3,0(a5)
freep = p;
988: 00000717 auipc a4,0x0
98c: 22f73423 sd a5,552(a4) # bb0 <freep>
}
990: 6422 ld s0,8(sp)
992: 0141 addi sp,sp,16
994: 8082 ret
0000000000000996 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
996: 7139 addi sp,sp,-64
998: fc06 sd ra,56(sp)
99a: f822 sd s0,48(sp)
99c: f426 sd s1,40(sp)
99e: f04a sd s2,32(sp)
9a0: ec4e sd s3,24(sp)
9a2: e852 sd s4,16(sp)
9a4: e456 sd s5,8(sp)
9a6: e05a sd s6,0(sp)
9a8: 0080 addi s0,sp,64
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
9aa: 02051493 slli s1,a0,0x20
9ae: 9081 srli s1,s1,0x20
9b0: 04bd addi s1,s1,15
9b2: 8091 srli s1,s1,0x4
9b4: 0014899b addiw s3,s1,1
9b8: 0485 addi s1,s1,1
if((prevp = freep) == 0){
9ba: 00000517 auipc a0,0x0
9be: 1f653503 ld a0,502(a0) # bb0 <freep>
9c2: c515 beqz a0,9ee <malloc+0x58>
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
9c4: 611c ld a5,0(a0)
if(p->s.size >= nunits){
9c6: 4798 lw a4,8(a5)
9c8: 02977f63 bgeu a4,s1,a06 <malloc+0x70>
9cc: 8a4e mv s4,s3
9ce: 0009871b sext.w a4,s3
9d2: 6685 lui a3,0x1
9d4: 00d77363 bgeu a4,a3,9da <malloc+0x44>
9d8: 6a05 lui s4,0x1
9da: 000a0b1b sext.w s6,s4
p = sbrk(nu * sizeof(Header));
9de: 004a1a1b slliw s4,s4,0x4
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
9e2: 00000917 auipc s2,0x0
9e6: 1ce90913 addi s2,s2,462 # bb0 <freep>
if(p == (char*)-1)
9ea: 5afd li s5,-1
9ec: a88d j a5e <malloc+0xc8>
base.s.ptr = freep = prevp = &base;
9ee: 00000797 auipc a5,0x0
9f2: 1ca78793 addi a5,a5,458 # bb8 <base>
9f6: 00000717 auipc a4,0x0
9fa: 1af73d23 sd a5,442(a4) # bb0 <freep>
9fe: e39c sd a5,0(a5)
base.s.size = 0;
a00: 0007a423 sw zero,8(a5)
if(p->s.size >= nunits){
a04: b7e1 j 9cc <malloc+0x36>
if(p->s.size == nunits)
a06: 02e48b63 beq s1,a4,a3c <malloc+0xa6>
p->s.size -= nunits;
a0a: 4137073b subw a4,a4,s3
a0e: c798 sw a4,8(a5)
p += p->s.size;
a10: 1702 slli a4,a4,0x20
a12: 9301 srli a4,a4,0x20
a14: 0712 slli a4,a4,0x4
a16: 97ba add a5,a5,a4
p->s.size = nunits;
a18: 0137a423 sw s3,8(a5)
freep = prevp;
a1c: 00000717 auipc a4,0x0
a20: 18a73a23 sd a0,404(a4) # bb0 <freep>
return (void*)(p + 1);
a24: 01078513 addi a0,a5,16
if((p = morecore(nunits)) == 0)
return 0;
}
}
a28: 70e2 ld ra,56(sp)
a2a: 7442 ld s0,48(sp)
a2c: 74a2 ld s1,40(sp)
a2e: 7902 ld s2,32(sp)
a30: 69e2 ld s3,24(sp)
a32: 6a42 ld s4,16(sp)
a34: 6aa2 ld s5,8(sp)
a36: 6b02 ld s6,0(sp)
a38: 6121 addi sp,sp,64
a3a: 8082 ret
prevp->s.ptr = p->s.ptr;
a3c: 6398 ld a4,0(a5)
a3e: e118 sd a4,0(a0)
a40: bff1 j a1c <malloc+0x86>
hp->s.size = nu;
a42: 01652423 sw s6,8(a0)
free((void*)(hp + 1));
a46: 0541 addi a0,a0,16
a48: 00000097 auipc ra,0x0
a4c: ec6080e7 jalr -314(ra) # 90e <free>
return freep;
a50: 00093503 ld a0,0(s2)
if((p = morecore(nunits)) == 0)
a54: d971 beqz a0,a28 <malloc+0x92>
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
a56: 611c ld a5,0(a0)
if(p->s.size >= nunits){
a58: 4798 lw a4,8(a5)
a5a: fa9776e3 bgeu a4,s1,a06 <malloc+0x70>
if(p == freep)
a5e: 00093703 ld a4,0(s2)
a62: 853e mv a0,a5
a64: fef719e3 bne a4,a5,a56 <malloc+0xc0>
p = sbrk(nu * sizeof(Header));
a68: 8552 mv a0,s4
a6a: 00000097 auipc ra,0x0
a6e: b6e080e7 jalr -1170(ra) # 5d8 <sbrk>
if(p == (char*)-1)
a72: fd5518e3 bne a0,s5,a42 <malloc+0xac>
return 0;
a76: 4501 li a0,0
a78: bf45 j a28 <malloc+0x92>
| 30.652148
| 76
| 0.466626
|
697db22eea74ea8e1dca4ae7e6f16cc6f945d376
| 754
|
asm
|
Assembly
|
oeis/083/A083022.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/083/A083022.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/083/A083022.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A083022: Numbers n such that 4*n^2 - 3 is prime.
; Submitted by Christian Krause
; 2,4,5,7,10,13,16,17,20,22,23,29,32,34,40,43,44,46,49,55,56,59,62,64,68,70,71,73,82,86,95,97,101,103,104,109,110,125,127,133,134,148,149,152,155,160,161,163,164,166,170,175,178,181,185,208,209,218,220,226,230,235,244,247,251,253,254,263,265,274,277,280,287,290,293,295,304,313,317,320,326,328,329,331,332,334,343,346,347,352,356,361,364,368,373,385,386,395,397,398
mov $2,$0
pow $2,2
add $2,1
mov $6,1
lpb $2
add $1,6
mov $3,$1
add $5,$1
add $3,$5
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
add $1,$6
add $1,1
mov $4,$0
max $4,0
cmp $4,$0
mul $2,$4
sub $2,1
sub $5,2
lpe
mov $0,$1
div $0,8
add $0,2
| 26.928571
| 365
| 0.644562
|
e523e5734cbb05c0a58ddd5e8909104532db1907
| 2,304
|
asm
|
Assembly
|
programs/oeis/181/A181543.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/181/A181543.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/181/A181543.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
; A181543: Triangle of cubed binomial coefficients, T(n,k) = C(n,k)^3, read by rows.
; 1,1,1,1,8,1,1,27,27,1,1,64,216,64,1,1,125,1000,1000,125,1,1,216,3375,8000,3375,216,1,1,343,9261,42875,42875,9261,343,1,1,512,21952,175616,343000,175616,21952,512,1,1,729,46656,592704,2000376,2000376,592704,46656,729,1,1,1000,91125,1728000,9261000,16003008,9261000,1728000,91125,1000,1,1,1331,166375,4492125,35937000,98611128,98611128,35937000,4492125,166375,1331,1,1,1728,287496,10648000,121287375,496793088,788889024,496793088,121287375,10648000,287496,1728,1,1,2197,474552,23393656,365525875,2131746903,5053029696,5053029696,2131746903,365525875,23393656,474552,2197,1,1,2744,753571,48228544,1003003001,8024024008,27081081027,40424237568,27081081027,8024024008,1003003001,48228544,753571,2744,1,1,3375,1157625,94196375,2543302125,27081081027,125375375125,266468362875,266468362875,125375375125,27081081027,2543302125,94196375,1157625,3375,1,1,4096,1728000,175616000,6028568000,83338924032,513537536512,1497193984000,2131746903000,1497193984000,513537536512,83338924032,6028568000,175616000,1728000,4096,1,1,4913,2515456,314432000,13481272000,236946836672,1895574693376,7355714043392,14366628991000,14366628991000,7355714043392,1895574693376,236946836672,13481272000,314432000,2515456,4913,1,1,5832,3581577,543338496,28652616000,628982226432,6397564590144,32230296244224,83786180275512,114933031928000,83786180275512,32230296244224,6397564590144,628982226432,28652616000,543338496,3581577,5832,1,1,6859,5000211,909853209,58230605376,1572226345152,19973097643968,127932640011072,431772660037368,788325665994152,788325665994152,431772660037368,127932640011072,19973097643968,1572226345152,58230605376,909853209,5000211,6859,1,1,8000,6859000,1481544000,113731651125,3726758744064,58230605376000,465844843008000,1998947500173000,4738245926336000,6306605327953216,4738245926336000,1998947500173000,465844843008000,58230605376000,3726758744064,113731651125,1481544000,6859000,8000,1,1,9261,9261000,2352637000,214384046625,8426150568549,159784781151744,1572226345152000,8426150568549000
cal $0,206735 ; Triangle T(n,k), read by rows, given by (0, 2, -1/2, 1/2, 0, 0, 0, 0, 0, 0, 0, ...) DELTA (1, 0, -1/2, 1/2, 0, 0, 0, 0, 0, 0, 0, ...) where DELTA is the operator defined in A084938.
pow $0,3
trn $0,1
mov $1,$0
add $1,1
| 256
| 1,982
| 0.836806
|
c87445dbccda08922fb03a557d9b61f3a830ff1a
| 439
|
asm
|
Assembly
|
programs/oeis/333/A333870.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/333/A333870.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/333/A333870.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A333870: The number of iterations of the absolute Möbius divisor function (A173557) required to reach from n to 1.
; 0,1,2,1,2,2,3,1,2,2,3,2,3,3,2,1,2,2,3,2,3,3,4,2,2,3,2,3,4,2,3,1,3,2,3,2,3,3,3,2,3,3,4,3,2,4,5,2,3,2,2,3,4,2,3,3,3,4,5,2,3,3,3,1,3,3,4,2,4,3,4,2,3,3,2,3,3,3,4,2,2,3,4,3,2,4,4,3,4,2,3,4,3,5,3,2,3,3,3,2
lpb $0
seq $0,3958 ; If n = Product p(k)^e(k) then a(n) = Product (p(k)-1)^e(k).
sub $0,1
add $1,1
lpe
mov $0,$1
| 43.9
| 201
| 0.578588
|
9088878b93afa3244fad1dd7ae22d4fe4b058a87
| 831
|
asm
|
Assembly
|
programs/oeis/142/A142588.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/142/A142588.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/142/A142588.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A142588: A trisection of A000129, the Pell numbers.
; 0,5,70,985,13860,195025,2744210,38613965,543339720,7645370045,107578520350,1513744654945,21300003689580,299713796309065,4217293152016490,59341817924539925,835002744095575440,11749380235262596085,165326326037771920630,2326317944764069484905,32733777552734744709300,460599203683050495415105,6481122629115441680520770,91196316011299234022705885,1283229546787304717998403160,18056409971033565286000350125,254072969141257218722003304910,3575077977948634627394046618865,50305164660422142002238655969020,707847383223858622658735230185145,9960168529794442859224531878561050,140150206800346058651802181530039845
mul $0,3
seq $0,163271 ; Numerators of fractions in a 'zero-transform' approximation of sqrt(2) by means of a(n) = (a(n-1) + c)/(a(n-1) + 1) with c=2 and a(1)=0.
div $0,2
| 118.714286
| 604
| 0.866426
|
fe1b8ee343bda7e0f84e6998e029791e9159dd0a
| 472
|
asm
|
Assembly
|
oeis/348/A348132.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/348/A348132.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/348/A348132.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A348132: a(n) is the denominator of the relativistic sum of n velocities of 1/n, in units where the speed of light is 1.
; Submitted by Jamie Morken(s2)
; 1,5,9,353,275,66637,18571,24405761,2215269,14712104501,411625181,13218256749601,109949704423,16565151205544957,39931933598775,27614800115689879553,18928981513351817,59095217374989483261925,11350851717672992089,157904201452248753415276001
add $0,1
seq $0,62024 ; a(n) = ((n+1)^n + (n-1)^n)/2.
lpb $0
dif $0,4
lpe
| 47.2
| 239
| 0.78178
|
debb10757fd720ae4d9826f3141730c7be436ab7
| 339
|
asm
|
Assembly
|
3rdParties/src/nasm/nasm-2.15.02/test/prefixsym.asm
|
blue3k/StormForge
|
1557e699a673ae9adcc8f987868139f601ec0887
|
[
"Apache-2.0"
] | 1
|
2020-06-20T07:35:25.000Z
|
2020-06-20T07:35:25.000Z
|
3rdParties/src/nasm/nasm-2.15.02/test/prefixsym.asm
|
blue3k/StormForge
|
1557e699a673ae9adcc8f987868139f601ec0887
|
[
"Apache-2.0"
] | null | null | null |
3rdParties/src/nasm/nasm-2.15.02/test/prefixsym.asm
|
blue3k/StormForge
|
1557e699a673ae9adcc8f987868139f601ec0887
|
[
"Apache-2.0"
] | null | null | null |
; The FIRST definition of prefixes win, so more specific first
%pragma win64 gprefix W64_
%pragma win gprefix W_
%pragma elf gprefix
%pragma elf lprefix .L.
%pragma output gprefix _
%pragma output lprefix L.
extern malloc
global call_malloc
call_malloc:
call malloc
ret
myfunc:
jmp call_malloc
| 14.73913
| 63
| 0.696165
|
b1c00ae046d99edc80558ed82dc3bc1cb658a1e3
| 741,368
|
asm
|
Assembly
|
win32/VC10/Win32/libxml2_Release/xmlregexp.asm
|
txwizard/libxml2_x64_and_ARM
|
bc19a931370a09ee379d641a7c9a862fecebff3b
|
[
"MIT"
] | null | null | null |
win32/VC10/Win32/libxml2_Release/xmlregexp.asm
|
txwizard/libxml2_x64_and_ARM
|
bc19a931370a09ee379d641a7c9a862fecebff3b
|
[
"MIT"
] | null | null | null |
win32/VC10/Win32/libxml2_Release/xmlregexp.asm
|
txwizard/libxml2_x64_and_ARM
|
bc19a931370a09ee379d641a7c9a862fecebff3b
|
[
"MIT"
] | null | null | null |
; Listing generated by Microsoft (R) Optimizing Compiler Version 19.16.27027.1
TITLE C:\Users\DAG\Documents\_Clients\CodeProject Authors Group\Windows on ARM\libxml2\libxml2-2.9.9\xmlregexp.c
.686P
.XMM
include listing.inc
.model flat
INCLUDELIB MSVCRT
INCLUDELIB OLDNAMES
PUBLIC _forbiddenExp
PUBLIC _emptyExp
_DATA SEGMENT
COMM _xmlMalloc:DWORD
COMM _xmlMallocAtomic:DWORD
COMM _xmlRealloc:DWORD
COMM _xmlFree:DWORD
COMM _xmlMemStrdup:DWORD
COMM _xmlIsBaseCharGroup:BYTE:010H
COMM _xmlIsCharGroup:BYTE:010H
COMM _xmlIsCombiningGroup:BYTE:010H
COMM _xmlIsDigitGroup:BYTE:010H
COMM _xmlIsExtenderGroup:BYTE:010H
COMM _xmlIsIdeographicGroup:BYTE:010H
COMM _xmlIsPubidChar_tab:BYTE:0100H
COMM _xmlParserMaxDepth:DWORD
_DATA ENDS
msvcjmc SEGMENT
__188180DA_corecrt_math@h DB 01H
__2CC6E67D_corecrt_stdio_config@h DB 01H
__05476D76_corecrt_wstdio@h DB 01H
__A452D4A0_stdio@h DB 01H
__4384A2D9_corecrt_memcpy_s@h DB 01H
__4E51A221_corecrt_wstring@h DB 01H
__2140C079_string@h DB 01H
__F6DD4902_xmlregexp@c DB 01H
msvcjmc ENDS
_DATA SEGMENT
_forbiddenExp DD FLAT:_forbiddenExpNode
_emptyExp DD FLAT:_emptyExpNode
_forbiddenExpNode DB 01H
DB 00H
DW 00H
DD 00H
DD 00H
DD 00H
DD 00H
DD 00H
DD 00H
_emptyExpNode DB 00H
DB 01H
DW 00H
DD 00H
DD 00H
DD 00H
DD 00H
DD 00H
DD 00H
_DATA ENDS
PUBLIC ___local_stdio_printf_options
PUBLIC _fprintf
PUBLIC _printf
PUBLIC _snprintf
PUBLIC _xmlRegexpCompile
PUBLIC _xmlRegFreeRegexp
PUBLIC _xmlRegexpExec
PUBLIC _xmlRegexpPrint
PUBLIC _xmlRegexpIsDeterminist
PUBLIC _xmlRegNewExecCtxt
PUBLIC _xmlRegFreeExecCtxt
PUBLIC _xmlRegExecPushString
PUBLIC _xmlRegExecPushString2
PUBLIC _xmlRegExecNextValues
PUBLIC _xmlRegExecErrInfo
PUBLIC _xmlExpFreeCtxt
PUBLIC _xmlExpNewCtxt
PUBLIC _xmlExpCtxtNbNodes
PUBLIC _xmlExpCtxtNbCons
PUBLIC _xmlExpFree
PUBLIC _xmlExpRef
PUBLIC _xmlExpParse
PUBLIC _xmlExpNewAtom
PUBLIC _xmlExpNewOr
PUBLIC _xmlExpNewSeq
PUBLIC _xmlExpNewRange
PUBLIC _xmlExpIsNillable
PUBLIC _xmlExpMaxToken
PUBLIC _xmlExpGetLanguage
PUBLIC _xmlExpGetStart
PUBLIC _xmlExpStringDerive
PUBLIC _xmlExpExpDerive
PUBLIC _xmlExpSubsume
PUBLIC _xmlExpDump
PUBLIC _xmlNewAutomata
PUBLIC _xmlFreeAutomata
PUBLIC _xmlAutomataGetInitState
PUBLIC _xmlAutomataSetFinalState
PUBLIC _xmlAutomataNewState
PUBLIC _xmlAutomataNewTransition
PUBLIC _xmlAutomataNewTransition2
PUBLIC _xmlAutomataNewNegTrans
PUBLIC _xmlAutomataNewCountTrans
PUBLIC _xmlAutomataNewCountTrans2
PUBLIC _xmlAutomataNewOnceTrans
PUBLIC _xmlAutomataNewOnceTrans2
PUBLIC _xmlAutomataNewAllTrans
PUBLIC _xmlAutomataNewEpsilon
PUBLIC _xmlAutomataNewCountedTrans
PUBLIC _xmlAutomataNewCounterTrans
PUBLIC _xmlAutomataNewCounter
PUBLIC _xmlAutomataCompile
PUBLIC _xmlAutomataIsDeterminist
PUBLIC _xmlAutomataSetFlags
PUBLIC __JustMyCode_Default
PUBLIC ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@ ; `string'
PUBLIC ??_C@_0BH@CFFLONMP@failed?5to?5compile?3?5?$CFs?6@ ; `string'
PUBLIC ??_C@_0BB@FJPDMDM@compiling?5regexp@ ; `string'
PUBLIC ??_C@_0BB@PBEHJOM@allocating?5range@ ; `string'
PUBLIC ??_C@_0BA@JCPCIFNM@allocating?5atom@ ; `string'
PUBLIC ??_C@_0N@ECMBACNP@copying?5atom@ ; `string'
PUBLIC ??_C@_0BB@CKELLPME@allocating?5state@ ; `string'
PUBLIC ??_C@_08LJGDJFJP@epsilon?5@ ; `string'
PUBLIC ??_C@_08DFHMJFEK@charval?5@ ; `string'
PUBLIC ??_C@_07IPEOMBMH@ranges?5@ ; `string'
PUBLIC ??_C@_08BABENLJO@subexpr?5@ ; `string'
PUBLIC ??_C@_07HBAIICBM@string?5@ ; `string'
PUBLIC ??_C@_08IIDGBAEF@anychar?5@ ; `string'
PUBLIC ??_C@_09IFBFMEEE@anyspace?5@ ; `string'
PUBLIC ??_C@_09PIGAJOFL@notspace?5@ ; `string'
PUBLIC ??_C@_09PGNNJPMN@initname?5@ ; `string'
PUBLIC ??_C@_0N@PKALLFNP@notinitname?5@ ; `string'
PUBLIC ??_C@_09GMGKKJAH@namechar?5@ ; `string'
PUBLIC ??_C@_0N@GALMIDBF@notnamechar?5@ ; `string'
PUBLIC ??_C@_08CDKGKILA@decimal?5@ ; `string'
PUBLIC ??_C@_0M@EDJHICHL@notdecimal?5@ ; `string'
PUBLIC ??_C@_09MOCDMJPB@realchar?5@ ; `string'
PUBLIC ??_C@_0N@MCPFODOD@notrealchar?5@ ; `string'
PUBLIC ??_C@_07POCGPIHD@LETTER?5@ ; `string'
PUBLIC ??_C@_0BC@KMHMCLHI@LETTER_UPPERCASE?5@ ; `string'
PUBLIC ??_C@_0BC@MLADGGJK@LETTER_LOWERCASE?5@ ; `string'
PUBLIC ??_C@_0BC@FGJDLGPN@LETTER_TITLECASE?5@ ; `string'
PUBLIC ??_C@_0BB@MHDADLFE@LETTER_MODIFIER?5@ ; `string'
PUBLIC ??_C@_0P@ONCGNHEJ@LETTER_OTHERS?5@ ; `string'
PUBLIC ??_C@_05BACHLHLN@MARK?5@ ; `string'
PUBLIC ??_C@_0BB@FIDLEIEL@MARK_NONSPACING?5@ ; `string'
PUBLIC ??_C@_0BF@GJKDPMF@MARK_SPACECOMBINING?5@ ; `string'
PUBLIC ??_C@_0BA@NNNPPLBP@MARK_ENCLOSING?5@ ; `string'
PUBLIC ??_C@_07BAKEFCLB@NUMBER?5@ ; `string'
PUBLIC ??_C@_0BA@JLEBGNKM@NUMBER_DECIMAL?5@ ; `string'
PUBLIC ??_C@_0P@FJBLFHMA@NUMBER_LETTER?5@ ; `string'
PUBLIC ??_C@_0P@PDKFLOJK@NUMBER_OTHERS?5@ ; `string'
PUBLIC ??_C@_06INFGODEH@PUNCT?5@ ; `string'
PUBLIC ??_C@_0BB@DCHADIII@PUNCT_CONNECTOR?5@ ; `string'
PUBLIC ??_C@_0M@BBMKBPFM@PUNCT_DASH?5@ ; `string'
PUBLIC ??_C@_0M@FHHCCFFM@PUNCT_OPEN?5@ ; `string'
PUBLIC ??_C@_0N@OCGFHNOE@PUNCT_CLOSE?5@ ; `string'
PUBLIC ??_C@_0BB@HJFINBLL@PUNCT_INITQUOTE?5@ ; `string'
PUBLIC ??_C@_0BA@EBCHGEDF@PUNCT_FINQUOTE?5@ ; `string'
PUBLIC ??_C@_0O@FIEDELON@PUNCT_OTHERS?5@ ; `string'
PUBLIC ??_C@_06MODMGGJL@SEPAR?5@ ; `string'
PUBLIC ??_C@_0N@CEDLANHM@SEPAR_SPACE?5@ ; `string'
PUBLIC ??_C@_0M@GPNEEMIA@SEPAR_LINE?5@ ; `string'
PUBLIC ??_C@_0M@DGHGIFFK@SEPAR_PARA?5@ ; `string'
PUBLIC ??_C@_07EJLPHCCB@SYMBOL?5@ ; `string'
PUBLIC ??_C@_0N@LBDJILGE@SYMBOL_MATH?5@ ; `string'
PUBLIC ??_C@_0BB@MBFAMNND@SYMBOL_CURRENCY?5@ ; `string'
PUBLIC ??_C@_0BB@CEPANLJE@SYMBOL_MODIFIER?5@ ; `string'
PUBLIC ??_C@_0P@LKPECLCL@SYMBOL_OTHERS?5@ ; `string'
PUBLIC ??_C@_06HJDKAKAL@OTHER?5@ ; `string'
PUBLIC ??_C@_0P@FGFCBEPI@OTHER_CONTROL?5@ ; `string'
PUBLIC ??_C@_0O@BACNFCMB@OTHER_FORMAT?5@ ; `string'
PUBLIC ??_C@_0P@DEHNHHA@OTHER_PRIVATE?5@ ; `string'
PUBLIC ??_C@_09NECDEFOF@OTHER_NA?5@ ; `string'
PUBLIC ??_C@_06HDNEPAAO@BLOCK?5@ ; `string'
PUBLIC ??_C@_05GDJGFPHL@once?5@ ; `string'
PUBLIC ??_C@_02LKANKAOC@?$DP?5@ ; `string'
PUBLIC ??_C@_02KAOAMBHJ@?$CK?5@ ; `string'
PUBLIC ??_C@_02KBCCKLEO@?$CL?5@ ; `string'
PUBLIC ??_C@_06IBKHBGID@range?5@ ; `string'
PUBLIC ??_C@_09EPCGBNDN@onceonly?5@ ; `string'
PUBLIC ??_C@_04DIDGAIEC@all?5@ ; `string'
PUBLIC ??_C@_09LLABEBOE@?5?5range?3?5@ ; `string'
PUBLIC ??_C@_09KDBNABJA@negative?5@ ; `string'
PUBLIC ??_C@_08BNCIEJGK@?$CFc?5?9?5?$CFc?6@ ; `string'
PUBLIC ??_C@_07LAIPMBOA@?5atom?3?5@ ; `string'
PUBLIC ??_C@_05NJDBAOFA@NULL?6@ ; `string'
PUBLIC ??_C@_04LKOGMCLF@not?5@ ; `string'
PUBLIC ??_C@_06BIJEIIBB@?$CFd?9?$CFd?5@ ; `string'
PUBLIC ??_C@_05IMLJLABD@?8?$CFs?8?5@ ; `string'
PUBLIC ??_C@_08PCGOOLFO@char?5?$CFc?6@ ; `string'
PUBLIC ??_C@_0M@BCDCHBAM@?$CFd?5entries?6@ ; `string'
PUBLIC ??_C@_0BB@GBMGKEL@start?5?$CFd?5end?5?$CFd?6@ ; `string'
PUBLIC ??_C@_01EEMJAFIK@?6@ ; `string'
PUBLIC ??_C@_09KCGMBGNH@?5?5trans?3?5@ ; `string'
PUBLIC ??_C@_08IDDAKHFP@removed?6@ ; `string'
PUBLIC ??_C@_0BH@PJNPIGKD@last?5not?5determinist?0?5@ ; `string'
PUBLIC ??_C@_0BC@EKCPHBCA@not?5determinist?0?5@ ; `string'
PUBLIC ??_C@_0N@NIIDMCG@counted?5?$CFd?0?5@ ; `string'
PUBLIC ??_C@_0BB@CPMJDJHN@all?5transition?0?5@ ; `string'
PUBLIC ??_C@_0BB@LHHOLMKP@count?5based?5?$CFd?0?5@ ; `string'
PUBLIC ??_C@_0P@BEFDCDEN@epsilon?5to?5?$CFd?6@ ; `string'
PUBLIC ??_C@_08JNAFCHHG@char?5?$CFc?5@ ; `string'
PUBLIC ??_C@_0BA@DDAHGLMD@atom?5?$CFd?0?5to?5?$CFd?6@ ; `string'
PUBLIC ??_C@_08NOIFNCJM@?5state?3?5@ ; `string'
PUBLIC ??_C@_06BNBHINFE@START?5@ ; `string'
PUBLIC ??_C@_06EFHALCBA@FINAL?5@ ; `string'
PUBLIC ??_C@_0BF@NHMHHIIL@?$CFd?0?5?$CFd?5transitions?3?6@ ; `string'
PUBLIC ??_C@_0BI@MEBKNK@add?5range?3?5atom?5is?5NULL@ ; `string'
PUBLIC ??_C@_0BO@PJJILLLG@add?5range?3?5atom?5is?5not?5ranges@ ; `string'
PUBLIC ??_C@_0O@INOJCFAI@adding?5ranges@ ; `string'
PUBLIC ??_C@_0BD@OEINICOI@allocating?5counter@ ; `string'
PUBLIC ??_C@_0BI@LIIKMBAE@atom?5push?3?5atom?5is?5NULL@ ; `string'
PUBLIC ??_C@_0N@PMKNEBIB@pushing?5atom@ ; `string'
PUBLIC ??_C@_0BC@FHJHIDDF@adding?5transition@ ; `string'
PUBLIC ??_C@_0BJ@KPILLGIF@add?5state?3?5state?5is?5NULL@ ; `string'
PUBLIC ??_C@_0BK@PPLNMJBI@add?5state?3?5target?5is?5NULL@ ; `string'
PUBLIC ??_C@_0N@NHLBLLB@adding?5state@ ; `string'
PUBLIC ??_C@_0CB@LMLDANHN@genrate?5transition?3?5atom?5?$DN?$DN?5NUL@ ; `string'
PUBLIC ??_C@_0BJ@POCEJEIB@TODO?3?5XML_REGEXP_STRING?6@ ; `string'
PUBLIC ??_C@_0O@PEGCJGLF@saving?5regexp@ ; `string'
PUBLIC ??_C@_0BN@CPBANDJM@exec?5save?3?5allocation?5failed@ ; `string'
PUBLIC ??_C@_0P@IJHGICCJ@running?5regexp@ ; `string'
PUBLIC ??_C@_0CE@CMNJHAKA@epsilon?5transition?5left?5at?5runt@ ; `string'
PUBLIC ??_C@_0BL@LMPHHOAL@creating?5execution?5context@ ; `string'
PUBLIC ??_C@_0BF@FEDDAGIG@pushing?5input?5string@ ; `string'
PUBLIC ??_C@_0GL@GCGJPEPF@c?3?2users?2dag?2documents?2_clients@ ; `string'
PUBLIC ??_C@_0BO@MDEMDPPE@Unimplemented?5block?5at?5?$CFs?3?$CFd?6@ ; `string'
PUBLIC ??_C@_0BA@KPLOEDJN@IsXXXX?5expected@ ; `string'
PUBLIC ??_C@_0BG@ECFAFFBF@Unknown?5char?5property@ ; `string'
PUBLIC ??_C@_0BO@BOFONOMH@Escaped?5sequence?3?5expecting?5?2@ ; `string'
PUBLIC ??_C@_0O@OGGGBIPE@Expecting?5?8?$HL?8@ ; `string'
PUBLIC ??_C@_0O@OCOLGEEG@Expecting?5?8?$HN?8@ ; `string'
PUBLIC ??_C@_0CP@BDPLJNDH@Wrong?5escape?5sequence?0?5misuse?5o@ ; `string'
PUBLIC ??_C@_0O@NKKGCCKG@Expecting?5?8?$FN?8@ ; `string'
PUBLIC ??_C@_0BF@HOMDEKLG@Invalid?5escape?5value@ ; `string'
PUBLIC ??_C@_0BH@LOJMKNAD@Expecting?5a?5char?5range@ ; `string'
PUBLIC ??_C@_0CC@JHFKDBIP@Expecting?5the?5end?5of?5a?5char?5ran@ ; `string'
PUBLIC ??_C@_0CG@BKADGONK@End?5of?5range?5is?5before?5start?5of@ ; `string'
PUBLIC ??_C@_0BM@FJAEMPFO@charClassExpr?3?5?8?$FN?8?5expected@ ; `string'
PUBLIC ??_C@_0CC@FKLKCEIP@xmlFAParseCharClass?3?5?8?$FN?8?5expect@ ; `string'
PUBLIC ??_C@_0BE@PGBJEMPN@Improper?5quantifier@ ; `string'
PUBLIC ??_C@_0BI@HKPFPPFN@Unterminated?5quantifier@ ; `string'
PUBLIC ??_C@_0BO@CCFFKIJF@xmlFAParseAtom?3?5expecting?5?8?$CJ?8@ ; `string'
PUBLIC ??_C@_0BM@PFFMPGPF@internal?3?5no?5atom?5generated@ ; `string'
PUBLIC ??_C@_0BL@KAIMKABF@expecting?5a?5branch?5after?5?$HM@ ; `string'
PUBLIC ??_C@_09BNLLHCCB@?5regexp?3?5@ ; `string'
PUBLIC ??_C@_0L@PLBJGPP@?$CFd?5atoms?3?6@ ; `string'
PUBLIC ??_C@_06NLBGECGK@?5?$CF02d?5@ ; `string'
PUBLIC ??_C@_0L@LDKKLMNF@?$CFd?5states?3@ ; `string'
PUBLIC ??_C@_0O@EOOCDOKK@?$CFd?5counters?3?6@ ; `string'
PUBLIC ??_C@_0BE@LNLBBGGH@?5?$CFd?3?5min?5?$CFd?5max?5?$CFd?6@ ; `string'
PUBLIC ??_C@_0CD@GPPIOFAL@xmlFAParseRegExp?3?5extra?5charact@ ; `string'
PUBLIC ??_C@_06NGEMONLJ@not?5?$CFs@ ; `string'
PUBLIC ??_C@_0BF@FNELPLND@unbalanced?5?8?$CI?8?5?3?5?$CFs?6@ ; `string'
PUBLIC ??_C@_01ODHLEDKK@?$CI@ ; `string'
PUBLIC ??_C@_05LBJMNBOG@empty@ ; `string'
PUBLIC ??_C@_09PDGFMGED@forbidden@ ; `string'
PUBLIC ??_C@_03NKFKBEPL@?5?0?5@ ; `string'
PUBLIC ??_C@_03LGOGDKEL@?5?$HM?5@ ; `string'
PUBLIC ??_C@_04PFHMOCHH@?$HL?$CFd?$HN@ ; `string'
PUBLIC ??_C@_08EMBBFCPF@?$HL?$CFd?0inf?$HN@ ; `string'
PUBLIC ??_C@_07CDJFAPGJ@?$HL?$CFd?0?$CFd?$HN@ ; `string'
PUBLIC ??_C@_0P@OCJKDKLA@Error?5in?5tree?6@ ; `string'
PUBLIC ??_C@_01PKGAHCOL@?$CJ@ ; `string'
EXTRN _xmlStrdup:PROC
EXTRN _xmlStrndup:PROC
EXTRN _xmlStrEqual:PROC
EXTRN __imp____acrt_iob_func:PROC
EXTRN __imp____stdio_common_vfprintf:PROC
EXTRN __imp____stdio_common_vsprintf:PROC
EXTRN _xmlDictCreate:PROC
EXTRN _xmlDictReference:PROC
EXTRN _xmlDictFree:PROC
EXTRN _xmlDictLookup:PROC
EXTRN _xmlDictExists:PROC
EXTRN _xmlBufferWriteCHAR:PROC
EXTRN _xmlBufferWriteChar:PROC
EXTRN ___xmlRaiseError:PROC
EXTRN ___xmlGenericError:PROC
EXTRN ___xmlGenericErrorContext:PROC
EXTRN _xmlCharInRange:PROC
EXTRN _xmlStringCurrentChar:PROC
EXTRN _xmlUCSIsBlock:PROC
EXTRN _xmlUCSIsCatC:PROC
EXTRN _xmlUCSIsCatCc:PROC
EXTRN _xmlUCSIsCatCf:PROC
EXTRN _xmlUCSIsCatCo:PROC
EXTRN _xmlUCSIsCatL:PROC
EXTRN _xmlUCSIsCatLl:PROC
EXTRN _xmlUCSIsCatLm:PROC
EXTRN _xmlUCSIsCatLo:PROC
EXTRN _xmlUCSIsCatLt:PROC
EXTRN _xmlUCSIsCatLu:PROC
EXTRN _xmlUCSIsCatM:PROC
EXTRN _xmlUCSIsCatMc:PROC
EXTRN _xmlUCSIsCatMe:PROC
EXTRN _xmlUCSIsCatMn:PROC
EXTRN _xmlUCSIsCatN:PROC
EXTRN _xmlUCSIsCatNd:PROC
EXTRN _xmlUCSIsCatNl:PROC
EXTRN _xmlUCSIsCatNo:PROC
EXTRN _xmlUCSIsCatP:PROC
EXTRN _xmlUCSIsCatPc:PROC
EXTRN _xmlUCSIsCatPd:PROC
EXTRN _xmlUCSIsCatPe:PROC
EXTRN _xmlUCSIsCatPf:PROC
EXTRN _xmlUCSIsCatPi:PROC
EXTRN _xmlUCSIsCatPo:PROC
EXTRN _xmlUCSIsCatPs:PROC
EXTRN _xmlUCSIsCatS:PROC
EXTRN _xmlUCSIsCatSc:PROC
EXTRN _xmlUCSIsCatSk:PROC
EXTRN _xmlUCSIsCatSm:PROC
EXTRN _xmlUCSIsCatSo:PROC
EXTRN _xmlUCSIsCatZ:PROC
EXTRN _xmlUCSIsCatZl:PROC
EXTRN _xmlUCSIsCatZp:PROC
EXTRN _xmlUCSIsCatZs:PROC
EXTRN @__CheckForDebuggerJustMyCode@4:PROC
EXTRN _memcpy:PROC
EXTRN _memset:PROC
_DATA SEGMENT
COMM ?_OptionsStorage@?1??__local_stdio_printf_options@@9@9:QWORD ; `__local_stdio_printf_options'::`2'::_OptionsStorage
_DATA ENDS
; COMDAT ??_C@_01PKGAHCOL@?$CJ@
CONST SEGMENT
??_C@_01PKGAHCOL@?$CJ@ DB ')', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0P@OCJKDKLA@Error?5in?5tree?6@
CONST SEGMENT
??_C@_0P@OCJKDKLA@Error?5in?5tree?6@ DB 'Error in tree', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_07CDJFAPGJ@?$HL?$CFd?0?$CFd?$HN@
CONST SEGMENT
??_C@_07CDJFAPGJ@?$HL?$CFd?0?$CFd?$HN@ DB '{%d,%d}', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_08EMBBFCPF@?$HL?$CFd?0inf?$HN@
CONST SEGMENT
??_C@_08EMBBFCPF@?$HL?$CFd?0inf?$HN@ DB '{%d,inf}', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_04PFHMOCHH@?$HL?$CFd?$HN@
CONST SEGMENT
??_C@_04PFHMOCHH@?$HL?$CFd?$HN@ DB '{%d}', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_03LGOGDKEL@?5?$HM?5@
CONST SEGMENT
??_C@_03LGOGDKEL@?5?$HM?5@ DB ' | ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_03NKFKBEPL@?5?0?5@
CONST SEGMENT
??_C@_03NKFKBEPL@?5?0?5@ DB ' , ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09PDGFMGED@forbidden@
CONST SEGMENT
??_C@_09PDGFMGED@forbidden@ DB 'forbidden', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_05LBJMNBOG@empty@
CONST SEGMENT
??_C@_05LBJMNBOG@empty@ DB 'empty', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_01ODHLEDKK@?$CI@
CONST SEGMENT
??_C@_01ODHLEDKK@?$CI@ DB '(', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BF@FNELPLND@unbalanced?5?8?$CI?8?5?3?5?$CFs?6@
CONST SEGMENT
??_C@_0BF@FNELPLND@unbalanced?5?8?$CI?8?5?3?5?$CFs?6@ DB 'unbalanced ''('''
DB ' : %s', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_06NGEMONLJ@not?5?$CFs@
CONST SEGMENT
??_C@_06NGEMONLJ@not?5?$CFs@ DB 'not %s', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0CD@GPPIOFAL@xmlFAParseRegExp?3?5extra?5charact@
CONST SEGMENT
??_C@_0CD@GPPIOFAL@xmlFAParseRegExp?3?5extra?5charact@ DB 'xmlFAParseRegE'
DB 'xp: extra characters', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BE@LNLBBGGH@?5?$CFd?3?5min?5?$CFd?5max?5?$CFd?6@
CONST SEGMENT
??_C@_0BE@LNLBBGGH@?5?$CFd?3?5min?5?$CFd?5max?5?$CFd?6@ DB ' %d: min %d m'
DB 'ax %d', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0O@EOOCDOKK@?$CFd?5counters?3?6@
CONST SEGMENT
??_C@_0O@EOOCDOKK@?$CFd?5counters?3?6@ DB '%d counters:', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0L@LDKKLMNF@?$CFd?5states?3@
CONST SEGMENT
??_C@_0L@LDKKLMNF@?$CFd?5states?3@ DB '%d states:', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_06NLBGECGK@?5?$CF02d?5@
CONST SEGMENT
??_C@_06NLBGECGK@?5?$CF02d?5@ DB ' %02d ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0L@PLBJGPP@?$CFd?5atoms?3?6@
CONST SEGMENT
??_C@_0L@PLBJGPP@?$CFd?5atoms?3?6@ DB '%d atoms:', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09BNLLHCCB@?5regexp?3?5@
CONST SEGMENT
??_C@_09BNLLHCCB@?5regexp?3?5@ DB ' regexp: ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BL@KAIMKABF@expecting?5a?5branch?5after?5?$HM@
CONST SEGMENT
??_C@_0BL@KAIMKABF@expecting?5a?5branch?5after?5?$HM@ DB 'expecting a bra'
DB 'nch after |', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BM@PFFMPGPF@internal?3?5no?5atom?5generated@
CONST SEGMENT
??_C@_0BM@PFFMPGPF@internal?3?5no?5atom?5generated@ DB 'internal: no atom'
DB ' generated', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BO@CCFFKIJF@xmlFAParseAtom?3?5expecting?5?8?$CJ?8@
CONST SEGMENT
??_C@_0BO@CCFFKIJF@xmlFAParseAtom?3?5expecting?5?8?$CJ?8@ DB 'xmlFAParseA'
DB 'tom: expecting '')''', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BI@HKPFPPFN@Unterminated?5quantifier@
CONST SEGMENT
??_C@_0BI@HKPFPPFN@Unterminated?5quantifier@ DB 'Unterminated quantifier', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BE@PGBJEMPN@Improper?5quantifier@
CONST SEGMENT
??_C@_0BE@PGBJEMPN@Improper?5quantifier@ DB 'Improper quantifier', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0CC@FKLKCEIP@xmlFAParseCharClass?3?5?8?$FN?8?5expect@
CONST SEGMENT
??_C@_0CC@FKLKCEIP@xmlFAParseCharClass?3?5?8?$FN?8?5expect@ DB 'xmlFAPars'
DB 'eCharClass: '']'' expected', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BM@FJAEMPFO@charClassExpr?3?5?8?$FN?8?5expected@
CONST SEGMENT
??_C@_0BM@FJAEMPFO@charClassExpr?3?5?8?$FN?8?5expected@ DB 'charClassExpr'
DB ': '']'' expected', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0CG@BKADGONK@End?5of?5range?5is?5before?5start?5of@
CONST SEGMENT
??_C@_0CG@BKADGONK@End?5of?5range?5is?5before?5start?5of@ DB 'End of rang'
DB 'e is before start of range', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0CC@JHFKDBIP@Expecting?5the?5end?5of?5a?5char?5ran@
CONST SEGMENT
??_C@_0CC@JHFKDBIP@Expecting?5the?5end?5of?5a?5char?5ran@ DB 'Expecting t'
DB 'he end of a char range', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BH@LOJMKNAD@Expecting?5a?5char?5range@
CONST SEGMENT
??_C@_0BH@LOJMKNAD@Expecting?5a?5char?5range@ DB 'Expecting a char range', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BF@HOMDEKLG@Invalid?5escape?5value@
CONST SEGMENT
??_C@_0BF@HOMDEKLG@Invalid?5escape?5value@ DB 'Invalid escape value', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0O@NKKGCCKG@Expecting?5?8?$FN?8@
CONST SEGMENT
??_C@_0O@NKKGCCKG@Expecting?5?8?$FN?8@ DB 'Expecting '']''', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0CP@BDPLJNDH@Wrong?5escape?5sequence?0?5misuse?5o@
CONST SEGMENT
??_C@_0CP@BDPLJNDH@Wrong?5escape?5sequence?0?5misuse?5o@ DB 'Wrong escape'
DB ' sequence, misuse of character ''\''', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0O@OCOLGEEG@Expecting?5?8?$HN?8@
CONST SEGMENT
??_C@_0O@OCOLGEEG@Expecting?5?8?$HN?8@ DB 'Expecting ''}''', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0O@OGGGBIPE@Expecting?5?8?$HL?8@
CONST SEGMENT
??_C@_0O@OGGGBIPE@Expecting?5?8?$HL?8@ DB 'Expecting ''{''', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BO@BOFONOMH@Escaped?5sequence?3?5expecting?5?2@
CONST SEGMENT
??_C@_0BO@BOFONOMH@Escaped?5sequence?3?5expecting?5?2@ DB 'Escaped sequen'
DB 'ce: expecting \', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BG@ECFAFFBF@Unknown?5char?5property@
CONST SEGMENT
??_C@_0BG@ECFAFFBF@Unknown?5char?5property@ DB 'Unknown char property', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BA@KPLOEDJN@IsXXXX?5expected@
CONST SEGMENT
??_C@_0BA@KPLOEDJN@IsXXXX?5expected@ DB 'IsXXXX expected', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BO@MDEMDPPE@Unimplemented?5block?5at?5?$CFs?3?$CFd?6@
CONST SEGMENT
??_C@_0BO@MDEMDPPE@Unimplemented?5block?5at?5?$CFs?3?$CFd?6@ DB 'Unimplem'
DB 'ented block at %s:%d', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0GL@GCGJPEPF@c?3?2users?2dag?2documents?2_clients@
CONST SEGMENT
??_C@_0GL@GCGJPEPF@c?3?2users?2dag?2documents?2_clients@ DB 'c:\users\dag'
DB '\documents\_clients\codeproject authors group\windows on arm\'
DB 'libxml2\libxml2-2.9.9\xmlregexp.c', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BF@FEDDAGIG@pushing?5input?5string@
CONST SEGMENT
??_C@_0BF@FEDDAGIG@pushing?5input?5string@ DB 'pushing input string', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BL@LMPHHOAL@creating?5execution?5context@
CONST SEGMENT
??_C@_0BL@LMPHHOAL@creating?5execution?5context@ DB 'creating execution c'
DB 'ontext', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0CE@CMNJHAKA@epsilon?5transition?5left?5at?5runt@
CONST SEGMENT
??_C@_0CE@CMNJHAKA@epsilon?5transition?5left?5at?5runt@ DB 'epsilon trans'
DB 'ition left at runtime', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0P@IJHGICCJ@running?5regexp@
CONST SEGMENT
??_C@_0P@IJHGICCJ@running?5regexp@ DB 'running regexp', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BN@CPBANDJM@exec?5save?3?5allocation?5failed@
CONST SEGMENT
??_C@_0BN@CPBANDJM@exec?5save?3?5allocation?5failed@ DB 'exec save: alloc'
DB 'ation failed', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0O@PEGCJGLF@saving?5regexp@
CONST SEGMENT
??_C@_0O@PEGCJGLF@saving?5regexp@ DB 'saving regexp', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BJ@POCEJEIB@TODO?3?5XML_REGEXP_STRING?6@
CONST SEGMENT
??_C@_0BJ@POCEJEIB@TODO?3?5XML_REGEXP_STRING?6@ DB 'TODO: XML_REGEXP_STRI'
DB 'NG', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0CB@LMLDANHN@genrate?5transition?3?5atom?5?$DN?$DN?5NUL@
CONST SEGMENT
??_C@_0CB@LMLDANHN@genrate?5transition?3?5atom?5?$DN?$DN?5NUL@ DB 'genrat'
DB 'e transition: atom == NULL', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@NHLBLLB@adding?5state@
CONST SEGMENT
??_C@_0N@NHLBLLB@adding?5state@ DB 'adding state', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BK@PPLNMJBI@add?5state?3?5target?5is?5NULL@
CONST SEGMENT
??_C@_0BK@PPLNMJBI@add?5state?3?5target?5is?5NULL@ DB 'add state: target '
DB 'is NULL', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BJ@KPILLGIF@add?5state?3?5state?5is?5NULL@
CONST SEGMENT
??_C@_0BJ@KPILLGIF@add?5state?3?5state?5is?5NULL@ DB 'add state: state is'
DB ' NULL', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BC@FHJHIDDF@adding?5transition@
CONST SEGMENT
??_C@_0BC@FHJHIDDF@adding?5transition@ DB 'adding transition', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@PMKNEBIB@pushing?5atom@
CONST SEGMENT
??_C@_0N@PMKNEBIB@pushing?5atom@ DB 'pushing atom', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BI@LIIKMBAE@atom?5push?3?5atom?5is?5NULL@
CONST SEGMENT
??_C@_0BI@LIIKMBAE@atom?5push?3?5atom?5is?5NULL@ DB 'atom push: atom is N'
DB 'ULL', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BD@OEINICOI@allocating?5counter@
CONST SEGMENT
??_C@_0BD@OEINICOI@allocating?5counter@ DB 'allocating counter', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0O@INOJCFAI@adding?5ranges@
CONST SEGMENT
??_C@_0O@INOJCFAI@adding?5ranges@ DB 'adding ranges', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BO@PJJILLLG@add?5range?3?5atom?5is?5not?5ranges@
CONST SEGMENT
??_C@_0BO@PJJILLLG@add?5range?3?5atom?5is?5not?5ranges@ DB 'add range: at'
DB 'om is not ranges', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BI@MEBKNK@add?5range?3?5atom?5is?5NULL@
CONST SEGMENT
??_C@_0BI@MEBKNK@add?5range?3?5atom?5is?5NULL@ DB 'add range: atom is NUL'
DB 'L', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BF@NHMHHIIL@?$CFd?0?5?$CFd?5transitions?3?6@
CONST SEGMENT
??_C@_0BF@NHMHHIIL@?$CFd?0?5?$CFd?5transitions?3?6@ DB '%d, %d transition'
DB 's:', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_06EFHALCBA@FINAL?5@
CONST SEGMENT
??_C@_06EFHALCBA@FINAL?5@ DB 'FINAL ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_06BNBHINFE@START?5@
CONST SEGMENT
??_C@_06BNBHINFE@START?5@ DB 'START ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_08NOIFNCJM@?5state?3?5@
CONST SEGMENT
??_C@_08NOIFNCJM@?5state?3?5@ DB ' state: ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BA@DDAHGLMD@atom?5?$CFd?0?5to?5?$CFd?6@
CONST SEGMENT
??_C@_0BA@DDAHGLMD@atom?5?$CFd?0?5to?5?$CFd?6@ DB 'atom %d, to %d', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_08JNAFCHHG@char?5?$CFc?5@
CONST SEGMENT
??_C@_08JNAFCHHG@char?5?$CFc?5@ DB 'char %c ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0P@BEFDCDEN@epsilon?5to?5?$CFd?6@
CONST SEGMENT
??_C@_0P@BEFDCDEN@epsilon?5to?5?$CFd?6@ DB 'epsilon to %d', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@LHHOLMKP@count?5based?5?$CFd?0?5@
CONST SEGMENT
??_C@_0BB@LHHOLMKP@count?5based?5?$CFd?0?5@ DB 'count based %d, ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@CPMJDJHN@all?5transition?0?5@
CONST SEGMENT
??_C@_0BB@CPMJDJHN@all?5transition?0?5@ DB 'all transition, ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@NIIDMCG@counted?5?$CFd?0?5@
CONST SEGMENT
??_C@_0N@NIIDMCG@counted?5?$CFd?0?5@ DB 'counted %d, ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BC@EKCPHBCA@not?5determinist?0?5@
CONST SEGMENT
??_C@_0BC@EKCPHBCA@not?5determinist?0?5@ DB 'not determinist, ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BH@PJNPIGKD@last?5not?5determinist?0?5@
CONST SEGMENT
??_C@_0BH@PJNPIGKD@last?5not?5determinist?0?5@ DB 'last not determinist, '
DB 00H ; `string'
CONST ENDS
; COMDAT ??_C@_08IDDAKHFP@removed?6@
CONST SEGMENT
??_C@_08IDDAKHFP@removed?6@ DB 'removed', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09KCGMBGNH@?5?5trans?3?5@
CONST SEGMENT
??_C@_09KCGMBGNH@?5?5trans?3?5@ DB ' trans: ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_01EEMJAFIK@?6@
CONST SEGMENT
??_C@_01EEMJAFIK@?6@ DB 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@GBMGKEL@start?5?$CFd?5end?5?$CFd?6@
CONST SEGMENT
??_C@_0BB@GBMGKEL@start?5?$CFd?5end?5?$CFd?6@ DB 'start %d end %d', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0M@BCDCHBAM@?$CFd?5entries?6@
CONST SEGMENT
??_C@_0M@BCDCHBAM@?$CFd?5entries?6@ DB '%d entries', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_08PCGOOLFO@char?5?$CFc?6@
CONST SEGMENT
??_C@_08PCGOOLFO@char?5?$CFc?6@ DB 'char %c', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_05IMLJLABD@?8?$CFs?8?5@
CONST SEGMENT
??_C@_05IMLJLABD@?8?$CFs?8?5@ DB '''%s'' ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_06BIJEIIBB@?$CFd?9?$CFd?5@
CONST SEGMENT
??_C@_06BIJEIIBB@?$CFd?9?$CFd?5@ DB '%d-%d ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_04LKOGMCLF@not?5@
CONST SEGMENT
??_C@_04LKOGMCLF@not?5@ DB 'not ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_05NJDBAOFA@NULL?6@
CONST SEGMENT
??_C@_05NJDBAOFA@NULL?6@ DB 'NULL', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_07LAIPMBOA@?5atom?3?5@
CONST SEGMENT
??_C@_07LAIPMBOA@?5atom?3?5@ DB ' atom: ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_08BNCIEJGK@?$CFc?5?9?5?$CFc?6@
CONST SEGMENT
??_C@_08BNCIEJGK@?$CFc?5?9?5?$CFc?6@ DB '%c - %c', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09KDBNABJA@negative?5@
CONST SEGMENT
??_C@_09KDBNABJA@negative?5@ DB 'negative ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09LLABEBOE@?5?5range?3?5@
CONST SEGMENT
??_C@_09LLABEBOE@?5?5range?3?5@ DB ' range: ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_04DIDGAIEC@all?5@
CONST SEGMENT
??_C@_04DIDGAIEC@all?5@ DB 'all ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09EPCGBNDN@onceonly?5@
CONST SEGMENT
??_C@_09EPCGBNDN@onceonly?5@ DB 'onceonly ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_06IBKHBGID@range?5@
CONST SEGMENT
??_C@_06IBKHBGID@range?5@ DB 'range ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_02KBCCKLEO@?$CL?5@
CONST SEGMENT
??_C@_02KBCCKLEO@?$CL?5@ DB '+ ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_02KAOAMBHJ@?$CK?5@
CONST SEGMENT
??_C@_02KAOAMBHJ@?$CK?5@ DB '* ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_02LKANKAOC@?$DP?5@
CONST SEGMENT
??_C@_02LKANKAOC@?$DP?5@ DB '? ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_05GDJGFPHL@once?5@
CONST SEGMENT
??_C@_05GDJGFPHL@once?5@ DB 'once ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_06HDNEPAAO@BLOCK?5@
CONST SEGMENT
??_C@_06HDNEPAAO@BLOCK?5@ DB 'BLOCK ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09NECDEFOF@OTHER_NA?5@
CONST SEGMENT
??_C@_09NECDEFOF@OTHER_NA?5@ DB 'OTHER_NA ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0P@DEHNHHA@OTHER_PRIVATE?5@
CONST SEGMENT
??_C@_0P@DEHNHHA@OTHER_PRIVATE?5@ DB 'OTHER_PRIVATE ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0O@BACNFCMB@OTHER_FORMAT?5@
CONST SEGMENT
??_C@_0O@BACNFCMB@OTHER_FORMAT?5@ DB 'OTHER_FORMAT ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0P@FGFCBEPI@OTHER_CONTROL?5@
CONST SEGMENT
??_C@_0P@FGFCBEPI@OTHER_CONTROL?5@ DB 'OTHER_CONTROL ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_06HJDKAKAL@OTHER?5@
CONST SEGMENT
??_C@_06HJDKAKAL@OTHER?5@ DB 'OTHER ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0P@LKPECLCL@SYMBOL_OTHERS?5@
CONST SEGMENT
??_C@_0P@LKPECLCL@SYMBOL_OTHERS?5@ DB 'SYMBOL_OTHERS ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@CEPANLJE@SYMBOL_MODIFIER?5@
CONST SEGMENT
??_C@_0BB@CEPANLJE@SYMBOL_MODIFIER?5@ DB 'SYMBOL_MODIFIER ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@MBFAMNND@SYMBOL_CURRENCY?5@
CONST SEGMENT
??_C@_0BB@MBFAMNND@SYMBOL_CURRENCY?5@ DB 'SYMBOL_CURRENCY ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@LBDJILGE@SYMBOL_MATH?5@
CONST SEGMENT
??_C@_0N@LBDJILGE@SYMBOL_MATH?5@ DB 'SYMBOL_MATH ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_07EJLPHCCB@SYMBOL?5@
CONST SEGMENT
??_C@_07EJLPHCCB@SYMBOL?5@ DB 'SYMBOL ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0M@DGHGIFFK@SEPAR_PARA?5@
CONST SEGMENT
??_C@_0M@DGHGIFFK@SEPAR_PARA?5@ DB 'SEPAR_PARA ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0M@GPNEEMIA@SEPAR_LINE?5@
CONST SEGMENT
??_C@_0M@GPNEEMIA@SEPAR_LINE?5@ DB 'SEPAR_LINE ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@CEDLANHM@SEPAR_SPACE?5@
CONST SEGMENT
??_C@_0N@CEDLANHM@SEPAR_SPACE?5@ DB 'SEPAR_SPACE ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_06MODMGGJL@SEPAR?5@
CONST SEGMENT
??_C@_06MODMGGJL@SEPAR?5@ DB 'SEPAR ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0O@FIEDELON@PUNCT_OTHERS?5@
CONST SEGMENT
??_C@_0O@FIEDELON@PUNCT_OTHERS?5@ DB 'PUNCT_OTHERS ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BA@EBCHGEDF@PUNCT_FINQUOTE?5@
CONST SEGMENT
??_C@_0BA@EBCHGEDF@PUNCT_FINQUOTE?5@ DB 'PUNCT_FINQUOTE ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@HJFINBLL@PUNCT_INITQUOTE?5@
CONST SEGMENT
??_C@_0BB@HJFINBLL@PUNCT_INITQUOTE?5@ DB 'PUNCT_INITQUOTE ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@OCGFHNOE@PUNCT_CLOSE?5@
CONST SEGMENT
??_C@_0N@OCGFHNOE@PUNCT_CLOSE?5@ DB 'PUNCT_CLOSE ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0M@FHHCCFFM@PUNCT_OPEN?5@
CONST SEGMENT
??_C@_0M@FHHCCFFM@PUNCT_OPEN?5@ DB 'PUNCT_OPEN ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0M@BBMKBPFM@PUNCT_DASH?5@
CONST SEGMENT
??_C@_0M@BBMKBPFM@PUNCT_DASH?5@ DB 'PUNCT_DASH ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@DCHADIII@PUNCT_CONNECTOR?5@
CONST SEGMENT
??_C@_0BB@DCHADIII@PUNCT_CONNECTOR?5@ DB 'PUNCT_CONNECTOR ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_06INFGODEH@PUNCT?5@
CONST SEGMENT
??_C@_06INFGODEH@PUNCT?5@ DB 'PUNCT ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0P@PDKFLOJK@NUMBER_OTHERS?5@
CONST SEGMENT
??_C@_0P@PDKFLOJK@NUMBER_OTHERS?5@ DB 'NUMBER_OTHERS ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0P@FJBLFHMA@NUMBER_LETTER?5@
CONST SEGMENT
??_C@_0P@FJBLFHMA@NUMBER_LETTER?5@ DB 'NUMBER_LETTER ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BA@JLEBGNKM@NUMBER_DECIMAL?5@
CONST SEGMENT
??_C@_0BA@JLEBGNKM@NUMBER_DECIMAL?5@ DB 'NUMBER_DECIMAL ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_07BAKEFCLB@NUMBER?5@
CONST SEGMENT
??_C@_07BAKEFCLB@NUMBER?5@ DB 'NUMBER ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BA@NNNPPLBP@MARK_ENCLOSING?5@
CONST SEGMENT
??_C@_0BA@NNNPPLBP@MARK_ENCLOSING?5@ DB 'MARK_ENCLOSING ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BF@GJKDPMF@MARK_SPACECOMBINING?5@
CONST SEGMENT
??_C@_0BF@GJKDPMF@MARK_SPACECOMBINING?5@ DB 'MARK_SPACECOMBINING ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@FIDLEIEL@MARK_NONSPACING?5@
CONST SEGMENT
??_C@_0BB@FIDLEIEL@MARK_NONSPACING?5@ DB 'MARK_NONSPACING ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_05BACHLHLN@MARK?5@
CONST SEGMENT
??_C@_05BACHLHLN@MARK?5@ DB 'MARK ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0P@ONCGNHEJ@LETTER_OTHERS?5@
CONST SEGMENT
??_C@_0P@ONCGNHEJ@LETTER_OTHERS?5@ DB 'LETTER_OTHERS ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@MHDADLFE@LETTER_MODIFIER?5@
CONST SEGMENT
??_C@_0BB@MHDADLFE@LETTER_MODIFIER?5@ DB 'LETTER_MODIFIER ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BC@FGJDLGPN@LETTER_TITLECASE?5@
CONST SEGMENT
??_C@_0BC@FGJDLGPN@LETTER_TITLECASE?5@ DB 'LETTER_TITLECASE ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BC@MLADGGJK@LETTER_LOWERCASE?5@
CONST SEGMENT
??_C@_0BC@MLADGGJK@LETTER_LOWERCASE?5@ DB 'LETTER_LOWERCASE ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BC@KMHMCLHI@LETTER_UPPERCASE?5@
CONST SEGMENT
??_C@_0BC@KMHMCLHI@LETTER_UPPERCASE?5@ DB 'LETTER_UPPERCASE ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_07POCGPIHD@LETTER?5@
CONST SEGMENT
??_C@_07POCGPIHD@LETTER?5@ DB 'LETTER ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@MCPFODOD@notrealchar?5@
CONST SEGMENT
??_C@_0N@MCPFODOD@notrealchar?5@ DB 'notrealchar ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09MOCDMJPB@realchar?5@
CONST SEGMENT
??_C@_09MOCDMJPB@realchar?5@ DB 'realchar ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0M@EDJHICHL@notdecimal?5@
CONST SEGMENT
??_C@_0M@EDJHICHL@notdecimal?5@ DB 'notdecimal ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_08CDKGKILA@decimal?5@
CONST SEGMENT
??_C@_08CDKGKILA@decimal?5@ DB 'decimal ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@GALMIDBF@notnamechar?5@
CONST SEGMENT
??_C@_0N@GALMIDBF@notnamechar?5@ DB 'notnamechar ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09GMGKKJAH@namechar?5@
CONST SEGMENT
??_C@_09GMGKKJAH@namechar?5@ DB 'namechar ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@PKALLFNP@notinitname?5@
CONST SEGMENT
??_C@_0N@PKALLFNP@notinitname?5@ DB 'notinitname ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09PGNNJPMN@initname?5@
CONST SEGMENT
??_C@_09PGNNJPMN@initname?5@ DB 'initname ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09PIGAJOFL@notspace?5@
CONST SEGMENT
??_C@_09PIGAJOFL@notspace?5@ DB 'notspace ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_09IFBFMEEE@anyspace?5@
CONST SEGMENT
??_C@_09IFBFMEEE@anyspace?5@ DB 'anyspace ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_08IIDGBAEF@anychar?5@
CONST SEGMENT
??_C@_08IIDGBAEF@anychar?5@ DB 'anychar ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_07HBAIICBM@string?5@
CONST SEGMENT
??_C@_07HBAIICBM@string?5@ DB 'string ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_08BABENLJO@subexpr?5@
CONST SEGMENT
??_C@_08BABENLJO@subexpr?5@ DB 'subexpr ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_07IPEOMBMH@ranges?5@
CONST SEGMENT
??_C@_07IPEOMBMH@ranges?5@ DB 'ranges ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_08DFHMJFEK@charval?5@
CONST SEGMENT
??_C@_08DFHMJFEK@charval?5@ DB 'charval ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_08LJGDJFJP@epsilon?5@
CONST SEGMENT
??_C@_08LJGDJFJP@epsilon?5@ DB 'epsilon ', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@CKELLPME@allocating?5state@
CONST SEGMENT
??_C@_0BB@CKELLPME@allocating?5state@ DB 'allocating state', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0N@ECMBACNP@copying?5atom@
CONST SEGMENT
??_C@_0N@ECMBACNP@copying?5atom@ DB 'copying atom', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BA@JCPCIFNM@allocating?5atom@
CONST SEGMENT
??_C@_0BA@JCPCIFNM@allocating?5atom@ DB 'allocating atom', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@PBEHJOM@allocating?5range@
CONST SEGMENT
??_C@_0BB@PBEHJOM@allocating?5range@ DB 'allocating range', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BB@FJPDMDM@compiling?5regexp@
CONST SEGMENT
??_C@_0BB@FJPDMDM@compiling?5regexp@ DB 'compiling regexp', 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BH@CFFLONMP@failed?5to?5compile?3?5?$CFs?6@
CONST SEGMENT
??_C@_0BH@CFFLONMP@failed?5to?5compile?3?5?$CFs?6@ DB 'failed to compile:'
DB ' %s', 0aH, 00H ; `string'
CONST ENDS
; COMDAT ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
CONST SEGMENT
??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@ DB 'Memory al'
DB 'location failed : %s', 0aH, 00H ; `string'
CONST ENDS
; Function compile flags: /Odt
; COMDAT __JustMyCode_Default
_TEXT SEGMENT
__JustMyCode_Default PROC ; COMDAT
push ebp
mov ebp, esp
pop ebp
ret 0
__JustMyCode_Default ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpDumpInt
_TEXT SEGMENT
_rep$1 = -40 ; size = 40
_buf$ = 8 ; size = 4
_expr$ = 12 ; size = 4
_glob$ = 16 ; size = 4
_xmlExpDumpInt PROC ; COMDAT
; 8043 : xmlExpDumpInt(xmlBufferPtr buf, xmlExpNodePtr expr, int glob) {
push ebp
mov ebp, esp
sub esp, 40 ; 00000028H
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push edi
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR _expr$[ebp]
test edi, edi
je $LN38@xmlExpDump
; 8044 : xmlExpNodePtr c;
; 8045 :
; 8046 : if (expr == NULL) return;
; 8047 : if (glob) xmlBufferWriteChar(buf, "(");
cmp DWORD PTR _glob$[ebp], 0
push esi
mov esi, DWORD PTR _buf$[ebp]
je SHORT $LN5@xmlExpDump
push OFFSET ??_C@_01ODHLEDKK@?$CI@
push esi
call _xmlBufferWriteChar
add esp, 8
$LN5@xmlExpDump:
; 8048 : switch (expr->type) {
movzx eax, BYTE PTR [edi]
cmp eax, 5
ja $LN37@xmlExpDump
jmp DWORD PTR $LN48@xmlExpDump[eax*4]
$LN6@xmlExpDump:
; 8049 : case XML_EXP_EMPTY:
; 8050 : xmlBufferWriteChar(buf, "empty");
push OFFSET ??_C@_05LBJMNBOG@empty@
push esi
call _xmlBufferWriteChar
; 8051 : break;
jmp $LN45@xmlExpDump
$LN7@xmlExpDump:
; 8052 : case XML_EXP_FORBID:
; 8053 : xmlBufferWriteChar(buf, "forbidden");
push OFFSET ??_C@_09PDGFMGED@forbidden@
push esi
call _xmlBufferWriteChar
; 8054 : break;
jmp $LN45@xmlExpDump
$LN8@xmlExpDump:
; 8055 : case XML_EXP_ATOM:
; 8056 : xmlBufferWriteCHAR(buf, expr->exp_str);
push DWORD PTR [edi+20]
push esi
call _xmlBufferWriteCHAR
; 8057 : break;
jmp $LN45@xmlExpDump
$LN9@xmlExpDump:
; 8058 : case XML_EXP_SEQ:
; 8059 : c = expr->exp_left;
mov ecx, DWORD PTR [edi+12]
; 8060 : if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
mov al, BYTE PTR [ecx]
cmp al, 3
je SHORT $LN12@xmlExpDump
cmp al, 4
je SHORT $LN12@xmlExpDump
; 8062 : else
; 8063 : xmlExpDumpInt(buf, c, 0);
xor eax, eax
jmp SHORT $LN11@xmlExpDump
$LN12@xmlExpDump:
; 8061 : xmlExpDumpInt(buf, c, 1);
mov eax, 1
$LN11@xmlExpDump:
; 8064 : xmlBufferWriteChar(buf, " , ");
push eax
push ecx
push esi
call _xmlExpDumpInt
push OFFSET ??_C@_03NKFKBEPL@?5?0?5@
$LN46@xmlExpDump:
; 8114 : }
; 8115 : if (glob)
push esi
call _xmlBufferWriteChar
mov ecx, DWORD PTR [edi+20]
add esp, 20 ; 00000014H
mov al, BYTE PTR [ecx]
cmp al, 3
je SHORT $LN15@xmlExpDump
cmp al, 4
je SHORT $LN15@xmlExpDump
xor eax, eax
push eax
push ecx
push esi
call _xmlExpDumpInt
add esp, 12 ; 0000000cH
jmp $LN2@xmlExpDump
$LN15@xmlExpDump:
mov eax, 1
push eax
push ecx
push esi
call _xmlExpDumpInt
add esp, 12 ; 0000000cH
jmp $LN2@xmlExpDump
$LN16@xmlExpDump:
; 8065 : c = expr->exp_right;
; 8066 : if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
; 8067 : xmlExpDumpInt(buf, c, 1);
; 8068 : else
; 8069 : xmlExpDumpInt(buf, c, 0);
; 8070 : break;
; 8071 : case XML_EXP_OR:
; 8072 : c = expr->exp_left;
mov ecx, DWORD PTR [edi+12]
; 8073 : if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
mov al, BYTE PTR [ecx]
cmp al, 3
je SHORT $LN19@xmlExpDump
cmp al, 4
je SHORT $LN19@xmlExpDump
; 8075 : else
; 8076 : xmlExpDumpInt(buf, c, 0);
xor eax, eax
; 8077 : xmlBufferWriteChar(buf, " | ");
push eax
push ecx
push esi
call _xmlExpDumpInt
push OFFSET ??_C@_03LGOGDKEL@?5?$HM?5@
; 8078 : c = expr->exp_right;
; 8079 : if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
; 8080 : xmlExpDumpInt(buf, c, 1);
; 8081 : else
; 8082 : xmlExpDumpInt(buf, c, 0);
jmp SHORT $LN46@xmlExpDump
$LN19@xmlExpDump:
; 8074 : xmlExpDumpInt(buf, c, 1);
mov eax, 1
; 8077 : xmlBufferWriteChar(buf, " | ");
push eax
push ecx
push esi
call _xmlExpDumpInt
push OFFSET ??_C@_03LGOGDKEL@?5?$HM?5@
; 8078 : c = expr->exp_right;
; 8079 : if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
; 8080 : xmlExpDumpInt(buf, c, 1);
; 8081 : else
; 8082 : xmlExpDumpInt(buf, c, 0);
jmp SHORT $LN46@xmlExpDump
$LN23@xmlExpDump:
; 8083 : break;
; 8084 : case XML_EXP_COUNT: {
; 8085 : char rep[40];
; 8086 :
; 8087 : c = expr->exp_left;
mov ecx, DWORD PTR [edi+12]
; 8088 : if ((c->type == XML_EXP_SEQ) || (c->type == XML_EXP_OR))
mov al, BYTE PTR [ecx]
cmp al, 3
je SHORT $LN26@xmlExpDump
cmp al, 4
je SHORT $LN26@xmlExpDump
; 8090 : else
; 8091 : xmlExpDumpInt(buf, c, 0);
xor eax, eax
jmp SHORT $LN25@xmlExpDump
$LN26@xmlExpDump:
; 8089 : xmlExpDumpInt(buf, c, 1);
mov eax, 1
$LN25@xmlExpDump:
; 8092 : if ((expr->exp_min == 0) && (expr->exp_max == 1)) {
push eax
push ecx
push esi
call _xmlExpDumpInt
mov eax, DWORD PTR [edi+20]
add esp, 12 ; 0000000cH
test eax, eax
jne SHORT $LN41@xmlExpDump
mov ecx, DWORD PTR [edi+24]
cmp ecx, 1
jne SHORT $LN43@xmlExpDump
; 8107 : }
; 8108 : rep[39] = 0;
mov BYTE PTR _rep$1[ebp+39], al
; 8109 : xmlBufferWriteChar(buf, rep);
lea eax, DWORD PTR _rep$1[ebp]
push eax
push esi
mov WORD PTR _rep$1[ebp], 63 ; 0000003fH
call _xmlBufferWriteChar
; 8110 : break;
jmp $LN45@xmlExpDump
$LN43@xmlExpDump:
; 8093 : rep[0] = '?';
; 8094 : rep[1] = 0;
; 8095 : } else if ((expr->exp_min == 0) && (expr->exp_max == -1)) {
cmp ecx, -1
jne SHORT $LN42@xmlExpDump
; 8109 : xmlBufferWriteChar(buf, rep);
lea eax, DWORD PTR _rep$1[ebp]
mov WORD PTR _rep$1[ebp], 42 ; 0000002aH
push eax
push esi
mov BYTE PTR _rep$1[ebp+39], 0
call _xmlBufferWriteChar
; 8110 : break;
jmp $LN45@xmlExpDump
$LN41@xmlExpDump:
; 8096 : rep[0] = '*';
; 8097 : rep[1] = 0;
; 8098 : } else if ((expr->exp_min == 1) && (expr->exp_max == -1)) {
cmp eax, 1
jne SHORT $LN42@xmlExpDump
cmp DWORD PTR [edi+24], -1
jne SHORT $LN42@xmlExpDump
; 8109 : xmlBufferWriteChar(buf, rep);
lea eax, DWORD PTR _rep$1[ebp]
mov WORD PTR _rep$1[ebp], 43 ; 0000002bH
push eax
push esi
mov BYTE PTR _rep$1[ebp+39], 0
call _xmlBufferWriteChar
; 8110 : break;
jmp $LN45@xmlExpDump
$LN42@xmlExpDump:
; 8099 : rep[0] = '+';
; 8100 : rep[1] = 0;
; 8101 : } else if (expr->exp_max == expr->exp_min) {
mov ecx, DWORD PTR [edi+24]
cmp ecx, eax
jne SHORT $LN33@xmlExpDump
; 8102 : snprintf(rep, 39, "{%d}", expr->exp_min);
push eax
push OFFSET ??_C@_04PFHMOCHH@?$HL?$CFd?$HN@
lea eax, DWORD PTR _rep$1[ebp]
push 39 ; 00000027H
push eax
call _snprintf
add esp, 16 ; 00000010H
; 8107 : }
; 8108 : rep[39] = 0;
mov BYTE PTR _rep$1[ebp+39], 0
; 8109 : xmlBufferWriteChar(buf, rep);
lea eax, DWORD PTR _rep$1[ebp]
push eax
push esi
call _xmlBufferWriteChar
; 8110 : break;
jmp SHORT $LN45@xmlExpDump
$LN33@xmlExpDump:
; 8103 : } else if (expr->exp_max < 0) {
test ecx, ecx
jns SHORT $LN35@xmlExpDump
; 8104 : snprintf(rep, 39, "{%d,inf}", expr->exp_min);
push eax
push OFFSET ??_C@_08EMBBFCPF@?$HL?$CFd?0inf?$HN@
lea eax, DWORD PTR _rep$1[ebp]
push 39 ; 00000027H
push eax
call _snprintf
add esp, 16 ; 00000010H
; 8107 : }
; 8108 : rep[39] = 0;
mov BYTE PTR _rep$1[ebp+39], 0
; 8109 : xmlBufferWriteChar(buf, rep);
lea eax, DWORD PTR _rep$1[ebp]
push eax
push esi
call _xmlBufferWriteChar
; 8110 : break;
jmp SHORT $LN45@xmlExpDump
$LN35@xmlExpDump:
; 8105 : } else {
; 8106 : snprintf(rep, 39, "{%d,%d}", expr->exp_min, expr->exp_max);
push ecx
push eax
push OFFSET ??_C@_07CDJFAPGJ@?$HL?$CFd?0?$CFd?$HN@
lea eax, DWORD PTR _rep$1[ebp]
push 39 ; 00000027H
push eax
call _snprintf
add esp, 20 ; 00000014H
; 8107 : }
; 8108 : rep[39] = 0;
mov BYTE PTR _rep$1[ebp+39], 0
; 8109 : xmlBufferWriteChar(buf, rep);
lea eax, DWORD PTR _rep$1[ebp]
push eax
push esi
call _xmlBufferWriteChar
; 8110 : break;
jmp SHORT $LN45@xmlExpDump
$LN37@xmlExpDump:
; 8111 : }
; 8112 : default:
; 8113 : fprintf(stderr, "Error in tree\n");
push OFFSET ??_C@_0P@OCJKDKLA@Error?5in?5tree?6@
push 2
call DWORD PTR __imp____acrt_iob_func
add esp, 4
push eax
call _fprintf
$LN45@xmlExpDump:
; 8114 : }
; 8115 : if (glob)
add esp, 8
$LN2@xmlExpDump:
cmp DWORD PTR _glob$[ebp], 0
je SHORT $LN44@xmlExpDump
; 8116 : xmlBufferWriteChar(buf, ")");
push OFFSET ??_C@_01PKGAHCOL@?$CJ@
push esi
call _xmlBufferWriteChar
add esp, 8
$LN44@xmlExpDump:
pop esi
$LN38@xmlExpDump:
pop edi
; 8117 : }
mov esp, ebp
pop ebp
ret 0
$LN48@xmlExpDump:
DD $LN6@xmlExpDump
DD $LN7@xmlExpDump
DD $LN8@xmlExpDump
DD $LN9@xmlExpDump
DD $LN16@xmlExpDump
DD $LN23@xmlExpDump
_xmlExpDumpInt ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpParseSeq
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlExpParseSeq PROC ; COMDAT
; 7970 : xmlExpParseSeq(xmlExpCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
push esi
call _xmlExpParseOr
mov ecx, DWORD PTR [esi+28]
add esp, 4
mov edi, eax
$LL2@xmlExpPars:
; 7971 : xmlExpNodePtr ret, right;
; 7972 :
; 7973 : ret = xmlExpParseOr(ctxt);
; 7974 : SKIP_BLANKS
mov dl, BYTE PTR [ecx]
cmp dl, 32 ; 00000020H
je SHORT $LN6@xmlExpPars
cmp dl, 10 ; 0000000aH
je SHORT $LN6@xmlExpPars
cmp dl, 13 ; 0000000dH
je SHORT $LN6@xmlExpPars
cmp dl, 9
jne SHORT $LN12@xmlExpPars
$LN6@xmlExpPars:
inc ecx
mov DWORD PTR [esi+28], ecx
jmp SHORT $LL2@xmlExpPars
$LN12@xmlExpPars:
; 7975 : while (CUR == '|') {
cmp dl, 124 ; 0000007cH
jne SHORT $LN5@xmlExpPars
$LL4@xmlExpPars:
; 7976 : NEXT
lea eax, DWORD PTR [ecx+1]
; 7977 : right = xmlExpParseOr(ctxt);
push esi
mov DWORD PTR [esi+28], eax
call _xmlExpParseOr
add esp, 4
; 7978 : if (right == NULL) {
test eax, eax
je SHORT $LN13@xmlExpPars
; 7980 : return(NULL);
; 7981 : }
; 7982 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, right, NULL, 0, 0);
push 0
push 0
push 0
push eax
push edi
push 4
push esi
call _xmlExpHashGetEntry
mov edi, eax
add esp, 28 ; 0000001cH
; 7983 : if (ret == NULL)
test edi, edi
je SHORT $LN14@xmlExpPars
; 7975 : while (CUR == '|') {
mov ecx, DWORD PTR [esi+28]
cmp BYTE PTR [ecx], 124 ; 0000007cH
je SHORT $LL4@xmlExpPars
$LN5@xmlExpPars:
; 7984 : return(NULL);
; 7985 : }
; 7986 : return(ret);
mov eax, edi
pop edi
; 7987 : }
pop esi
pop ebp
ret 0
$LN13@xmlExpPars:
; 7979 : xmlExpFree(ctxt, ret);
push edi
push esi
call _xmlExpFree
add esp, 8
$LN14@xmlExpPars:
; 7987 : }
pop edi
xor eax, eax
pop esi
pop ebp
ret 0
_xmlExpParseSeq ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpParseOr
_TEXT SEGMENT
tv3237 = 8 ; size = 4
tv3230 = 8 ; size = 4
tv3227 = 8 ; size = 4
_ctxt$ = 8 ; size = 4
_xmlExpParseOr PROC ; COMDAT
; 7893 : xmlExpParseOr(xmlExpCtxtPtr ctxt) {
push ebp
mov ebp, esp
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
mov ebx, DWORD PTR [esi+28]
$LN491@xmlExpPars:
; 7894 : const char *base;
; 7895 : xmlExpNodePtr ret;
; 7896 : const xmlChar *val;
; 7897 :
; 7898 : SKIP_BLANKS
mov al, BYTE PTR [ebx]
mov ecx, ebx
cmp al, 32 ; 00000020H
je SHORT $LN24@xmlExpPars
cmp al, 10 ; 0000000aH
je SHORT $LN24@xmlExpPars
cmp al, 13 ; 0000000dH
je SHORT $LN24@xmlExpPars
cmp al, 9
jne SHORT $LN3@xmlExpPars
$LN24@xmlExpPars:
inc ebx
mov DWORD PTR [esi+28], ebx
jmp SHORT $LN491@xmlExpPars
$LN3@xmlExpPars:
; 7899 : base = ctxt->cur;
; 7900 : if (*ctxt->cur == '(') {
cmp al, 40 ; 00000028H
jne $LN357@xmlExpPars
; 7901 : NEXT
lea eax, DWORD PTR [ebx+1]
; 7902 : ret = xmlExpParseExpr(ctxt);
push esi
mov DWORD PTR [esi+28], eax
call _xmlExpParseExpr
mov ecx, DWORD PTR [esi+28]
add esp, 4
mov edi, eax
npad 4
$LL4@xmlExpPars:
; 7903 : SKIP_BLANKS
mov al, BYTE PTR [ecx]
cmp al, 32 ; 00000020H
je SHORT $LN26@xmlExpPars
cmp al, 10 ; 0000000aH
je SHORT $LN26@xmlExpPars
cmp al, 13 ; 0000000dH
je SHORT $LN26@xmlExpPars
cmp al, 9
jne SHORT $LN5@xmlExpPars
$LN26@xmlExpPars:
inc ecx
mov DWORD PTR [esi+28], ecx
jmp SHORT $LL4@xmlExpPars
$LN5@xmlExpPars:
; 7904 : if (*ctxt->cur != ')') {
cmp al, 41 ; 00000029H
je SHORT $LN27@xmlExpPars
; 7905 : fprintf(stderr, "unbalanced '(' : %s\n", base);
push ebx
push OFFSET ??_C@_0BF@FNELPLND@unbalanced?5?8?$CI?8?5?3?5?$CFs?6@
push 2
call DWORD PTR __imp____acrt_iob_func
add esp, 4
push eax
call _fprintf
; 7906 : xmlExpFree(ctxt, ret);
push edi
push esi
call _xmlExpFree
add esp, 20 ; 00000014H
$LN442@xmlExpPars:
; 7966 : }
pop edi
pop esi
xor eax, eax
pop ebx
pop ebp
ret 0
$LN27@xmlExpPars:
; 7907 : return(NULL);
; 7908 : }
; 7909 : NEXT;
; 7910 : SKIP_BLANKS
inc ecx
mov DWORD PTR [esi+28], ecx
mov al, BYTE PTR [ecx]
cmp al, 32 ; 00000020H
je SHORT $LN27@xmlExpPars
cmp al, 10 ; 0000000aH
je SHORT $LN27@xmlExpPars
cmp al, 13 ; 0000000dH
je SHORT $LN27@xmlExpPars
cmp al, 9
je SHORT $LN27@xmlExpPars
$parse_quantifier$493:
; 7924 : parse_quantifier:
; 7925 : if (CUR == '{') {
cmp al, 123 ; 0000007bH
jne $LN32@xmlExpPars
; 7926 : int min, max;
; 7927 :
; 7928 : NEXT
lea eax, DWORD PTR [ecx+1]
; 7929 : min = xmlExpParseNumber(ctxt);
push esi
mov DWORD PTR [esi+28], eax
call _xmlExpParseNumber
mov ebx, eax
add esp, 4
; 7930 : if (min < 0) {
test ebx, ebx
js $LN441@xmlExpPars
mov eax, DWORD PTR [esi+28]
npad 2
$LL12@xmlExpPars:
; 7931 : xmlExpFree(ctxt, ret);
; 7932 : return(NULL);
; 7933 : }
; 7934 : SKIP_BLANKS
mov cl, BYTE PTR [eax]
cmp cl, 32 ; 00000020H
je SHORT $LN35@xmlExpPars
cmp cl, 10 ; 0000000aH
je SHORT $LN35@xmlExpPars
cmp cl, 13 ; 0000000dH
je SHORT $LN35@xmlExpPars
cmp cl, 9
jne $LN13@xmlExpPars
$LN35@xmlExpPars:
inc eax
mov DWORD PTR [esi+28], eax
jmp SHORT $LL12@xmlExpPars
$LN357@xmlExpPars:
; 7911 : goto parse_quantifier;
; 7912 : }
; 7913 : while ((CUR != 0) && (!(IS_BLANK(CUR))) && (CUR != '(') &&
; 7914 : (CUR != ')') && (CUR != '|') && (CUR != ',') && (CUR != '{') &&
; 7915 : (CUR != '*') && (CUR != '+') && (CUR != '?') && (CUR != '}'))
test al, al
je SHORT $LN483@xmlExpPars
mov edi, ebx
$LL8@xmlExpPars:
mov edx, ecx
cmp al, 32 ; 00000020H
je SHORT $LN483@xmlExpPars
cmp al, 10 ; 0000000aH
je SHORT $LN483@xmlExpPars
cmp al, 13 ; 0000000dH
je SHORT $LN483@xmlExpPars
cmp al, 9
je SHORT $LN483@xmlExpPars
cmp al, 40 ; 00000028H
je SHORT $LN483@xmlExpPars
cmp al, 41 ; 00000029H
je SHORT $LN483@xmlExpPars
cmp al, 124 ; 0000007cH
je SHORT $LN483@xmlExpPars
cmp al, 44 ; 0000002cH
je SHORT $LN483@xmlExpPars
cmp al, 123 ; 0000007bH
je SHORT $LN483@xmlExpPars
cmp al, 42 ; 0000002aH
je SHORT $LN483@xmlExpPars
cmp al, 43 ; 0000002bH
je SHORT $LN483@xmlExpPars
cmp al, 63 ; 0000003fH
je SHORT $LN483@xmlExpPars
cmp al, 125 ; 0000007dH
je SHORT $LN483@xmlExpPars
; 7916 : NEXT;
lea ecx, DWORD PTR [edi+1]
mov DWORD PTR [esi+28], ecx
mov edi, ecx
mov al, BYTE PTR [ecx]
test al, al
jne SHORT $LL8@xmlExpPars
$LN483@xmlExpPars:
; 7917 : val = xmlDictLookup(ctxt->dict, BAD_CAST base, ctxt->cur - base);
sub ecx, ebx
push ecx
push ebx
push DWORD PTR [esi]
call _xmlDictLookup
add esp, 12 ; 0000000cH
; 7918 : if (val == NULL)
test eax, eax
je $LN442@xmlExpPars
; 7919 : return(NULL);
; 7920 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_ATOM, NULL, NULL, val, 0, 0);
push 0
push 0
push eax
push 0
push 0
push 2
push esi
call _xmlExpHashGetEntry
mov edi, eax
add esp, 28 ; 0000001cH
; 7921 : if (ret == NULL)
test edi, edi
je $LN442@xmlExpPars
npad 2
$LL10@xmlExpPars:
; 7922 : return(NULL);
; 7923 : SKIP_BLANKS
mov ecx, DWORD PTR [esi+28]
mov al, BYTE PTR [ecx]
cmp al, 32 ; 00000020H
je SHORT $LN31@xmlExpPars
cmp al, 10 ; 0000000aH
je SHORT $LN31@xmlExpPars
cmp al, 13 ; 0000000dH
je SHORT $LN31@xmlExpPars
cmp al, 9
jne $parse_quantifier$493
$LN31@xmlExpPars:
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+28], eax
jmp SHORT $LL10@xmlExpPars
$LN13@xmlExpPars:
; 7935 : if (CUR == ',') {
cmp cl, 44 ; 0000002cH
jne SHORT $LN36@xmlExpPars
; 7936 : NEXT
inc eax
; 7937 : max = xmlExpParseNumber(ctxt);
push esi
mov DWORD PTR [esi+28], eax
call _xmlExpParseNumber
mov edx, eax
add esp, 4
mov eax, DWORD PTR [esi+28]
$LL14@xmlExpPars:
; 7938 : SKIP_BLANKS
mov cl, BYTE PTR [eax]
cmp cl, 32 ; 00000020H
je SHORT $LN38@xmlExpPars
cmp cl, 10 ; 0000000aH
je SHORT $LN38@xmlExpPars
cmp cl, 13 ; 0000000dH
je SHORT $LN38@xmlExpPars
cmp cl, 9
jne SHORT $LN37@xmlExpPars
$LN38@xmlExpPars:
inc eax
mov DWORD PTR [esi+28], eax
jmp SHORT $LL14@xmlExpPars
$LN36@xmlExpPars:
; 7939 : } else
; 7940 : max = min;
mov edx, ebx
$LN37@xmlExpPars:
; 7941 : if (CUR != '}') {
cmp cl, 125 ; 0000007dH
jne SHORT $LN441@xmlExpPars
; 7943 : return(NULL);
; 7944 : }
; 7945 : NEXT
; 7946 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
push edx
push ebx
push 0
push 0
push edi
inc eax
push 5
push esi
mov DWORD PTR [esi+28], eax
call _xmlExpHashGetEntry
mov ecx, DWORD PTR [esi+28]
add esp, 28 ; 0000001cH
mov edi, eax
$LL16@xmlExpPars:
; 7947 : min, max);
; 7948 : SKIP_BLANKS
mov al, BYTE PTR [ecx]
cmp al, 32 ; 00000020H
je SHORT $LN40@xmlExpPars
cmp al, 10 ; 0000000aH
je SHORT $LN40@xmlExpPars
cmp al, 13 ; 0000000dH
je SHORT $LN40@xmlExpPars
cmp al, 9
jne $LN485@xmlExpPars
$LN40@xmlExpPars:
inc ecx
mov DWORD PTR [esi+28], ecx
jmp SHORT $LL16@xmlExpPars
$LN441@xmlExpPars:
; 7942 : xmlExpFree(ctxt, ret);
push edi
push esi
call _xmlExpFree
add esp, 8
; 7966 : }
xor eax, eax
pop edi
pop esi
pop ebx
pop ebp
ret 0
$LN32@xmlExpPars:
; 7949 : } else if (CUR == '?') {
cmp al, 63 ; 0000003fH
jne $LN41@xmlExpPars
; 7950 : NEXT
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+28], eax
; 6604 : kbase += left->key;
mov ax, WORD PTR [edi+2]
inc ax
movzx ebx, ax
; 6605 : } else if (type == XML_EXP_OR) {
; 6606 : /* Forbid reduction rules */
; 6607 : if (left->type == XML_EXP_FORBID) {
; 6608 : xmlExpFree(ctxt, left);
; 6609 : return(right);
; 6610 : }
; 6611 : if (right->type == XML_EXP_FORBID) {
; 6612 : xmlExpFree(ctxt, right);
; 6613 : return(left);
; 6614 : }
; 6615 :
; 6616 : /* OR reduction rule 1 */
; 6617 : /* a | a reduced to a */
; 6618 : if (left == right) {
; 6619 : left->ref--;
; 6620 : return(left);
; 6621 : }
; 6622 : /* OR canonicalization rule 1 */
; 6623 : /* linearize (a | b) | c into a | (b | c) */
; 6624 : if ((left->type == XML_EXP_OR) && (right->type != XML_EXP_OR)) {
; 6625 : xmlExpNodePtr tmp = left;
; 6626 : left = right;
; 6627 : right = tmp;
; 6628 : }
; 6629 : /* OR reduction rule 2 */
; 6630 : /* a | (a | b) and b | (a | b) are reduced to a | b */
; 6631 : if (right->type == XML_EXP_OR) {
; 6632 : if ((left == right->exp_left) ||
; 6633 : (left == right->exp_right)) {
; 6634 : xmlExpFree(ctxt, left);
; 6635 : return(right);
; 6636 : }
; 6637 : }
; 6638 : /* OR canonicalization rule 2 */
; 6639 : /* linearize (a | b) | c into a | (b | c) */
; 6640 : if (left->type == XML_EXP_OR) {
; 6641 : xmlExpNodePtr tmp;
; 6642 :
; 6643 : /* OR canonicalization rule 2 */
; 6644 : if ((left->exp_right->type != XML_EXP_OR) &&
; 6645 : (left->exp_right->key < left->exp_left->key)) {
; 6646 : tmp = left->exp_right;
; 6647 : left->exp_right = left->exp_left;
; 6648 : left->exp_left = tmp;
; 6649 : }
; 6650 : left->exp_right->ref++;
; 6651 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_right, right,
; 6652 : NULL, 0, 0);
; 6653 : left->exp_left->ref++;
; 6654 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_left, tmp,
; 6655 : NULL, 0, 0);
; 6656 :
; 6657 : xmlExpFree(ctxt, left);
; 6658 : return(tmp);
; 6659 : }
; 6660 : if (right->type == XML_EXP_OR) {
; 6661 : /* Ordering in the tree */
; 6662 : /* C | (A | B) -> A | (B | C) */
; 6663 : if (left->key > right->exp_right->key) {
; 6664 : xmlExpNodePtr tmp;
; 6665 : right->exp_right->ref++;
; 6666 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_right,
; 6667 : left, NULL, 0, 0);
; 6668 : right->exp_left->ref++;
; 6669 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
; 6670 : tmp, NULL, 0, 0);
; 6671 : xmlExpFree(ctxt, right);
; 6672 : return(tmp);
; 6673 : }
; 6674 : /* Ordering in the tree */
; 6675 : /* B | (A | C) -> A | (B | C) */
; 6676 : if (left->key > right->exp_left->key) {
; 6677 : xmlExpNodePtr tmp;
; 6678 : right->exp_right->ref++;
; 6679 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left,
; 6680 : right->exp_right, NULL, 0, 0);
; 6681 : right->exp_left->ref++;
; 6682 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
; 6683 : tmp, NULL, 0, 0);
; 6684 : xmlExpFree(ctxt, right);
; 6685 : return(tmp);
; 6686 : }
; 6687 : }
; 6688 : /* we know both types are != XML_EXP_OR here */
; 6689 : else if (left->key > right->key) {
; 6690 : xmlExpNodePtr tmp = left;
; 6691 : left = right;
; 6692 : right = tmp;
; 6693 : }
; 6694 : kbase = xmlExpHashComputeKey(type, left, right);
; 6695 : } else if (type == XML_EXP_SEQ) {
; 6696 : /* Forbid reduction rules */
; 6697 : if (left->type == XML_EXP_FORBID) {
; 6698 : xmlExpFree(ctxt, right);
; 6699 : return(left);
; 6700 : }
; 6701 : if (right->type == XML_EXP_FORBID) {
; 6702 : xmlExpFree(ctxt, left);
; 6703 : return(right);
; 6704 : }
; 6705 : /* Empty reduction rules */
; 6706 : if (right->type == XML_EXP_EMPTY) {
; 6707 : return(left);
; 6708 : }
; 6709 : if (left->type == XML_EXP_EMPTY) {
; 6710 : return(right);
; 6711 : }
; 6712 : kbase = xmlExpHashComputeKey(type, left, right);
; 6713 : } else
; 6714 : return(NULL);
; 6715 :
; 6716 : key = kbase % ctxt->size;
mov eax, ebx
cdq
idiv DWORD PTR [esi+8]
; 6717 : if (ctxt->table[key] != NULL) {
mov eax, DWORD PTR [esi+4]
movzx ecx, dx
shl ecx, 2
mov DWORD PTR tv3237[ebp], ecx
mov eax, DWORD PTR [ecx+eax]
test eax, eax
je SHORT $LN464@xmlExpPars
$LL71@xmlExpPars:
; 6720 : if ((insert->key == kbase) &&
cmp WORD PTR [eax+2], bx
jne SHORT $LN69@xmlExpPars
cmp BYTE PTR [eax], 5
jne SHORT $LN69@xmlExpPars
; 6721 : (insert->type == type)) {
; 6722 : if (type == XML_EXP_ATOM) {
; 6723 : if (name == insert->exp_str) {
; 6724 : insert->ref++;
; 6725 : return(insert);
; 6726 : }
; 6727 : } else if (type == XML_EXP_COUNT) {
; 6728 : if ((insert->exp_min == min) && (insert->exp_max == max) &&
cmp DWORD PTR [eax+20], 0
jne SHORT $LN69@xmlExpPars
cmp DWORD PTR [eax+24], 1
jne SHORT $LN69@xmlExpPars
cmp DWORD PTR [eax+12], edi
je $LN368@xmlExpPars
$LN69@xmlExpPars:
; 6718 : for (insert = ctxt->table[key]; insert != NULL;
; 6719 : insert = insert->next) {
mov eax, DWORD PTR [eax+16]
test eax, eax
jne SHORT $LL71@xmlExpPars
$LN464@xmlExpPars:
; 6545 : if (ctxt->nb_nodes >= MAX_NODES)
cmp DWORD PTR [esi+16], 10000 ; 00002710H
jge SHORT $LN423@xmlExpPars
; 6546 : return(NULL);
; 6547 : ret = (xmlExpNodePtr) xmlMalloc(sizeof(xmlExpNode));
push 28 ; 0000001cH
call DWORD PTR _xmlMalloc
mov ecx, eax
add esp, 4
; 6548 : if (ret == NULL)
test ecx, ecx
je SHORT $LN423@xmlExpPars
xorps xmm0, xmm0
; 6549 : return(NULL);
; 6550 : memset(ret, 0, sizeof(xmlExpNode));
movups XMMWORD PTR [ecx], xmm0
movq QWORD PTR [ecx+16], xmm0
mov DWORD PTR [ecx+24], 0
; 6551 : ret->type = type;
mov BYTE PTR [ecx], 5
; 6552 : ret->next = NULL;
; 6553 : ctxt->nb_nodes++;
inc DWORD PTR [esi+16]
; 6554 : ctxt->nb_cons++;
inc DWORD PTR [esi+32]
; 6757 : entry->info |= XML_EXP_NILABLE;
or BYTE PTR [ecx+1], 1
mov DWORD PTR [ecx+12], edi
mov WORD PTR [ecx+2], bx
mov DWORD PTR [ecx+20], 0
mov DWORD PTR [ecx+24], 1
; 6758 : if (max < 0)
; 6759 : entry->c_max = -1;
; 6760 : else
; 6761 : entry->c_max = max * entry->exp_left->c_max;
mov eax, DWORD PTR [edi+8]
; 6762 : } else {
; 6763 : entry->exp_left = left;
; 6764 : entry->exp_right = right;
; 6765 : if (type == XML_EXP_OR) {
; 6766 : if ((IS_NILLABLE(left)) || (IS_NILLABLE(right)))
; 6767 : entry->info |= XML_EXP_NILABLE;
; 6768 : if ((entry->exp_left->c_max == -1) ||
; 6769 : (entry->exp_right->c_max == -1))
; 6770 : entry->c_max = -1;
; 6771 : else if (entry->exp_left->c_max > entry->exp_right->c_max)
; 6772 : entry->c_max = entry->exp_left->c_max;
; 6773 : else
; 6774 : entry->c_max = entry->exp_right->c_max;
; 6775 : } else {
; 6776 : if ((IS_NILLABLE(left)) && (IS_NILLABLE(right)))
; 6777 : entry->info |= XML_EXP_NILABLE;
; 6778 : if ((entry->exp_left->c_max == -1) ||
; 6779 : (entry->exp_right->c_max == -1))
; 6780 : entry->c_max = -1;
; 6781 : else
; 6782 : entry->c_max = entry->exp_left->c_max + entry->exp_right->c_max;
; 6783 : }
; 6784 : }
; 6785 : entry->ref = 1;
; 6786 : if (ctxt->table[key] != NULL)
mov edi, DWORD PTR tv3237[ebp]
mov DWORD PTR [ecx+8], eax
mov DWORD PTR [ecx+4], 1
mov eax, DWORD PTR [esi+4]
mov edx, DWORD PTR [edi+eax]
test edx, edx
je SHORT $LN136@xmlExpPars
; 6787 : entry->next = ctxt->table[key];
mov DWORD PTR [ecx+16], edx
mov eax, DWORD PTR [esi+4]
$LN136@xmlExpPars:
; 6788 :
; 6789 : ctxt->table[key] = entry;
mov DWORD PTR [eax+edi], ecx
; 6790 : ctxt->nbElems++;
; 6791 :
; 6792 : return(entry);
mov edi, ecx
inc DWORD PTR [esi+12]
jmp SHORT $LL18@xmlExpPars
$LN368@xmlExpPars:
; 6729 : (insert->exp_left == left)) {
; 6730 : insert->ref++;
inc DWORD PTR [eax+4]
; 6731 : left->ref--;
dec DWORD PTR [edi+4]
; 6732 : return(insert);
mov edi, eax
jmp SHORT $LL18@xmlExpPars
$LN423@xmlExpPars:
; 6733 : }
; 6734 : } else if ((insert->exp_left == left) &&
; 6735 : (insert->exp_right == right)) {
; 6736 : insert->ref++;
; 6737 : left->ref--;
; 6738 : right->ref--;
; 6739 : return(insert);
; 6740 : }
; 6741 : }
; 6742 : }
; 6743 : }
; 6744 :
; 6745 : entry = xmlExpNewNode(ctxt, type);
; 6746 : if (entry == NULL)
; 6747 : return(NULL);
xor edi, edi
npad 2
$LL18@xmlExpPars:
; 7951 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
; 7952 : 0, 1);
; 7953 : SKIP_BLANKS
mov ecx, DWORD PTR [esi+28]
mov al, BYTE PTR [ecx]
cmp al, 32 ; 00000020H
je SHORT $LN43@xmlExpPars
cmp al, 10 ; 0000000aH
je SHORT $LN43@xmlExpPars
cmp al, 13 ; 0000000dH
je SHORT $LN43@xmlExpPars
cmp al, 9
jne $LN485@xmlExpPars
$LN43@xmlExpPars:
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+28], eax
jmp SHORT $LL18@xmlExpPars
$LN41@xmlExpPars:
; 7954 : } else if (CUR == '+') {
cmp al, 43 ; 0000002bH
jne $LN44@xmlExpPars
; 7955 : NEXT
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+28], eax
; 6604 : kbase += left->key;
mov ax, WORD PTR [edi+2]
add ax, 80 ; 00000050H
movzx ebx, ax
; 6605 : } else if (type == XML_EXP_OR) {
; 6606 : /* Forbid reduction rules */
; 6607 : if (left->type == XML_EXP_FORBID) {
; 6608 : xmlExpFree(ctxt, left);
; 6609 : return(right);
; 6610 : }
; 6611 : if (right->type == XML_EXP_FORBID) {
; 6612 : xmlExpFree(ctxt, right);
; 6613 : return(left);
; 6614 : }
; 6615 :
; 6616 : /* OR reduction rule 1 */
; 6617 : /* a | a reduced to a */
; 6618 : if (left == right) {
; 6619 : left->ref--;
; 6620 : return(left);
; 6621 : }
; 6622 : /* OR canonicalization rule 1 */
; 6623 : /* linearize (a | b) | c into a | (b | c) */
; 6624 : if ((left->type == XML_EXP_OR) && (right->type != XML_EXP_OR)) {
; 6625 : xmlExpNodePtr tmp = left;
; 6626 : left = right;
; 6627 : right = tmp;
; 6628 : }
; 6629 : /* OR reduction rule 2 */
; 6630 : /* a | (a | b) and b | (a | b) are reduced to a | b */
; 6631 : if (right->type == XML_EXP_OR) {
; 6632 : if ((left == right->exp_left) ||
; 6633 : (left == right->exp_right)) {
; 6634 : xmlExpFree(ctxt, left);
; 6635 : return(right);
; 6636 : }
; 6637 : }
; 6638 : /* OR canonicalization rule 2 */
; 6639 : /* linearize (a | b) | c into a | (b | c) */
; 6640 : if (left->type == XML_EXP_OR) {
; 6641 : xmlExpNodePtr tmp;
; 6642 :
; 6643 : /* OR canonicalization rule 2 */
; 6644 : if ((left->exp_right->type != XML_EXP_OR) &&
; 6645 : (left->exp_right->key < left->exp_left->key)) {
; 6646 : tmp = left->exp_right;
; 6647 : left->exp_right = left->exp_left;
; 6648 : left->exp_left = tmp;
; 6649 : }
; 6650 : left->exp_right->ref++;
; 6651 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_right, right,
; 6652 : NULL, 0, 0);
; 6653 : left->exp_left->ref++;
; 6654 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_left, tmp,
; 6655 : NULL, 0, 0);
; 6656 :
; 6657 : xmlExpFree(ctxt, left);
; 6658 : return(tmp);
; 6659 : }
; 6660 : if (right->type == XML_EXP_OR) {
; 6661 : /* Ordering in the tree */
; 6662 : /* C | (A | B) -> A | (B | C) */
; 6663 : if (left->key > right->exp_right->key) {
; 6664 : xmlExpNodePtr tmp;
; 6665 : right->exp_right->ref++;
; 6666 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_right,
; 6667 : left, NULL, 0, 0);
; 6668 : right->exp_left->ref++;
; 6669 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
; 6670 : tmp, NULL, 0, 0);
; 6671 : xmlExpFree(ctxt, right);
; 6672 : return(tmp);
; 6673 : }
; 6674 : /* Ordering in the tree */
; 6675 : /* B | (A | C) -> A | (B | C) */
; 6676 : if (left->key > right->exp_left->key) {
; 6677 : xmlExpNodePtr tmp;
; 6678 : right->exp_right->ref++;
; 6679 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left,
; 6680 : right->exp_right, NULL, 0, 0);
; 6681 : right->exp_left->ref++;
; 6682 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
; 6683 : tmp, NULL, 0, 0);
; 6684 : xmlExpFree(ctxt, right);
; 6685 : return(tmp);
; 6686 : }
; 6687 : }
; 6688 : /* we know both types are != XML_EXP_OR here */
; 6689 : else if (left->key > right->key) {
; 6690 : xmlExpNodePtr tmp = left;
; 6691 : left = right;
; 6692 : right = tmp;
; 6693 : }
; 6694 : kbase = xmlExpHashComputeKey(type, left, right);
; 6695 : } else if (type == XML_EXP_SEQ) {
; 6696 : /* Forbid reduction rules */
; 6697 : if (left->type == XML_EXP_FORBID) {
; 6698 : xmlExpFree(ctxt, right);
; 6699 : return(left);
; 6700 : }
; 6701 : if (right->type == XML_EXP_FORBID) {
; 6702 : xmlExpFree(ctxt, left);
; 6703 : return(right);
; 6704 : }
; 6705 : /* Empty reduction rules */
; 6706 : if (right->type == XML_EXP_EMPTY) {
; 6707 : return(left);
; 6708 : }
; 6709 : if (left->type == XML_EXP_EMPTY) {
; 6710 : return(right);
; 6711 : }
; 6712 : kbase = xmlExpHashComputeKey(type, left, right);
; 6713 : } else
; 6714 : return(NULL);
; 6715 :
; 6716 : key = kbase % ctxt->size;
mov eax, ebx
cdq
idiv DWORD PTR [esi+8]
; 6717 : if (ctxt->table[key] != NULL) {
mov eax, DWORD PTR [esi+4]
movzx ecx, dx
shl ecx, 2
mov DWORD PTR tv3230[ebp], ecx
mov eax, DWORD PTR [ecx+eax]
test eax, eax
je SHORT $LN465@xmlExpPars
$LL166@xmlExpPars:
; 6720 : if ((insert->key == kbase) &&
cmp WORD PTR [eax+2], bx
jne SHORT $LN164@xmlExpPars
cmp BYTE PTR [eax], 5
jne SHORT $LN164@xmlExpPars
; 6721 : (insert->type == type)) {
; 6722 : if (type == XML_EXP_ATOM) {
; 6723 : if (name == insert->exp_str) {
; 6724 : insert->ref++;
; 6725 : return(insert);
; 6726 : }
; 6727 : } else if (type == XML_EXP_COUNT) {
; 6728 : if ((insert->exp_min == min) && (insert->exp_max == max) &&
cmp DWORD PTR [eax+20], 1
jne SHORT $LN164@xmlExpPars
cmp DWORD PTR [eax+24], -1
jne SHORT $LN164@xmlExpPars
cmp DWORD PTR [eax+12], edi
je $LN369@xmlExpPars
$LN164@xmlExpPars:
; 6718 : for (insert = ctxt->table[key]; insert != NULL;
; 6719 : insert = insert->next) {
mov eax, DWORD PTR [eax+16]
test eax, eax
jne SHORT $LL166@xmlExpPars
$LN465@xmlExpPars:
; 6545 : if (ctxt->nb_nodes >= MAX_NODES)
cmp DWORD PTR [esi+16], 10000 ; 00002710H
jge SHORT $LN424@xmlExpPars
; 6546 : return(NULL);
; 6547 : ret = (xmlExpNodePtr) xmlMalloc(sizeof(xmlExpNode));
push 28 ; 0000001cH
call DWORD PTR _xmlMalloc
add esp, 4
; 6548 : if (ret == NULL)
test eax, eax
je SHORT $LN424@xmlExpPars
xorps xmm0, xmm0
; 6549 : return(NULL);
; 6550 : memset(ret, 0, sizeof(xmlExpNode));
movups XMMWORD PTR [eax], xmm0
movq QWORD PTR [eax+16], xmm0
mov DWORD PTR [eax+24], 0
; 6551 : ret->type = type;
mov BYTE PTR [eax], 5
; 6552 : ret->next = NULL;
; 6553 : ctxt->nb_nodes++;
inc DWORD PTR [esi+16]
; 6554 : ctxt->nb_cons++;
inc DWORD PTR [esi+32]
; 6748 : entry->key = kbase;
mov WORD PTR [eax+2], bx
; 6749 : if (type == XML_EXP_ATOM) {
; 6750 : entry->exp_str = name;
; 6751 : entry->c_max = 1;
; 6752 : } else if (type == XML_EXP_COUNT) {
; 6753 : entry->exp_min = min;
mov DWORD PTR [eax+20], 1
; 6754 : entry->exp_max = max;
mov DWORD PTR [eax+24], -1
; 6755 : entry->exp_left = left;
mov DWORD PTR [eax+12], edi
; 6756 : if ((min == 0) || (IS_NILLABLE(left)))
test BYTE PTR [edi+1], 1
je SHORT $LN214@xmlExpPars
; 6757 : entry->info |= XML_EXP_NILABLE;
or BYTE PTR [eax+1], 1
$LN214@xmlExpPars:
; 6762 : } else {
; 6763 : entry->exp_left = left;
; 6764 : entry->exp_right = right;
; 6765 : if (type == XML_EXP_OR) {
; 6766 : if ((IS_NILLABLE(left)) || (IS_NILLABLE(right)))
; 6767 : entry->info |= XML_EXP_NILABLE;
; 6768 : if ((entry->exp_left->c_max == -1) ||
; 6769 : (entry->exp_right->c_max == -1))
; 6770 : entry->c_max = -1;
; 6771 : else if (entry->exp_left->c_max > entry->exp_right->c_max)
; 6772 : entry->c_max = entry->exp_left->c_max;
; 6773 : else
; 6774 : entry->c_max = entry->exp_right->c_max;
; 6775 : } else {
; 6776 : if ((IS_NILLABLE(left)) && (IS_NILLABLE(right)))
; 6777 : entry->info |= XML_EXP_NILABLE;
; 6778 : if ((entry->exp_left->c_max == -1) ||
; 6779 : (entry->exp_right->c_max == -1))
; 6780 : entry->c_max = -1;
; 6781 : else
; 6782 : entry->c_max = entry->exp_left->c_max + entry->exp_right->c_max;
; 6783 : }
; 6784 : }
; 6785 : entry->ref = 1;
; 6786 : if (ctxt->table[key] != NULL)
mov edi, DWORD PTR tv3230[ebp]
mov DWORD PTR [eax+8], -1
mov DWORD PTR [eax+4], 1
mov ecx, DWORD PTR [esi+4]
mov edx, DWORD PTR [edi+ecx]
test edx, edx
je SHORT $LN231@xmlExpPars
; 6787 : entry->next = ctxt->table[key];
mov DWORD PTR [eax+16], edx
mov ecx, DWORD PTR [esi+4]
$LN231@xmlExpPars:
; 6788 :
; 6789 : ctxt->table[key] = entry;
mov DWORD PTR [ecx+edi], eax
; 6790 : ctxt->nbElems++;
; 6791 :
; 6792 : return(entry);
mov edi, eax
inc DWORD PTR [esi+12]
jmp SHORT $LN392@xmlExpPars
$LN369@xmlExpPars:
; 6729 : (insert->exp_left == left)) {
; 6730 : insert->ref++;
inc DWORD PTR [eax+4]
; 6731 : left->ref--;
dec DWORD PTR [edi+4]
; 6732 : return(insert);
mov edi, eax
jmp SHORT $LN392@xmlExpPars
$LN424@xmlExpPars:
; 6733 : }
; 6734 : } else if ((insert->exp_left == left) &&
; 6735 : (insert->exp_right == right)) {
; 6736 : insert->ref++;
; 6737 : left->ref--;
; 6738 : right->ref--;
; 6739 : return(insert);
; 6740 : }
; 6741 : }
; 6742 : }
; 6743 : }
; 6744 :
; 6745 : entry = xmlExpNewNode(ctxt, type);
; 6746 : if (entry == NULL)
; 6747 : return(NULL);
xor edi, edi
$LN392@xmlExpPars:
mov ecx, DWORD PTR [esi+28]
$LL20@xmlExpPars:
; 7956 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
; 7957 : 1, -1);
; 7958 : SKIP_BLANKS
mov al, BYTE PTR [ecx]
cmp al, 32 ; 00000020H
je SHORT $LN46@xmlExpPars
cmp al, 10 ; 0000000aH
je SHORT $LN46@xmlExpPars
cmp al, 13 ; 0000000dH
je SHORT $LN46@xmlExpPars
cmp al, 9
jne $LN485@xmlExpPars
$LN46@xmlExpPars:
inc ecx
mov DWORD PTR [esi+28], ecx
jmp SHORT $LL20@xmlExpPars
$LN44@xmlExpPars:
; 7959 : } else if (CUR == '*') {
cmp al, 42 ; 0000002aH
jne $LN485@xmlExpPars
; 7960 : NEXT
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+28], eax
; 6604 : kbase += left->key;
mov ax, WORD PTR [edi+2]
add ax, 79 ; 0000004fH
movzx ebx, ax
; 6605 : } else if (type == XML_EXP_OR) {
; 6606 : /* Forbid reduction rules */
; 6607 : if (left->type == XML_EXP_FORBID) {
; 6608 : xmlExpFree(ctxt, left);
; 6609 : return(right);
; 6610 : }
; 6611 : if (right->type == XML_EXP_FORBID) {
; 6612 : xmlExpFree(ctxt, right);
; 6613 : return(left);
; 6614 : }
; 6615 :
; 6616 : /* OR reduction rule 1 */
; 6617 : /* a | a reduced to a */
; 6618 : if (left == right) {
; 6619 : left->ref--;
; 6620 : return(left);
; 6621 : }
; 6622 : /* OR canonicalization rule 1 */
; 6623 : /* linearize (a | b) | c into a | (b | c) */
; 6624 : if ((left->type == XML_EXP_OR) && (right->type != XML_EXP_OR)) {
; 6625 : xmlExpNodePtr tmp = left;
; 6626 : left = right;
; 6627 : right = tmp;
; 6628 : }
; 6629 : /* OR reduction rule 2 */
; 6630 : /* a | (a | b) and b | (a | b) are reduced to a | b */
; 6631 : if (right->type == XML_EXP_OR) {
; 6632 : if ((left == right->exp_left) ||
; 6633 : (left == right->exp_right)) {
; 6634 : xmlExpFree(ctxt, left);
; 6635 : return(right);
; 6636 : }
; 6637 : }
; 6638 : /* OR canonicalization rule 2 */
; 6639 : /* linearize (a | b) | c into a | (b | c) */
; 6640 : if (left->type == XML_EXP_OR) {
; 6641 : xmlExpNodePtr tmp;
; 6642 :
; 6643 : /* OR canonicalization rule 2 */
; 6644 : if ((left->exp_right->type != XML_EXP_OR) &&
; 6645 : (left->exp_right->key < left->exp_left->key)) {
; 6646 : tmp = left->exp_right;
; 6647 : left->exp_right = left->exp_left;
; 6648 : left->exp_left = tmp;
; 6649 : }
; 6650 : left->exp_right->ref++;
; 6651 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_right, right,
; 6652 : NULL, 0, 0);
; 6653 : left->exp_left->ref++;
; 6654 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_left, tmp,
; 6655 : NULL, 0, 0);
; 6656 :
; 6657 : xmlExpFree(ctxt, left);
; 6658 : return(tmp);
; 6659 : }
; 6660 : if (right->type == XML_EXP_OR) {
; 6661 : /* Ordering in the tree */
; 6662 : /* C | (A | B) -> A | (B | C) */
; 6663 : if (left->key > right->exp_right->key) {
; 6664 : xmlExpNodePtr tmp;
; 6665 : right->exp_right->ref++;
; 6666 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_right,
; 6667 : left, NULL, 0, 0);
; 6668 : right->exp_left->ref++;
; 6669 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
; 6670 : tmp, NULL, 0, 0);
; 6671 : xmlExpFree(ctxt, right);
; 6672 : return(tmp);
; 6673 : }
; 6674 : /* Ordering in the tree */
; 6675 : /* B | (A | C) -> A | (B | C) */
; 6676 : if (left->key > right->exp_left->key) {
; 6677 : xmlExpNodePtr tmp;
; 6678 : right->exp_right->ref++;
; 6679 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left,
; 6680 : right->exp_right, NULL, 0, 0);
; 6681 : right->exp_left->ref++;
; 6682 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
; 6683 : tmp, NULL, 0, 0);
; 6684 : xmlExpFree(ctxt, right);
; 6685 : return(tmp);
; 6686 : }
; 6687 : }
; 6688 : /* we know both types are != XML_EXP_OR here */
; 6689 : else if (left->key > right->key) {
; 6690 : xmlExpNodePtr tmp = left;
; 6691 : left = right;
; 6692 : right = tmp;
; 6693 : }
; 6694 : kbase = xmlExpHashComputeKey(type, left, right);
; 6695 : } else if (type == XML_EXP_SEQ) {
; 6696 : /* Forbid reduction rules */
; 6697 : if (left->type == XML_EXP_FORBID) {
; 6698 : xmlExpFree(ctxt, right);
; 6699 : return(left);
; 6700 : }
; 6701 : if (right->type == XML_EXP_FORBID) {
; 6702 : xmlExpFree(ctxt, left);
; 6703 : return(right);
; 6704 : }
; 6705 : /* Empty reduction rules */
; 6706 : if (right->type == XML_EXP_EMPTY) {
; 6707 : return(left);
; 6708 : }
; 6709 : if (left->type == XML_EXP_EMPTY) {
; 6710 : return(right);
; 6711 : }
; 6712 : kbase = xmlExpHashComputeKey(type, left, right);
; 6713 : } else
; 6714 : return(NULL);
; 6715 :
; 6716 : key = kbase % ctxt->size;
mov eax, ebx
cdq
idiv DWORD PTR [esi+8]
; 6717 : if (ctxt->table[key] != NULL) {
mov eax, DWORD PTR [esi+4]
movzx ecx, dx
shl ecx, 2
mov DWORD PTR tv3227[ebp], ecx
mov eax, DWORD PTR [ecx+eax]
test eax, eax
je SHORT $LN466@xmlExpPars
$LL261@xmlExpPars:
; 6720 : if ((insert->key == kbase) &&
cmp WORD PTR [eax+2], bx
jne SHORT $LN259@xmlExpPars
cmp BYTE PTR [eax], 5
jne SHORT $LN259@xmlExpPars
; 6721 : (insert->type == type)) {
; 6722 : if (type == XML_EXP_ATOM) {
; 6723 : if (name == insert->exp_str) {
; 6724 : insert->ref++;
; 6725 : return(insert);
; 6726 : }
; 6727 : } else if (type == XML_EXP_COUNT) {
; 6728 : if ((insert->exp_min == min) && (insert->exp_max == max) &&
cmp DWORD PTR [eax+20], 0
jne SHORT $LN259@xmlExpPars
cmp DWORD PTR [eax+24], -1
jne SHORT $LN259@xmlExpPars
cmp DWORD PTR [eax+12], edi
je SHORT $LN370@xmlExpPars
$LN259@xmlExpPars:
; 6718 : for (insert = ctxt->table[key]; insert != NULL;
; 6719 : insert = insert->next) {
mov eax, DWORD PTR [eax+16]
test eax, eax
jne SHORT $LL261@xmlExpPars
$LN466@xmlExpPars:
; 6545 : if (ctxt->nb_nodes >= MAX_NODES)
cmp DWORD PTR [esi+16], 10000 ; 00002710H
jge SHORT $LN425@xmlExpPars
; 6546 : return(NULL);
; 6547 : ret = (xmlExpNodePtr) xmlMalloc(sizeof(xmlExpNode));
push 28 ; 0000001cH
call DWORD PTR _xmlMalloc
add esp, 4
; 6548 : if (ret == NULL)
test eax, eax
je SHORT $LN425@xmlExpPars
xorps xmm0, xmm0
; 6549 : return(NULL);
; 6550 : memset(ret, 0, sizeof(xmlExpNode));
movups XMMWORD PTR [eax], xmm0
movq QWORD PTR [eax+16], xmm0
mov DWORD PTR [eax+24], 0
; 6551 : ret->type = type;
mov BYTE PTR [eax], 5
; 6552 : ret->next = NULL;
; 6553 : ctxt->nb_nodes++;
inc DWORD PTR [esi+16]
; 6554 : ctxt->nb_cons++;
inc DWORD PTR [esi+32]
; 6757 : entry->info |= XML_EXP_NILABLE;
or BYTE PTR [eax+1], 1
mov DWORD PTR [eax+12], edi
; 6762 : } else {
; 6763 : entry->exp_left = left;
; 6764 : entry->exp_right = right;
; 6765 : if (type == XML_EXP_OR) {
; 6766 : if ((IS_NILLABLE(left)) || (IS_NILLABLE(right)))
; 6767 : entry->info |= XML_EXP_NILABLE;
; 6768 : if ((entry->exp_left->c_max == -1) ||
; 6769 : (entry->exp_right->c_max == -1))
; 6770 : entry->c_max = -1;
; 6771 : else if (entry->exp_left->c_max > entry->exp_right->c_max)
; 6772 : entry->c_max = entry->exp_left->c_max;
; 6773 : else
; 6774 : entry->c_max = entry->exp_right->c_max;
; 6775 : } else {
; 6776 : if ((IS_NILLABLE(left)) && (IS_NILLABLE(right)))
; 6777 : entry->info |= XML_EXP_NILABLE;
; 6778 : if ((entry->exp_left->c_max == -1) ||
; 6779 : (entry->exp_right->c_max == -1))
; 6780 : entry->c_max = -1;
; 6781 : else
; 6782 : entry->c_max = entry->exp_left->c_max + entry->exp_right->c_max;
; 6783 : }
; 6784 : }
; 6785 : entry->ref = 1;
; 6786 : if (ctxt->table[key] != NULL)
mov edi, DWORD PTR tv3227[ebp]
mov WORD PTR [eax+2], bx
mov DWORD PTR [eax+20], 0
mov DWORD PTR [eax+24], -1
mov DWORD PTR [eax+8], -1
mov DWORD PTR [eax+4], 1
mov ecx, DWORD PTR [esi+4]
mov edx, DWORD PTR [edi+ecx]
test edx, edx
je SHORT $LN326@xmlExpPars
; 6787 : entry->next = ctxt->table[key];
mov DWORD PTR [eax+16], edx
mov ecx, DWORD PTR [esi+4]
$LN326@xmlExpPars:
; 6788 :
; 6789 : ctxt->table[key] = entry;
mov DWORD PTR [ecx+edi], eax
; 6790 : ctxt->nbElems++;
; 6791 :
; 6792 : return(entry);
mov edi, eax
inc DWORD PTR [esi+12]
jmp SHORT $LL22@xmlExpPars
$LN370@xmlExpPars:
; 6729 : (insert->exp_left == left)) {
; 6730 : insert->ref++;
inc DWORD PTR [eax+4]
; 6731 : left->ref--;
dec DWORD PTR [edi+4]
; 6732 : return(insert);
mov edi, eax
jmp SHORT $LL22@xmlExpPars
$LN425@xmlExpPars:
; 6733 : }
; 6734 : } else if ((insert->exp_left == left) &&
; 6735 : (insert->exp_right == right)) {
; 6736 : insert->ref++;
; 6737 : left->ref--;
; 6738 : right->ref--;
; 6739 : return(insert);
; 6740 : }
; 6741 : }
; 6742 : }
; 6743 : }
; 6744 :
; 6745 : entry = xmlExpNewNode(ctxt, type);
; 6746 : if (entry == NULL)
; 6747 : return(NULL);
xor edi, edi
npad 6
$LL22@xmlExpPars:
; 7961 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, ret, NULL, NULL,
; 7962 : 0, -1);
; 7963 : SKIP_BLANKS
mov ecx, DWORD PTR [esi+28]
mov al, BYTE PTR [ecx]
cmp al, 32 ; 00000020H
je SHORT $LN48@xmlExpPars
cmp al, 10 ; 0000000aH
je SHORT $LN48@xmlExpPars
cmp al, 13 ; 0000000dH
je SHORT $LN48@xmlExpPars
cmp al, 9
jne SHORT $LN485@xmlExpPars
$LN48@xmlExpPars:
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+28], eax
jmp SHORT $LL22@xmlExpPars
$LN485@xmlExpPars:
; 7964 : }
; 7965 : return(ret);
mov eax, edi
pop edi
; 7966 : }
pop esi
pop ebx
pop ebp
ret 0
_xmlExpParseOr ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpParseNumber
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlExpParseNumber PROC ; COMDAT
; 7875 : xmlExpParseNumber(xmlExpCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
xor ecx, ecx
mov edx, DWORD PTR [esi+28]
$LL2@xmlExpPars:
; 7876 : int ret = 0;
; 7877 :
; 7878 : SKIP_BLANKS
mov al, BYTE PTR [edx]
cmp al, 32 ; 00000020H
je SHORT $LN6@xmlExpPars
cmp al, 10 ; 0000000aH
je SHORT $LN6@xmlExpPars
cmp al, 13 ; 0000000dH
je SHORT $LN6@xmlExpPars
cmp al, 9
jne SHORT $LN3@xmlExpPars
$LN6@xmlExpPars:
inc edx
mov DWORD PTR [esi+28], edx
jmp SHORT $LL2@xmlExpPars
$LN3@xmlExpPars:
; 7879 : if (CUR == '*') {
cmp al, 42 ; 0000002aH
jne SHORT $LN7@xmlExpPars
; 7880 : NEXT
lea eax, DWORD PTR [edx+1]
mov DWORD PTR [esi+28], eax
$LN9@xmlExpPars:
; 7890 : }
or eax, -1
pop esi
pop ebp
ret 0
$LN7@xmlExpPars:
; 7881 : return(-1);
; 7882 : }
; 7883 : if ((CUR < '0') || (CUR > '9'))
cmp al, 48 ; 00000030H
jl SHORT $LN9@xmlExpPars
cmp al, 57 ; 00000039H
jg SHORT $LN9@xmlExpPars
$LL4@xmlExpPars:
; 7884 : return(-1);
; 7885 : while ((CUR >= '0') && (CUR <= '9')) {
cmp al, 57 ; 00000039H
jg SHORT $LN5@xmlExpPars
; 7886 : ret = ret * 10 + (CUR - '0');
movsx eax, al
lea ecx, DWORD PTR [ecx+ecx*4]
; 7887 : NEXT
inc edx
lea ecx, DWORD PTR [ecx-24]
mov DWORD PTR [esi+28], edx
lea ecx, DWORD PTR [eax+ecx*2]
mov al, BYTE PTR [edx]
cmp al, 48 ; 00000030H
jge SHORT $LL4@xmlExpPars
$LN5@xmlExpPars:
; 7888 : }
; 7889 : return(ret);
mov eax, ecx
pop esi
; 7890 : }
pop ebp
ret 0
_xmlExpParseNumber ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpParseExpr
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlExpParseExpr PROC ; COMDAT
; 7990 : xmlExpParseExpr(xmlExpCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
push esi
call _xmlExpParseSeq
mov ecx, DWORD PTR [esi+28]
add esp, 4
mov edi, eax
$LL2@xmlExpPars:
; 7991 : xmlExpNodePtr ret, right;
; 7992 :
; 7993 : ret = xmlExpParseSeq(ctxt);
; 7994 : SKIP_BLANKS
mov dl, BYTE PTR [ecx]
cmp dl, 32 ; 00000020H
je SHORT $LN6@xmlExpPars
cmp dl, 10 ; 0000000aH
je SHORT $LN6@xmlExpPars
cmp dl, 13 ; 0000000dH
je SHORT $LN6@xmlExpPars
cmp dl, 9
jne SHORT $LN12@xmlExpPars
$LN6@xmlExpPars:
inc ecx
mov DWORD PTR [esi+28], ecx
jmp SHORT $LL2@xmlExpPars
$LN12@xmlExpPars:
; 7995 : while (CUR == ',') {
cmp dl, 44 ; 0000002cH
jne SHORT $LN5@xmlExpPars
$LL4@xmlExpPars:
; 7996 : NEXT
lea eax, DWORD PTR [ecx+1]
; 7997 : right = xmlExpParseSeq(ctxt);
push esi
mov DWORD PTR [esi+28], eax
call _xmlExpParseSeq
add esp, 4
; 7998 : if (right == NULL) {
test eax, eax
je SHORT $LN13@xmlExpPars
; 8000 : return(NULL);
; 8001 : }
; 8002 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, right, NULL, 0, 0);
push 0
push 0
push 0
push eax
push edi
push 3
push esi
call _xmlExpHashGetEntry
mov edi, eax
add esp, 28 ; 0000001cH
; 8003 : if (ret == NULL)
test edi, edi
je SHORT $LN14@xmlExpPars
; 7995 : while (CUR == ',') {
mov ecx, DWORD PTR [esi+28]
cmp BYTE PTR [ecx], 44 ; 0000002cH
je SHORT $LL4@xmlExpPars
$LN5@xmlExpPars:
; 8004 : return(NULL);
; 8005 : }
; 8006 : return(ret);
mov eax, edi
pop edi
; 8007 : }
pop esi
pop ebp
ret 0
$LN13@xmlExpPars:
; 7999 : xmlExpFree(ctxt, ret);
push edi
push esi
call _xmlExpFree
add esp, 8
$LN14@xmlExpPars:
; 8007 : }
pop edi
xor eax, eax
pop esi
pop ebp
ret 0
_xmlExpParseExpr ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpDivide
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_exp$ = 12 ; size = 4
_sub$ = 16 ; size = 4
_mult$ = 20 ; size = 4
_remain$ = 24 ; size = 4
_xmlExpDivide PROC ; COMDAT
; 7266 : xmlExpNodePtr *mult, xmlExpNodePtr *remain) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _mult$[ebp]
test eax, eax
je SHORT $LN5@xmlExpDivi
; 7267 : int i;
; 7268 : xmlExpNodePtr tmp, tmp2;
; 7269 :
; 7270 : if (mult != NULL) *mult = NULL;
mov DWORD PTR [eax], 0
$LN5@xmlExpDivi:
; 7271 : if (remain != NULL) *remain = NULL;
mov eax, DWORD PTR _remain$[ebp]
test eax, eax
je SHORT $LN6@xmlExpDivi
mov DWORD PTR [eax], 0
$LN6@xmlExpDivi:
; 7272 : if (exp->c_max == -1) return(0);
mov eax, DWORD PTR _exp$[ebp]
push ebx
push esi
push edi
mov ecx, DWORD PTR [eax+8]
cmp ecx, -1
je $LN3@xmlExpDivi
; 7273 : if (IS_NILLABLE(exp) && (!IS_NILLABLE(sub))) return(0);
test BYTE PTR [eax+1], 1
mov eax, DWORD PTR _sub$[ebp]
je SHORT $LN8@xmlExpDivi
test BYTE PTR [eax+1], 1
je $LN3@xmlExpDivi
$LN8@xmlExpDivi:
; 7274 :
; 7275 : for (i = 1;i <= exp->c_max;i++) {
mov ebx, 1
cmp ecx, ebx
jl $LN3@xmlExpDivi
mov edi, DWORD PTR _ctxt$[ebp]
npad 4
$LL4@xmlExpDivi:
; 7276 : sub->ref++;
inc DWORD PTR [eax+4]
; 7277 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT,
push ebx
push ebx
push 0
push 0
push eax
push 5
push edi
call _xmlExpHashGetEntry
mov esi, eax
add esp, 28 ; 0000001cH
; 7278 : sub, NULL, NULL, i, i);
; 7279 : if (tmp == NULL) {
test esi, esi
je $LN25@xmlExpDivi
; 7234 : if (sub->c_max == -1) {
mov edx, DWORD PTR _exp$[ebp]
mov eax, DWORD PTR [esi+8]
mov ecx, DWORD PTR [edx+8]
cmp ecx, -1
je SHORT $LN22@xmlExpDivi
; 7235 : if (exp->c_max != -1)
; 7236 : ret = 0;
; 7237 : } else if ((exp->c_max >= 0) && (exp->c_max < sub->c_max)) {
test eax, eax
js SHORT $LN10@xmlExpDivi
cmp eax, ecx
jge SHORT $LN10@xmlExpDivi
; 7280 : return(-1);
; 7281 : }
; 7282 : if (!xmlExpCheckCard(tmp, exp)) {
jmp SHORT $LN2@xmlExpDivi
$LN22@xmlExpDivi:
cmp eax, -1
jne SHORT $LN2@xmlExpDivi
$LN10@xmlExpDivi:
; 7283 : xmlExpFree(ctxt, tmp);
; 7284 : continue;
; 7285 : }
; 7286 : tmp2 = xmlExpExpDeriveInt(ctxt, tmp, exp);
push edx
push esi
push edi
call _xmlExpExpDeriveInt
mov edi, eax
add esp, 12 ; 0000000cH
; 7287 : if (tmp2 == NULL) {
test edi, edi
je SHORT $LN26@xmlExpDivi
; 7289 : return(-1);
; 7290 : }
; 7291 : if ((tmp2 != forbiddenExp) && (IS_NILLABLE(tmp2))) {
cmp edi, DWORD PTR _forbiddenExp
je SHORT $LN12@xmlExpDivi
test BYTE PTR [edi+1], 1
jne SHORT $LN27@xmlExpDivi
$LN12@xmlExpDivi:
; 7304 : }
; 7305 : xmlExpFree(ctxt, tmp);
mov eax, DWORD PTR _ctxt$[ebp]
push esi
push eax
call _xmlExpFree
; 7306 : xmlExpFree(ctxt, tmp2);
mov esi, edi
add esp, 8
mov edi, DWORD PTR _ctxt$[ebp]
$LN2@xmlExpDivi:
; 7274 :
; 7275 : for (i = 1;i <= exp->c_max;i++) {
push esi
push edi
call _xmlExpFree
mov eax, DWORD PTR _exp$[ebp]
inc ebx
add esp, 8
cmp ebx, DWORD PTR [eax+8]
jg SHORT $LN3@xmlExpDivi
mov eax, DWORD PTR _sub$[ebp]
jmp $LL4@xmlExpDivi
$LN27@xmlExpDivi:
; 7292 : if (remain != NULL)
mov eax, DWORD PTR _remain$[ebp]
test eax, eax
je SHORT $LN13@xmlExpDivi
; 7293 : *remain = tmp2;
mov DWORD PTR [eax], edi
mov edi, DWORD PTR _ctxt$[ebp]
jmp SHORT $LN14@xmlExpDivi
$LN13@xmlExpDivi:
; 7294 : else
; 7295 : xmlExpFree(ctxt, tmp2);
push edi
mov edi, DWORD PTR _ctxt$[ebp]
push edi
call _xmlExpFree
add esp, 8
$LN14@xmlExpDivi:
; 7296 : if (mult != NULL)
mov eax, DWORD PTR _mult$[ebp]
test eax, eax
je SHORT $LN15@xmlExpDivi
; 7297 : *mult = tmp;
pop edi
mov DWORD PTR [eax], esi
; 7300 : #ifdef DEBUG_DERIV
; 7301 : printf("Divide succeeded %d\n", i);
; 7302 : #endif
; 7303 : return(i);
mov eax, ebx
; 7307 : }
; 7308 : #ifdef DEBUG_DERIV
; 7309 : printf("Divide failed\n");
; 7310 : #endif
; 7311 : return(0);
; 7312 : }
pop esi
pop ebx
pop ebp
ret 0
$LN15@xmlExpDivi:
; 7298 : else
; 7299 : xmlExpFree(ctxt, tmp);
push esi
push edi
call _xmlExpFree
add esp, 8
; 7300 : #ifdef DEBUG_DERIV
; 7301 : printf("Divide succeeded %d\n", i);
; 7302 : #endif
; 7303 : return(i);
mov eax, ebx
pop edi
; 7307 : }
; 7308 : #ifdef DEBUG_DERIV
; 7309 : printf("Divide failed\n");
; 7310 : #endif
; 7311 : return(0);
; 7312 : }
pop esi
pop ebx
pop ebp
ret 0
$LN26@xmlExpDivi:
; 7288 : xmlExpFree(ctxt, tmp);
mov eax, DWORD PTR _ctxt$[ebp]
push esi
push eax
call _xmlExpFree
add esp, 8
$LN25@xmlExpDivi:
; 7307 : }
; 7308 : #ifdef DEBUG_DERIV
; 7309 : printf("Divide failed\n");
; 7310 : #endif
; 7311 : return(0);
; 7312 : }
pop edi
pop esi
or eax, -1
pop ebx
pop ebp
ret 0
$LN3@xmlExpDivi:
pop edi
pop esi
xor eax, eax
pop ebx
pop ebp
ret 0
_xmlExpDivide ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpExpDeriveInt
_TEXT SEGMENT
_tmp2$4$ = -20 ; size = 4
_sub$1$ = -16 ; size = 4
_tmp3$1$ = -16 ; size = 4
tv1441 = -16 ; size = 4
tv1407 = -16 ; size = 4
_len$1$ = -12 ; size = 4
_i$1$ = -8 ; size = 4
$T1 = -4 ; size = 4
_tmp$7$ = -4 ; size = 4
_ctxt$ = 8 ; size = 4
_exp$1$ = 12 ; size = 4
_tab$1$ = 12 ; size = 4
_tmp2$1$ = 12 ; size = 4
_ret$6$ = 12 ; size = 4
_ret$4$ = 12 ; size = 4
tv1450 = 12 ; size = 4
tv1444 = 12 ; size = 4
tv1434 = 12 ; size = 4
tv1375 = 12 ; size = 4
tv1364 = 12 ; size = 4
_exp$ = 12 ; size = 4
_i$1$ = 16 ; size = 4
_ret$7$ = 16 ; size = 4
tv1449 = 16 ; size = 4
_sub$ = 16 ; size = 4
_xmlExpExpDeriveInt PROC ; COMDAT
; 7326 : xmlExpExpDeriveInt(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
push ebp
mov ebp, esp
sub esp, 20 ; 00000014H
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push ebx
push esi
push edi
call @__CheckForDebuggerJustMyCode@4
mov ebx, DWORD PTR _exp$[ebp]
mov esi, DWORD PTR _sub$[ebp]
cmp ebx, esi
jne SHORT $LN9@xmlExpExpD
; 7327 : xmlExpNodePtr ret, tmp, tmp2, tmp3;
; 7328 : const xmlChar **tab;
; 7329 : int len, i;
; 7330 :
; 7331 : /*
; 7332 : * In case of equality and if the expression can only consume a finite
; 7333 : * amount, then the derivation is empty
; 7334 : */
; 7335 : if ((exp == sub) && (exp->c_max >= 0)) {
cmp DWORD PTR [ebx+8], 0
jge $LN155@xmlExpExpD
$LN9@xmlExpExpD:
; 7336 : #ifdef DEBUG_DERIV
; 7337 : printf("Equal(exp, sub) and finite -> Empty\n");
; 7338 : #endif
; 7339 : return(emptyExp);
; 7340 : }
; 7341 : /*
; 7342 : * decompose sub sequence first
; 7343 : */
; 7344 : if (sub->type == XML_EXP_EMPTY) {
mov al, BYTE PTR [esi]
test al, al
jne SHORT $LN10@xmlExpExpD
; 7345 : #ifdef DEBUG_DERIV
; 7346 : printf("Empty(sub) -> Empty\n");
; 7347 : #endif
; 7348 : exp->ref++;
inc DWORD PTR [ebx+4]
; 7349 : return(exp);
mov eax, ebx
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN10@xmlExpExpD:
; 7350 : }
; 7351 : if (sub->type == XML_EXP_SEQ) {
cmp al, 3
jne SHORT $LN11@xmlExpExpD
; 7352 : #ifdef DEBUG_DERIV
; 7353 : printf("Seq(sub) -> decompose\n");
; 7354 : #endif
; 7355 : tmp = xmlExpExpDeriveInt(ctxt, exp, sub->exp_left);
push DWORD PTR [esi+12]
push ebx
mov ebx, DWORD PTR _ctxt$[ebp]
push ebx
call _xmlExpExpDeriveInt
mov edi, eax
add esp, 12 ; 0000000cH
; 7356 : if (tmp == NULL)
test edi, edi
je $LN149@xmlExpExpD
; 7357 : return(NULL);
; 7358 : if (tmp == forbiddenExp)
cmp edi, DWORD PTR _forbiddenExp
je $LN1@xmlExpExpD
; 7359 : return(tmp);
; 7360 : ret = xmlExpExpDeriveInt(ctxt, tmp, sub->exp_right);
push DWORD PTR [esi+20]
push edi
push ebx
call _xmlExpExpDeriveInt
; 7361 : xmlExpFree(ctxt, tmp);
push edi
push ebx
mov esi, eax
call _xmlExpFree
add esp, 20 ; 00000014H
; 7362 : return(ret);
mov eax, esi
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN11@xmlExpExpD:
; 7363 : }
; 7364 : if (sub->type == XML_EXP_OR) {
cmp al, 4
jne SHORT $LN14@xmlExpExpD
; 7365 : #ifdef DEBUG_DERIV
; 7366 : printf("Or(sub) -> decompose\n");
; 7367 : #endif
; 7368 : tmp = xmlExpExpDeriveInt(ctxt, exp, sub->exp_left);
push DWORD PTR [esi+12]
push ebx
push DWORD PTR _ctxt$[ebp]
call _xmlExpExpDeriveInt
mov edi, eax
add esp, 12 ; 0000000cH
; 7369 : if (tmp == forbiddenExp)
cmp edi, DWORD PTR _forbiddenExp
je $LN1@xmlExpExpD
; 7370 : return(tmp);
; 7371 : if (tmp == NULL)
test edi, edi
je $LN149@xmlExpExpD
; 7372 : return(NULL);
; 7373 : ret = xmlExpExpDeriveInt(ctxt, exp, sub->exp_right);
push DWORD PTR [esi+20]
push ebx
mov ebx, DWORD PTR _ctxt$[ebp]
push ebx
call _xmlExpExpDeriveInt
mov esi, eax
add esp, 12 ; 0000000cH
; 7374 : if ((ret == NULL) || (ret == forbiddenExp)) {
test esi, esi
je SHORT $LN18@xmlExpExpD
cmp esi, DWORD PTR _forbiddenExp
je SHORT $LN18@xmlExpExpD
; 7377 : }
; 7378 : return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, tmp, ret, NULL, 0, 0));
push 0
push 0
push 0
push esi
push edi
push 4
push ebx
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN18@xmlExpExpD:
; 7375 : xmlExpFree(ctxt, tmp);
push edi
push ebx
call _xmlExpFree
add esp, 8
; 7376 : return(ret);
mov eax, esi
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN14@xmlExpExpD:
; 7379 : }
; 7380 : if (!xmlExpCheckCard(exp, sub)) {
push esi
push ebx
call _xmlExpCheckCard
add esp, 8
test eax, eax
je $LN158@xmlExpExpD
; 7381 : #ifdef DEBUG_DERIV
; 7382 : printf("CheckCard(exp, sub) failed -> Forbid\n");
; 7383 : #endif
; 7384 : return(forbiddenExp);
; 7385 : }
; 7386 : switch (exp->type) {
movzx eax, BYTE PTR [ebx]
mov edi, DWORD PTR _ctxt$[ebp]
cmp eax, 5
ja $LN157@xmlExpExpD
jmp DWORD PTR $LN163@xmlExpExpD[eax*4]
$LN20@xmlExpExpD:
; 7387 : case XML_EXP_EMPTY:
; 7388 : if (sub == emptyExp)
cmp esi, DWORD PTR _emptyExp
jmp SHORT $LN159@xmlExpExpD
$LN23@xmlExpExpD:
; 7389 : return(emptyExp);
; 7390 : #ifdef DEBUG_DERIV
; 7391 : printf("Empty(exp) -> Forbid\n");
; 7392 : #endif
; 7393 : return(forbiddenExp);
; 7394 : case XML_EXP_FORBID:
; 7395 : #ifdef DEBUG_DERIV
; 7396 : printf("Forbid(exp) -> Forbid\n");
; 7397 : #endif
; 7398 : return(forbiddenExp);
; 7399 : case XML_EXP_ATOM:
; 7400 : if (sub->type == XML_EXP_ATOM) {
mov al, BYTE PTR [esi]
cmp al, 2
jne SHORT $LN24@xmlExpExpD
; 7401 : /* TODO: handle wildcards */
; 7402 : if (exp->exp_str == sub->exp_str) {
mov eax, DWORD PTR [ebx+20]
cmp eax, DWORD PTR [esi+20]
jmp SHORT $LN159@xmlExpExpD
$LN24@xmlExpExpD:
; 7403 : #ifdef DEBUG_DERIV
; 7404 : printf("Atom match -> Empty\n");
; 7405 : #endif
; 7406 : return(emptyExp);
; 7407 : }
; 7408 : #ifdef DEBUG_DERIV
; 7409 : printf("Atom mismatch -> Forbid\n");
; 7410 : #endif
; 7411 : return(forbiddenExp);
; 7412 : }
; 7413 : if ((sub->type == XML_EXP_COUNT) &&
; 7414 : (sub->exp_max == 1) &&
cmp al, 5
jne $LN158@xmlExpExpD
cmp DWORD PTR [esi+24], 1
jne $LN158@xmlExpExpD
mov ecx, DWORD PTR [esi+12]
cmp BYTE PTR [ecx], 2
jne $LN158@xmlExpExpD
; 7415 : (sub->exp_left->type == XML_EXP_ATOM)) {
; 7416 : /* TODO: handle wildcards */
; 7417 : if (exp->exp_str == sub->exp_left->exp_str) {
mov eax, DWORD PTR [ebx+20]
cmp eax, DWORD PTR [ecx+20]
$LN159@xmlExpExpD:
; 7418 : #ifdef DEBUG_DERIV
; 7419 : printf("Atom match -> Empty\n");
; 7420 : #endif
; 7421 : return(emptyExp);
jne $LN158@xmlExpExpD
$LN155@xmlExpExpD:
mov eax, DWORD PTR _emptyExp
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN28@xmlExpExpD:
; 7422 : }
; 7423 : #ifdef DEBUG_DERIV
; 7424 : printf("Atom mismatch -> Forbid\n");
; 7425 : #endif
; 7426 : return(forbiddenExp);
; 7427 : }
; 7428 : #ifdef DEBUG_DERIV
; 7429 : printf("Compex exp vs Atom -> Forbid\n");
; 7430 : #endif
; 7431 : return(forbiddenExp);
; 7432 : case XML_EXP_SEQ:
; 7433 : /* try to get the sequence consumed only if possible */
; 7434 : if (xmlExpCheckCard(exp->exp_left, sub)) {
push esi
push DWORD PTR [ebx+12]
call _xmlExpCheckCard
add esp, 8
test eax, eax
je SHORT $LN156@xmlExpExpD
; 7435 : /* See if the sequence can be consumed directly */
; 7436 : #ifdef DEBUG_DERIV
; 7437 : printf("Seq trying left only\n");
; 7438 : #endif
; 7439 : ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
push esi
push DWORD PTR [ebx+12]
push edi
call _xmlExpExpDeriveInt
add esp, 12 ; 0000000cH
; 7440 : if ((ret != forbiddenExp) && (ret != NULL)) {
cmp eax, DWORD PTR _forbiddenExp
je SHORT $LN156@xmlExpExpD
test eax, eax
je SHORT $LN156@xmlExpExpD
; 7441 : #ifdef DEBUG_DERIV
; 7442 : printf("Seq trying left only worked\n");
; 7443 : #endif
; 7444 : /*
; 7445 : * TODO: assumption here that we are determinist
; 7446 : * i.e. we won't get to a nillable exp left
; 7447 : * subset which could be matched by the right
; 7448 : * part too.
; 7449 : * e.g.: (a | b)+,(a | c) and 'a+,a'
; 7450 : */
; 7451 : exp->exp_right->ref++;
mov ecx, DWORD PTR [ebx+20]
; 7452 : return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret,
push 0
push 0
push 0
inc DWORD PTR [ecx+4]
push DWORD PTR [ebx+20]
push eax
push 3
push edi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN156@xmlExpExpD:
; 7453 : exp->exp_right, NULL, 0, 0));
; 7454 : }
; 7455 : #ifdef DEBUG_DERIV
; 7456 : } else {
; 7457 : printf("Seq: left too short\n");
; 7458 : #endif
; 7459 : }
; 7460 : /* Try instead to decompose */
; 7461 : if (sub->type == XML_EXP_COUNT) {
cmp BYTE PTR [esi], 5
jne $LN157@xmlExpExpD
; 7462 : int min, max;
; 7463 :
; 7464 : #ifdef DEBUG_DERIV
; 7465 : printf("Seq: sub is a count\n");
; 7466 : #endif
; 7467 : ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub->exp_left);
push DWORD PTR [esi+12]
push DWORD PTR [ebx+12]
push edi
call _xmlExpExpDeriveInt
add esp, 12 ; 0000000cH
mov DWORD PTR _ret$4$[ebp], eax
; 7468 : if (ret == NULL)
test eax, eax
je SHORT $LN149@xmlExpExpD
; 7469 : return(NULL);
; 7470 : if (ret != forbiddenExp) {
cmp eax, DWORD PTR _forbiddenExp
je $LN157@xmlExpExpD
; 7471 : #ifdef DEBUG_DERIV
; 7472 : printf("Seq , Count match on left\n");
; 7473 : #endif
; 7474 : if (sub->exp_max < 0)
mov ecx, DWORD PTR [esi+24]
; 7475 : max = -1;
; 7476 : else
; 7477 : max = sub->exp_max -1;
; 7478 : if (sub->exp_min > 0)
or eax, -1
test ecx, ecx
; 7479 : min = sub->exp_min -1;
; 7480 : else
; 7481 : min = 0;
; 7482 : exp->exp_right->ref++;
; 7483 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret,
push 0
push 0
lea edx, DWORD PTR [ecx-1]
cmovns eax, edx
mov DWORD PTR tv1449[ebp], eax
mov eax, DWORD PTR [esi+20]
mov DWORD PTR tv1441[ebp], eax
mov eax, DWORD PTR [ebx+20]
push 0
inc DWORD PTR [eax+4]
push DWORD PTR [ebx+20]
push DWORD PTR _ret$4$[ebp]
push 3
push edi
call _xmlExpHashGetEntry
mov ebx, eax
add esp, 28 ; 0000001cH
; 7484 : exp->exp_right, NULL, 0, 0);
; 7485 : if (tmp == NULL)
test ebx, ebx
je SHORT $LN149@xmlExpExpD
; 7486 : return(NULL);
; 7487 :
; 7488 : sub->exp_left->ref++;
mov ecx, DWORD PTR [esi+12]
xor edx, edx
mov eax, DWORD PTR tv1441[ebp]
; 7489 : tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT,
push DWORD PTR tv1449[ebp]
inc DWORD PTR [ecx+4]
test eax, eax
lea ecx, DWORD PTR [eax-1]
cmovle ecx, edx
push ecx
push edx
push edx
push DWORD PTR [esi+12]
push 5
push edi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
mov DWORD PTR _tmp2$1$[ebp], eax
; 7490 : sub->exp_left, NULL, NULL, min, max);
; 7491 : if (tmp2 == NULL) {
test eax, eax
jne SHORT $LN39@xmlExpExpD
; 7492 : xmlExpFree(ctxt, tmp);
push ebx
push edi
call _xmlExpFree
add esp, 8
$LN149@xmlExpExpD:
; 7763 : }
pop edi
pop esi
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN39@xmlExpExpD:
; 7493 : return(NULL);
; 7494 : }
; 7495 : ret = xmlExpExpDeriveInt(ctxt, tmp, tmp2);
push eax
push ebx
push edi
call _xmlExpExpDeriveInt
; 7496 : xmlExpFree(ctxt, tmp);
push ebx
push edi
mov esi, eax
call _xmlExpFree
; 7497 : xmlExpFree(ctxt, tmp2);
push DWORD PTR _tmp2$1$[ebp]
push edi
call _xmlExpFree
add esp, 28 ; 0000001cH
; 7498 : return(ret);
mov eax, esi
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN40@xmlExpExpD:
; 7499 : }
; 7500 : }
; 7501 : /* we made no progress on structured operations */
; 7502 : break;
; 7503 : case XML_EXP_OR:
; 7504 : #ifdef DEBUG_DERIV
; 7505 : printf("Or , trying both side\n");
; 7506 : #endif
; 7507 : ret = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
push esi
push DWORD PTR [ebx+12]
push edi
call _xmlExpExpDeriveInt
add esp, 12 ; 0000000cH
mov DWORD PTR _ret$6$[ebp], eax
; 7508 : if (ret == NULL)
test eax, eax
je SHORT $LN149@xmlExpExpD
; 7509 : return(NULL);
; 7510 : tmp = xmlExpExpDeriveInt(ctxt, exp->exp_right, sub);
push esi
push DWORD PTR [ebx+20]
push edi
call _xmlExpExpDeriveInt
add esp, 12 ; 0000000cH
; 7511 : if (tmp == NULL) {
test eax, eax
jne SHORT $LN42@xmlExpExpD
; 7512 : xmlExpFree(ctxt, ret);
push DWORD PTR _ret$6$[ebp]
push edi
call _xmlExpFree
add esp, 8
; 7513 : return(NULL);
xor eax, eax
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN42@xmlExpExpD:
; 7514 : }
; 7515 : return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, tmp, NULL, 0, 0));
push 0
push 0
push 0
push eax
push DWORD PTR _ret$6$[ebp]
push 4
push edi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN43@xmlExpExpD:
; 7516 : case XML_EXP_COUNT: {
; 7517 : int min, max;
; 7518 :
; 7519 : if (sub->type == XML_EXP_COUNT) {
cmp BYTE PTR [esi], 5
jne $LN44@xmlExpExpD
; 7520 : /*
; 7521 : * Try to see if the loop is completely subsumed
; 7522 : */
; 7523 : tmp = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub->exp_left);
push DWORD PTR [esi+12]
push DWORD PTR [ebx+12]
push edi
call _xmlExpExpDeriveInt
mov edi, eax
add esp, 12 ; 0000000cH
; 7524 : if (tmp == NULL)
test edi, edi
je $LN149@xmlExpExpD
; 7525 : return(NULL);
; 7526 : if (tmp == forbiddenExp) {
cmp edi, DWORD PTR _forbiddenExp
jne $LN46@xmlExpExpD
; 7527 : int mult;
; 7528 :
; 7529 : #ifdef DEBUG_DERIV
; 7530 : printf("Count, Count inner don't subsume\n");
; 7531 : #endif
; 7532 : mult = xmlExpDivide(ctxt, sub->exp_left, exp->exp_left,
mov eax, DWORD PTR [esi+12]
mov ecx, DWORD PTR [ebx+12]
mov DWORD PTR _sub$1$[ebp], ecx
mov DWORD PTR _exp$1$[ebp], eax
; 7272 : if (exp->c_max == -1) return(0);
mov edx, DWORD PTR [eax+8]
cmp edx, -1
je $LN158@xmlExpExpD
; 7273 : if (IS_NILLABLE(exp) && (!IS_NILLABLE(sub))) return(0);
test BYTE PTR [eax+1], 1
je SHORT $LN111@xmlExpExpD
test BYTE PTR [ecx+1], 1
je $LN158@xmlExpExpD
$LN111@xmlExpExpD:
; 7274 :
; 7275 : for (i = 1;i <= exp->c_max;i++) {
mov eax, 1
mov DWORD PTR _i$1$[ebp], eax
cmp edx, eax
jl $LN158@xmlExpExpD
mov edi, DWORD PTR _ctxt$[ebp]
$LL107@xmlExpExpD:
; 7276 : sub->ref++;
inc DWORD PTR [ecx+4]
; 7277 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT,
push eax
push eax
push 0
push 0
push ecx
push 5
push edi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
mov DWORD PTR $T1[ebp], eax
; 7278 : sub, NULL, NULL, i, i);
; 7279 : if (tmp == NULL) {
test eax, eax
je $LN158@xmlExpExpD
; 7234 : if (sub->c_max == -1) {
mov edx, DWORD PTR _exp$1$[ebp]
mov ecx, DWORD PTR [eax+8]
mov edx, DWORD PTR [edx+8]
cmp edx, -1
je SHORT $LN125@xmlExpExpD
; 7235 : if (exp->c_max != -1)
; 7236 : ret = 0;
; 7237 : } else if ((exp->c_max >= 0) && (exp->c_max < sub->c_max)) {
test ecx, ecx
js SHORT $LN113@xmlExpExpD
cmp ecx, edx
jge SHORT $LN113@xmlExpExpD
; 7282 : if (!xmlExpCheckCard(tmp, exp)) {
jmp SHORT $LN105@xmlExpExpD
$LN125@xmlExpExpD:
cmp ecx, -1
jne SHORT $LN105@xmlExpExpD
$LN113@xmlExpExpD:
; 7283 : xmlExpFree(ctxt, tmp);
; 7284 : continue;
; 7285 : }
; 7286 : tmp2 = xmlExpExpDeriveInt(ctxt, tmp, exp);
push DWORD PTR _exp$1$[ebp]
push eax
push edi
call _xmlExpExpDeriveInt
mov edi, eax
add esp, 12 ; 0000000cH
; 7287 : if (tmp2 == NULL) {
test edi, edi
je $LN131@xmlExpExpD
; 7290 : }
; 7291 : if ((tmp2 != forbiddenExp) && (IS_NILLABLE(tmp2))) {
cmp edi, DWORD PTR _forbiddenExp
je SHORT $LN115@xmlExpExpD
test BYTE PTR [edi+1], 1
jne SHORT $LN132@xmlExpExpD
$LN115@xmlExpExpD:
; 7300 : #ifdef DEBUG_DERIV
; 7301 : printf("Divide succeeded %d\n", i);
; 7302 : #endif
; 7303 : return(i);
; 7304 : }
; 7305 : xmlExpFree(ctxt, tmp);
push DWORD PTR $T1[ebp]
mov eax, DWORD PTR _ctxt$[ebp]
push eax
call _xmlExpFree
; 7306 : xmlExpFree(ctxt, tmp2);
mov eax, edi
add esp, 8
mov edi, DWORD PTR _ctxt$[ebp]
$LN105@xmlExpExpD:
; 7274 :
; 7275 : for (i = 1;i <= exp->c_max;i++) {
push eax
push edi
call _xmlExpFree
mov eax, DWORD PTR _i$1$[ebp]
add esp, 8
mov ecx, DWORD PTR _exp$1$[ebp]
inc eax
mov DWORD PTR _i$1$[ebp], eax
cmp eax, DWORD PTR [ecx+8]
jg $LN158@xmlExpExpD
mov ecx, DWORD PTR _sub$1$[ebp]
jmp $LL107@xmlExpExpD
$LN132@xmlExpExpD:
; 7292 : if (remain != NULL)
; 7293 : *remain = tmp2;
; 7294 : else
; 7295 : xmlExpFree(ctxt, tmp2);
; 7296 : if (mult != NULL)
; 7297 : *mult = tmp;
; 7298 : else
; 7299 : xmlExpFree(ctxt, tmp);
push DWORD PTR $T1[ebp]
mov eax, DWORD PTR _ctxt$[ebp]
push eax
call _xmlExpFree
; 7533 : NULL, &tmp);
; 7534 : if (mult <= 0) {
mov eax, DWORD PTR _i$1$[ebp]
; 7299 : xmlExpFree(ctxt, tmp);
add esp, 8
; 7533 : NULL, &tmp);
; 7534 : if (mult <= 0) {
test eax, eax
jle SHORT $LN158@xmlExpExpD
; 7535 : #ifdef DEBUG_DERIV
; 7536 : printf("Count, Count not multiple => forbidden\n");
; 7537 : #endif
; 7538 : return(forbiddenExp);
; 7539 : }
; 7540 : if (sub->exp_max == -1) {
mov ecx, DWORD PTR [esi+24]
mov edx, DWORD PTR [ebx+24]
cmp ecx, -1
jne SHORT $LN49@xmlExpExpD
; 7541 : max = -1;
; 7542 : if (exp->exp_max == -1) {
cmp edx, ecx
jne SHORT $LN152@xmlExpExpD
; 7543 : if (exp->exp_min <= sub->exp_min * mult)
mov edx, DWORD PTR [esi+20]
; 7544 : min = 0;
; 7545 : else
; 7546 : min = exp->exp_min - sub->exp_min * mult;
; 7547 : } else {
; 7548 : #ifdef DEBUG_DERIV
; 7549 : printf("Count, Count finite can't subsume infinite\n");
; 7550 : #endif
; 7551 : xmlExpFree(ctxt, tmp);
; 7552 : return(forbiddenExp);
; 7553 : }
; 7554 : } else {
xor esi, esi
mov ecx, DWORD PTR [ebx+20]
imul edx, eax
sub ecx, edx
cmp DWORD PTR [ebx+20], edx
cmovg esi, ecx
or edx, -1
jmp $LN73@xmlExpExpD
$LN49@xmlExpExpD:
; 7555 : if (exp->exp_max == -1) {
cmp edx, -1
jne SHORT $LN55@xmlExpExpD
; 7556 : #ifdef DEBUG_DERIV
; 7557 : printf("Infinite loop consume mult finite loop\n");
; 7558 : #endif
; 7559 : if (exp->exp_min > sub->exp_min * mult) {
mov ecx, DWORD PTR [esi+20]
; 7560 : max = -1;
; 7561 : min = exp->exp_min - sub->exp_min * mult;
; 7562 : } else {
; 7563 : max = -1;
; 7564 : min = 0;
; 7565 : }
; 7566 : } else {
or edx, edx
mov esi, DWORD PTR [ebx+20]
imul ecx, eax
mov DWORD PTR tv1364[ebp], 0
sub esi, ecx
cmp DWORD PTR [ebx+20], ecx
cmovle esi, DWORD PTR tv1364[ebp]
jmp $LN73@xmlExpExpD
$LN55@xmlExpExpD:
; 7567 : if (exp->exp_max < sub->exp_max * mult) {
imul ecx, eax
mov DWORD PTR tv1434[ebp], ecx
cmp edx, ecx
jge SHORT $LN59@xmlExpExpD
$LN152@xmlExpExpD:
; 7763 : }
push edi
$LN161@xmlExpExpD:
push DWORD PTR _ctxt$[ebp]
call _xmlExpFree
add esp, 8
$LN158@xmlExpExpD:
mov eax, DWORD PTR _forbiddenExp
$LN1@xmlExpExpD:
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN59@xmlExpExpD:
; 7568 : #ifdef DEBUG_DERIV
; 7569 : printf("loops max mult mismatch => forbidden\n");
; 7570 : #endif
; 7571 : xmlExpFree(ctxt, tmp);
; 7572 : return(forbiddenExp);
; 7573 : }
; 7574 : if (sub->exp_max * mult > exp->exp_min)
mov ecx, DWORD PTR [ebx+20]
; 7575 : min = 0;
; 7576 : else
; 7577 : min = exp->exp_min - sub->exp_max * mult;
; 7578 : max = exp->exp_max - sub->exp_max * mult;
xor esi, esi
sub edx, DWORD PTR tv1434[ebp]
mov eax, ecx
sub eax, DWORD PTR tv1434[ebp]
cmp DWORD PTR tv1434[ebp], ecx
; 7579 : }
; 7580 : }
jmp SHORT $LN160@xmlExpExpD
$LN131@xmlExpExpD:
; 7288 : xmlExpFree(ctxt, tmp);
push DWORD PTR $T1[ebp]
; 7289 : return(-1);
jmp SHORT $LN161@xmlExpExpD
$LN46@xmlExpExpD:
; 7581 : } else if (!IS_NILLABLE(tmp)) {
test BYTE PTR [edi+1], 1
je SHORT $LN152@xmlExpExpD
; 7582 : /*
; 7583 : * TODO: loop here to try to grow if working on finite
; 7584 : * blocks.
; 7585 : */
; 7586 : #ifdef DEBUG_DERIV
; 7587 : printf("Count, Count remain not nillable => forbidden\n");
; 7588 : #endif
; 7589 : xmlExpFree(ctxt, tmp);
; 7590 : return(forbiddenExp);
; 7591 : } else if (sub->exp_max == -1) {
mov eax, DWORD PTR [esi+24]
mov edx, DWORD PTR [ebx+24]
mov DWORD PTR tv1450[ebp], eax
cmp eax, -1
jne SHORT $LN64@xmlExpExpD
; 7592 : if (exp->exp_max == -1) {
mov esi, DWORD PTR [esi+20]
mov ecx, DWORD PTR [ebx+20]
mov DWORD PTR tv1444[ebp], esi
cmp edx, eax
jne SHORT $LN66@xmlExpExpD
; 7593 : if (exp->exp_min <= sub->exp_min) {
; 7594 : #ifdef DEBUG_DERIV
; 7595 : printf("Infinite loops Okay => COUNT(0,Inf)\n");
; 7596 : #endif
; 7597 : max = -1;
; 7598 : min = 0;
; 7599 : } else {
; 7600 : #ifdef DEBUG_DERIV
; 7601 : printf("Infinite loops min => Count(X,Inf)\n");
; 7602 : #endif
; 7603 : max = -1;
; 7604 : min = exp->exp_min - sub->exp_min;
; 7605 : }
mov eax, ecx
sub eax, esi
xor esi, esi
cmp ecx, DWORD PTR tv1444[ebp]
cmovg esi, eax
; 7615 : }
; 7616 : } else {
or edx, -1
jmp SHORT $LN73@xmlExpExpD
$LN66@xmlExpExpD:
; 7606 : } else if (exp->exp_min > sub->exp_min) {
cmp ecx, esi
jg SHORT $LN152@xmlExpExpD
; 7607 : #ifdef DEBUG_DERIV
; 7608 : printf("loops min mismatch 1 => forbidden ???\n");
; 7609 : #endif
; 7610 : xmlExpFree(ctxt, tmp);
; 7611 : return(forbiddenExp);
; 7612 : } else {
; 7613 : max = -1;
; 7614 : min = 0;
xor esi, esi
; 7615 : }
; 7616 : } else {
or edx, -1
jmp SHORT $LN73@xmlExpExpD
$LN64@xmlExpExpD:
; 7617 : if (exp->exp_max == -1) {
cmp edx, -1
jne SHORT $LN72@xmlExpExpD
; 7618 : #ifdef DEBUG_DERIV
; 7619 : printf("Infinite loop consume finite loop\n");
; 7620 : #endif
; 7621 : if (exp->exp_min > sub->exp_min) {
mov eax, DWORD PTR [esi+20]
; 7622 : max = -1;
; 7623 : min = exp->exp_min - sub->exp_min;
; 7624 : } else {
; 7625 : max = -1;
; 7626 : min = 0;
; 7627 : }
; 7628 : } else {
or edx, edx
mov esi, DWORD PTR [ebx+20]
sub esi, eax
mov DWORD PTR tv1375[ebp], 0
cmp DWORD PTR [ebx+20], eax
cmovle esi, DWORD PTR tv1375[ebp]
jmp SHORT $LN73@xmlExpExpD
$LN72@xmlExpExpD:
; 7629 : if (exp->exp_max < sub->exp_max) {
cmp edx, eax
jl $LN152@xmlExpExpD
; 7630 : #ifdef DEBUG_DERIV
; 7631 : printf("loops max mismatch => forbidden\n");
; 7632 : #endif
; 7633 : xmlExpFree(ctxt, tmp);
; 7634 : return(forbiddenExp);
; 7635 : }
; 7636 : if (sub->exp_max > exp->exp_min)
mov ecx, DWORD PTR [ebx+20]
; 7637 : min = 0;
; 7638 : else
; 7639 : min = exp->exp_min - sub->exp_max;
; 7640 : max = exp->exp_max - sub->exp_max;
sub edx, eax
mov eax, ecx
xor esi, esi
sub eax, DWORD PTR tv1450[ebp]
cmp DWORD PTR tv1450[ebp], ecx
$LN160@xmlExpExpD:
; 7641 : }
; 7642 : }
; 7643 : #ifdef DEBUG_DERIV
; 7644 : printf("loops match => SEQ(COUNT())\n");
; 7645 : #endif
; 7646 : exp->exp_left->ref++;
cmovle esi, eax
$LN73@xmlExpExpD:
mov eax, DWORD PTR [ebx+12]
; 7647 : tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left,
push edx
push esi
push 0
inc DWORD PTR [eax+4]
push 0
push DWORD PTR [ebx+12]
mov ebx, DWORD PTR _ctxt$[ebp]
push 5
push ebx
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
; 7648 : NULL, NULL, min, max);
; 7649 : if (tmp2 == NULL) {
test eax, eax
je $LN149@xmlExpExpD
; 7650 : return(NULL);
; 7651 : }
; 7652 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, tmp, tmp2,
push 0
push 0
push 0
push eax
push edi
push 3
push ebx
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN44@xmlExpExpD:
; 7653 : NULL, 0, 0);
; 7654 : return(ret);
; 7655 : }
; 7656 : tmp = xmlExpExpDeriveInt(ctxt, exp->exp_left, sub);
push esi
push DWORD PTR [ebx+12]
push edi
call _xmlExpExpDeriveInt
mov edi, eax
add esp, 12 ; 0000000cH
; 7657 : if (tmp == NULL)
test edi, edi
je $LN149@xmlExpExpD
; 7658 : return(NULL);
; 7659 : if (tmp == forbiddenExp) {
cmp edi, DWORD PTR _forbiddenExp
je $LN158@xmlExpExpD
; 7660 : #ifdef DEBUG_DERIV
; 7661 : printf("loop mismatch => forbidden\n");
; 7662 : #endif
; 7663 : return(forbiddenExp);
; 7664 : }
; 7665 : if (exp->exp_min > 0)
; 7666 : min = exp->exp_min - 1;
; 7667 : else
; 7668 : min = 0;
; 7669 : if (exp->exp_max < 0)
; 7670 : max = -1;
; 7671 : else
; 7672 : max = exp->exp_max - 1;
; 7673 :
; 7674 : #ifdef DEBUG_DERIV
; 7675 : printf("loop match => SEQ(COUNT())\n");
; 7676 : #endif
; 7677 : exp->exp_left->ref++;
mov ecx, DWORD PTR [ebx+12]
or eax, -1
mov edx, DWORD PTR [ebx+24]
mov esi, DWORD PTR [ebx+20]
inc DWORD PTR [ecx+4]
test edx, edx
lea ecx, DWORD PTR [edx-1]
cmovns eax, ecx
xor ecx, ecx
; 7678 : tmp2 = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left,
push eax
test esi, esi
lea eax, DWORD PTR [esi-1]
mov esi, DWORD PTR _ctxt$[ebp]
cmovle eax, ecx
push eax
push ecx
push ecx
push DWORD PTR [ebx+12]
push 5
push esi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
; 7679 : NULL, NULL, min, max);
; 7680 : if (tmp2 == NULL)
test eax, eax
je $LN149@xmlExpExpD
; 7681 : return(NULL);
; 7682 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, tmp, tmp2,
push 0
push 0
push 0
push eax
push edi
push 3
push esi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN157@xmlExpExpD:
; 7683 : NULL, 0, 0);
; 7684 : return(ret);
; 7685 : }
; 7686 : }
; 7687 :
; 7688 : #ifdef DEBUG_DERIV
; 7689 : printf("Fallback to derivative\n");
; 7690 : #endif
; 7691 : if (IS_NILLABLE(sub)) {
test BYTE PTR [esi+1], 1
je SHORT $LN87@xmlExpExpD
; 7692 : if (!(IS_NILLABLE(exp)))
test BYTE PTR [ebx+1], 1
je $LN158@xmlExpExpD
; 7693 : return(forbiddenExp);
; 7694 : else
; 7695 : ret = emptyExp;
mov eax, DWORD PTR _emptyExp
mov DWORD PTR _ret$7$[ebp], eax
; 7696 : } else
jmp SHORT $LN88@xmlExpExpD
$LN87@xmlExpExpD:
; 7697 : ret = NULL;
mov DWORD PTR _ret$7$[ebp], 0
$LN88@xmlExpExpD:
; 7698 : /*
; 7699 : * here the structured derivation made no progress so
; 7700 : * we use the default token based derivation to force one more step
; 7701 : */
; 7702 : if (ctxt->tabSize == 0)
mov eax, DWORD PTR [edi+36]
test eax, eax
jne SHORT $LN91@xmlExpExpD
; 7703 : ctxt->tabSize = 40;
mov DWORD PTR [edi+36], 40 ; 00000028H
mov eax, 40 ; 00000028H
$LN91@xmlExpExpD:
; 7704 :
; 7705 : tab = (const xmlChar **) xmlMalloc(ctxt->tabSize *
shl eax, 2
push eax
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR _tab$1$[ebp], eax
; 7706 : sizeof(const xmlChar *));
; 7707 : if (tab == NULL) {
test eax, eax
je $LN149@xmlExpExpD
; 7708 : return(NULL);
; 7709 : }
; 7710 :
; 7711 : /*
; 7712 : * collect all the strings accepted by the subexpression on input
; 7713 : */
; 7714 : len = xmlExpGetStartInt(ctxt, sub, tab, ctxt->tabSize, 0);
push 0
push DWORD PTR [edi+36]
push eax
push esi
push edi
call _xmlExpGetStartInt
add esp, 20 ; 00000014H
mov DWORD PTR _len$1$[ebp], eax
; 7715 : while (len < 0) {
test eax, eax
jns SHORT $LN5@xmlExpExpD
npad 4
$LL4@xmlExpExpD:
; 7716 : const xmlChar **temp;
; 7717 : temp = (const xmlChar **) xmlRealloc((xmlChar **) tab, ctxt->tabSize * 2 *
mov eax, DWORD PTR [edi+36]
shl eax, 3
push eax
push DWORD PTR _tab$1$[ebp]
call DWORD PTR _xmlRealloc
add esp, 8
; 7718 : sizeof(const xmlChar *));
; 7719 : if (temp == NULL) {
test eax, eax
je $LN133@xmlExpExpD
; 7720 : xmlFree((xmlChar **) tab);
; 7721 : return(NULL);
; 7722 : }
; 7723 : tab = temp;
; 7724 : ctxt->tabSize *= 2;
mov ecx, DWORD PTR [edi+36]
; 7725 : len = xmlExpGetStartInt(ctxt, sub, tab, ctxt->tabSize, 0);
push 0
add ecx, ecx
mov DWORD PTR _tab$1$[ebp], eax
push ecx
push eax
push esi
push edi
mov DWORD PTR [edi+36], ecx
call _xmlExpGetStartInt
add esp, 20 ; 00000014H
mov DWORD PTR _len$1$[ebp], eax
test eax, eax
js SHORT $LL4@xmlExpExpD
$LN5@xmlExpExpD:
; 7726 : }
; 7727 : for (i = 0;i < len;i++) {
xor ecx, ecx
mov DWORD PTR _i$1$[ebp], ecx
test eax, eax
jle $LN7@xmlExpExpD
npad 8
$LL8@xmlExpExpD:
; 7728 : tmp = xmlExpStringDeriveInt(ctxt, exp, tab[i]);
mov eax, DWORD PTR _tab$1$[ebp]
push DWORD PTR [eax+ecx*4]
lea eax, DWORD PTR [eax+ecx*4]
push ebx
push edi
mov DWORD PTR tv1407[ebp], eax
call _xmlExpStringDeriveInt
add esp, 12 ; 0000000cH
mov DWORD PTR _tmp$7$[ebp], eax
; 7729 : if ((tmp == NULL) || (tmp == forbiddenExp)) {
test eax, eax
je $LN95@xmlExpExpD
cmp eax, DWORD PTR _forbiddenExp
je $LN95@xmlExpExpD
; 7733 : }
; 7734 : tmp2 = xmlExpStringDeriveInt(ctxt, sub, tab[i]);
mov eax, DWORD PTR tv1407[ebp]
push DWORD PTR [eax]
push esi
push edi
call _xmlExpStringDeriveInt
add esp, 12 ; 0000000cH
mov DWORD PTR _tmp2$4$[ebp], eax
; 7735 : if ((tmp2 == NULL) || (tmp2 == forbiddenExp)) {
test eax, eax
je $LN97@xmlExpExpD
cmp eax, DWORD PTR _forbiddenExp
je $LN97@xmlExpExpD
; 7740 : }
; 7741 : tmp3 = xmlExpExpDeriveInt(ctxt, tmp, tmp2);
push eax
push DWORD PTR _tmp$7$[ebp]
push edi
call _xmlExpExpDeriveInt
; 7742 : xmlExpFree(ctxt, tmp);
push DWORD PTR _tmp$7$[ebp]
mov DWORD PTR _tmp3$1$[ebp], eax
push edi
call _xmlExpFree
; 7743 : xmlExpFree(ctxt, tmp2);
push DWORD PTR _tmp2$4$[ebp]
push edi
call _xmlExpFree
; 7744 :
; 7745 : if ((tmp3 == NULL) || (tmp3 == forbiddenExp)) {
mov ecx, DWORD PTR _tmp3$1$[ebp]
add esp, 28 ; 0000001cH
test ecx, ecx
je SHORT $LN99@xmlExpExpD
cmp ecx, DWORD PTR _forbiddenExp
je SHORT $LN99@xmlExpExpD
; 7749 : }
; 7750 :
; 7751 : if (ret == NULL)
mov eax, DWORD PTR _ret$7$[ebp]
test eax, eax
jne SHORT $LN100@xmlExpExpD
; 7752 : ret = tmp3;
mov DWORD PTR _ret$7$[ebp], ecx
jmp SHORT $LN6@xmlExpExpD
$LN133@xmlExpExpD:
; 7763 : }
push DWORD PTR _tab$1$[ebp]
call DWORD PTR _xmlFree
add esp, 4
xor eax, eax
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN100@xmlExpExpD:
; 7753 : else {
; 7754 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, ret, tmp3, NULL, 0, 0);
push 0
push 0
push 0
push ecx
push eax
push 4
push edi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
mov DWORD PTR _ret$7$[ebp], eax
; 7755 : if (ret == NULL) {
test eax, eax
je SHORT $LN133@xmlExpExpD
$LN6@xmlExpExpD:
; 7726 : }
; 7727 : for (i = 0;i < len;i++) {
mov ecx, DWORD PTR _i$1$[ebp]
inc ecx
mov DWORD PTR _i$1$[ebp], ecx
cmp ecx, DWORD PTR _len$1$[ebp]
jl $LL8@xmlExpExpD
$LN7@xmlExpExpD:
; 7756 : xmlFree((xmlChar **) tab);
; 7757 : return(NULL);
; 7758 : }
; 7759 : }
; 7760 : }
; 7761 : xmlFree((xmlChar **) tab);
push DWORD PTR _tab$1$[ebp]
call DWORD PTR _xmlFree
; 7762 : return(ret);
mov eax, DWORD PTR _ret$7$[ebp]
add esp, 4
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN99@xmlExpExpD:
; 7746 : xmlExpFree(ctxt, ret);
push DWORD PTR _ret$7$[ebp]
push edi
call _xmlExpFree
; 7747 : xmlFree((xmlChar **) tab);
push DWORD PTR _tab$1$[ebp]
call DWORD PTR _xmlFree
; 7748 : return(tmp3);
mov eax, DWORD PTR _tmp3$1$[ebp]
add esp, 12 ; 0000000cH
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN97@xmlExpExpD:
; 7736 : xmlExpFree(ctxt, tmp);
mov ebx, DWORD PTR _tmp$7$[ebp]
push ebx
push edi
call _xmlExpFree
; 7737 : xmlExpFree(ctxt, ret);
push DWORD PTR _ret$7$[ebp]
push edi
call _xmlExpFree
; 7738 : xmlFree((xmlChar **) tab);
push DWORD PTR _tab$1$[ebp]
call DWORD PTR _xmlFree
add esp, 20 ; 00000014H
; 7739 : return(tmp);
mov eax, ebx
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN95@xmlExpExpD:
; 7730 : xmlExpFree(ctxt, ret);
push DWORD PTR _ret$7$[ebp]
push edi
call _xmlExpFree
; 7731 : xmlFree((xmlChar **) tab);
push DWORD PTR _tab$1$[ebp]
call DWORD PTR _xmlFree
; 7732 : return(tmp);
mov eax, DWORD PTR _tmp$7$[ebp]
add esp, 12 ; 0000000cH
pop edi
; 7763 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
npad 1
$LN163@xmlExpExpD:
DD $LN20@xmlExpExpD
DD $LN158@xmlExpExpD
DD $LN23@xmlExpExpD
DD $LN28@xmlExpExpD
DD $LN40@xmlExpExpD
DD $LN43@xmlExpExpD
_xmlExpExpDeriveInt ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpCheckCard
_TEXT SEGMENT
_exp$ = 8 ; size = 4
_sub$ = 12 ; size = 4
_xmlExpCheckCard PROC ; COMDAT
; 7231 : xmlExpCheckCard(xmlExpNodePtr exp, xmlExpNodePtr sub) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _sub$[ebp]
mov ecx, 1
mov esi, DWORD PTR [eax+8]
mov eax, DWORD PTR _exp$[ebp]
mov edx, DWORD PTR [eax+8]
cmp esi, -1
jne SHORT $LN2@xmlExpChec
; 7232 : int ret = 1;
; 7233 :
; 7234 : if (sub->c_max == -1) {
; 7235 : if (exp->c_max != -1)
; 7236 : ret = 0;
; 7237 : } else if ((exp->c_max >= 0) && (exp->c_max < sub->c_max)) {
xor eax, eax
cmp edx, esi
pop esi
sete al
; 7238 : ret = 0;
; 7239 : }
; 7240 : #if 0
; 7241 : if ((IS_NILLABLE(sub)) && (!IS_NILLABLE(exp)))
; 7242 : ret = 0;
; 7243 : #endif
; 7244 : return(ret);
; 7245 : }
pop ebp
ret 0
$LN2@xmlExpChec:
; 7232 : int ret = 1;
; 7233 :
; 7234 : if (sub->c_max == -1) {
; 7235 : if (exp->c_max != -1)
; 7236 : ret = 0;
; 7237 : } else if ((exp->c_max >= 0) && (exp->c_max < sub->c_max)) {
test edx, edx
js SHORT $LN7@xmlExpChec
xor eax, eax
cmp edx, esi
cmovl ecx, eax
$LN7@xmlExpChec:
; 7238 : ret = 0;
; 7239 : }
; 7240 : #if 0
; 7241 : if ((IS_NILLABLE(sub)) && (!IS_NILLABLE(exp)))
; 7242 : ret = 0;
; 7243 : #endif
; 7244 : return(ret);
; 7245 : }
mov eax, ecx
pop esi
pop ebp
ret 0
_xmlExpCheckCard ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpStringDeriveInt
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
tv358 = 12 ; size = 4
_exp$ = 12 ; size = 4
_str$ = 16 ; size = 4
_xmlExpStringDeriveInt PROC ; COMDAT
; 7091 : {
push ebp
mov ebp, esp
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _exp$[ebp]
movzx eax, BYTE PTR [esi]
cmp eax, 5
ja SHORT $LN2@xmlExpStri
; 7092 : xmlExpNodePtr ret;
; 7093 :
; 7094 : switch (exp->type) {
jmp DWORD PTR $LN33@xmlExpStri[eax*4]
$LN6@xmlExpStri:
; 7095 : case XML_EXP_EMPTY:
; 7096 : return(forbiddenExp);
; 7097 : case XML_EXP_FORBID:
; 7098 : return(forbiddenExp);
; 7099 : case XML_EXP_ATOM:
; 7100 : if (exp->exp_str == str) {
mov ecx, DWORD PTR [esi+20]
cmp ecx, DWORD PTR _str$[ebp]
mov eax, DWORD PTR _forbiddenExp
cmove eax, DWORD PTR _emptyExp
pop edi
; 7193 : NULL, 0, 0));
; 7194 : }
; 7195 : }
; 7196 : return(NULL);
; 7197 : }
pop esi
pop ebx
pop ebp
ret 0
$LN9@xmlExpStri:
; 7101 : #ifdef DEBUG_DERIV
; 7102 : printf("deriv atom: equal => Empty\n");
; 7103 : #endif
; 7104 : ret = emptyExp;
; 7105 : } else {
; 7106 : #ifdef DEBUG_DERIV
; 7107 : printf("deriv atom: mismatch => forbid\n");
; 7108 : #endif
; 7109 : /* TODO wildcards here */
; 7110 : ret = forbiddenExp;
; 7111 : }
; 7112 : return(ret);
; 7113 : case XML_EXP_OR: {
; 7114 : xmlExpNodePtr tmp;
; 7115 :
; 7116 : #ifdef DEBUG_DERIV
; 7117 : printf("deriv or: => or(derivs)\n");
; 7118 : #endif
; 7119 : tmp = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
push DWORD PTR _str$[ebp]
mov edi, DWORD PTR _ctxt$[ebp]
push DWORD PTR [esi+12]
push edi
call _xmlExpStringDeriveInt
mov ebx, eax
add esp, 12 ; 0000000cH
; 7120 : if (tmp == NULL) {
test ebx, ebx
je SHORT $LN2@xmlExpStri
; 7121 : return(NULL);
; 7122 : }
; 7123 : ret = xmlExpStringDeriveInt(ctxt, exp->exp_right, str);
push DWORD PTR _str$[ebp]
push DWORD PTR [esi+20]
push edi
call _xmlExpStringDeriveInt
add esp, 12 ; 0000000cH
; 7124 : if (ret == NULL) {
test eax, eax
jne SHORT $LN11@xmlExpStri
; 7125 : xmlExpFree(ctxt, tmp);
push ebx
push edi
call _xmlExpFree
add esp, 8
$LN2@xmlExpStri:
; 7193 : NULL, 0, 0));
; 7194 : }
; 7195 : }
; 7196 : return(NULL);
; 7197 : }
xor eax, eax
$LN1@xmlExpStri:
pop edi
pop esi
pop ebx
pop ebp
ret 0
$LN11@xmlExpStri:
; 7126 : return(NULL);
; 7127 : }
; 7128 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_OR, tmp, ret,
push 0
push 0
push 0
push eax
push ebx
push 4
push edi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
pop edi
; 7193 : NULL, 0, 0));
; 7194 : }
; 7195 : }
; 7196 : return(NULL);
; 7197 : }
pop esi
pop ebx
pop ebp
ret 0
$LN12@xmlExpStri:
; 7129 : NULL, 0, 0);
; 7130 : return(ret);
; 7131 : }
; 7132 : case XML_EXP_SEQ:
; 7133 : #ifdef DEBUG_DERIV
; 7134 : printf("deriv seq: starting with left\n");
; 7135 : #endif
; 7136 : ret = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
mov ebx, DWORD PTR _str$[ebp]
mov edi, DWORD PTR _ctxt$[ebp]
push ebx
push DWORD PTR [esi+12]
push edi
call _xmlExpStringDeriveInt
mov edx, eax
add esp, 12 ; 0000000cH
; 7137 : if (ret == NULL) {
test edx, edx
je SHORT $LN2@xmlExpStri
; 7138 : return(NULL);
; 7139 : } else if (ret == forbiddenExp) {
cmp edx, DWORD PTR _forbiddenExp
jne SHORT $LN15@xmlExpStri
; 7140 : if (IS_NILLABLE(exp->exp_left)) {
mov ecx, DWORD PTR [esi+12]
test BYTE PTR [ecx+1], 1
je SHORT $LN16@xmlExpStri
; 7141 : #ifdef DEBUG_DERIV
; 7142 : printf("deriv seq: left failed but nillable\n");
; 7143 : #endif
; 7144 : ret = xmlExpStringDeriveInt(ctxt, exp->exp_right, str);
push ebx
push DWORD PTR [esi+20]
push edi
call _xmlExpStringDeriveInt
add esp, 12 ; 0000000cH
; 7152 : NULL, 0, 0);
; 7153 : }
; 7154 : return(ret);
mov edx, eax
pop edi
; 7193 : NULL, 0, 0));
; 7194 : }
; 7195 : }
; 7196 : return(NULL);
; 7197 : }
pop esi
pop ebx
pop ebp
ret 0
$LN15@xmlExpStri:
; 7145 : }
; 7146 : } else {
; 7147 : #ifdef DEBUG_DERIV
; 7148 : printf("deriv seq: left match => sequence\n");
; 7149 : #endif
; 7150 : exp->exp_right->ref++;
mov eax, DWORD PTR [esi+20]
; 7151 : ret = xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, exp->exp_right,
push 0
push 0
push 0
inc DWORD PTR [eax+4]
push DWORD PTR [esi+20]
push edx
push 3
push edi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
; 7152 : NULL, 0, 0);
; 7153 : }
; 7154 : return(ret);
mov edx, eax
$LN16@xmlExpStri:
; 7193 : NULL, 0, 0));
; 7194 : }
; 7195 : }
; 7196 : return(NULL);
; 7197 : }
pop edi
pop esi
mov eax, edx
pop ebx
pop ebp
ret 0
$LN18@xmlExpStri:
; 7155 : case XML_EXP_COUNT: {
; 7156 : int min, max;
; 7157 : xmlExpNodePtr tmp;
; 7158 :
; 7159 : if (exp->exp_max == 0)
cmp DWORD PTR [esi+24], 0
je $LN30@xmlExpStri
; 7161 : ret = xmlExpStringDeriveInt(ctxt, exp->exp_left, str);
push DWORD PTR _str$[ebp]
mov ebx, DWORD PTR _ctxt$[ebp]
push DWORD PTR [esi+12]
push ebx
call _xmlExpStringDeriveInt
mov edi, eax
add esp, 12 ; 0000000cH
; 7162 : if (ret == NULL)
test edi, edi
je $LN2@xmlExpStri
; 7163 : return(NULL);
; 7164 : if (ret == forbiddenExp) {
cmp edi, DWORD PTR _forbiddenExp
je $LN1@xmlExpStri
; 7165 : #ifdef DEBUG_DERIV
; 7166 : printf("deriv count: pattern mismatch => forbid\n");
; 7167 : #endif
; 7168 : return(ret);
; 7169 : }
; 7170 : if (exp->exp_max == 1)
mov ecx, DWORD PTR [esi+24]
mov DWORD PTR tv358[ebp], ecx
cmp ecx, 1
je $LN1@xmlExpStri
; 7171 : return(ret);
; 7172 : if (exp->exp_max < 0) /* unbounded */
; 7173 : max = -1;
; 7174 : else
; 7175 : max = exp->exp_max - 1;
; 7176 : if (exp->exp_min > 0)
; 7177 : min = exp->exp_min - 1;
; 7178 : else
; 7179 : min = 0;
; 7180 : exp->exp_left->ref++;
mov eax, DWORD PTR [esi+12]
dec ecx
mov edx, DWORD PTR [esi+20]
inc DWORD PTR [eax+4]
or eax, -1
cmp DWORD PTR tv358[ebp], 0
cmovge eax, ecx
xor ecx, ecx
; 7181 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, exp->exp_left, NULL,
push eax
test edx, edx
lea eax, DWORD PTR [edx-1]
cmovle eax, ecx
push eax
push ecx
push ecx
push DWORD PTR [esi+12]
push 5
push ebx
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
; 7182 : NULL, min, max);
; 7183 : if (ret == emptyExp) {
cmp edi, DWORD PTR _emptyExp
je $LN1@xmlExpStri
; 7184 : #ifdef DEBUG_DERIV
; 7185 : printf("deriv count: match to empty => new count\n");
; 7186 : #endif
; 7187 : return(tmp);
; 7188 : }
; 7189 : #ifdef DEBUG_DERIV
; 7190 : printf("deriv count: match => sequence with new count\n");
; 7191 : #endif
; 7192 : return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, ret, tmp,
push 0
push 0
push 0
push eax
push edi
push 3
push ebx
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
pop edi
; 7193 : NULL, 0, 0));
; 7194 : }
; 7195 : }
; 7196 : return(NULL);
; 7197 : }
pop esi
pop ebx
pop ebp
ret 0
$LN30@xmlExpStri:
; 7160 : return(forbiddenExp);
mov eax, DWORD PTR _forbiddenExp
pop edi
; 7193 : NULL, 0, 0));
; 7194 : }
; 7195 : }
; 7196 : return(NULL);
; 7197 : }
pop esi
pop ebx
pop ebp
ret 0
npad 2
$LN33@xmlExpStri:
DD $LN30@xmlExpStri
DD $LN30@xmlExpStri
DD $LN6@xmlExpStri
DD $LN12@xmlExpStri
DD $LN9@xmlExpStri
DD $LN18@xmlExpStri
_xmlExpStringDeriveInt ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpGetStartInt
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_exp$ = 12 ; size = 4
_list$ = 16 ; size = 4
_len$ = 20 ; size = 4
_nb$ = 24 ; size = 4
_xmlExpGetStartInt PROC ; COMDAT
; 7008 : const xmlChar**list, int len, int nb) {
push ebp
mov ebp, esp
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _exp$[ebp]
movzx eax, BYTE PTR [esi]
cmp eax, 5
ja SHORT $LN2@xmlExpGetS
npad 5
$tail$32:
; 7009 : int tmp, tmp2;
; 7010 : tail:
; 7011 : switch (exp->type) {
jmp DWORD PTR $LN31@xmlExpGetS[eax*4]
$LN12@xmlExpGetS:
; 7023 : return(1);
; 7024 : case XML_EXP_COUNT:
; 7025 : exp = exp->exp_left;
mov esi, DWORD PTR [esi+12]
movzx eax, BYTE PTR [esi]
cmp eax, 5
jbe SHORT $tail$32
$LN2@xmlExpGetS:
; 7048 : }
; 7049 : return(-1);
or eax, -1
$LN1@xmlExpGetS:
pop edi
; 7050 : }
pop esi
pop ebx
pop ebp
ret 0
$LN9@xmlExpGetS:
; 7012 : case XML_EXP_FORBID:
; 7013 : return(0);
; 7014 : case XML_EXP_EMPTY:
; 7015 : return(0);
; 7016 : case XML_EXP_ATOM:
; 7017 : for (tmp = 0;tmp < nb;tmp++)
mov ecx, DWORD PTR _nb$[ebp]
xor eax, eax
mov edx, DWORD PTR _list$[ebp]
test ecx, ecx
jle SHORT $LN5@xmlExpGetS
; 7018 : if (list[tmp] == exp->exp_str)
mov edi, DWORD PTR [esi+20]
npad 7
$LL6@xmlExpGetS:
cmp DWORD PTR [edx+eax*4], edi
je SHORT $LN23@xmlExpGetS
; 7012 : case XML_EXP_FORBID:
; 7013 : return(0);
; 7014 : case XML_EXP_EMPTY:
; 7015 : return(0);
; 7016 : case XML_EXP_ATOM:
; 7017 : for (tmp = 0;tmp < nb;tmp++)
inc eax
cmp eax, ecx
jl SHORT $LL6@xmlExpGetS
$LN5@xmlExpGetS:
; 7019 : return(0);
; 7020 : if (nb >= len)
cmp ecx, DWORD PTR _len$[ebp]
jl SHORT $LN11@xmlExpGetS
; 7050 : }
pop edi
pop esi
mov eax, -2 ; fffffffeH
pop ebx
pop ebp
ret 0
$LN11@xmlExpGetS:
; 7021 : return(-2);
; 7022 : list[nb] = exp->exp_str;
mov eax, DWORD PTR [esi+20]
pop edi
; 7050 : }
pop esi
mov DWORD PTR [edx+ecx*4], eax
mov eax, 1
pop ebx
pop ebp
ret 0
$LN23@xmlExpGetS:
pop edi
pop esi
xor eax, eax
pop ebx
pop ebp
ret 0
$LN13@xmlExpGetS:
; 7026 : goto tail;
; 7027 : case XML_EXP_SEQ:
; 7028 : tmp = xmlExpGetStartInt(ctxt, exp->exp_left, list, len, nb);
mov ebx, DWORD PTR _nb$[ebp]
push ebx
push DWORD PTR _len$[ebp]
push DWORD PTR _list$[ebp]
push DWORD PTR [esi+12]
push DWORD PTR _ctxt$[ebp]
call _xmlExpGetStartInt
mov edi, eax
add esp, 20 ; 00000014H
; 7029 : if (tmp < 0)
test edi, edi
js SHORT $LN15@xmlExpGetS
; 7030 : return(tmp);
; 7031 : if (IS_NILLABLE(exp->exp_left)) {
mov eax, DWORD PTR [esi+12]
test BYTE PTR [eax+1], 1
je SHORT $LN15@xmlExpGetS
; 7032 : tmp2 = xmlExpGetStartInt(ctxt, exp->exp_right, list, len,
lea eax, DWORD PTR [edi+ebx]
push eax
push DWORD PTR _len$[ebp]
push DWORD PTR _list$[ebp]
push DWORD PTR [esi+20]
push DWORD PTR _ctxt$[ebp]
call _xmlExpGetStartInt
add esp, 20 ; 00000014H
; 7033 : nb + tmp);
; 7034 : if (tmp2 < 0)
test eax, eax
js $LN1@xmlExpGetS
; 7035 : return(tmp2);
; 7036 : tmp += tmp2;
add edi, eax
$LN15@xmlExpGetS:
; 7050 : }
mov eax, edi
pop edi
pop esi
pop ebx
pop ebp
ret 0
$LN17@xmlExpGetS:
; 7037 : }
; 7038 : return(tmp);
; 7039 : case XML_EXP_OR:
; 7040 : tmp = xmlExpGetStartInt(ctxt, exp->exp_left, list, len, nb);
mov ebx, DWORD PTR _nb$[ebp]
push ebx
push DWORD PTR _len$[ebp]
push DWORD PTR _list$[ebp]
push DWORD PTR [esi+12]
push DWORD PTR _ctxt$[ebp]
call _xmlExpGetStartInt
mov edi, eax
add esp, 20 ; 00000014H
; 7041 : if (tmp < 0)
test edi, edi
js SHORT $LN15@xmlExpGetS
; 7042 : return(tmp);
; 7043 : tmp2 = xmlExpGetStartInt(ctxt, exp->exp_right, list, len,
lea eax, DWORD PTR [edi+ebx]
push eax
push DWORD PTR _len$[ebp]
push DWORD PTR _list$[ebp]
push DWORD PTR [esi+20]
push DWORD PTR _ctxt$[ebp]
call _xmlExpGetStartInt
add esp, 20 ; 00000014H
; 7044 : nb + tmp);
; 7045 : if (tmp2 < 0)
test eax, eax
js $LN1@xmlExpGetS
; 7046 : return(tmp2);
; 7047 : return(tmp + tmp2);
add eax, edi
pop edi
; 7050 : }
pop esi
pop ebx
pop ebp
ret 0
npad 3
$LN31@xmlExpGetS:
DD $LN23@xmlExpGetS
DD $LN23@xmlExpGetS
DD $LN9@xmlExpGetS
DD $LN13@xmlExpGetS
DD $LN17@xmlExpGetS
DD $LN12@xmlExpGetS
_xmlExpGetStartInt ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpGetLanguageInt
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_exp$ = 12 ; size = 4
_list$ = 16 ; size = 4
_len$ = 20 ; size = 4
_nb$ = 24 ; size = 4
_xmlExpGetLanguageInt PROC ; COMDAT
; 6955 : const xmlChar**list, int len, int nb) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _exp$[ebp]
movzx eax, BYTE PTR [esi]
cmp eax, 5
ja SHORT $LN2@xmlExpGetL
npad 6
$tail$28:
; 6956 : int tmp, tmp2;
; 6957 : tail:
; 6958 : switch (exp->type) {
jmp DWORD PTR $LN27@xmlExpGetL[eax*4]
$LN11@xmlExpGetL:
; 6969 : case XML_EXP_COUNT:
; 6970 : exp = exp->exp_left;
mov esi, DWORD PTR [esi+12]
movzx eax, BYTE PTR [esi]
cmp eax, 5
jbe SHORT $tail$28
$LN2@xmlExpGetL:
pop edi
; 6982 : }
; 6983 : return(-1);
or eax, -1
; 6984 : }
pop esi
pop ebp
ret 0
$LN8@xmlExpGetL:
; 6959 : case XML_EXP_EMPTY:
; 6960 : return(0);
; 6961 : case XML_EXP_ATOM:
; 6962 : for (tmp = 0;tmp < nb;tmp++)
mov ecx, DWORD PTR _nb$[ebp]
xor eax, eax
mov edx, DWORD PTR _list$[ebp]
test ecx, ecx
jle SHORT $LN5@xmlExpGetL
; 6963 : if (list[tmp] == exp->exp_str)
mov edi, DWORD PTR [esi+20]
$LL6@xmlExpGetL:
cmp DWORD PTR [edx+eax*4], edi
je SHORT $LN18@xmlExpGetL
; 6959 : case XML_EXP_EMPTY:
; 6960 : return(0);
; 6961 : case XML_EXP_ATOM:
; 6962 : for (tmp = 0;tmp < nb;tmp++)
inc eax
cmp eax, ecx
jl SHORT $LL6@xmlExpGetL
$LN5@xmlExpGetL:
; 6965 : if (nb >= len)
cmp ecx, DWORD PTR _len$[ebp]
jl SHORT $LN10@xmlExpGetL
; 6966 : return(-2);
pop edi
mov eax, -2 ; fffffffeH
; 6984 : }
pop esi
pop ebp
ret 0
$LN10@xmlExpGetL:
; 6967 : list[nb] = exp->exp_str;
mov eax, DWORD PTR [esi+20]
pop edi
mov DWORD PTR [edx+ecx*4], eax
; 6968 : return(1);
mov eax, 1
; 6984 : }
pop esi
pop ebp
ret 0
$LN18@xmlExpGetL:
pop edi
; 6964 : return(0);
xor eax, eax
; 6984 : }
pop esi
pop ebp
ret 0
$LN12@xmlExpGetL:
push ebx
; 6971 : goto tail;
; 6972 : case XML_EXP_SEQ:
; 6973 : case XML_EXP_OR:
; 6974 : tmp = xmlExpGetLanguageInt(ctxt, exp->exp_left, list, len, nb);
mov ebx, DWORD PTR _nb$[ebp]
push ebx
push DWORD PTR _len$[ebp]
push DWORD PTR _list$[ebp]
push DWORD PTR [esi+12]
push DWORD PTR _ctxt$[ebp]
call _xmlExpGetLanguageInt
mov edi, eax
add esp, 20 ; 00000014H
; 6975 : if (tmp < 0)
test edi, edi
jns SHORT $LN13@xmlExpGetL
$LN25@xmlExpGetL:
pop ebx
pop edi
; 6984 : }
pop esi
pop ebp
ret 0
$LN13@xmlExpGetL:
; 6976 : return(tmp);
; 6977 : tmp2 = xmlExpGetLanguageInt(ctxt, exp->exp_right, list, len,
lea eax, DWORD PTR [edi+ebx]
push eax
push DWORD PTR _len$[ebp]
push DWORD PTR _list$[ebp]
push DWORD PTR [esi+20]
push DWORD PTR _ctxt$[ebp]
call _xmlExpGetLanguageInt
add esp, 20 ; 00000014H
; 6978 : nb + tmp);
; 6979 : if (tmp2 < 0)
test eax, eax
js SHORT $LN25@xmlExpGetL
; 6980 : return(tmp2);
; 6981 : return(tmp + tmp2);
pop ebx
add eax, edi
pop edi
; 6984 : }
pop esi
pop ebp
ret 0
$LN27@xmlExpGetL:
DD $LN18@xmlExpGetL
DD $LN2@xmlExpGetL
DD $LN8@xmlExpGetL
DD $LN12@xmlExpGetL
DD $LN12@xmlExpGetL
DD $LN11@xmlExpGetL
_xmlExpGetLanguageInt ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpHashGetEntry
_TEXT SEGMENT
tv1599 = -12 ; size = 4
_min$1$ = -8 ; size = 4
_type$1$ = -4 ; size = 4
tv1631 = -4 ; size = 4
_kbase$ = 8 ; size = 2
_value$1 = 8 ; size = 2
_ctxt$ = 8 ; size = 4
_kbase$1$ = 10 ; size = 2
_type$ = 12 ; size = 4
_left$ = 16 ; size = 4
_right$ = 20 ; size = 4
_name$ = 24 ; size = 4
_min$ = 28 ; size = 4
_max$ = 32 ; size = 4
_xmlExpHashGetEntry PROC ; COMDAT
; 6571 : const xmlChar *name, int min, int max) {
push ebp
mov ebp, esp
sub esp, 12 ; 0000000cH
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push ebx
push esi
push edi
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
test esi, esi
je $LN32@xmlExpHash
; 6572 : unsigned short kbase, key;
; 6573 : xmlExpNodePtr entry;
; 6574 : xmlExpNodePtr insert;
; 6575 :
; 6576 : if (ctxt == NULL)
; 6577 : return(NULL);
; 6578 :
; 6579 : /*
; 6580 : * Check for duplicate and insertion location.
; 6581 : */
; 6582 : if (type == XML_EXP_ATOM) {
mov eax, DWORD PTR _type$[ebp]
mov ecx, DWORD PTR _min$[ebp]
mov edx, DWORD PTR _max$[ebp]
mov DWORD PTR _type$1$[ebp], eax
mov DWORD PTR _min$1$[ebp], ecx
cmp eax, 2
jne SHORT $LN6@xmlExpHash
; 6583 : kbase = xmlExpHashNameComputeKey(name);
mov eax, DWORD PTR _name$[ebp]
mov edi, eax
; 6494 : unsigned short value = 0L;
mov DWORD PTR _value$1[ebp], 0
; 6495 : char ch;
; 6496 :
; 6497 : if (name != NULL) {
test eax, eax
je SHORT $LN100@xmlExpHash
; 6498 : value += 30 * (*name);
mov bl, BYTE PTR [eax]
movzx eax, bl
mov cx, ax
shl cx, 4
sub cx, ax
add cx, cx
movzx ecx, cx
mov DWORD PTR _value$1[ebp], ecx
; 6499 : while ((ch = *name++) != 0) {
test bl, bl
je SHORT $LN100@xmlExpHash
mov dx, cx
$LL72@xmlExpHash:
; 6500 : value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
mov ax, dx
shl ecx, 5
shr ax, 3
lea edi, DWORD PTR [edi+1]
add cx, ax
movsx ax, bl
mov bl, BYTE PTR [edi]
add cx, ax
xor dx, cx
mov WORD PTR _value$1[ebp], dx
test bl, bl
je SHORT $LN85@xmlExpHash
; 6499 : while ((ch = *name++) != 0) {
mov ecx, DWORD PTR _value$1[ebp]
jmp SHORT $LL72@xmlExpHash
$LN100@xmlExpHash:
mov dx, WORD PTR _value$1[ebp]
$LN85@xmlExpHash:
; 6583 : kbase = xmlExpHashNameComputeKey(name);
mov ebx, DWORD PTR _right$[ebp]
mov edi, DWORD PTR _left$[ebp]
movzx eax, dx
jmp $LN110@xmlExpHash
$LN6@xmlExpHash:
; 6584 : } else if (type == XML_EXP_COUNT) {
mov edi, DWORD PTR _left$[ebp]
cmp eax, 5
jne SHORT $LN8@xmlExpHash
; 6585 : /* COUNT reduction rule 1 */
; 6586 : /* a{1} -> a */
; 6587 : if (min == max) {
cmp ecx, edx
jne SHORT $LN12@xmlExpHash
; 6588 : if (min == 1) {
cmp ecx, 1
je SHORT $LN97@xmlExpHash
; 6589 : return(left);
; 6590 : }
; 6591 : if (min == 0) {
test ecx, ecx
jne SHORT $LN111@xmlExpHash
; 6592 : xmlExpFree(ctxt, left);
push edi
push esi
call _xmlExpFree
; 6593 : return(emptyExp);
mov eax, DWORD PTR _emptyExp
add esp, 8
pop edi
; 6793 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN12@xmlExpHash:
; 6594 : }
; 6595 : }
; 6596 : if (min < 0) {
test ecx, ecx
$LN111@xmlExpHash:
jns SHORT $LN13@xmlExpHash
; 6597 : xmlExpFree(ctxt, left);
push edi
push esi
call _xmlExpFree
; 6598 : return(forbiddenExp);
mov eax, DWORD PTR _forbiddenExp
add esp, 8
pop edi
; 6793 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN13@xmlExpHash:
; 6599 : }
; 6600 : if (max == -1)
movzx ecx, cx
cmp edx, -1
jne SHORT $LN14@xmlExpHash
; 6601 : kbase = min + 79;
lea eax, DWORD PTR [ecx+79]
jmp SHORT $LN112@xmlExpHash
$LN14@xmlExpHash:
; 6602 : else
; 6603 : kbase = max - min;
mov eax, edx
sub eax, ecx
$LN112@xmlExpHash:
; 6604 : kbase += left->key;
mov ebx, DWORD PTR _right$[ebp]
movzx eax, ax
mov DWORD PTR _kbase$[ebp], eax
add ax, WORD PTR [edi+2]
jmp $LN113@xmlExpHash
$LN8@xmlExpHash:
; 6605 : } else if (type == XML_EXP_OR) {
mov ebx, DWORD PTR _right$[ebp]
cmp eax, 4
jne $LN16@xmlExpHash
; 6606 : /* Forbid reduction rules */
; 6607 : if (left->type == XML_EXP_FORBID) {
mov dl, BYTE PTR [edi]
cmp dl, 1
je SHORT $LN24@xmlExpHash
; 6608 : xmlExpFree(ctxt, left);
; 6609 : return(right);
; 6610 : }
; 6611 : if (right->type == XML_EXP_FORBID) {
mov cl, BYTE PTR [ebx]
cmp cl, 1
je $LN95@xmlExpHash
; 6612 : xmlExpFree(ctxt, right);
; 6613 : return(left);
; 6614 : }
; 6615 :
; 6616 : /* OR reduction rule 1 */
; 6617 : /* a | a reduced to a */
; 6618 : if (left == right) {
cmp edi, ebx
jne SHORT $LN20@xmlExpHash
; 6619 : left->ref--;
dec DWORD PTR [edi+4]
$LN97@xmlExpHash:
; 6793 : }
mov eax, edi
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN20@xmlExpHash:
; 6620 : return(left);
; 6621 : }
; 6622 : /* OR canonicalization rule 1 */
; 6623 : /* linearize (a | b) | c into a | (b | c) */
; 6624 : if ((left->type == XML_EXP_OR) && (right->type != XML_EXP_OR)) {
mov al, cl
cmp dl, 4
jne SHORT $LN21@xmlExpHash
cmp cl, dl
je SHORT $LN21@xmlExpHash
; 6625 : xmlExpNodePtr tmp = left;
mov eax, edi
; 6626 : left = right;
mov edi, ebx
; 6627 : right = tmp;
mov ebx, eax
mov al, dl
$LN21@xmlExpHash:
; 6628 : }
; 6629 : /* OR reduction rule 2 */
; 6630 : /* a | (a | b) and b | (a | b) are reduced to a | b */
; 6631 : if (right->type == XML_EXP_OR) {
cmp al, 4
jne SHORT $LN94@xmlExpHash
; 6632 : if ((left == right->exp_left) ||
cmp edi, DWORD PTR [ebx+12]
je SHORT $LN24@xmlExpHash
cmp edi, DWORD PTR [ebx+20]
jne SHORT $LN94@xmlExpHash
$LN24@xmlExpHash:
; 6793 : }
push edi
push esi
call _xmlExpFree
add esp, 8
$LN116@xmlExpHash:
pop edi
pop esi
mov eax, ebx
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN94@xmlExpHash:
; 6633 : (left == right->exp_right)) {
; 6634 : xmlExpFree(ctxt, left);
; 6635 : return(right);
; 6636 : }
; 6637 : }
; 6638 : /* OR canonicalization rule 2 */
; 6639 : /* linearize (a | b) | c into a | (b | c) */
; 6640 : if (left->type == XML_EXP_OR) {
cmp BYTE PTR [edi], 4
jne SHORT $LN25@xmlExpHash
; 6641 : xmlExpNodePtr tmp;
; 6642 :
; 6643 : /* OR canonicalization rule 2 */
; 6644 : if ((left->exp_right->type != XML_EXP_OR) &&
mov ecx, DWORD PTR [edi+20]
mov edx, ecx
cmp BYTE PTR [ecx], 4
je SHORT $LN26@xmlExpHash
mov esi, DWORD PTR [edi+12]
mov ax, WORD PTR [ecx+2]
cmp ax, WORD PTR [esi+2]
mov esi, DWORD PTR _ctxt$[ebp]
jae SHORT $LN26@xmlExpHash
; 6645 : (left->exp_right->key < left->exp_left->key)) {
; 6646 : tmp = left->exp_right;
; 6647 : left->exp_right = left->exp_left;
mov eax, DWORD PTR [edi+12]
; 6648 : left->exp_left = tmp;
mov edx, eax
mov DWORD PTR [edi+20], eax
mov DWORD PTR [edi+12], ecx
$LN26@xmlExpHash:
; 6649 : }
; 6650 : left->exp_right->ref++;
inc DWORD PTR [edx+4]
; 6651 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_right, right,
push 0
push 0
push 0
push ebx
push DWORD PTR [edi+20]
push 4
push esi
call _xmlExpHashGetEntry
; 6652 : NULL, 0, 0);
; 6653 : left->exp_left->ref++;
mov ecx, DWORD PTR [edi+12]
; 6654 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left->exp_left, tmp,
push 0
push 0
push 0
inc DWORD PTR [ecx+4]
push eax
push DWORD PTR [edi+12]
push 4
push esi
call _xmlExpHashGetEntry
; 6655 : NULL, 0, 0);
; 6656 :
; 6657 : xmlExpFree(ctxt, left);
push edi
push DWORD PTR _ctxt$[ebp]
mov esi, eax
call _xmlExpFree
add esp, 64 ; 00000040H
; 6658 : return(tmp);
mov eax, esi
pop edi
; 6793 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN25@xmlExpHash:
; 6659 : }
; 6660 : if (right->type == XML_EXP_OR) {
cmp al, 4
jne $LN27@xmlExpHash
; 6661 : /* Ordering in the tree */
; 6662 : /* C | (A | B) -> A | (B | C) */
; 6663 : if (left->key > right->exp_right->key) {
mov ecx, DWORD PTR [ebx+20]
movzx edx, WORD PTR [edi+2]
cmp dx, WORD PTR [ecx+2]
jbe SHORT $LN29@xmlExpHash
; 6664 : xmlExpNodePtr tmp;
; 6665 : right->exp_right->ref++;
inc DWORD PTR [ecx+4]
; 6666 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_right,
push 0
push 0
push 0
push edi
push DWORD PTR [ebx+20]
push 4
push esi
call _xmlExpHashGetEntry
; 6667 : left, NULL, 0, 0);
; 6668 : right->exp_left->ref++;
mov ecx, DWORD PTR [ebx+12]
; 6669 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
push 0
push 0
push 0
inc DWORD PTR [ecx+4]
push eax
push DWORD PTR [ebx+12]
push 4
push esi
call _xmlExpHashGetEntry
; 6670 : tmp, NULL, 0, 0);
; 6671 : xmlExpFree(ctxt, right);
push ebx
push DWORD PTR _ctxt$[ebp]
mov esi, eax
call _xmlExpFree
add esp, 64 ; 00000040H
; 6672 : return(tmp);
mov eax, esi
pop edi
; 6793 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN29@xmlExpHash:
; 6673 : }
; 6674 : /* Ordering in the tree */
; 6675 : /* B | (A | C) -> A | (B | C) */
; 6676 : if (left->key > right->exp_left->key) {
mov eax, DWORD PTR [ebx+12]
cmp dx, WORD PTR [eax+2]
jbe SHORT $LN31@xmlExpHash
; 6677 : xmlExpNodePtr tmp;
; 6678 : right->exp_right->ref++;
inc DWORD PTR [ecx+4]
; 6679 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, left,
push 0
push 0
push 0
push DWORD PTR [ebx+20]
push edi
push 4
push esi
call _xmlExpHashGetEntry
; 6680 : right->exp_right, NULL, 0, 0);
; 6681 : right->exp_left->ref++;
mov ecx, DWORD PTR [ebx+12]
; 6682 : tmp = xmlExpHashGetEntry(ctxt, XML_EXP_OR, right->exp_left,
push 0
push 0
push 0
inc DWORD PTR [ecx+4]
push eax
push DWORD PTR [ebx+12]
push 4
push esi
call _xmlExpHashGetEntry
; 6683 : tmp, NULL, 0, 0);
; 6684 : xmlExpFree(ctxt, right);
push ebx
push DWORD PTR _ctxt$[ebp]
mov esi, eax
call _xmlExpFree
add esp, 64 ; 00000040H
; 6685 : return(tmp);
mov eax, esi
pop edi
; 6793 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN27@xmlExpHash:
; 6686 : }
; 6687 : }
; 6688 : /* we know both types are != XML_EXP_OR here */
; 6689 : else if (left->key > right->key) {
mov ax, WORD PTR [edi+2]
cmp ax, WORD PTR [ebx+2]
jbe SHORT $LN31@xmlExpHash
; 6690 : xmlExpNodePtr tmp = left;
mov eax, edi
; 6691 : left = right;
mov edi, ebx
; 6692 : right = tmp;
mov ebx, eax
$LN31@xmlExpHash:
; 6693 : }
; 6694 : kbase = xmlExpHashComputeKey(type, left, right);
push ebx
push edi
push 4
jmp SHORT $LN114@xmlExpHash
$LN16@xmlExpHash:
; 6695 : } else if (type == XML_EXP_SEQ) {
cmp eax, 3
jne $LN32@xmlExpHash
; 6696 : /* Forbid reduction rules */
; 6697 : if (left->type == XML_EXP_FORBID) {
mov al, BYTE PTR [edi]
cmp al, 1
jne SHORT $LN34@xmlExpHash
$LN95@xmlExpHash:
; 6698 : xmlExpFree(ctxt, right);
push ebx
push esi
call _xmlExpFree
add esp, 8
; 6699 : return(left);
mov eax, edi
pop edi
; 6793 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN34@xmlExpHash:
; 6700 : }
; 6701 : if (right->type == XML_EXP_FORBID) {
mov cl, BYTE PTR [ebx]
cmp cl, 1
je $LN24@xmlExpHash
; 6702 : xmlExpFree(ctxt, left);
; 6703 : return(right);
; 6704 : }
; 6705 : /* Empty reduction rules */
; 6706 : if (right->type == XML_EXP_EMPTY) {
test cl, cl
je $LN97@xmlExpHash
; 6707 : return(left);
; 6708 : }
; 6709 : if (left->type == XML_EXP_EMPTY) {
test al, al
je $LN116@xmlExpHash
; 6710 : return(right);
; 6711 : }
; 6712 : kbase = xmlExpHashComputeKey(type, left, right);
push ebx
push edi
push 3
$LN114@xmlExpHash:
; 6713 : } else
; 6714 : return(NULL);
; 6715 :
; 6716 : key = kbase % ctxt->size;
call _xmlExpHashComputeKey
movzx eax, ax
add esp, 12 ; 0000000cH
$LN110@xmlExpHash:
mov DWORD PTR _kbase$[ebp], eax
$LN113@xmlExpHash:
mov WORD PTR _kbase$1$[ebp], ax
movzx eax, ax
cdq
idiv DWORD PTR [esi+8]
; 6717 : if (ctxt->table[key] != NULL) {
mov eax, DWORD PTR [esi+4]
movzx ecx, dx
shl ecx, 2
mov DWORD PTR tv1599[ebp], ecx
mov ecx, DWORD PTR [ecx+eax]
test ecx, ecx
je SHORT $LN98@xmlExpHash
mov ax, WORD PTR _kbase$1$[ebp]
$LL4@xmlExpHash:
; 6720 : if ((insert->key == kbase) &&
cmp WORD PTR [ecx+2], ax
jne SHORT $LN2@xmlExpHash
movzx eax, BYTE PTR [ecx]
mov edx, DWORD PTR _type$1$[ebp]
cmp eax, edx
jne SHORT $LN109@xmlExpHash
; 6721 : (insert->type == type)) {
; 6722 : if (type == XML_EXP_ATOM) {
cmp edx, 2
jne SHORT $LN40@xmlExpHash
; 6723 : if (name == insert->exp_str) {
mov eax, DWORD PTR _name$[ebp]
cmp eax, DWORD PTR [ecx+20]
jne SHORT $LN109@xmlExpHash
; 6724 : insert->ref++;
inc DWORD PTR [ecx+4]
; 6725 : return(insert);
mov eax, ecx
pop edi
; 6793 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN40@xmlExpHash:
; 6726 : }
; 6727 : } else if (type == XML_EXP_COUNT) {
cmp edx, 5
jne SHORT $LN43@xmlExpHash
; 6728 : if ((insert->exp_min == min) && (insert->exp_max == max) &&
mov eax, DWORD PTR _min$1$[ebp]
cmp DWORD PTR [ecx+20], eax
jne SHORT $LN109@xmlExpHash
mov eax, DWORD PTR _max$[ebp]
cmp DWORD PTR [ecx+24], eax
jne SHORT $LN109@xmlExpHash
cmp DWORD PTR [ecx+12], edi
jne SHORT $LN109@xmlExpHash
; 6729 : (insert->exp_left == left)) {
; 6730 : insert->ref++;
inc DWORD PTR [ecx+4]
; 6731 : left->ref--;
; 6732 : return(insert);
mov eax, ecx
dec DWORD PTR [edi+4]
pop edi
; 6793 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN43@xmlExpHash:
; 6733 : }
; 6734 : } else if ((insert->exp_left == left) &&
cmp DWORD PTR [ecx+12], edi
jne SHORT $LN109@xmlExpHash
cmp DWORD PTR [ecx+20], ebx
je SHORT $LN84@xmlExpHash
$LN109@xmlExpHash:
; 6718 : for (insert = ctxt->table[key]; insert != NULL;
; 6719 : insert = insert->next) {
mov ax, WORD PTR _kbase$1$[ebp]
$LN2@xmlExpHash:
mov ecx, DWORD PTR [ecx+16]
test ecx, ecx
jne SHORT $LL4@xmlExpHash
$LN98@xmlExpHash:
; 6545 : if (ctxt->nb_nodes >= MAX_NODES)
cmp DWORD PTR [esi+16], 10000 ; 00002710H
jge $LN32@xmlExpHash
; 6546 : return(NULL);
; 6547 : ret = (xmlExpNodePtr) xmlMalloc(sizeof(xmlExpNode));
push 28 ; 0000001cH
call DWORD PTR _xmlMalloc
mov ecx, eax
add esp, 4
; 6548 : if (ret == NULL)
test ecx, ecx
je $LN32@xmlExpHash
; 6551 : ret->type = type;
mov eax, DWORD PTR _type$1$[ebp]
xorps xmm0, xmm0
; 6740 : }
; 6741 : }
; 6742 : }
; 6743 : }
; 6744 :
; 6745 : entry = xmlExpNewNode(ctxt, type);
; 6746 : if (entry == NULL)
; 6747 : return(NULL);
; 6748 : entry->key = kbase;
mov dx, WORD PTR _kbase$1$[ebp]
; 6550 : memset(ret, 0, sizeof(xmlExpNode));
movups XMMWORD PTR [ecx], xmm0
movq QWORD PTR [ecx+16], xmm0
mov DWORD PTR [ecx+24], 0
; 6551 : ret->type = type;
mov BYTE PTR [ecx], al
; 6552 : ret->next = NULL;
; 6553 : ctxt->nb_nodes++;
inc DWORD PTR [esi+16]
; 6554 : ctxt->nb_cons++;
inc DWORD PTR [esi+32]
; 6740 : }
; 6741 : }
; 6742 : }
; 6743 : }
; 6744 :
; 6745 : entry = xmlExpNewNode(ctxt, type);
; 6746 : if (entry == NULL)
; 6747 : return(NULL);
; 6748 : entry->key = kbase;
mov WORD PTR [ecx+2], dx
; 6749 : if (type == XML_EXP_ATOM) {
cmp eax, 2
jne SHORT $LN48@xmlExpHash
; 6750 : entry->exp_str = name;
mov eax, DWORD PTR _name$[ebp]
mov DWORD PTR [ecx+20], eax
; 6751 : entry->c_max = 1;
mov eax, 1
jmp $LN115@xmlExpHash
$LN84@xmlExpHash:
; 6735 : (insert->exp_right == right)) {
; 6736 : insert->ref++;
inc DWORD PTR [ecx+4]
; 6737 : left->ref--;
; 6738 : right->ref--;
; 6739 : return(insert);
mov eax, ecx
dec DWORD PTR [edi+4]
dec DWORD PTR [ebx+4]
pop edi
; 6793 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN48@xmlExpHash:
; 6752 : } else if (type == XML_EXP_COUNT) {
mov DWORD PTR [ecx+12], edi
cmp eax, 5
jne SHORT $LN50@xmlExpHash
; 6753 : entry->exp_min = min;
mov eax, DWORD PTR _min$1$[ebp]
; 6754 : entry->exp_max = max;
mov edx, DWORD PTR _max$[ebp]
mov DWORD PTR [ecx+20], eax
mov DWORD PTR [ecx+24], edx
; 6755 : entry->exp_left = left;
; 6756 : if ((min == 0) || (IS_NILLABLE(left)))
test eax, eax
je SHORT $LN53@xmlExpHash
test BYTE PTR [edi+1], 1
je SHORT $LN52@xmlExpHash
$LN53@xmlExpHash:
; 6757 : entry->info |= XML_EXP_NILABLE;
or BYTE PTR [ecx+1], 1
$LN52@xmlExpHash:
; 6758 : if (max < 0)
test edx, edx
js SHORT $LN68@xmlExpHash
; 6759 : entry->c_max = -1;
; 6760 : else
; 6761 : entry->c_max = max * entry->exp_left->c_max;
mov eax, DWORD PTR [edi+8]
imul eax, edx
; 6762 : } else {
jmp SHORT $LN115@xmlExpHash
$LN50@xmlExpHash:
; 6763 : entry->exp_left = left;
; 6764 : entry->exp_right = right;
mov DWORD PTR [ecx+20], ebx
mov dl, BYTE PTR [edi+1]
and dl, 1
; 6765 : if (type == XML_EXP_OR) {
cmp eax, 4
jne SHORT $LN56@xmlExpHash
; 6766 : if ((IS_NILLABLE(left)) || (IS_NILLABLE(right)))
test dl, dl
jne SHORT $LN59@xmlExpHash
test BYTE PTR [ebx+1], 1
je SHORT $LN58@xmlExpHash
$LN59@xmlExpHash:
; 6767 : entry->info |= XML_EXP_NILABLE;
or BYTE PTR [ecx+1], 1
$LN58@xmlExpHash:
; 6768 : if ((entry->exp_left->c_max == -1) ||
mov edx, DWORD PTR [edi+8]
cmp edx, -1
je SHORT $LN68@xmlExpHash
mov eax, DWORD PTR [ebx+8]
cmp eax, -1
je SHORT $LN68@xmlExpHash
; 6769 : (entry->exp_right->c_max == -1))
; 6770 : entry->c_max = -1;
; 6771 : else if (entry->exp_left->c_max > entry->exp_right->c_max)
cmp edx, eax
cmovg eax, edx
; 6772 : entry->c_max = entry->exp_left->c_max;
; 6773 : else
; 6774 : entry->c_max = entry->exp_right->c_max;
jmp SHORT $LN115@xmlExpHash
$LN56@xmlExpHash:
; 6775 : } else {
; 6776 : if ((IS_NILLABLE(left)) && (IS_NILLABLE(right)))
test dl, dl
je SHORT $LN65@xmlExpHash
test BYTE PTR [ebx+1], 1
je SHORT $LN65@xmlExpHash
; 6777 : entry->info |= XML_EXP_NILABLE;
or BYTE PTR [ecx+1], 1
$LN65@xmlExpHash:
; 6778 : if ((entry->exp_left->c_max == -1) ||
mov edx, DWORD PTR [edi+8]
cmp edx, -1
je SHORT $LN68@xmlExpHash
mov eax, DWORD PTR [ebx+8]
cmp eax, -1
je SHORT $LN68@xmlExpHash
; 6779 : (entry->exp_right->c_max == -1))
; 6780 : entry->c_max = -1;
; 6781 : else
; 6782 : entry->c_max = entry->exp_left->c_max + entry->exp_right->c_max;
add eax, edx
jmp SHORT $LN115@xmlExpHash
$LN68@xmlExpHash:
; 6783 : }
; 6784 : }
; 6785 : entry->ref = 1;
or eax, -1
$LN115@xmlExpHash:
; 6786 : if (ctxt->table[key] != NULL)
mov edi, DWORD PTR tv1599[ebp]
mov edx, ecx
mov DWORD PTR [edx+8], eax
mov DWORD PTR [ecx+4], 1
mov eax, DWORD PTR [esi+4]
mov edx, DWORD PTR [eax+edi]
test edx, edx
je SHORT $LN69@xmlExpHash
; 6787 : entry->next = ctxt->table[key];
mov DWORD PTR [ecx+16], edx
mov eax, DWORD PTR [esi+4]
$LN69@xmlExpHash:
; 6788 :
; 6789 : ctxt->table[key] = entry;
mov DWORD PTR [eax+edi], ecx
; 6790 : ctxt->nbElems++;
; 6791 :
; 6792 : return(entry);
mov eax, ecx
inc DWORD PTR [esi+12]
pop edi
; 6793 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN32@xmlExpHash:
pop edi
pop esi
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
ret 0
_xmlExpHashGetEntry ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpHashComputeKey
_TEXT SEGMENT
_type$ = 8 ; size = 4
_left$ = 12 ; size = 4
_right$ = 16 ; size = 4
_xmlExpHashComputeKey PROC ; COMDAT
; 6512 : xmlExpNodePtr right) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _type$[ebp]
sub eax, 3
je SHORT $LN4@xmlExpHash
; 6513 : unsigned long value;
; 6514 : unsigned short ret;
; 6515 :
; 6516 : switch (type) {
sub eax, 1
je SHORT $LN5@xmlExpHash
sub eax, 1
je SHORT $LN6@xmlExpHash
; 6533 : break;
; 6534 : default:
; 6535 : ret = 0;
xor eax, eax
; 6536 : }
; 6537 : return(ret);
; 6538 : }
pop ebp
ret 0
$LN6@xmlExpHash:
; 6527 : ret = (unsigned short) value;
; 6528 : break;
; 6529 : case XML_EXP_COUNT:
; 6530 : value = left->key;
; 6531 : value += right->key;
mov eax, DWORD PTR _left$[ebp]
mov cx, WORD PTR [eax+2]
mov eax, DWORD PTR _right$[ebp]
add cx, WORD PTR [eax+2]
; 6532 : ret = (unsigned short) value;
movzx eax, cx
; 6536 : }
; 6537 : return(ret);
; 6538 : }
pop ebp
ret 0
$LN5@xmlExpHash:
; 6521 : ret = (unsigned short) value;
; 6522 : break;
; 6523 : case XML_EXP_OR:
; 6524 : value = left->key;
; 6525 : value += right->key;
; 6526 : value *= 7;
mov eax, DWORD PTR _left$[ebp]
mov cx, WORD PTR [eax+2]
mov eax, DWORD PTR _right$[ebp]
add cx, WORD PTR [eax+2]
mov ax, cx
shl ax, 3
sub ax, cx
; 6536 : }
; 6537 : return(ret);
; 6538 : }
movzx eax, ax
pop ebp
ret 0
$LN4@xmlExpHash:
; 6517 : case XML_EXP_SEQ:
; 6518 : value = left->key;
; 6519 : value += right->key;
; 6520 : value *= 3;
mov eax, DWORD PTR _left$[ebp]
mov cx, WORD PTR [eax+2]
mov eax, DWORD PTR _right$[ebp]
add cx, WORD PTR [eax+2]
mov ax, cx
add cx, cx
add ax, cx
; 6536 : }
; 6537 : return(ret);
; 6538 : }
movzx eax, ax
pop ebp
ret 0
_xmlExpHashComputeKey ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpHashNameComputeKey
_TEXT SEGMENT
_value$ = -4 ; size = 2
_name$ = 8 ; size = 4
_xmlExpHashNameComputeKey PROC ; COMDAT
; 6493 : xmlExpHashNameComputeKey(const xmlChar *name) {
push ebp
mov ebp, esp
push ecx
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _name$[ebp]
mov DWORD PTR _value$[ebp], 0
test esi, esi
je SHORT $LN12@xmlExpHash
; 6494 : unsigned short value = 0L;
; 6495 : char ch;
; 6496 :
; 6497 : if (name != NULL) {
; 6498 : value += 30 * (*name);
push ebx
mov bl, BYTE PTR [esi]
movzx eax, bl
mov cx, ax
shl cx, 4
sub cx, ax
add cx, cx
movzx eax, cx
mov DWORD PTR _value$[ebp], eax
; 6499 : while ((ch = *name++) != 0) {
test bl, bl
je SHORT $LN11@xmlExpHash
mov dx, ax
npad 3
$LL2@xmlExpHash:
; 6500 : value = value ^ ((value << 5) + (value >> 3) + (unsigned long)ch);
mov cx, dx
shl eax, 5
shr cx, 3
lea esi, DWORD PTR [esi+1]
add ax, cx
movsx cx, bl
mov bl, BYTE PTR [esi]
add ax, cx
xor dx, ax
mov WORD PTR _value$[ebp], dx
test bl, bl
je SHORT $LN16@xmlExpHash
; 6499 : while ((ch = *name++) != 0) {
mov eax, DWORD PTR _value$[ebp]
jmp SHORT $LL2@xmlExpHash
$LN16@xmlExpHash:
pop ebx
; 6501 : }
; 6502 : }
; 6503 : return (value);
mov ax, dx
pop esi
; 6504 : }
mov esp, ebp
pop ebp
ret 0
$LN11@xmlExpHash:
; 6501 : }
; 6502 : }
; 6503 : return (value);
mov ax, WORD PTR _value$[ebp]
pop ebx
pop esi
; 6504 : }
mov esp, ebp
pop ebp
ret 0
$LN12@xmlExpHash:
; 6501 : }
; 6502 : }
; 6503 : return (value);
mov ax, WORD PTR _value$[ebp]
pop esi
; 6504 : }
mov esp, ebp
pop ebp
ret 0
_xmlExpHashNameComputeKey ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpNewNode
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_type$ = 12 ; size = 4
_xmlExpNewNode PROC ; COMDAT
; 6542 : xmlExpNewNode(xmlExpCtxtPtr ctxt, xmlExpNodeType type) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
cmp DWORD PTR [esi+16], 10000 ; 00002710H
jge SHORT $LN5@xmlExpNewN
; 6543 : xmlExpNodePtr ret;
; 6544 :
; 6545 : if (ctxt->nb_nodes >= MAX_NODES)
; 6546 : return(NULL);
; 6547 : ret = (xmlExpNodePtr) xmlMalloc(sizeof(xmlExpNode));
push 28 ; 0000001cH
call DWORD PTR _xmlMalloc
add esp, 4
; 6548 : if (ret == NULL)
test eax, eax
je SHORT $LN5@xmlExpNewN
; 6550 : memset(ret, 0, sizeof(xmlExpNode));
; 6551 : ret->type = type;
mov cl, BYTE PTR _type$[ebp]
xorps xmm0, xmm0
movups XMMWORD PTR [eax], xmm0
movq QWORD PTR [eax+16], xmm0
mov DWORD PTR [eax+24], 0
mov BYTE PTR [eax], cl
; 6552 : ret->next = NULL;
; 6553 : ctxt->nb_nodes++;
inc DWORD PTR [esi+16]
; 6554 : ctxt->nb_cons++;
inc DWORD PTR [esi+32]
pop esi
; 6555 : return(ret);
; 6556 : }
pop ebp
ret 0
$LN5@xmlExpNewN:
; 6549 : return(NULL);
xor eax, eax
pop esi
; 6555 : return(ret);
; 6556 : }
pop ebp
ret 0
_xmlExpNewNode ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParseBranch
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_to$ = 12 ; size = 4
_xmlFAParseBranch PROC ; COMDAT
; 5344 : xmlFAParseBranch(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr to) {
push ebp
mov ebp, esp
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
push esi
mov edi, DWORD PTR [esi+24]
call _xmlFAParsePiece
add esp, 4
test eax, eax
je SHORT $LN3@xmlFAParse
; 5345 : xmlRegStatePtr previous;
; 5346 : int ret;
; 5347 :
; 5348 : previous = ctxt->state;
; 5349 : ret = xmlFAParsePiece(ctxt);
; 5350 : if (ret != 0) {
; 5351 : if (xmlFAGenerateTransitions(ctxt, previous,
; 5352 : (CUR=='|' || CUR==')') ? to : NULL, ctxt->atom) < 0)
mov ebx, DWORD PTR _to$[ebp]
$LN21@xmlFAParse:
; 5353 : return(-1);
; 5354 : previous = ctxt->state;
; 5355 : ctxt->atom = NULL;
; 5356 : }
; 5357 : while ((ret != 0) && (ctxt->error == 0)) {
mov eax, DWORD PTR [esi+4]
mov al, BYTE PTR [eax]
cmp al, 124 ; 0000007cH
je SHORT $LN9@xmlFAParse
cmp al, 41 ; 00000029H
je SHORT $LN9@xmlFAParse
xor eax, eax
jmp SHORT $LN10@xmlFAParse
$LN9@xmlFAParse:
mov eax, ebx
$LN10@xmlFAParse:
push DWORD PTR [esi+28]
push eax
push edi
push esi
call _xmlFAGenerateTransitions
add esp, 16 ; 00000010H
test eax, eax
js SHORT $LN14@xmlFAParse
cmp DWORD PTR [esi+8], 0
mov edi, DWORD PTR [esi+24]
mov DWORD PTR [esi+28], 0
jne SHORT $LN3@xmlFAParse
; 5358 : ret = xmlFAParsePiece(ctxt);
push esi
call _xmlFAParsePiece
add esp, 4
; 5359 : if (ret != 0) {
test eax, eax
jne SHORT $LN21@xmlFAParse
$LN3@xmlFAParse:
pop edi
; 5360 : if (xmlFAGenerateTransitions(ctxt, previous,
; 5361 : (CUR=='|' || CUR==')') ? to : NULL, ctxt->atom) < 0)
; 5362 : return(-1);
; 5363 : previous = ctxt->state;
; 5364 : ctxt->atom = NULL;
; 5365 : }
; 5366 : }
; 5367 : return(0);
; 5368 : }
pop esi
xor eax, eax
pop ebx
pop ebp
ret 0
$LN14@xmlFAParse:
pop edi
pop esi
or eax, -1
pop ebx
pop ebp
ret 0
_xmlFAParseBranch ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParsePiece
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlFAParsePiece PROC ; COMDAT
; 5319 : xmlFAParsePiece(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
push esi
mov DWORD PTR [esi+28], 0
call _xmlFAParseAtom
add esp, 4
test eax, eax
jne SHORT $LN2@xmlFAParse
pop esi
; 5331 : }
pop ebp
ret 0
$LN2@xmlFAParse:
; 5320 : int ret;
; 5321 :
; 5322 : ctxt->atom = NULL;
; 5323 : ret = xmlFAParseAtom(ctxt);
; 5324 : if (ret == 0)
; 5325 : return(0);
; 5326 : if (ctxt->atom == NULL) {
cmp DWORD PTR [esi+28], 0
jne SHORT $LN3@xmlFAParse
; 5327 : ERROR("internal: no atom generated");
push OFFSET ??_C@_0BM@PFFMPGPF@internal?3?5no?5atom?5generated@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
$LN3@xmlFAParse:
; 5201 : cur = CUR;
mov ecx, DWORD PTR [esi+4]
push ebx
push edi
mov al, BYTE PTR [ecx]
; 5202 : if ((cur == '?') || (cur == '*') || (cur == '+')) {
cmp al, 63 ; 0000003fH
je $LN7@xmlFAParse
cmp al, 42 ; 0000002aH
je $LN7@xmlFAParse
cmp al, 43 ; 0000002bH
je $LN7@xmlFAParse
; 5212 : return(1);
; 5213 : }
; 5214 : if (cur == '{') {
cmp al, 123 ; 0000007bH
jne $LN14@xmlFAParse
; 5215 : int min = 0, max = 0;
; 5216 :
; 5217 : NEXT;
lea eax, DWORD PTR [ecx+1]
xor edi, edi
; 5218 : cur = xmlFAParseQuantExact(ctxt);
push esi
xor ebx, ebx
mov DWORD PTR [esi+4], eax
call _xmlFAParseQuantExact
add esp, 4
; 5219 : if (cur >= 0)
test eax, eax
cmovns edi, eax
; 5220 : min = cur;
; 5221 : if (CUR == ',') {
mov eax, DWORD PTR [esi+4]
cmp BYTE PTR [eax], 44 ; 0000002cH
jne SHORT $LN20@xmlFAParse
; 5222 : NEXT;
inc eax
mov DWORD PTR [esi+4], eax
; 5223 : if (CUR == '}')
cmp BYTE PTR [eax], 125 ; 0000007dH
jne SHORT $LN17@xmlFAParse
; 5224 : max = INT_MAX;
mov ebx, 2147483647 ; 7fffffffH
jmp SHORT $LN20@xmlFAParse
$LN17@xmlFAParse:
; 5225 : else {
; 5226 : cur = xmlFAParseQuantExact(ctxt);
push esi
call _xmlFAParseQuantExact
add esp, 4
; 5227 : if (cur >= 0)
test eax, eax
js SHORT $LN19@xmlFAParse
; 5228 : max = cur;
mov ebx, eax
jmp SHORT $LN20@xmlFAParse
$LN19@xmlFAParse:
; 5229 : else {
; 5230 : ERROR("Improper quantifier");
push OFFSET ??_C@_0BE@PGBJEMPN@Improper?5quantifier@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
$LN20@xmlFAParse:
; 5231 : }
; 5232 : }
; 5233 : }
; 5234 : if (CUR == '}') {
mov eax, DWORD PTR [esi+4]
cmp BYTE PTR [eax], 125 ; 0000007dH
jne SHORT $LN21@xmlFAParse
; 5235 : NEXT;
inc eax
mov DWORD PTR [esi+4], eax
; 5236 : } else {
jmp SHORT $LN22@xmlFAParse
$LN21@xmlFAParse:
; 5237 : ERROR("Unterminated quantifier");
push OFFSET ??_C@_0BI@HKPFPPFN@Unterminated?5quantifier@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
$LN22@xmlFAParse:
; 5238 : }
; 5239 : if (max == 0)
; 5240 : max = min;
; 5241 : if (ctxt->atom != NULL) {
mov eax, DWORD PTR [esi+28]
test eax, eax
je SHORT $LN14@xmlFAParse
; 5242 : ctxt->atom->quant = XML_REGEXP_QUANT_RANGE;
mov DWORD PTR [eax+8], 8
test ebx, ebx
; 5243 : ctxt->atom->min = min;
mov eax, DWORD PTR [esi+28]
mov DWORD PTR [eax+12], edi
cmovne edi, ebx
; 5244 : ctxt->atom->max = max;
mov eax, DWORD PTR [esi+28]
mov DWORD PTR [eax+16], edi
; 5328 : }
; 5329 : xmlFAParseQuantifier(ctxt);
; 5330 : return(1);
mov eax, 1
pop edi
pop ebx
pop esi
; 5331 : }
pop ebp
ret 0
$LN7@xmlFAParse:
; 5203 : if (ctxt->atom != NULL) {
mov ecx, DWORD PTR [esi+28]
test ecx, ecx
je SHORT $LN13@xmlFAParse
; 5204 : if (cur == '?')
cmp al, 63 ; 0000003fH
jne SHORT $LN9@xmlFAParse
; 5328 : }
; 5329 : xmlFAParseQuantifier(ctxt);
; 5330 : return(1);
pop edi
; 5205 : ctxt->atom->quant = XML_REGEXP_QUANT_OPT;
mov DWORD PTR [ecx+8], 3
; 5328 : }
; 5329 : xmlFAParseQuantifier(ctxt);
; 5330 : return(1);
mov eax, 1
; 5211 : NEXT;
inc DWORD PTR [esi+4]
; 5328 : }
; 5329 : xmlFAParseQuantifier(ctxt);
; 5330 : return(1);
pop ebx
pop esi
; 5331 : }
pop ebp
ret 0
$LN9@xmlFAParse:
; 5206 : else if (cur == '*')
cmp al, 42 ; 0000002aH
jne SHORT $LN11@xmlFAParse
; 5328 : }
; 5329 : xmlFAParseQuantifier(ctxt);
; 5330 : return(1);
pop edi
; 5207 : ctxt->atom->quant = XML_REGEXP_QUANT_MULT;
mov DWORD PTR [ecx+8], 4
; 5328 : }
; 5329 : xmlFAParseQuantifier(ctxt);
; 5330 : return(1);
mov eax, 1
; 5211 : NEXT;
inc DWORD PTR [esi+4]
; 5328 : }
; 5329 : xmlFAParseQuantifier(ctxt);
; 5330 : return(1);
pop ebx
pop esi
; 5331 : }
pop ebp
ret 0
$LN11@xmlFAParse:
; 5208 : else if (cur == '+')
cmp al, 43 ; 0000002bH
jne SHORT $LN13@xmlFAParse
; 5209 : ctxt->atom->quant = XML_REGEXP_QUANT_PLUS;
mov DWORD PTR [ecx+8], 5
$LN13@xmlFAParse:
; 5210 : }
; 5211 : NEXT;
inc DWORD PTR [esi+4]
$LN14@xmlFAParse:
; 5328 : }
; 5329 : xmlFAParseQuantifier(ctxt);
; 5330 : return(1);
pop edi
pop ebx
mov eax, 1
pop esi
; 5331 : }
pop ebp
ret 0
_xmlFAParsePiece ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParseAtom
_TEXT SEGMENT
_len$ = -4 ; size = 4
_oldend$1$ = 8 ; size = 4
_len$1 = 8 ; size = 4
_ctxt$ = 8 ; size = 4
_xmlFAParseAtom PROC ; COMDAT
; 5258 : xmlFAParseAtom(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push ecx
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
; 4606 : cur = CUR_SCHAR(ctxt->cur, len);
mov esi, DWORD PTR _ctxt$[ebp]
lea eax, DWORD PTR _len$1[ebp]
push eax
push DWORD PTR [esi+4]
push 0
call _xmlStringCurrentChar
add esp, 12 ; 0000000cH
; 4607 : if ((cur == '.') || (cur == '\\') || (cur == '?') ||
; 4608 : (cur == '*') || (cur == '+') || (cur == '(') ||
; 4609 : (cur == ')') || (cur == '|') || (cur == 0x5B) ||
; 4610 : (cur == 0x5D) || (cur == 0))
cmp eax, 46 ; 0000002eH
je SHORT $LN2@xmlFAParse
cmp eax, 92 ; 0000005cH
je SHORT $LN2@xmlFAParse
cmp eax, 63 ; 0000003fH
je SHORT $LN2@xmlFAParse
cmp eax, 42 ; 0000002aH
je SHORT $LN2@xmlFAParse
cmp eax, 43 ; 0000002bH
je SHORT $LN2@xmlFAParse
cmp eax, 40 ; 00000028H
je SHORT $LN2@xmlFAParse
cmp eax, 41 ; 00000029H
je SHORT $LN2@xmlFAParse
cmp eax, 124 ; 0000007cH
je SHORT $LN2@xmlFAParse
cmp eax, 91 ; 0000005bH
je SHORT $LN2@xmlFAParse
cmp eax, 93 ; 0000005dH
je SHORT $LN2@xmlFAParse
test eax, eax
; 5259 : int codepoint, len;
; 5260 :
; 5261 : codepoint = xmlFAIsChar(ctxt);
; 5262 : if (codepoint > 0) {
jle SHORT $LN2@xmlFAParse
; 5263 : ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_CHARVAL);
push 2
push esi
call _xmlRegNewAtom
add esp, 8
mov DWORD PTR [esi+28], eax
; 5264 : if (ctxt->atom == NULL)
test eax, eax
je $LN52@xmlFAParse
; 5265 : return(-1);
; 5266 : codepoint = CUR_SCHAR(ctxt->cur, len);
lea eax, DWORD PTR _len$[ebp]
push eax
push DWORD PTR [esi+4]
push 0
call _xmlStringCurrentChar
; 5267 : ctxt->atom->codepoint = codepoint;
mov ecx, DWORD PTR [esi+28]
add esp, 12 ; 0000000cH
mov DWORD PTR [ecx+32], eax
; 5268 : NEXTL(len);
mov eax, DWORD PTR _len$[ebp]
add DWORD PTR [esi+4], eax
; 5269 : return(1);
mov eax, 1
pop edi
; 5308 : }
; 5309 : return(0);
; 5310 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN2@xmlFAParse:
; 5270 : } else if (CUR == '|') {
mov ecx, DWORD PTR [esi+4]
mov al, BYTE PTR [ecx]
cmp al, 124 ; 0000007cH
je $LN51@xmlFAParse
; 5271 : return(0);
; 5272 : } else if (CUR == 0) {
test al, al
je $LN51@xmlFAParse
; 5273 : return(0);
; 5274 : } else if (CUR == ')') {
cmp al, 41 ; 00000029H
je $LN51@xmlFAParse
; 5275 : return(0);
; 5276 : } else if (CUR == '(') {
cmp al, 40 ; 00000028H
jne $LN11@xmlFAParse
; 5277 : xmlRegStatePtr start, oldend, start0;
; 5278 :
; 5279 : NEXT;
; 5280 : /*
; 5281 : * this extra Epsilon transition is needed if we count with 0 allowed
; 5282 : * unfortunately this can't be known at that point
; 5283 : */
; 5284 : xmlFAGenerateEpsilonTransition(ctxt, ctxt->state, NULL);
push 0
push DWORD PTR [esi+24]
lea eax, DWORD PTR [ecx+1]
push esi
mov DWORD PTR [esi+4], eax
call _xmlFAGenerateEpsilonTransition
; 5285 : start0 = ctxt->state;
mov edi, DWORD PTR [esi+24]
; 5286 : xmlFAGenerateEpsilonTransition(ctxt, ctxt->state, NULL);
push 0
push edi
push esi
call _xmlFAGenerateEpsilonTransition
; 5287 : start = ctxt->state;
; 5288 : oldend = ctxt->end;
mov eax, DWORD PTR [esi+20]
mov ebx, DWORD PTR [esi+24]
; 5289 : ctxt->end = NULL;
; 5290 : ctxt->atom = NULL;
; 5291 : xmlFAParseRegExp(ctxt, 0);
push 0
push esi
mov DWORD PTR _oldend$1$[ebp], eax
mov DWORD PTR [esi+20], 0
mov DWORD PTR [esi+28], 0
call _xmlFAParseRegExp
; 5292 : if (CUR == ')') {
mov eax, DWORD PTR [esi+4]
add esp, 32 ; 00000020H
cmp BYTE PTR [eax], 41 ; 00000029H
jne SHORT $LN13@xmlFAParse
; 5293 : NEXT;
inc eax
mov DWORD PTR [esi+4], eax
; 5294 : } else {
jmp SHORT $LN14@xmlFAParse
$LN13@xmlFAParse:
; 5295 : ERROR("xmlFAParseAtom: expecting ')'");
push OFFSET ??_C@_0BO@CCFFKIJF@xmlFAParseAtom?3?5expecting?5?8?$CJ?8@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
$LN14@xmlFAParse:
; 5296 : }
; 5297 : ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_SUBREG);
push 4
push esi
call _xmlRegNewAtom
add esp, 8
mov DWORD PTR [esi+28], eax
; 5298 : if (ctxt->atom == NULL)
test eax, eax
jne SHORT $LN15@xmlFAParse
$LN52@xmlFAParse:
pop edi
; 5308 : }
; 5309 : return(0);
; 5310 : }
pop esi
or eax, -1
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN15@xmlFAParse:
; 5299 : return(-1);
; 5300 : ctxt->atom->start = start;
mov DWORD PTR [eax+36], ebx
; 5301 : ctxt->atom->start0 = start0;
mov eax, DWORD PTR [esi+28]
mov DWORD PTR [eax+40], edi
; 5302 : ctxt->atom->stop = ctxt->state;
mov ecx, DWORD PTR [esi+28]
mov eax, DWORD PTR [esi+24]
pop edi
mov DWORD PTR [ecx+44], eax
; 5303 : ctxt->end = oldend;
mov eax, DWORD PTR _oldend$1$[ebp]
mov DWORD PTR [esi+20], eax
; 5304 : return(1);
mov eax, 1
; 5308 : }
; 5309 : return(0);
; 5310 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN11@xmlFAParse:
; 5305 : } else if ((CUR == '[') || (CUR == '\\') || (CUR == '.')) {
cmp al, 91 ; 0000005bH
je SHORT $LN50@xmlFAParse
cmp al, 92 ; 0000005cH
je SHORT $LN44@xmlFAParse
cmp al, 46 ; 0000002eH
jne SHORT $LN51@xmlFAParse
$LN44@xmlFAParse:
; 5159 : xmlFAParseCharClassEsc(ctxt);
push esi
call _xmlFAParseCharClassEsc
add esp, 4
; 5306 : xmlFAParseCharClass(ctxt);
; 5307 : return(1);
mov eax, 1
pop edi
; 5308 : }
; 5309 : return(0);
; 5310 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN50@xmlFAParse:
; 5148 : NEXT;
lea eax, DWORD PTR [ecx+1]
; 5149 : ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_RANGES);
push 3
push esi
mov DWORD PTR [esi+4], eax
call _xmlRegNewAtom
add esp, 8
mov DWORD PTR [esi+28], eax
; 5150 : if (ctxt->atom == NULL)
test eax, eax
je SHORT $LN45@xmlFAParse
; 5151 : return;
; 5152 : xmlFAParseCharGroup(ctxt);
push esi
call _xmlFAParseCharGroup
; 5153 : if (CUR == ']') {
mov eax, DWORD PTR [esi+4]
add esp, 4
cmp BYTE PTR [eax], 93 ; 0000005dH
jne SHORT $LN47@xmlFAParse
; 5154 : NEXT;
inc eax
pop edi
mov DWORD PTR [esi+4], eax
; 5306 : xmlFAParseCharClass(ctxt);
; 5307 : return(1);
mov eax, 1
; 5308 : }
; 5309 : return(0);
; 5310 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN47@xmlFAParse:
; 5156 : ERROR("xmlFAParseCharClass: ']' expected");
push OFFSET ??_C@_0CC@FKLKCEIP@xmlFAParseCharClass?3?5?8?$FN?8?5expect@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
$LN45@xmlFAParse:
pop edi
; 5308 : }
; 5309 : return(0);
; 5310 : }
pop esi
mov eax, 1
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN51@xmlFAParse:
pop edi
pop esi
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
ret 0
_xmlFAParseAtom ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParseQuantifier
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlFAParseQuantifier PROC ; COMDAT
; 5198 : xmlFAParseQuantifier(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
mov ecx, DWORD PTR [esi+4]
mov al, BYTE PTR [ecx]
cmp al, 63 ; 0000003fH
je $LN3@xmlFAParse
; 5199 : int cur;
; 5200 :
; 5201 : cur = CUR;
; 5202 : if ((cur == '?') || (cur == '*') || (cur == '+')) {
cmp al, 42 ; 0000002aH
je $LN3@xmlFAParse
cmp al, 43 ; 0000002bH
je $LN3@xmlFAParse
; 5212 : return(1);
; 5213 : }
; 5214 : if (cur == '{') {
cmp al, 123 ; 0000007bH
jne $LN10@xmlFAParse
; 5215 : int min = 0, max = 0;
push ebx
push edi
; 5216 :
; 5217 : NEXT;
lea eax, DWORD PTR [ecx+1]
xor edi, edi
; 5218 : cur = xmlFAParseQuantExact(ctxt);
push esi
xor ebx, ebx
mov DWORD PTR [esi+4], eax
call _xmlFAParseQuantExact
add esp, 4
; 5219 : if (cur >= 0)
test eax, eax
cmovns edi, eax
; 5220 : min = cur;
; 5221 : if (CUR == ',') {
mov eax, DWORD PTR [esi+4]
cmp BYTE PTR [eax], 44 ; 0000002cH
jne SHORT $LN16@xmlFAParse
; 5222 : NEXT;
inc eax
mov DWORD PTR [esi+4], eax
; 5223 : if (CUR == '}')
cmp BYTE PTR [eax], 125 ; 0000007dH
jne SHORT $LN13@xmlFAParse
; 5224 : max = INT_MAX;
mov ebx, 2147483647 ; 7fffffffH
jmp SHORT $LN16@xmlFAParse
$LN13@xmlFAParse:
; 5225 : else {
; 5226 : cur = xmlFAParseQuantExact(ctxt);
push esi
call _xmlFAParseQuantExact
add esp, 4
; 5227 : if (cur >= 0)
test eax, eax
js SHORT $LN15@xmlFAParse
; 5228 : max = cur;
mov ebx, eax
jmp SHORT $LN16@xmlFAParse
$LN15@xmlFAParse:
; 5229 : else {
; 5230 : ERROR("Improper quantifier");
push OFFSET ??_C@_0BE@PGBJEMPN@Improper?5quantifier@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
$LN16@xmlFAParse:
; 5231 : }
; 5232 : }
; 5233 : }
; 5234 : if (CUR == '}') {
mov eax, DWORD PTR [esi+4]
cmp BYTE PTR [eax], 125 ; 0000007dH
jne SHORT $LN17@xmlFAParse
; 5235 : NEXT;
inc eax
mov DWORD PTR [esi+4], eax
; 5236 : } else {
jmp SHORT $LN18@xmlFAParse
$LN17@xmlFAParse:
; 5237 : ERROR("Unterminated quantifier");
push OFFSET ??_C@_0BI@HKPFPPFN@Unterminated?5quantifier@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
$LN18@xmlFAParse:
; 5238 : }
; 5239 : if (max == 0)
; 5240 : max = min;
; 5241 : if (ctxt->atom != NULL) {
mov eax, DWORD PTR [esi+28]
test eax, eax
je SHORT $LN20@xmlFAParse
; 5242 : ctxt->atom->quant = XML_REGEXP_QUANT_RANGE;
mov DWORD PTR [eax+8], 8
test ebx, ebx
; 5243 : ctxt->atom->min = min;
mov eax, DWORD PTR [esi+28]
mov DWORD PTR [eax+12], edi
cmovne edi, ebx
; 5244 : ctxt->atom->max = max;
mov eax, DWORD PTR [esi+28]
mov DWORD PTR [eax+16], edi
$LN20@xmlFAParse:
; 5245 : }
; 5246 : return(1);
pop edi
pop ebx
; 5249 : }
mov eax, 1
pop esi
pop ebp
ret 0
$LN10@xmlFAParse:
; 5247 : }
; 5248 : return(0);
xor eax, eax
pop esi
; 5249 : }
pop ebp
ret 0
$LN3@xmlFAParse:
; 5203 : if (ctxt->atom != NULL) {
mov ecx, DWORD PTR [esi+28]
test ecx, ecx
je SHORT $LN9@xmlFAParse
; 5204 : if (cur == '?')
cmp al, 63 ; 0000003fH
jne SHORT $LN5@xmlFAParse
; 5205 : ctxt->atom->quant = XML_REGEXP_QUANT_OPT;
mov DWORD PTR [ecx+8], 3
; 5249 : }
mov eax, 1
inc DWORD PTR [esi+4]
pop esi
pop ebp
ret 0
$LN5@xmlFAParse:
; 5206 : else if (cur == '*')
cmp al, 42 ; 0000002aH
jne SHORT $LN7@xmlFAParse
; 5207 : ctxt->atom->quant = XML_REGEXP_QUANT_MULT;
mov DWORD PTR [ecx+8], 4
; 5249 : }
mov eax, 1
inc DWORD PTR [esi+4]
pop esi
pop ebp
ret 0
$LN7@xmlFAParse:
; 5208 : else if (cur == '+')
cmp al, 43 ; 0000002bH
jne SHORT $LN9@xmlFAParse
; 5209 : ctxt->atom->quant = XML_REGEXP_QUANT_PLUS;
mov DWORD PTR [ecx+8], 5
$LN9@xmlFAParse:
; 5210 : }
; 5211 : NEXT;
inc DWORD PTR [esi+4]
; 5249 : }
mov eax, 1
pop esi
pop ebp
ret 0
_xmlFAParseQuantifier ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParseQuantExact
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlFAParseQuantExact PROC ; COMDAT
; 5172 : xmlFAParseQuantExact(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR _ctxt$[ebp]
xor ecx, ecx
xor esi, esi
mov edx, DWORD PTR [edi+4]
mov al, BYTE PTR [edx]
cmp al, 48 ; 00000030H
jb SHORT $LN10@xmlFAParse
npad 1
$LL2@xmlFAParse:
; 5173 : int ret = 0;
; 5174 : int ok = 0;
; 5175 :
; 5176 : while ((CUR >= '0') && (CUR <= '9')) {
cmp al, 57 ; 00000039H
ja SHORT $LN3@xmlFAParse
; 5177 : ret = ret * 10 + (CUR - '0');
movzx eax, al
lea ecx, DWORD PTR [ecx+ecx*4]
; 5178 : ok = 1;
; 5179 : NEXT;
inc edx
lea ecx, DWORD PTR [ecx-24]
mov DWORD PTR [edi+4], edx
mov esi, 1
lea ecx, DWORD PTR [eax+ecx*2]
mov al, BYTE PTR [edx]
cmp al, 48 ; 00000030H
jae SHORT $LL2@xmlFAParse
; 5183 : }
; 5184 : return(ret);
pop edi
mov eax, ecx
; 5185 : }
pop esi
pop ebp
ret 0
$LN3@xmlFAParse:
; 5180 : }
; 5181 : if (ok != 1) {
cmp esi, 1
jne SHORT $LN10@xmlFAParse
; 5183 : }
; 5184 : return(ret);
pop edi
mov eax, ecx
; 5185 : }
pop esi
pop ebp
ret 0
$LN10@xmlFAParse:
pop edi
; 5182 : return(-1);
or eax, -1
; 5185 : }
pop esi
pop ebp
ret 0
_xmlFAParseQuantExact ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParseCharClass
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlFAParseCharClass PROC ; COMDAT
; 5146 : xmlFAParseCharClass(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
mov eax, DWORD PTR [esi+4]
cmp BYTE PTR [eax], 91 ; 0000005bH
jne SHORT $LN2@xmlFAParse
; 5147 : if (CUR == '[') {
; 5148 : NEXT;
; 5149 : ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_RANGES);
inc eax
push 3
push esi
mov DWORD PTR [esi+4], eax
call _xmlRegNewAtom
add esp, 8
mov DWORD PTR [esi+28], eax
; 5150 : if (ctxt->atom == NULL)
test eax, eax
je SHORT $LN3@xmlFAParse
; 5151 : return;
; 5152 : xmlFAParseCharGroup(ctxt);
push esi
call _xmlFAParseCharGroup
; 5153 : if (CUR == ']') {
mov eax, DWORD PTR [esi+4]
add esp, 4
cmp BYTE PTR [eax], 93 ; 0000005dH
jne SHORT $LN5@xmlFAParse
; 5154 : NEXT;
inc eax
mov DWORD PTR [esi+4], eax
pop esi
; 5160 : }
; 5161 : }
pop ebp
ret 0
$LN5@xmlFAParse:
; 5155 : } else {
; 5156 : ERROR("xmlFAParseCharClass: ']' expected");
push OFFSET ??_C@_0CC@FKLKCEIP@xmlFAParseCharClass?3?5?8?$FN?8?5expect@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop esi
; 5160 : }
; 5161 : }
pop ebp
ret 0
$LN2@xmlFAParse:
; 5157 : }
; 5158 : } else {
; 5159 : xmlFAParseCharClassEsc(ctxt);
push esi
call _xmlFAParseCharClassEsc
add esp, 4
$LN3@xmlFAParse:
pop esi
; 5160 : }
; 5161 : }
pop ebp
ret 0
_xmlFAParseCharClass ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParseCharGroup
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlFAParseCharGroup PROC ; COMDAT
; 5107 : xmlFAParseCharGroup(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push ebx
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
mov eax, DWORD PTR [esi+4]
mov ebx, DWORD PTR [esi+12]
cmp BYTE PTR [eax], 93 ; 0000005dH
je $LN18@xmlFAParse
push edi
$LL2@xmlFAParse:
; 5108 : int n = ctxt->neg;
; 5109 : while ((CUR != ']') && (ctxt->error == 0)) {
cmp DWORD PTR [esi+8], 0
jne $LN19@xmlFAParse
; 5110 : if (CUR == '^') {
mov cl, BYTE PTR [eax]
cmp cl, 94 ; 0000005eH
jne SHORT $LN4@xmlFAParse
; 5111 : int neg = ctxt->neg;
mov edi, DWORD PTR [esi+12]
; 5112 :
; 5113 : NEXT;
inc eax
mov DWORD PTR [esi+4], eax
; 5114 : ctxt->neg = !ctxt->neg;
xor eax, eax
test edi, edi
; 5115 : xmlFAParsePosCharGroup(ctxt);
push esi
sete al
mov DWORD PTR [esi+12], eax
call _xmlFAParsePosCharGroup
; 5116 : ctxt->neg = neg;
mov DWORD PTR [esi+12], edi
jmp SHORT $LN21@xmlFAParse
$LN4@xmlFAParse:
; 5117 : } else if ((CUR == '-') && (NXT(1) == '[')) {
cmp cl, 45 ; 0000002dH
jne SHORT $LN6@xmlFAParse
cmp BYTE PTR [eax+1], 91 ; 0000005bH
je SHORT $LN13@xmlFAParse
$LN6@xmlFAParse:
; 5127 : break;
; 5128 : }
; 5129 : ctxt->neg = neg;
; 5130 : break;
; 5131 : } else if (CUR != ']') {
cmp cl, 93 ; 0000005dH
je SHORT $LN10@xmlFAParse
; 5132 : xmlFAParsePosCharGroup(ctxt);
push esi
call _xmlFAParsePosCharGroup
$LN21@xmlFAParse:
; 5108 : int n = ctxt->neg;
; 5109 : while ((CUR != ']') && (ctxt->error == 0)) {
add esp, 4
$LN10@xmlFAParse:
mov eax, DWORD PTR [esi+4]
cmp BYTE PTR [eax], 93 ; 0000005dH
jne SHORT $LL2@xmlFAParse
; 5133 : }
; 5134 : }
; 5135 : ctxt->neg = n;
; 5136 : }
pop edi
mov DWORD PTR [esi+12], ebx
pop esi
pop ebx
pop ebp
ret 0
$LN13@xmlFAParse:
; 5118 : int neg = ctxt->neg;
; 5119 : ctxt->neg = 2;
; 5120 : NEXT; /* eat the '-' */
; 5121 : NEXT; /* eat the '[' */
add eax, 2
mov DWORD PTR [esi+12], 2
; 5122 : xmlFAParseCharGroup(ctxt);
push esi
mov DWORD PTR [esi+4], eax
call _xmlFAParseCharGroup
; 5123 : if (CUR == ']') {
mov eax, DWORD PTR [esi+4]
add esp, 4
cmp BYTE PTR [eax], 93 ; 0000005dH
jne SHORT $LN8@xmlFAParse
; 5124 : NEXT;
inc eax
; 5133 : }
; 5134 : }
; 5135 : ctxt->neg = n;
; 5136 : }
mov DWORD PTR [esi+12], ebx
pop edi
mov DWORD PTR [esi+4], eax
pop esi
pop ebx
pop ebp
ret 0
$LN8@xmlFAParse:
; 5125 : } else {
; 5126 : ERROR("charClassExpr: ']' expected");
push OFFSET ??_C@_0BM@FJAEMPFO@charClassExpr?3?5?8?$FN?8?5expected@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
$LN19@xmlFAParse:
pop edi
$LN18@xmlFAParse:
; 5133 : }
; 5134 : }
; 5135 : ctxt->neg = n;
; 5136 : }
mov DWORD PTR [esi+12], ebx
pop esi
pop ebx
pop ebp
ret 0
_xmlFAParseCharGroup ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParsePosCharGroup
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlFAParsePosCharGroup PROC ; COMDAT
; 5086 : xmlFAParsePosCharGroup(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
mov eax, DWORD PTR [esi+4]
mov al, BYTE PTR [eax]
$LL4@xmlFAParse:
; 5087 : do {
; 5088 : if (CUR == '\\') {
push esi
cmp al, 92 ; 0000005cH
jne SHORT $LN5@xmlFAParse
; 5089 : xmlFAParseCharClassEsc(ctxt);
call _xmlFAParseCharClassEsc
; 5090 : } else {
jmp SHORT $LN12@xmlFAParse
$LN5@xmlFAParse:
; 5091 : xmlFAParseCharRange(ctxt);
call _xmlFAParseCharRange
$LN12@xmlFAParse:
; 5092 : }
; 5093 : } while ((CUR != ']') && (CUR != '^') && (CUR != '-') &&
; 5094 : (CUR != 0) && (ctxt->error == 0));
mov eax, DWORD PTR [esi+4]
add esp, 4
mov al, BYTE PTR [eax]
cmp al, 93 ; 0000005dH
je SHORT $LN7@xmlFAParse
cmp al, 94 ; 0000005eH
je SHORT $LN7@xmlFAParse
cmp al, 45 ; 0000002dH
je SHORT $LN7@xmlFAParse
test al, al
je SHORT $LN7@xmlFAParse
cmp DWORD PTR [esi+8], 0
je SHORT $LL4@xmlFAParse
$LN7@xmlFAParse:
pop esi
; 5095 : }
pop ebp
ret 0
_xmlFAParsePosCharGroup ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParseCharRange
_TEXT SEGMENT
_len$ = -4 ; size = 4
_ctxt$ = 8 ; size = 4
_xmlFAParseCharRange PROC ; COMDAT
; 4994 : xmlFAParseCharRange(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push ecx
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
mov ecx, DWORD PTR [esi+4]
mov al, BYTE PTR [ecx]
test al, al
jne SHORT $LN6@xmlFAParse
; 4995 : int cur, len;
; 4996 : int start = -1;
; 4997 : int end = -1;
; 4998 :
; 4999 : if (CUR == '\0') {
; 5000 : ERROR("Expecting ']'");
push OFFSET ??_C@_0O@NKKGCCKG@Expecting?5?8?$FN?8@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop esi
; 5074 : XML_REGEXP_CHARVAL, start, end, NULL);
; 5075 : }
; 5076 : return;
; 5077 : }
mov esp, ebp
pop ebp
ret 0
$LN6@xmlFAParse:
push edi
; 5001 : return;
; 5002 : }
; 5003 :
; 5004 : cur = CUR;
; 5005 : if (cur == '\\') {
cmp al, 92 ; 0000005cH
jne SHORT $LN7@xmlFAParse
; 5006 : NEXT;
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+4], eax
; 5007 : cur = CUR;
movzx edi, BYTE PTR [eax]
; 5008 : switch (cur) {
lea eax, DWORD PTR [edi-40]
cmp eax, 85 ; 00000055H
ja $LN25@xmlFAParse
movzx eax, BYTE PTR $LN31@xmlFAParse[eax]
jmp DWORD PTR $LN37@xmlFAParse[eax*4]
$LN9@xmlFAParse:
; 5012 : case '\\': case '|': case '.': case '-': case '^': case '?':
; 5013 : case '*': case '+': case '{': case '}': case '(': case ')':
; 5014 : case '[': case ']':
; 5015 : start = cur; break;
; 5016 : default:
; 5017 : ERROR("Invalid escape value");
; 5018 : return;
; 5019 : }
; 5020 : end = start;
; 5021 : len = 1;
mov eax, 1
mov edi, 10 ; 0000000aH
mov DWORD PTR _len$[ebp], eax
jmp SHORT $LN15@xmlFAParse
$LN10@xmlFAParse:
mov eax, 1
mov edi, 13 ; 0000000dH
mov DWORD PTR _len$[ebp], eax
jmp SHORT $LN15@xmlFAParse
$LN11@xmlFAParse:
; 5009 : case 'n': start = 0xA; break;
; 5010 : case 'r': start = 0xD; break;
; 5011 : case 't': start = 0x9; break;
mov edi, 9
$LN12@xmlFAParse:
; 5012 : case '\\': case '|': case '.': case '-': case '^': case '?':
; 5013 : case '*': case '+': case '{': case '}': case '(': case ')':
; 5014 : case '[': case ']':
; 5015 : start = cur; break;
; 5016 : default:
; 5017 : ERROR("Invalid escape value");
; 5018 : return;
; 5019 : }
; 5020 : end = start;
; 5021 : len = 1;
mov eax, 1
mov DWORD PTR _len$[ebp], eax
jmp SHORT $LN15@xmlFAParse
$LN7@xmlFAParse:
; 5022 : } else if ((cur != 0x5B) && (cur != 0x5D)) {
cmp al, 91 ; 0000005bH
je $LN14@xmlFAParse
cmp al, 93 ; 0000005dH
je $LN14@xmlFAParse
; 5023 : end = start = CUR_SCHAR(ctxt->cur, len);
lea eax, DWORD PTR _len$[ebp]
push eax
push ecx
push 0
call _xmlStringCurrentChar
mov edi, eax
add esp, 12 ; 0000000cH
mov eax, DWORD PTR _len$[ebp]
$LN15@xmlFAParse:
; 5026 : return;
; 5027 : }
; 5028 : /*
; 5029 : * Since we are "inside" a range, we can assume ctxt->cur is past
; 5030 : * the start of ctxt->string, and PREV should be safe
; 5031 : */
; 5032 : if ((start == '-') && (NXT(1) != ']') && (PREV != '[') && (PREV != '^')) {
cmp edi, 45 ; 0000002dH
jne SHORT $LN16@xmlFAParse
mov ecx, DWORD PTR [esi+4]
cmp BYTE PTR [ecx+1], 93 ; 0000005dH
je SHORT $LN16@xmlFAParse
mov dl, BYTE PTR [ecx-1]
cmp dl, 91 ; 0000005bH
je SHORT $LN16@xmlFAParse
cmp dl, 94 ; 0000005eH
je SHORT $LN16@xmlFAParse
; 5033 : NEXTL(len);
add eax, ecx
pop edi
mov DWORD PTR [esi+4], eax
pop esi
; 5074 : XML_REGEXP_CHARVAL, start, end, NULL);
; 5075 : }
; 5076 : return;
; 5077 : }
mov esp, ebp
pop ebp
ret 0
$LN16@xmlFAParse:
; 5034 : return;
; 5035 : }
; 5036 : NEXTL(len);
add DWORD PTR [esi+4], eax
mov ecx, DWORD PTR [esi+4]
; 5037 : cur = CUR;
; 5038 : if ((cur != '-') || (NXT(1) == ']')) {
cmp BYTE PTR [ecx], 45 ; 0000002dH
jne $LN18@xmlFAParse
inc ecx
cmp BYTE PTR [ecx], 93 ; 0000005dH
je $LN18@xmlFAParse
; 5040 : XML_REGEXP_CHARVAL, start, end, NULL);
; 5041 : return;
; 5042 : }
; 5043 : NEXT;
mov DWORD PTR [esi+4], ecx
; 5044 : cur = CUR;
mov al, BYTE PTR [ecx]
; 5045 : if (cur == '\\') {
cmp al, 92 ; 0000005cH
jne SHORT $LN19@xmlFAParse
; 5046 : NEXT;
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+4], eax
; 5047 : cur = CUR;
movzx ecx, BYTE PTR [eax]
; 5048 : switch (cur) {
lea eax, DWORD PTR [ecx-40]
cmp eax, 85 ; 00000055H
ja SHORT $LN25@xmlFAParse
movzx eax, BYTE PTR $LN32@xmlFAParse[eax]
jmp DWORD PTR $LN38@xmlFAParse[eax*4]
$LN21@xmlFAParse:
; 5059 : }
; 5060 : len = 1;
mov eax, 1
mov ecx, 10 ; 0000000aH
mov DWORD PTR _len$[ebp], eax
jmp SHORT $LN27@xmlFAParse
$LN22@xmlFAParse:
mov eax, 1
mov ecx, 13 ; 0000000dH
mov DWORD PTR _len$[ebp], eax
jmp SHORT $LN27@xmlFAParse
$LN23@xmlFAParse:
; 5049 : case 'n': end = 0xA; break;
; 5050 : case 'r': end = 0xD; break;
; 5051 : case 't': end = 0x9; break;
mov ecx, 9
$LN24@xmlFAParse:
; 5059 : }
; 5060 : len = 1;
mov eax, 1
mov DWORD PTR _len$[ebp], eax
jmp SHORT $LN27@xmlFAParse
$LN25@xmlFAParse:
; 5052 : case '\\': case '|': case '.': case '-': case '^': case '?':
; 5053 : case '*': case '+': case '{': case '}': case '(': case ')':
; 5054 : case '[': case ']':
; 5055 : end = cur; break;
; 5056 : default:
; 5057 : ERROR("Invalid escape value");
push OFFSET ??_C@_0BF@HOMDEKLG@Invalid?5escape?5value@
; 5058 : return;
jmp SHORT $LN34@xmlFAParse
$LN19@xmlFAParse:
; 5061 : } else if ((cur != '\0') && (cur != 0x5B) && (cur != 0x5D)) {
test al, al
je SHORT $LN26@xmlFAParse
cmp al, 91 ; 0000005bH
je SHORT $LN26@xmlFAParse
cmp al, 93 ; 0000005dH
je SHORT $LN26@xmlFAParse
; 5062 : end = CUR_SCHAR(ctxt->cur, len);
lea eax, DWORD PTR _len$[ebp]
push eax
push ecx
push 0
call _xmlStringCurrentChar
mov ecx, eax
add esp, 12 ; 0000000cH
mov eax, DWORD PTR _len$[ebp]
$LN27@xmlFAParse:
; 5066 : }
; 5067 :
; 5068 : /* TODO check that the values are acceptable character ranges for XML */
; 5069 : if (end < start) {
cmp ecx, edi
jge SHORT $LN28@xmlFAParse
; 5070 : ERROR("End of range is before start of range");
push OFFSET ??_C@_0CG@BKADGONK@End?5of?5range?5is?5before?5start?5of@
; 5071 : } else {
jmp SHORT $LN34@xmlFAParse
$LN28@xmlFAParse:
; 5072 : NEXTL(len);
add DWORD PTR [esi+4], eax
; 5073 : xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
push 0
push ecx
jmp SHORT $LN35@xmlFAParse
$LN26@xmlFAParse:
; 5063 : } else {
; 5064 : ERROR("Expecting the end of a char range");
push OFFSET ??_C@_0CC@JHFKDBIP@Expecting?5the?5end?5of?5a?5char?5ran@
; 5065 : return;
jmp SHORT $LN34@xmlFAParse
$LN18@xmlFAParse:
; 5039 : xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
push 0
push edi
$LN35@xmlFAParse:
push edi
push 2
push DWORD PTR [esi+12]
push DWORD PTR [esi+28]
push esi
call _xmlRegAtomAddRange
add esp, 28 ; 0000001cH
pop edi
pop esi
; 5074 : XML_REGEXP_CHARVAL, start, end, NULL);
; 5075 : }
; 5076 : return;
; 5077 : }
mov esp, ebp
pop ebp
ret 0
$LN14@xmlFAParse:
; 5024 : } else {
; 5025 : ERROR("Expecting a char range");
push OFFSET ??_C@_0BH@LOJMKNAD@Expecting?5a?5char?5range@
$LN34@xmlFAParse:
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop edi
pop esi
; 5074 : XML_REGEXP_CHARVAL, start, end, NULL);
; 5075 : }
; 5076 : return;
; 5077 : }
mov esp, ebp
pop ebp
ret 0
npad 3
$LN37@xmlFAParse:
DD $LN12@xmlFAParse
DD $LN9@xmlFAParse
DD $LN10@xmlFAParse
DD $LN11@xmlFAParse
DD $LN25@xmlFAParse
$LN31@xmlFAParse:
DB 0
DB 0
DB 0
DB 0
DB 4
DB 0
DB 0
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 0
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 0
DB 0
DB 0
DB 0
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 1
DB 4
DB 4
DB 4
DB 2
DB 4
DB 3
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 0
DB 0
DB 0
npad 2
$LN38@xmlFAParse:
DD $LN24@xmlFAParse
DD $LN21@xmlFAParse
DD $LN22@xmlFAParse
DD $LN23@xmlFAParse
DD $LN25@xmlFAParse
$LN32@xmlFAParse:
DB 0
DB 0
DB 0
DB 0
DB 4
DB 0
DB 0
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 0
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 0
DB 0
DB 0
DB 0
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 1
DB 4
DB 4
DB 4
DB 2
DB 4
DB 3
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 0
DB 0
DB 0
_xmlFAParseCharRange ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParseCharClassEsc
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlFAParseCharClassEsc PROC ; COMDAT
; 4849 : xmlFAParseCharClassEsc(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
mov ecx, DWORD PTR [esi+4]
mov al, BYTE PTR [ecx]
cmp al, 46 ; 0000002eH
jne SHORT $LN8@xmlFAParse
; 4850 : int cur;
; 4851 :
; 4852 : if (CUR == '.') {
; 4853 : if (ctxt->atom == NULL) {
mov eax, DWORD PTR [esi+28]
test eax, eax
jne SHORT $LN9@xmlFAParse
; 4854 : ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_ANYCHAR);
push 6
push esi
call _xmlRegNewAtom
add esp, 8
mov DWORD PTR [esi+28], eax
; 4857 : XML_REGEXP_ANYCHAR, 0, 0, NULL);
; 4858 : }
; 4859 : NEXT;
inc DWORD PTR [esi+4]
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN9@xmlFAParse:
; 4855 : } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
cmp DWORD PTR [eax+4], 3
jne SHORT $LN11@xmlFAParse
; 4856 : xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
push 0
push 0
push 0
push 6
push DWORD PTR [esi+12]
push eax
push esi
call _xmlRegAtomAddRange
add esp, 28 ; 0000001cH
$LN11@xmlFAParse:
; 4857 : XML_REGEXP_ANYCHAR, 0, 0, NULL);
; 4858 : }
; 4859 : NEXT;
inc DWORD PTR [esi+4]
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN8@xmlFAParse:
; 4860 : return;
; 4861 : }
; 4862 : if (CUR != '\\') {
cmp al, 92 ; 0000005cH
je SHORT $LN12@xmlFAParse
; 4863 : ERROR("Escaped sequence: expecting \\");
push OFFSET ??_C@_0BO@BOFONOMH@Escaped?5sequence?3?5expecting?5?2@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN12@xmlFAParse:
; 4864 : return;
; 4865 : }
; 4866 : NEXT;
lea edx, DWORD PTR [ecx+1]
push edi
mov DWORD PTR [esi+4], edx
; 4867 : cur = CUR;
movzx edi, BYTE PTR [edx]
; 4868 : if (cur == 'p') {
cmp edi, 112 ; 00000070H
jne SHORT $LN13@xmlFAParse
; 4869 : NEXT;
lea eax, DWORD PTR [edx+1]
mov DWORD PTR [esi+4], eax
; 4870 : if (CUR != '{') {
cmp BYTE PTR [eax], 123 ; 0000007bH
jne SHORT $LN54@xmlFAParse
; 4871 : ERROR("Expecting '{'");
; 4872 : return;
; 4873 : }
; 4874 : NEXT;
inc eax
; 4875 : xmlFAParseCharProp(ctxt);
push esi
mov DWORD PTR [esi+4], eax
call _xmlFAParseCharProp
; 4876 : if (CUR != '}') {
mov eax, DWORD PTR [esi+4]
add esp, 4
cmp BYTE PTR [eax], 125 ; 0000007dH
jne SHORT $LN53@xmlFAParse
$LN21@xmlFAParse:
; 4877 : ERROR("Expecting '}'");
; 4878 : return;
; 4879 : }
; 4880 : NEXT;
inc eax
pop edi
mov DWORD PTR [esi+4], eax
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN13@xmlFAParse:
; 4881 : } else if (cur == 'P') {
cmp edi, 80 ; 00000050H
jne SHORT $LN17@xmlFAParse
; 4882 : NEXT;
lea eax, DWORD PTR [edx+1]
mov DWORD PTR [esi+4], eax
; 4883 : if (CUR != '{') {
cmp BYTE PTR [eax], 123 ; 0000007bH
je SHORT $LN19@xmlFAParse
$LN54@xmlFAParse:
; 4884 : ERROR("Expecting '{'");
push OFFSET ??_C@_0O@OGGGBIPE@Expecting?5?8?$HL?8@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop edi
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN19@xmlFAParse:
; 4885 : return;
; 4886 : }
; 4887 : NEXT;
inc eax
; 4888 : xmlFAParseCharProp(ctxt);
push esi
mov DWORD PTR [esi+4], eax
call _xmlFAParseCharProp
; 4889 : if (ctxt->atom != NULL)
mov eax, DWORD PTR [esi+28]
add esp, 4
test eax, eax
je SHORT $LN20@xmlFAParse
; 4890 : ctxt->atom->neg = 1;
mov DWORD PTR [eax+28], 1
$LN20@xmlFAParse:
; 4891 : if (CUR != '}') {
mov eax, DWORD PTR [esi+4]
cmp BYTE PTR [eax], 125 ; 0000007dH
je SHORT $LN21@xmlFAParse
$LN53@xmlFAParse:
; 4892 : ERROR("Expecting '}'");
push OFFSET ??_C@_0O@OCOLGEEG@Expecting?5?8?$HN?8@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop edi
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN17@xmlFAParse:
; 4893 : return;
; 4894 : }
; 4895 : NEXT;
; 4896 : } else if ((cur == 'n') || (cur == 'r') || (cur == 't') || (cur == '\\') ||
; 4897 : (cur == '|') || (cur == '.') || (cur == '?') || (cur == '*') ||
; 4898 : (cur == '+') || (cur == '(') || (cur == ')') || (cur == '{') ||
; 4899 : (cur == '}') || (cur == 0x2D) || (cur == 0x5B) || (cur == 0x5D) ||
cmp edi, 110 ; 0000006eH
je $LN24@xmlFAParse
cmp edi, 114 ; 00000072H
je $LN24@xmlFAParse
cmp edi, 116 ; 00000074H
je $LN24@xmlFAParse
cmp edi, 92 ; 0000005cH
je $LN24@xmlFAParse
cmp edi, 124 ; 0000007cH
je $LN24@xmlFAParse
cmp edi, 46 ; 0000002eH
je $LN24@xmlFAParse
cmp edi, 63 ; 0000003fH
je $LN24@xmlFAParse
cmp edi, 42 ; 0000002aH
je $LN24@xmlFAParse
cmp edi, 43 ; 0000002bH
je $LN24@xmlFAParse
cmp edi, 40 ; 00000028H
je $LN24@xmlFAParse
cmp edi, 41 ; 00000029H
je $LN24@xmlFAParse
cmp edi, 123 ; 0000007bH
je $LN24@xmlFAParse
cmp edi, 125 ; 0000007dH
je $LN24@xmlFAParse
cmp edi, 45 ; 0000002dH
je $LN24@xmlFAParse
cmp edi, 91 ; 0000005bH
je $LN24@xmlFAParse
cmp edi, 93 ; 0000005dH
je $LN24@xmlFAParse
cmp edi, 94 ; 0000005eH
je $LN24@xmlFAParse
; 4934 : } else if ((cur == 's') || (cur == 'S') || (cur == 'i') || (cur == 'I') ||
; 4935 : (cur == 'c') || (cur == 'C') || (cur == 'd') || (cur == 'D') ||
; 4936 : (cur == 'w') || (cur == 'W')) {
cmp edi, 115 ; 00000073H
je SHORT $LN38@xmlFAParse
cmp edi, 83 ; 00000053H
je SHORT $LN38@xmlFAParse
cmp edi, 105 ; 00000069H
je SHORT $LN38@xmlFAParse
cmp edi, 73 ; 00000049H
je SHORT $LN38@xmlFAParse
cmp edi, 99 ; 00000063H
je SHORT $LN38@xmlFAParse
cmp edi, 67 ; 00000043H
je SHORT $LN38@xmlFAParse
cmp edi, 100 ; 00000064H
je SHORT $LN38@xmlFAParse
cmp edi, 68 ; 00000044H
je SHORT $LN38@xmlFAParse
cmp edi, 119 ; 00000077H
je SHORT $LN38@xmlFAParse
cmp edi, 87 ; 00000057H
je SHORT $LN38@xmlFAParse
; 4976 : type, 0, 0, NULL);
; 4977 : }
; 4978 : } else {
; 4979 : ERROR("Wrong escape sequence, misuse of character '\\'");
push OFFSET ??_C@_0CP@BDPLJNDH@Wrong?5escape?5sequence?0?5misuse?5o@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop edi
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN38@xmlFAParse:
; 4937 : xmlRegAtomType type = XML_REGEXP_ANYSPACE;
; 4938 :
; 4939 : switch (cur) {
add edi, -67 ; ffffffbdH
mov ecx, 7
cmp edi, 52 ; 00000034H
ja SHORT $LN6@xmlFAParse
movzx eax, BYTE PTR $LN55@xmlFAParse[edi]
jmp DWORD PTR $LN58@xmlFAParse[eax*4]
$LN40@xmlFAParse:
; 4940 : case 's':
; 4941 : type = XML_REGEXP_ANYSPACE;
; 4942 : break;
; 4943 : case 'S':
; 4944 : type = XML_REGEXP_NOTSPACE;
mov ecx, 8
; 4945 : break;
jmp SHORT $LN6@xmlFAParse
$LN41@xmlFAParse:
; 4946 : case 'i':
; 4947 : type = XML_REGEXP_INITNAME;
mov ecx, 9
; 4948 : break;
jmp SHORT $LN6@xmlFAParse
$LN42@xmlFAParse:
; 4949 : case 'I':
; 4950 : type = XML_REGEXP_NOTINITNAME;
mov ecx, 10 ; 0000000aH
; 4951 : break;
jmp SHORT $LN6@xmlFAParse
$LN43@xmlFAParse:
; 4952 : case 'c':
; 4953 : type = XML_REGEXP_NAMECHAR;
mov ecx, 11 ; 0000000bH
; 4954 : break;
jmp SHORT $LN6@xmlFAParse
$LN44@xmlFAParse:
; 4955 : case 'C':
; 4956 : type = XML_REGEXP_NOTNAMECHAR;
mov ecx, 12 ; 0000000cH
; 4957 : break;
jmp SHORT $LN6@xmlFAParse
$LN45@xmlFAParse:
; 4958 : case 'd':
; 4959 : type = XML_REGEXP_DECIMAL;
mov ecx, 13 ; 0000000dH
; 4960 : break;
jmp SHORT $LN6@xmlFAParse
$LN46@xmlFAParse:
; 4961 : case 'D':
; 4962 : type = XML_REGEXP_NOTDECIMAL;
mov ecx, 14 ; 0000000eH
; 4963 : break;
jmp SHORT $LN6@xmlFAParse
$LN47@xmlFAParse:
; 4964 : case 'w':
; 4965 : type = XML_REGEXP_REALCHAR;
mov ecx, 15 ; 0000000fH
; 4966 : break;
jmp SHORT $LN6@xmlFAParse
$LN48@xmlFAParse:
; 4967 : case 'W':
; 4968 : type = XML_REGEXP_NOTREALCHAR;
mov ecx, 16 ; 00000010H
$LN6@xmlFAParse:
; 4969 : break;
; 4970 : }
; 4971 : NEXT;
lea eax, DWORD PTR [edx+1]
mov DWORD PTR [esi+4], eax
; 4972 : if (ctxt->atom == NULL) {
mov eax, DWORD PTR [esi+28]
test eax, eax
jne SHORT $LN49@xmlFAParse
; 4973 : ctxt->atom = xmlRegNewAtom(ctxt, type);
push ecx
push esi
call _xmlRegNewAtom
add esp, 8
mov DWORD PTR [esi+28], eax
pop edi
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN49@xmlFAParse:
; 4974 : } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
cmp DWORD PTR [eax+4], 3
jne $LN56@xmlFAParse
; 4975 : xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
push 0
push 0
push 0
push ecx
push DWORD PTR [esi+12]
push eax
push esi
call _xmlRegAtomAddRange
add esp, 28 ; 0000001cH
pop edi
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN24@xmlFAParse:
; 4900 : (cur == 0x5E)) {
; 4901 : if (ctxt->atom == NULL) {
mov ecx, DWORD PTR [esi+28]
test ecx, ecx
jne SHORT $LN25@xmlFAParse
; 4902 : ctxt->atom = xmlRegNewAtom(ctxt, XML_REGEXP_CHARVAL);
push 2
push esi
call _xmlRegNewAtom
add esp, 8
mov DWORD PTR [esi+28], eax
; 4903 : if (ctxt->atom != NULL) {
test eax, eax
je $LN32@xmlFAParse
; 4904 : switch (cur) {
mov ecx, edi
sub ecx, 110 ; 0000006eH
je SHORT $LN28@xmlFAParse
sub ecx, 4
je SHORT $LN29@xmlFAParse
sub ecx, 2
je SHORT $LN30@xmlFAParse
; 4913 : break;
; 4914 : default:
; 4915 : ctxt->atom->codepoint = cur;
mov DWORD PTR [eax+32], edi
; 4931 : XML_REGEXP_CHARVAL, cur, cur, NULL);
; 4932 : }
; 4933 : NEXT;
inc DWORD PTR [esi+4]
pop edi
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN30@xmlFAParse:
; 4910 : break;
; 4911 : case 't':
; 4912 : ctxt->atom->codepoint = '\t';
mov DWORD PTR [eax+32], 9
; 4931 : XML_REGEXP_CHARVAL, cur, cur, NULL);
; 4932 : }
; 4933 : NEXT;
inc DWORD PTR [esi+4]
pop edi
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN29@xmlFAParse:
; 4907 : break;
; 4908 : case 'r':
; 4909 : ctxt->atom->codepoint = '\r';
mov DWORD PTR [eax+32], 13 ; 0000000dH
; 4931 : XML_REGEXP_CHARVAL, cur, cur, NULL);
; 4932 : }
; 4933 : NEXT;
inc DWORD PTR [esi+4]
pop edi
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN28@xmlFAParse:
; 4905 : case 'n':
; 4906 : ctxt->atom->codepoint = '\n';
mov DWORD PTR [eax+32], 10 ; 0000000aH
; 4931 : XML_REGEXP_CHARVAL, cur, cur, NULL);
; 4932 : }
; 4933 : NEXT;
inc DWORD PTR [esi+4]
pop edi
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
$LN25@xmlFAParse:
; 4916 : }
; 4917 : }
; 4918 : } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
cmp DWORD PTR [ecx+4], 3
jne SHORT $LN32@xmlFAParse
; 4919 : switch (cur) {
mov eax, edi
sub eax, 110 ; 0000006eH
je SHORT $LN33@xmlFAParse
sub eax, 4
je SHORT $LN34@xmlFAParse
sub eax, 2
jne SHORT $LN4@xmlFAParse
; 4926 : case 't':
; 4927 : cur = '\t';
lea edi, DWORD PTR [eax+9]
jmp SHORT $LN4@xmlFAParse
$LN34@xmlFAParse:
; 4922 : break;
; 4923 : case 'r':
; 4924 : cur = '\r';
mov edi, 13 ; 0000000dH
; 4925 : break;
jmp SHORT $LN4@xmlFAParse
$LN33@xmlFAParse:
; 4920 : case 'n':
; 4921 : cur = '\n';
mov edi, 10 ; 0000000aH
$LN4@xmlFAParse:
; 4928 : break;
; 4929 : }
; 4930 : xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
push 0
push edi
push edi
push 2
push DWORD PTR [esi+12]
push ecx
push esi
call _xmlRegAtomAddRange
add esp, 28 ; 0000001cH
$LN32@xmlFAParse:
; 4931 : XML_REGEXP_CHARVAL, cur, cur, NULL);
; 4932 : }
; 4933 : NEXT;
inc DWORD PTR [esi+4]
$LN56@xmlFAParse:
pop edi
pop esi
; 4980 : }
; 4981 : }
pop ebp
ret 0
npad 2
$LN58@xmlFAParse:
DD $LN44@xmlFAParse
DD $LN46@xmlFAParse
DD $LN42@xmlFAParse
DD $LN40@xmlFAParse
DD $LN48@xmlFAParse
DD $LN43@xmlFAParse
DD $LN45@xmlFAParse
DD $LN41@xmlFAParse
DD $LN6@xmlFAParse
DD $LN47@xmlFAParse
DD $LN6@xmlFAParse
$LN55@xmlFAParse:
DB 0
DB 1
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 2
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 3
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 4
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 5
DB 6
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 7
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 8
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 10 ; 0000000aH
DB 9
_xmlFAParseCharClassEsc ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParseCharProp
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlFAParseCharProp PROC ; COMDAT
; 4632 : xmlFAParseCharProp(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
xor ebx, ebx
mov ecx, DWORD PTR [esi+4]
mov al, BYTE PTR [ecx]
cmp al, 76 ; 0000004cH
jne SHORT $LN4@xmlFAParse
; 4633 : int cur;
; 4634 : xmlRegAtomType type = (xmlRegAtomType) 0;
; 4635 : xmlChar *blockName = NULL;
; 4636 :
; 4637 : cur = CUR;
; 4638 : if (cur == 'L') {
; 4639 : NEXT;
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+4], eax
; 4640 : cur = CUR;
mov cl, BYTE PTR [eax]
; 4641 : if (cur == 'u') {
cmp cl, 117 ; 00000075H
jne SHORT $LN6@xmlFAParse
; 4642 : NEXT;
inc eax
; 4643 : type = XML_REGEXP_LETTER_UPPERCASE;
lea edi, DWORD PTR [ebx+101]
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN6@xmlFAParse:
; 4644 : } else if (cur == 'l') {
cmp cl, 108 ; 0000006cH
jne SHORT $LN8@xmlFAParse
; 4645 : NEXT;
inc eax
; 4646 : type = XML_REGEXP_LETTER_LOWERCASE;
mov edi, 102 ; 00000066H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN8@xmlFAParse:
; 4647 : } else if (cur == 't') {
cmp cl, 116 ; 00000074H
jne SHORT $LN10@xmlFAParse
; 4648 : NEXT;
inc eax
; 4649 : type = XML_REGEXP_LETTER_TITLECASE;
mov edi, 103 ; 00000067H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN10@xmlFAParse:
; 4650 : } else if (cur == 'm') {
cmp cl, 109 ; 0000006dH
jne SHORT $LN12@xmlFAParse
; 4651 : NEXT;
inc eax
; 4652 : type = XML_REGEXP_LETTER_MODIFIER;
mov edi, 104 ; 00000068H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN12@xmlFAParse:
; 4653 : } else if (cur == 'o') {
cmp cl, 111 ; 0000006fH
jne SHORT $LN14@xmlFAParse
; 4654 : NEXT;
inc eax
; 4655 : type = XML_REGEXP_LETTER_OTHERS;
mov edi, 105 ; 00000069H
mov DWORD PTR [esi+4], eax
; 4656 : } else {
jmp $LN77@xmlFAParse
$LN14@xmlFAParse:
; 4657 : type = XML_REGEXP_LETTER;
mov edi, 100 ; 00000064H
; 4658 : }
jmp $LN77@xmlFAParse
$LN4@xmlFAParse:
; 4659 : } else if (cur == 'M') {
cmp al, 77 ; 0000004dH
jne SHORT $LN16@xmlFAParse
; 4660 : NEXT;
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+4], eax
; 4661 : cur = CUR;
mov cl, BYTE PTR [eax]
; 4662 : if (cur == 'n') {
cmp cl, 110 ; 0000006eH
jne SHORT $LN18@xmlFAParse
; 4663 : NEXT;
inc eax
; 4664 : /* nonspacing */
; 4665 : type = XML_REGEXP_MARK_NONSPACING;
mov edi, 107 ; 0000006bH
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN18@xmlFAParse:
; 4666 : } else if (cur == 'c') {
cmp cl, 99 ; 00000063H
jne SHORT $LN20@xmlFAParse
; 4667 : NEXT;
inc eax
; 4668 : /* spacing combining */
; 4669 : type = XML_REGEXP_MARK_SPACECOMBINING;
mov edi, 108 ; 0000006cH
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN20@xmlFAParse:
; 4670 : } else if (cur == 'e') {
cmp cl, 101 ; 00000065H
jne SHORT $LN22@xmlFAParse
; 4671 : NEXT;
inc eax
; 4672 : /* enclosing */
; 4673 : type = XML_REGEXP_MARK_ENCLOSING;
mov edi, 109 ; 0000006dH
mov DWORD PTR [esi+4], eax
; 4674 : } else {
jmp $LN77@xmlFAParse
$LN22@xmlFAParse:
; 4675 : /* all marks */
; 4676 : type = XML_REGEXP_MARK;
mov edi, 106 ; 0000006aH
; 4677 : }
jmp $LN77@xmlFAParse
$LN16@xmlFAParse:
; 4678 : } else if (cur == 'N') {
cmp al, 78 ; 0000004eH
jne SHORT $LN24@xmlFAParse
; 4679 : NEXT;
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+4], eax
; 4680 : cur = CUR;
mov cl, BYTE PTR [eax]
; 4681 : if (cur == 'd') {
cmp cl, 100 ; 00000064H
jne SHORT $LN26@xmlFAParse
; 4682 : NEXT;
inc eax
; 4683 : /* digital */
; 4684 : type = XML_REGEXP_NUMBER_DECIMAL;
mov edi, 111 ; 0000006fH
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN26@xmlFAParse:
; 4685 : } else if (cur == 'l') {
cmp cl, 108 ; 0000006cH
jne SHORT $LN28@xmlFAParse
; 4686 : NEXT;
inc eax
; 4687 : /* letter */
; 4688 : type = XML_REGEXP_NUMBER_LETTER;
mov edi, 112 ; 00000070H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN28@xmlFAParse:
; 4689 : } else if (cur == 'o') {
cmp cl, 111 ; 0000006fH
jne SHORT $LN30@xmlFAParse
; 4690 : NEXT;
inc eax
; 4691 : /* other */
; 4692 : type = XML_REGEXP_NUMBER_OTHERS;
mov edi, 113 ; 00000071H
mov DWORD PTR [esi+4], eax
; 4693 : } else {
jmp $LN77@xmlFAParse
$LN30@xmlFAParse:
; 4694 : /* all numbers */
; 4695 : type = XML_REGEXP_NUMBER;
mov edi, 110 ; 0000006eH
; 4696 : }
jmp $LN77@xmlFAParse
$LN24@xmlFAParse:
; 4697 : } else if (cur == 'P') {
cmp al, 80 ; 00000050H
jne $LN32@xmlFAParse
; 4698 : NEXT;
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+4], eax
; 4699 : cur = CUR;
mov cl, BYTE PTR [eax]
; 4700 : if (cur == 'c') {
cmp cl, 99 ; 00000063H
jne SHORT $LN34@xmlFAParse
; 4701 : NEXT;
inc eax
; 4702 : /* connector */
; 4703 : type = XML_REGEXP_PUNCT_CONNECTOR;
mov edi, 115 ; 00000073H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN34@xmlFAParse:
; 4704 : } else if (cur == 'd') {
cmp cl, 100 ; 00000064H
jne SHORT $LN36@xmlFAParse
; 4705 : NEXT;
inc eax
; 4706 : /* dash */
; 4707 : type = XML_REGEXP_PUNCT_DASH;
mov edi, 116 ; 00000074H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN36@xmlFAParse:
; 4708 : } else if (cur == 's') {
cmp cl, 115 ; 00000073H
jne SHORT $LN38@xmlFAParse
; 4709 : NEXT;
inc eax
; 4710 : /* open */
; 4711 : type = XML_REGEXP_PUNCT_OPEN;
mov edi, 117 ; 00000075H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN38@xmlFAParse:
; 4712 : } else if (cur == 'e') {
cmp cl, 101 ; 00000065H
jne SHORT $LN40@xmlFAParse
; 4713 : NEXT;
inc eax
; 4714 : /* close */
; 4715 : type = XML_REGEXP_PUNCT_CLOSE;
mov edi, 118 ; 00000076H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN40@xmlFAParse:
; 4716 : } else if (cur == 'i') {
cmp cl, 105 ; 00000069H
jne SHORT $LN42@xmlFAParse
; 4717 : NEXT;
inc eax
; 4718 : /* initial quote */
; 4719 : type = XML_REGEXP_PUNCT_INITQUOTE;
mov edi, 119 ; 00000077H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN42@xmlFAParse:
; 4720 : } else if (cur == 'f') {
cmp cl, 102 ; 00000066H
jne SHORT $LN44@xmlFAParse
; 4721 : NEXT;
inc eax
; 4722 : /* final quote */
; 4723 : type = XML_REGEXP_PUNCT_FINQUOTE;
mov edi, 120 ; 00000078H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN44@xmlFAParse:
; 4724 : } else if (cur == 'o') {
cmp cl, 111 ; 0000006fH
jne SHORT $LN46@xmlFAParse
; 4725 : NEXT;
inc eax
; 4726 : /* other */
; 4727 : type = XML_REGEXP_PUNCT_OTHERS;
mov edi, 121 ; 00000079H
mov DWORD PTR [esi+4], eax
; 4728 : } else {
jmp $LN77@xmlFAParse
$LN46@xmlFAParse:
; 4729 : /* all punctuation */
; 4730 : type = XML_REGEXP_PUNCT;
mov edi, 114 ; 00000072H
; 4731 : }
jmp $LN77@xmlFAParse
$LN32@xmlFAParse:
; 4732 : } else if (cur == 'Z') {
cmp al, 90 ; 0000005aH
jne SHORT $LN48@xmlFAParse
; 4733 : NEXT;
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+4], eax
; 4734 : cur = CUR;
mov cl, BYTE PTR [eax]
; 4735 : if (cur == 's') {
cmp cl, 115 ; 00000073H
jne SHORT $LN50@xmlFAParse
; 4736 : NEXT;
inc eax
; 4737 : /* space */
; 4738 : type = XML_REGEXP_SEPAR_SPACE;
mov edi, 123 ; 0000007bH
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN50@xmlFAParse:
; 4739 : } else if (cur == 'l') {
cmp cl, 108 ; 0000006cH
jne SHORT $LN52@xmlFAParse
; 4740 : NEXT;
inc eax
; 4741 : /* line */
; 4742 : type = XML_REGEXP_SEPAR_LINE;
mov edi, 124 ; 0000007cH
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN52@xmlFAParse:
; 4743 : } else if (cur == 'p') {
cmp cl, 112 ; 00000070H
jne SHORT $LN54@xmlFAParse
; 4744 : NEXT;
inc eax
; 4745 : /* paragraph */
; 4746 : type = XML_REGEXP_SEPAR_PARA;
mov edi, 125 ; 0000007dH
mov DWORD PTR [esi+4], eax
; 4747 : } else {
jmp $LN77@xmlFAParse
$LN54@xmlFAParse:
; 4748 : /* all separators */
; 4749 : type = XML_REGEXP_SEPAR;
mov edi, 122 ; 0000007aH
; 4750 : }
jmp $LN77@xmlFAParse
$LN48@xmlFAParse:
; 4751 : } else if (cur == 'S') {
cmp al, 83 ; 00000053H
jne SHORT $LN56@xmlFAParse
; 4752 : NEXT;
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+4], eax
; 4753 : cur = CUR;
mov cl, BYTE PTR [eax]
; 4754 : if (cur == 'm') {
cmp cl, 109 ; 0000006dH
jne SHORT $LN58@xmlFAParse
; 4755 : NEXT;
inc eax
; 4756 : type = XML_REGEXP_SYMBOL_MATH;
mov edi, 127 ; 0000007fH
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN58@xmlFAParse:
; 4757 : /* math */
; 4758 : } else if (cur == 'c') {
cmp cl, 99 ; 00000063H
jne SHORT $LN60@xmlFAParse
; 4759 : NEXT;
inc eax
; 4760 : type = XML_REGEXP_SYMBOL_CURRENCY;
mov edi, 128 ; 00000080H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN60@xmlFAParse:
; 4761 : /* currency */
; 4762 : } else if (cur == 'k') {
cmp cl, 107 ; 0000006bH
jne SHORT $LN62@xmlFAParse
; 4763 : NEXT;
inc eax
; 4764 : type = XML_REGEXP_SYMBOL_MODIFIER;
mov edi, 129 ; 00000081H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN62@xmlFAParse:
; 4765 : /* modifiers */
; 4766 : } else if (cur == 'o') {
cmp cl, 111 ; 0000006fH
jne SHORT $LN64@xmlFAParse
; 4767 : NEXT;
inc eax
; 4768 : type = XML_REGEXP_SYMBOL_OTHERS;
mov edi, 130 ; 00000082H
mov DWORD PTR [esi+4], eax
; 4769 : /* other */
; 4770 : } else {
jmp $LN77@xmlFAParse
$LN64@xmlFAParse:
; 4771 : /* all symbols */
; 4772 : type = XML_REGEXP_SYMBOL;
mov edi, 126 ; 0000007eH
; 4773 : }
jmp $LN77@xmlFAParse
$LN56@xmlFAParse:
; 4774 : } else if (cur == 'C') {
cmp al, 67 ; 00000043H
jne SHORT $LN66@xmlFAParse
; 4775 : NEXT;
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR [esi+4], eax
; 4776 : cur = CUR;
mov cl, BYTE PTR [eax]
; 4777 : if (cur == 'c') {
cmp cl, 99 ; 00000063H
jne SHORT $LN68@xmlFAParse
; 4778 : NEXT;
inc eax
; 4779 : /* control */
; 4780 : type = XML_REGEXP_OTHER_CONTROL;
mov edi, 132 ; 00000084H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN68@xmlFAParse:
; 4781 : } else if (cur == 'f') {
cmp cl, 102 ; 00000066H
jne SHORT $LN70@xmlFAParse
; 4782 : NEXT;
inc eax
; 4783 : /* format */
; 4784 : type = XML_REGEXP_OTHER_FORMAT;
mov edi, 133 ; 00000085H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN70@xmlFAParse:
; 4785 : } else if (cur == 'o') {
cmp cl, 111 ; 0000006fH
jne SHORT $LN72@xmlFAParse
; 4786 : NEXT;
inc eax
; 4787 : /* private use */
; 4788 : type = XML_REGEXP_OTHER_PRIVATE;
mov edi, 134 ; 00000086H
mov DWORD PTR [esi+4], eax
jmp $LN77@xmlFAParse
$LN72@xmlFAParse:
; 4789 : } else if (cur == 'n') {
cmp cl, 110 ; 0000006eH
jne SHORT $LN74@xmlFAParse
; 4790 : NEXT;
inc eax
; 4791 : /* not assigned */
; 4792 : type = XML_REGEXP_OTHER_NA;
mov edi, 135 ; 00000087H
mov DWORD PTR [esi+4], eax
; 4793 : } else {
jmp $LN77@xmlFAParse
$LN74@xmlFAParse:
; 4794 : /* all others */
; 4795 : type = XML_REGEXP_OTHER;
mov edi, 131 ; 00000083H
; 4796 : }
jmp $LN77@xmlFAParse
$LN66@xmlFAParse:
; 4797 : } else if (cur == 'I') {
cmp al, 73 ; 00000049H
jne $LN76@xmlFAParse
; 4798 : const xmlChar *start;
; 4799 : NEXT;
inc ecx
mov DWORD PTR [esi+4], ecx
; 4800 : cur = CUR;
; 4801 : if (cur != 's') {
cmp BYTE PTR [ecx], 115 ; 00000073H
je SHORT $LN78@xmlFAParse
; 4802 : ERROR("IsXXXX expected");
push OFFSET ??_C@_0BA@KPLOEDJN@IsXXXX?5expected@
; 4803 : return;
jmp $LN97@xmlFAParse
$LN78@xmlFAParse:
; 4804 : }
; 4805 : NEXT;
lea edx, DWORD PTR [ecx+1]
mov DWORD PTR [esi+4], edx
; 4806 : start = ctxt->cur;
; 4807 : cur = CUR;
mov cl, BYTE PTR [edx]
; 4808 : if (((cur >= 'a') && (cur <= 'z')) ||
; 4809 : ((cur >= 'A') && (cur <= 'Z')) ||
; 4810 : ((cur >= '0') && (cur <= '9')) ||
cmp cl, 97 ; 00000061H
jb SHORT $LN81@xmlFAParse
cmp cl, 122 ; 0000007aH
jbe SHORT $LN80@xmlFAParse
$LN81@xmlFAParse:
cmp cl, 65 ; 00000041H
jb SHORT $LN82@xmlFAParse
cmp cl, 90 ; 0000005aH
jbe SHORT $LN80@xmlFAParse
$LN82@xmlFAParse:
cmp cl, 48 ; 00000030H
jb SHORT $LN83@xmlFAParse
cmp cl, 57 ; 00000039H
jbe SHORT $LN80@xmlFAParse
$LN83@xmlFAParse:
mov eax, edx
cmp cl, 45 ; 0000002dH
jne SHORT $LN95@xmlFAParse
$LN80@xmlFAParse:
; 4811 : (cur == 0x2D)) {
; 4812 : NEXT;
lea eax, DWORD PTR [edx+1]
mov DWORD PTR [esi+4], eax
$LN98@xmlFAParse:
; 4813 : cur = CUR;
; 4814 : while (((cur >= 'a') && (cur <= 'z')) ||
; 4815 : ((cur >= 'A') && (cur <= 'Z')) ||
; 4816 : ((cur >= '0') && (cur <= '9')) ||
movzx ecx, BYTE PTR [eax]
cmp ecx, 97 ; 00000061H
jb SHORT $LN85@xmlFAParse
cmp ecx, 122 ; 0000007aH
jbe SHORT $LN84@xmlFAParse
$LN85@xmlFAParse:
cmp ecx, 65 ; 00000041H
jb SHORT $LN86@xmlFAParse
cmp ecx, 90 ; 0000005aH
jbe SHORT $LN84@xmlFAParse
$LN86@xmlFAParse:
cmp ecx, 48 ; 00000030H
jb SHORT $LN87@xmlFAParse
cmp ecx, 57 ; 00000039H
jbe SHORT $LN84@xmlFAParse
$LN87@xmlFAParse:
cmp ecx, 45 ; 0000002dH
jne SHORT $LN95@xmlFAParse
$LN84@xmlFAParse:
; 4817 : (cur == 0x2D)) {
; 4818 : NEXT;
inc DWORD PTR [esi+4]
mov eax, DWORD PTR [esi+4]
; 4819 : cur = CUR;
; 4820 : }
jmp SHORT $LN98@xmlFAParse
$LN95@xmlFAParse:
; 4821 : }
; 4822 : type = XML_REGEXP_BLOCK_NAME;
; 4823 : blockName = xmlStrndup(start, ctxt->cur - start);
sub eax, edx
mov edi, 136 ; 00000088H
push eax
push edx
call _xmlStrndup
add esp, 8
mov ebx, eax
$LN77@xmlFAParse:
; 4826 : return;
; 4827 : }
; 4828 : if (ctxt->atom == NULL) {
mov ecx, DWORD PTR [esi+28]
test ecx, ecx
jne SHORT $LN88@xmlFAParse
; 4829 : ctxt->atom = xmlRegNewAtom(ctxt, type);
push edi
push esi
call _xmlRegNewAtom
add esp, 8
mov DWORD PTR [esi+28], eax
; 4830 : if (ctxt->atom != NULL)
test eax, eax
je SHORT $LN91@xmlFAParse
; 4834 : type, 0, 0, blockName);
; 4835 : }
; 4836 : }
pop edi
pop esi
mov DWORD PTR [eax+20], ebx
pop ebx
pop ebp
ret 0
$LN88@xmlFAParse:
; 4831 : ctxt->atom->valuep = blockName;
; 4832 : } else if (ctxt->atom->type == XML_REGEXP_RANGES) {
cmp DWORD PTR [ecx+4], 3
jne SHORT $LN91@xmlFAParse
; 4833 : xmlRegAtomAddRange(ctxt, ctxt->atom, ctxt->neg,
push ebx
push 0
push 0
push edi
push DWORD PTR [esi+12]
push ecx
push esi
call _xmlRegAtomAddRange
add esp, 28 ; 0000001cH
pop edi
; 4834 : type, 0, 0, blockName);
; 4835 : }
; 4836 : }
pop esi
pop ebx
pop ebp
ret 0
$LN76@xmlFAParse:
; 4824 : } else {
; 4825 : ERROR("Unknown char property");
push OFFSET ??_C@_0BG@ECFAFFBF@Unknown?5char?5property@
$LN97@xmlFAParse:
; 4834 : type, 0, 0, blockName);
; 4835 : }
; 4836 : }
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
$LN91@xmlFAParse:
pop edi
pop esi
pop ebx
pop ebp
ret 0
_xmlFAParseCharProp ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAIsChar
_TEXT SEGMENT
_len$ = -4 ; size = 4
_ctxt$ = 8 ; size = 4
_xmlFAIsChar PROC ; COMDAT
; 4602 : xmlFAIsChar(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push ecx
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
lea eax, DWORD PTR _len$[ebp]
push eax
mov eax, DWORD PTR _ctxt$[ebp]
push DWORD PTR [eax+4]
push 0
call _xmlStringCurrentChar
add esp, 12 ; 0000000cH
cmp eax, 46 ; 0000002eH
je SHORT $LN3@xmlFAIsCha
; 4603 : int cur;
; 4604 : int len;
; 4605 :
; 4606 : cur = CUR_SCHAR(ctxt->cur, len);
; 4607 : if ((cur == '.') || (cur == '\\') || (cur == '?') ||
; 4608 : (cur == '*') || (cur == '+') || (cur == '(') ||
; 4609 : (cur == ')') || (cur == '|') || (cur == 0x5B) ||
; 4610 : (cur == 0x5D) || (cur == 0))
cmp eax, 92 ; 0000005cH
je SHORT $LN3@xmlFAIsCha
cmp eax, 63 ; 0000003fH
je SHORT $LN3@xmlFAIsCha
cmp eax, 42 ; 0000002aH
je SHORT $LN3@xmlFAIsCha
cmp eax, 43 ; 0000002bH
je SHORT $LN3@xmlFAIsCha
cmp eax, 40 ; 00000028H
je SHORT $LN3@xmlFAIsCha
cmp eax, 41 ; 00000029H
je SHORT $LN3@xmlFAIsCha
cmp eax, 124 ; 0000007cH
je SHORT $LN3@xmlFAIsCha
cmp eax, 91 ; 0000005bH
je SHORT $LN3@xmlFAIsCha
cmp eax, 93 ; 0000005dH
je SHORT $LN3@xmlFAIsCha
test eax, eax
jne SHORT $LN1@xmlFAIsCha
$LN3@xmlFAIsCha:
; 4611 : return(-1);
or eax, -1
$LN1@xmlFAIsCha:
; 4612 : return(cur);
; 4613 : }
mov esp, ebp
pop ebp
ret 0
_xmlFAIsChar ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegExecGetValues
_TEXT SEGMENT
_transno$1$ = -16 ; size = 4
tv1308 = -16 ; size = 4
tv1301 = -16 ; size = 4
tv1300 = -16 ; size = 4
tv1297 = -12 ; size = 4
tv1296 = -12 ; size = 4
_state$1$ = -8 ; size = 4
_maxval$1$ = -4 ; size = 4
_state$1$ = 8 ; size = 4
_exec$ = 8 ; size = 4
_err$ = 12 ; size = 4
_nbval$ = 16 ; size = 4
_nbneg$ = 20 ; size = 4
_values$ = 24 ; size = 4
_terminal$ = 28 ; size = 4
_xmlRegExecGetValues PROC ; COMDAT
; 4221 : xmlChar **values, int *terminal) {
push ebp
mov ebp, esp
sub esp, 16 ; 00000010H
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push ebx
push esi
push edi
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _exec$[ebp]
xor edi, edi
test eax, eax
je SHORT $LN15@xmlRegExec
; 4222 : int maxval;
; 4223 : int nb = 0;
; 4224 :
; 4225 : if ((exec == NULL) || (nbval == NULL) || (nbneg == NULL) ||
; 4226 : (values == NULL) || (*nbval <= 0))
mov ecx, DWORD PTR _nbval$[ebp]
test ecx, ecx
je SHORT $LN15@xmlRegExec
mov ebx, DWORD PTR _nbneg$[ebp]
test ebx, ebx
je SHORT $LN15@xmlRegExec
cmp DWORD PTR _values$[ebp], edi
je SHORT $LN15@xmlRegExec
mov esi, DWORD PTR [ecx]
mov DWORD PTR _maxval$1$[ebp], esi
test esi, esi
jle SHORT $LN15@xmlRegExec
; 4227 : return(-1);
; 4228 :
; 4229 : maxval = *nbval;
; 4230 : *nbval = 0;
mov DWORD PTR [ecx], edi
; 4231 : *nbneg = 0;
mov DWORD PTR [ebx], edi
; 4232 : if ((exec->comp != NULL) && (exec->comp->compact != NULL)) {
mov edx, DWORD PTR [eax+8]
test edx, edx
je $LN16@xmlRegExec
mov ebx, DWORD PTR [edx+40]
test ebx, ebx
je $LN16@xmlRegExec
; 4233 : xmlRegexpPtr comp;
; 4234 : int target, i, state;
; 4235 :
; 4236 : comp = exec->comp;
; 4237 :
; 4238 : if (err) {
cmp DWORD PTR _err$[ebp], edi
je SHORT $LN18@xmlRegExec
; 4239 : if (exec->errStateNo == -1) return(-1);
mov eax, DWORD PTR [eax+72]
mov DWORD PTR _state$1$[ebp], eax
cmp eax, -1
jne SHORT $LN19@xmlRegExec
$LN15@xmlRegExec:
pop edi
; 4357 : }
; 4358 : }
; 4359 : }
; 4360 : }
; 4361 : return(0);
; 4362 : }
pop esi
or eax, -1
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN18@xmlRegExec:
; 4240 : state = exec->errStateNo;
; 4241 : } else {
; 4242 : state = exec->index;
mov eax, DWORD PTR [eax+56]
mov DWORD PTR _state$1$[ebp], eax
$LN19@xmlRegExec:
; 4243 : }
; 4244 : if (terminal != NULL) {
mov esi, DWORD PTR _terminal$[ebp]
test esi, esi
je SHORT $LN22@xmlRegExec
; 4245 : if (comp->compact[state * (comp->nbstrings + 1)] ==
mov ecx, DWORD PTR [edx+48]
inc ecx
imul ecx, eax
xor eax, eax
cmp DWORD PTR [ebx+ecx*4], 2
sete al
mov DWORD PTR [esi], eax
$LN22@xmlRegExec:
; 4246 : XML_REGEXP_FINAL_STATE)
; 4247 : *terminal = 1;
; 4248 : else
; 4249 : *terminal = 0;
; 4250 : }
; 4251 : for (i = 0;(i < comp->nbstrings) && (nb < maxval);i++) {
mov ecx, DWORD PTR [edx+48]
xor ebx, ebx
test ecx, ecx
jle SHORT $LN81@xmlRegExec
mov esi, ecx
$LL4@xmlRegExec:
mov ecx, esi
cmp edi, DWORD PTR _maxval$1$[ebp]
jge SHORT $LN81@xmlRegExec
; 4252 : target = comp->compact[state * (comp->nbstrings + 1) + i + 1];
mov ecx, DWORD PTR [edx+40]
lea eax, DWORD PTR [esi+1]
mov DWORD PTR tv1301[ebp], eax
imul eax, DWORD PTR _state$1$[ebp]
add eax, ebx
mov eax, DWORD PTR [ecx+eax*4+4]
mov ecx, esi
; 4253 : if ((target > 0) && (target <= comp->nbstates) &&
test eax, eax
jle SHORT $LN2@xmlRegExec
cmp eax, DWORD PTR [edx+36]
jg SHORT $LN2@xmlRegExec
mov esi, DWORD PTR [edx+40]
lea eax, DWORD PTR [eax*4-4]
imul eax, DWORD PTR tv1301[ebp]
cmp DWORD PTR [eax+esi], 4
je SHORT $LN2@xmlRegExec
; 4254 : (comp->compact[(target - 1) * (comp->nbstrings + 1)] !=
; 4255 : XML_REGEXP_SINK_STATE)) {
; 4256 : values[nb++] = comp->stringMap[i];
mov eax, DWORD PTR [edx+52]
mov ecx, DWORD PTR _values$[ebp]
mov eax, DWORD PTR [eax+ebx*4]
mov DWORD PTR [ecx+edi*4], eax
inc edi
; 4257 : (*nbval)++;
mov eax, DWORD PTR _nbval$[ebp]
inc DWORD PTR [eax]
mov ecx, DWORD PTR [edx+48]
$LN2@xmlRegExec:
; 4246 : XML_REGEXP_FINAL_STATE)
; 4247 : *terminal = 1;
; 4248 : else
; 4249 : *terminal = 0;
; 4250 : }
; 4251 : for (i = 0;(i < comp->nbstrings) && (nb < maxval);i++) {
inc ebx
mov esi, ecx
cmp ebx, ecx
jl SHORT $LL4@xmlRegExec
$LN81@xmlRegExec:
; 4258 : }
; 4259 : }
; 4260 : for (i = 0;(i < comp->nbstrings) && (nb < maxval);i++) {
xor ebx, ebx
test ecx, ecx
jle $LN83@xmlRegExec
$LL7@xmlRegExec:
cmp edi, DWORD PTR _maxval$1$[ebp]
jge $LN83@xmlRegExec
; 4261 : target = comp->compact[state * (comp->nbstrings + 1) + i + 1];
mov esi, DWORD PTR [edx+40]
lea eax, DWORD PTR [ecx+1]
mov DWORD PTR tv1300[ebp], eax
imul eax, DWORD PTR _state$1$[ebp]
add eax, ebx
mov eax, DWORD PTR [esi+eax*4+4]
mov esi, ecx
; 4262 : if ((target > 0) && (target <= comp->nbstates) &&
test eax, eax
jle SHORT $LN5@xmlRegExec
cmp eax, DWORD PTR [edx+36]
jg SHORT $LN5@xmlRegExec
mov ecx, DWORD PTR [edx+40]
lea eax, DWORD PTR [eax*4-4]
imul eax, DWORD PTR tv1300[ebp]
cmp DWORD PTR [eax+ecx], 4
jne SHORT $LN5@xmlRegExec
; 4263 : (comp->compact[(target - 1) * (comp->nbstrings + 1)] ==
; 4264 : XML_REGEXP_SINK_STATE)) {
; 4265 : values[nb++] = comp->stringMap[i];
mov eax, DWORD PTR [edx+52]
mov ecx, DWORD PTR _values$[ebp]
mov eax, DWORD PTR [eax+ebx*4]
mov DWORD PTR [ecx+edi*4], eax
inc edi
; 4266 : (*nbneg)++;
mov eax, DWORD PTR _nbneg$[ebp]
inc DWORD PTR [eax]
mov esi, DWORD PTR [edx+48]
$LN5@xmlRegExec:
; 4258 : }
; 4259 : }
; 4260 : for (i = 0;(i < comp->nbstrings) && (nb < maxval);i++) {
inc ebx
mov ecx, esi
cmp ebx, esi
jl SHORT $LL7@xmlRegExec
; 4357 : }
; 4358 : }
; 4359 : }
; 4360 : }
; 4361 : return(0);
; 4362 : }
pop edi
pop esi
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN16@xmlRegExec:
; 4267 : }
; 4268 : }
; 4269 : } else {
; 4270 : int transno;
; 4271 : xmlRegTransPtr trans;
; 4272 : xmlRegAtomPtr atom;
; 4273 : xmlRegStatePtr state;
; 4274 :
; 4275 : if (terminal != NULL) {
mov edx, DWORD PTR _terminal$[ebp]
test edx, edx
je SHORT $LN27@xmlRegExec
; 4276 : if (exec->state->type == XML_REGEXP_FINAL_STATE)
mov eax, DWORD PTR [eax+20]
xor ecx, ecx
cmp DWORD PTR [eax], 2
mov eax, DWORD PTR _exec$[ebp]
sete cl
mov DWORD PTR [edx], ecx
$LN27@xmlRegExec:
; 4277 : *terminal = 1;
; 4278 : else
; 4279 : *terminal = 0;
; 4280 : }
; 4281 :
; 4282 : if (err) {
cmp DWORD PTR _err$[ebp], edi
je SHORT $LN29@xmlRegExec
; 4283 : if (exec->errState == NULL) return(-1);
mov ebx, DWORD PTR [eax+76]
; 4284 : state = exec->errState;
; 4285 : } else {
jmp SHORT $LN95@xmlRegExec
$LN29@xmlRegExec:
; 4286 : if (exec->state == NULL) return(-1);
mov ebx, DWORD PTR [eax+20]
$LN95@xmlRegExec:
; 4287 : state = exec->state;
; 4288 : }
; 4289 : for (transno = 0;
mov DWORD PTR _state$1$[ebp], ebx
test ebx, ebx
je $LN15@xmlRegExec
; 4290 : (transno < state->nbTrans) && (nb < maxval);
mov eax, DWORD PTR [ebx+24]
mov DWORD PTR _transno$1$[ebp], edi
test eax, eax
jle $LN82@xmlRegExec
xor ecx, ecx
mov DWORD PTR tv1297[ebp], ecx
$LL10@xmlRegExec:
cmp edi, esi
jge $LN82@xmlRegExec
; 4292 : trans = &state->trans[transno];
mov eax, DWORD PTR [ebx+28]
; 4293 : if (trans->to < 0)
mov ebx, DWORD PTR [eax+ecx+4]
add eax, ecx
test ebx, ebx
js $LN8@xmlRegExec
; 4294 : continue;
; 4295 : atom = trans->atom;
mov ecx, DWORD PTR [eax]
; 4296 : if ((atom == NULL) || (atom->valuep == NULL))
test ecx, ecx
je $LN8@xmlRegExec
mov esi, DWORD PTR [ecx+20]
test esi, esi
je $LN93@xmlRegExec
; 4297 : continue;
; 4298 : if (trans->count == REGEXP_ALL_LAX_COUNTER) {
mov edx, DWORD PTR [eax+12]
cmp edx, 1193047 ; 00123457H
jne SHORT $LN36@xmlRegExec
; 4299 : /* this should not be reached but ... */
; 4300 : TODO;
call ___xmlGenericError
mov esi, eax
call ___xmlGenericErrorContext
push 4300 ; 000010ccH
$LN97@xmlRegExec:
; 4291 : transno++) {
push OFFSET ??_C@_0GL@GCGJPEPF@c?3?2users?2dag?2documents?2_clients@
push OFFSET ??_C@_0BO@MDEMDPPE@Unimplemented?5block?5at?5?$CFs?3?$CFd?6@
push DWORD PTR [eax]
mov eax, DWORD PTR [esi]
call eax
add esp, 16 ; 00000010H
jmp $LN93@xmlRegExec
$LN36@xmlRegExec:
; 4301 : } else if (trans->count == REGEXP_ALL_COUNTER) {
cmp edx, 1193046 ; 00123456H
jne SHORT $LN38@xmlRegExec
; 4302 : /* this should not be reached but ... */
; 4303 : TODO;
call ___xmlGenericError
mov esi, eax
call ___xmlGenericErrorContext
push 4303 ; 000010cfH
jmp SHORT $LN97@xmlRegExec
$LN38@xmlRegExec:
; 4304 : } else if (trans->counter >= 0) {
mov edx, DWORD PTR [eax+8]
mov eax, DWORD PTR _exec$[ebp]
test edx, edx
js SHORT $LN40@xmlRegExec
; 4305 : xmlRegCounterPtr counter = NULL;
; 4306 : int count;
; 4307 :
; 4308 : if (err)
cmp DWORD PTR _err$[ebp], 0
je SHORT $LN42@xmlRegExec
; 4309 : count = exec->errCounts[trans->counter];
mov eax, DWORD PTR [eax+84]
jmp SHORT $LN96@xmlRegExec
$LN42@xmlRegExec:
; 4310 : else
; 4311 : count = exec->counts[trans->counter];
mov eax, DWORD PTR [eax+44]
$LN96@xmlRegExec:
; 4312 : if (exec->comp != NULL)
mov ebx, DWORD PTR [eax+edx*4]
mov eax, DWORD PTR _exec$[ebp]
mov eax, DWORD PTR [eax+8]
test eax, eax
je SHORT $LN46@xmlRegExec
; 4313 : counter = &exec->comp->counters[trans->counter];
mov eax, DWORD PTR [eax+24]
lea eax, DWORD PTR [eax+edx*8]
; 4314 : if ((counter == NULL) || (count < counter->max)) {
test eax, eax
je SHORT $LN46@xmlRegExec
cmp ebx, DWORD PTR [eax+4]
jge SHORT $LN93@xmlRegExec
; 4315 : if (atom->neg)
; 4316 : values[nb++] = (xmlChar *) atom->valuep2;
; 4317 : else
; 4318 : values[nb++] = (xmlChar *) atom->valuep;
; 4319 : (*nbval)++;
; 4320 : }
; 4321 : } else {
jmp SHORT $LN46@xmlRegExec
$LN40@xmlRegExec:
; 4322 : if ((exec->comp != NULL) && (exec->comp->states[trans->to] != NULL) &&
mov eax, DWORD PTR [eax+8]
test eax, eax
je SHORT $LN93@xmlRegExec
mov eax, DWORD PTR [eax+8]
mov eax, DWORD PTR [eax+ebx*4]
test eax, eax
je SHORT $LN93@xmlRegExec
cmp DWORD PTR [eax], 4
je SHORT $LN93@xmlRegExec
$LN46@xmlRegExec:
; 4291 : transno++) {
cmp DWORD PTR [ecx+28], 0
je SHORT $LN50@xmlRegExec
mov esi, DWORD PTR [ecx+24]
$LN50@xmlRegExec:
mov ecx, DWORD PTR _values$[ebp]
mov DWORD PTR [ecx+edi*4], esi
mov ecx, DWORD PTR _nbval$[ebp]
inc DWORD PTR [ecx]
inc edi
$LN93@xmlRegExec:
mov esi, DWORD PTR _maxval$1$[ebp]
$LN8@xmlRegExec:
; 4290 : (transno < state->nbTrans) && (nb < maxval);
mov ebx, DWORD PTR _state$1$[ebp]
; 4291 : transno++) {
mov ecx, DWORD PTR _transno$1$[ebp]
add DWORD PTR tv1297[ebp], 20 ; 00000014H
inc ecx
mov DWORD PTR _transno$1$[ebp], ecx
mov eax, DWORD PTR [ebx+24]
cmp ecx, eax
mov ecx, DWORD PTR tv1297[ebp]
jl $LL10@xmlRegExec
$LN82@xmlRegExec:
; 4323 : (exec->comp->states[trans->to]->type !=
; 4324 : XML_REGEXP_SINK_STATE)) {
; 4325 : if (atom->neg)
; 4326 : values[nb++] = (xmlChar *) atom->valuep2;
; 4327 : else
; 4328 : values[nb++] = (xmlChar *) atom->valuep;
; 4329 : (*nbval)++;
; 4330 : }
; 4331 : }
; 4332 : }
; 4333 : for (transno = 0;
xor ebx, ebx
; 4334 : (transno < state->nbTrans) && (nb < maxval);
test eax, eax
jle $LN83@xmlRegExec
; 4323 : (exec->comp->states[trans->to]->type !=
; 4324 : XML_REGEXP_SINK_STATE)) {
; 4325 : if (atom->neg)
; 4326 : values[nb++] = (xmlChar *) atom->valuep2;
; 4327 : else
; 4328 : values[nb++] = (xmlChar *) atom->valuep;
; 4329 : (*nbval)++;
; 4330 : }
; 4331 : }
; 4332 : }
; 4333 : for (transno = 0;
mov eax, DWORD PTR _state$1$[ebp]
xor ecx, ecx
mov DWORD PTR tv1296[ebp], ecx
$LL13@xmlRegExec:
; 4334 : (transno < state->nbTrans) && (nb < maxval);
cmp edi, esi
jge $LN83@xmlRegExec
; 4336 : trans = &state->trans[transno];
mov eax, DWORD PTR [eax+28]
add eax, ecx
; 4337 : if (trans->to < 0)
mov ecx, DWORD PTR [eax+4]
mov DWORD PTR tv1308[ebp], ecx
test ecx, ecx
js SHORT $LN11@xmlRegExec
; 4338 : continue;
; 4339 : atom = trans->atom;
mov ecx, DWORD PTR [eax]
; 4340 : if ((atom == NULL) || (atom->valuep == NULL))
test ecx, ecx
je SHORT $LN11@xmlRegExec
mov edx, DWORD PTR [ecx+20]
test edx, edx
je SHORT $LN11@xmlRegExec
; 4341 : continue;
; 4342 : if (trans->count == REGEXP_ALL_LAX_COUNTER) {
mov esi, DWORD PTR [eax+12]
cmp esi, 1193047 ; 00123457H
je SHORT $LN88@xmlRegExec
; 4343 : continue;
; 4344 : } else if (trans->count == REGEXP_ALL_COUNTER) {
cmp esi, 1193046 ; 00123456H
je SHORT $LN88@xmlRegExec
; 4345 : continue;
; 4346 : } else if (trans->counter >= 0) {
cmp DWORD PTR [eax+8], 0
jge SHORT $LN88@xmlRegExec
; 4347 : continue;
; 4348 : } else {
; 4349 : if ((exec->comp->states[trans->to] != NULL) &&
mov eax, DWORD PTR _exec$[ebp]
mov esi, DWORD PTR tv1308[ebp]
mov eax, DWORD PTR [eax+8]
mov eax, DWORD PTR [eax+8]
mov eax, DWORD PTR [eax+esi*4]
test eax, eax
je SHORT $LN88@xmlRegExec
cmp DWORD PTR [eax], 4
jne SHORT $LN88@xmlRegExec
; 4350 : (exec->comp->states[trans->to]->type ==
; 4351 : XML_REGEXP_SINK_STATE)) {
; 4352 : if (atom->neg)
cmp DWORD PTR [ecx+28], 0
je SHORT $LN62@xmlRegExec
; 4353 : values[nb++] = (xmlChar *) atom->valuep2;
mov edx, DWORD PTR [ecx+24]
$LN62@xmlRegExec:
; 4354 : else
; 4355 : values[nb++] = (xmlChar *) atom->valuep;
; 4356 : (*nbneg)++;
mov ecx, DWORD PTR _values$[ebp]
mov DWORD PTR [ecx+edi*4], edx
mov ecx, DWORD PTR _nbneg$[ebp]
inc DWORD PTR [ecx]
inc edi
$LN88@xmlRegExec:
; 4335 : transno++) {
mov esi, DWORD PTR _maxval$1$[ebp]
$LN11@xmlRegExec:
; 4334 : (transno < state->nbTrans) && (nb < maxval);
mov eax, DWORD PTR _state$1$[ebp]
; 4335 : transno++) {
inc ebx
add DWORD PTR tv1296[ebp], 20 ; 00000014H
mov ecx, DWORD PTR tv1296[ebp]
cmp ebx, DWORD PTR [eax+24]
jl SHORT $LL13@xmlRegExec
$LN83@xmlRegExec:
pop edi
; 4357 : }
; 4358 : }
; 4359 : }
; 4360 : }
; 4361 : return(0);
; 4362 : }
pop esi
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
ret 0
_xmlRegExecGetValues ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegExecPushStringInternal
_TEXT SEGMENT
_to$1$ = -36 ; size = 4
_count$1$ = -36 ; size = 4
tv1703 = -36 ; size = 4
_i$1$ = -32 ; size = 4
_final$1$ = -28 ; size = 4
_progress$1$ = -24 ; size = 4
tv1700 = -20 ; size = 4
_trans$1$ = -16 ; size = 4
_data$1$ = -12 ; size = 4
tv1817 = -8 ; size = 4
_atom$1$ = -4 ; size = 4
_value$1$ = 8 ; size = 4
_exec$ = 8 ; size = 4
_value$ = 12 ; size = 4
_data$ = 16 ; size = 4
_compound$ = 20 ; size = 4
_xmlRegExecPushStringInternal PROC ; COMDAT
; 3784 : void *data, int compound) {
push ebp
mov ebp, esp
sub esp, 36 ; 00000024H
push esi
mov esi, DWORD PTR _exec$[ebp]
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push edi
call @__CheckForDebuggerJustMyCode@4
xor edi, edi
mov DWORD PTR _progress$1$[ebp], 1
mov DWORD PTR _final$1$[ebp], edi
test esi, esi
je $LN132@xmlRegExec
; 3785 : xmlRegTransPtr trans;
; 3786 : xmlRegAtomPtr atom;
; 3787 : int ret;
; 3788 : int final = 0;
; 3789 : int progress = 1;
; 3790 :
; 3791 : if (exec == NULL)
; 3792 : return(-1);
; 3793 : if (exec->comp == NULL)
mov ecx, DWORD PTR [esi+8]
test ecx, ecx
je $LN132@xmlRegExec
; 3795 : if (exec->status != 0)
mov eax, DWORD PTR [esi]
test eax, eax
jne SHORT $LN1@xmlRegExec
; 3796 : return(exec->status);
; 3797 :
; 3798 : if (exec->comp->compact != NULL)
cmp DWORD PTR [ecx+40], edi
je SHORT $LN19@xmlRegExec
; 3799 : return(xmlRegCompactPushString(exec, exec->comp, value, data));
push DWORD PTR _data$[ebp]
push DWORD PTR _value$[ebp]
push ecx
push esi
call _xmlRegCompactPushString
add esp, 16 ; 00000010H
pop edi
; 4129 : }
pop esi
mov esp, ebp
pop ebp
ret 0
$LN19@xmlRegExec:
push ebx
; 3800 :
; 3801 : if (value == NULL) {
mov ebx, DWORD PTR _value$[ebp]
mov DWORD PTR _value$1$[ebp], ebx
test ebx, ebx
jne SHORT $LN128@xmlRegExec
; 3802 : if (exec->state->type == XML_REGEXP_FINAL_STATE)
mov eax, DWORD PTR [esi+20]
cmp DWORD PTR [eax], 2
jne SHORT $LN21@xmlRegExec
; 3803 : return(1);
lea eax, DWORD PTR [ebx+1]
pop ebx
$LN1@xmlRegExec:
; 4129 : }
pop edi
pop esi
mov esp, ebp
pop ebp
ret 0
$LN21@xmlRegExec:
; 3804 : final = 1;
mov edi, 1
mov DWORD PTR _final$1$[ebp], edi
$LN128@xmlRegExec:
; 3805 : }
; 3806 :
; 3807 : #ifdef DEBUG_PUSH
; 3808 : printf("value pushed: %s\n", value);
; 3809 : #endif
; 3810 : /*
; 3811 : * If we have an active rollback stack push the new value there
; 3812 : * and get back to where we were left
; 3813 : */
; 3814 : if ((value != NULL) && (exec->inputStackNr > 0)) {
xor ecx, ecx
test ebx, ebx
je SHORT $LN133@xmlRegExec
cmp DWORD PTR [esi+52], ecx
jle SHORT $LN133@xmlRegExec
; 3815 : xmlFARegExecSaveInputString(exec, value, data);
push DWORD PTR _data$[ebp]
push ebx
push esi
call _xmlFARegExecSaveInputString
; 3816 : value = exec->inputStack[exec->index].value;
mov ecx, DWORD PTR [esi+56]
add esp, 12 ; 0000000cH
mov eax, DWORD PTR [esi+68]
mov ebx, DWORD PTR [eax+ecx*8]
; 3817 : data = exec->inputStack[exec->index].data;
mov eax, DWORD PTR [eax+ecx*8+4]
mov ecx, DWORD PTR [esi]
mov DWORD PTR _value$1$[ebp], ebx
jmp SHORT $LN149@xmlRegExec
$LN133@xmlRegExec:
; 3805 : }
; 3806 :
; 3807 : #ifdef DEBUG_PUSH
; 3808 : printf("value pushed: %s\n", value);
; 3809 : #endif
; 3810 : /*
; 3811 : * If we have an active rollback stack push the new value there
; 3812 : * and get back to where we were left
; 3813 : */
; 3814 : if ((value != NULL) && (exec->inputStackNr > 0)) {
mov eax, DWORD PTR _data$[ebp]
$LN149@xmlRegExec:
; 3818 : #ifdef DEBUG_PUSH
; 3819 : printf("value loaded: %s\n", value);
; 3820 : #endif
; 3821 : }
; 3822 :
; 3823 : while ((exec->status == 0) &&
mov DWORD PTR _data$1$[ebp], eax
test ecx, ecx
jne $LN81@xmlRegExec
; 3900 : count = exec->counts[t->counter];
xor eax, eax
$LL2@xmlRegExec:
; 3818 : #ifdef DEBUG_PUSH
; 3819 : printf("value loaded: %s\n", value);
; 3820 : #endif
; 3821 : }
; 3822 :
; 3823 : while ((exec->status == 0) &&
test ebx, ebx
jne SHORT $LN130@xmlRegExec
mov ecx, eax
cmp edi, 1
jne $LN3@xmlRegExec
mov eax, DWORD PTR [esi+20]
lea edi, DWORD PTR [esi+20]
cmp DWORD PTR [eax], 2
je $LN3@xmlRegExec
; 3824 : ((value != NULL) ||
; 3825 : ((final == 1) &&
; 3826 : (exec->state->type != XML_REGEXP_FINAL_STATE)))) {
; 3827 :
; 3828 : /*
; 3829 : * End of input on non-terminal state, rollback, however we may
; 3830 : * still have epsilon like transition for counted transitions
; 3831 : * on counters, in that case don't break too early.
; 3832 : */
; 3833 : if ((value == NULL) && (exec->counts == NULL))
cmp DWORD PTR [esi+44], ebx
je $rollback$151
jmp SHORT $LN112@xmlRegExec
$LN130@xmlRegExec:
lea edi, DWORD PTR [esi+20]
$LN112@xmlRegExec:
; 3834 : goto rollback;
; 3835 :
; 3836 : exec->transcount = 0;
mov eax, edi
mov DWORD PTR [esi+28], 0
mov DWORD PTR tv1817[ebp], eax
; 3837 : for (;exec->transno < exec->state->nbTrans;exec->transno++) {
mov ecx, DWORD PTR [eax]
mov eax, DWORD PTR [esi+24]
cmp eax, DWORD PTR [ecx+24]
jge $LN5@xmlRegExec
npad 4
$LL6@xmlRegExec:
; 3838 : trans = &exec->state->trans[exec->transno];
mov edx, DWORD PTR [ecx+28]
lea eax, DWORD PTR [eax+eax*4]
; 3839 : if (trans->to < 0)
cmp DWORD PTR [edx+eax*4+4], 0
lea edi, DWORD PTR [edx+eax*4]
mov DWORD PTR _trans$1$[ebp], edi
jl $LN4@xmlRegExec
; 3840 : continue;
; 3841 : atom = trans->atom;
mov eax, DWORD PTR [edi]
; 3842 : ret = 0;
; 3843 : if (trans->count == REGEXP_ALL_LAX_COUNTER) {
mov edi, DWORD PTR [edi+12]
mov DWORD PTR _atom$1$[ebp], eax
cmp edi, 1193047 ; 00123457H
jne $LN26@xmlRegExec
; 3844 : int i;
; 3845 : int count;
; 3846 : xmlRegTransPtr t;
; 3847 : xmlRegCounterPtr counter;
; 3848 :
; 3849 : ret = 0;
; 3850 :
; 3851 : #ifdef DEBUG_PUSH
; 3852 : printf("testing all lax %d\n", trans->count);
; 3853 : #endif
; 3854 : /*
; 3855 : * Check all counted transitions from the current state
; 3856 : */
; 3857 : if ((value == NULL) && (final)) {
test ebx, ebx
jne SHORT $LN127@xmlRegExec
cmp DWORD PTR _final$1$[ebp], ebx
jne $LN142@xmlRegExec
; 3858 : ret = 1;
; 3859 : } else if (value != NULL) {
jmp $LN4@xmlRegExec
$LN127@xmlRegExec:
; 3860 : for (i = 0;i < exec->state->nbTrans;i++) {
cmp DWORD PTR [ecx+24], 0
mov DWORD PTR _i$1$[ebp], 0
jle $LN4@xmlRegExec
; 3818 : #ifdef DEBUG_PUSH
; 3819 : printf("value loaded: %s\n", value);
; 3820 : #endif
; 3821 : }
; 3822 :
; 3823 : while ((exec->status == 0) &&
mov eax, DWORD PTR tv1817[ebp]
xor edx, edx
mov DWORD PTR tv1700[ebp], edx
$LL9@xmlRegExec:
; 3861 : t = &exec->state->trans[i];
mov edi, DWORD PTR [ecx+28]
; 3862 : if ((t->counter < 0) || (t == trans))
mov ecx, DWORD PTR [edi+edx+8]
add edi, edx
test ecx, ecx
js SHORT $LN7@xmlRegExec
cmp edi, DWORD PTR _trans$1$[ebp]
je SHORT $LN7@xmlRegExec
; 3863 : continue;
; 3864 : counter = &exec->comp->counters[t->counter];
mov eax, DWORD PTR [esi+8]
mov eax, DWORD PTR [eax+24]
lea ebx, DWORD PTR [eax+ecx*8]
; 3865 : count = exec->counts[t->counter];
mov eax, DWORD PTR [esi+44]
mov eax, DWORD PTR [eax+ecx*4]
mov DWORD PTR _count$1$[ebp], eax
; 3866 : if ((count < counter->max) &&
; 3867 : (t->atom != NULL) &&
cmp eax, DWORD PTR [ebx+4]
jge SHORT $LN33@xmlRegExec
mov ecx, DWORD PTR [edi]
test ecx, ecx
je SHORT $LN33@xmlRegExec
push DWORD PTR [ecx+20]
push DWORD PTR _value$1$[ebp]
call _xmlStrEqual
add esp, 8
test eax, eax
jne $LN4@xmlRegExec
mov eax, DWORD PTR _count$1$[ebp]
mov edx, DWORD PTR tv1700[ebp]
$LN33@xmlRegExec:
; 3868 : (xmlStrEqual(value, t->atom->valuep))) {
; 3869 : ret = 0;
; 3870 : break;
; 3871 : }
; 3872 : if ((count >= counter->min) &&
; 3873 : (count < counter->max) &&
; 3874 : (t->atom != NULL) &&
cmp eax, DWORD PTR [ebx]
jl SHORT $LN145@xmlRegExec
cmp eax, DWORD PTR [ebx+4]
jge SHORT $LN145@xmlRegExec
mov eax, DWORD PTR [edi]
test eax, eax
je SHORT $LN145@xmlRegExec
push DWORD PTR [eax+20]
mov ebx, DWORD PTR _value$1$[ebp]
push ebx
call _xmlStrEqual
add esp, 8
test eax, eax
jne SHORT $LN142@xmlRegExec
mov edx, DWORD PTR tv1700[ebp]
$LN145@xmlRegExec:
; 3860 : for (i = 0;i < exec->state->nbTrans;i++) {
mov eax, DWORD PTR tv1817[ebp]
$LN7@xmlRegExec:
mov edi, DWORD PTR _i$1$[ebp]
add edx, 20 ; 00000014H
mov ecx, DWORD PTR [eax]
inc edi
mov DWORD PTR _i$1$[ebp], edi
mov DWORD PTR tv1700[ebp], edx
cmp edi, DWORD PTR [ecx+24]
jl $LL9@xmlRegExec
; 4064 : value = NULL;
; 4065 : data = NULL;
; 4066 : #ifdef DEBUG_PUSH
; 4067 : printf("end of input\n");
; 4068 : #endif
; 4069 : }
; 4070 : } else {
; 4071 : value = NULL;
; 4072 : data = NULL;
; 4073 : #ifdef DEBUG_PUSH
; 4074 : printf("end of input\n");
; 4075 : #endif
; 4076 : }
; 4077 : }
; 4078 : goto progress;
; 4079 : } else if (ret < 0) {
jmp $LN4@xmlRegExec
$LN26@xmlRegExec:
; 3875 : (xmlStrEqual(value, t->atom->valuep))) {
; 3876 : ret = 1;
; 3877 : break;
; 3878 : }
; 3879 : }
; 3880 : }
; 3881 : } else if (trans->count == REGEXP_ALL_COUNTER) {
cmp edi, 1193046 ; 00123456H
jne $LN35@xmlRegExec
; 3882 : int i;
; 3883 : int count;
; 3884 : xmlRegTransPtr t;
; 3885 : xmlRegCounterPtr counter;
; 3886 :
; 3887 : ret = 1;
; 3888 :
; 3889 : #ifdef DEBUG_PUSH
; 3890 : printf("testing all %d\n", trans->count);
; 3891 : #endif
; 3892 : /*
; 3893 : * Check all counted transitions from the current state
; 3894 : */
; 3895 : for (i = 0;i < exec->state->nbTrans;i++) {
mov eax, DWORD PTR [ecx+24]
xor edi, edi
mov DWORD PTR tv1703[ebp], eax
test eax, eax
jle SHORT $LN142@xmlRegExec
npad 2
$LL12@xmlRegExec:
; 3896 : t = &exec->state->trans[i];
; 3897 : if ((t->counter < 0) || (t == trans))
mov ecx, DWORD PTR [edx+8]
test ecx, ecx
js SHORT $LN10@xmlRegExec
cmp edx, DWORD PTR _trans$1$[ebp]
je SHORT $LN10@xmlRegExec
; 3898 : continue;
; 3899 : counter = &exec->comp->counters[t->counter];
mov eax, DWORD PTR [esi+8]
mov eax, DWORD PTR [eax+24]
lea ebx, DWORD PTR [eax+ecx*8]
; 3900 : count = exec->counts[t->counter];
mov eax, DWORD PTR [esi+44]
mov eax, DWORD PTR [eax+ecx*4]
; 3901 : if ((count < counter->min) || (count > counter->max)) {
cmp eax, DWORD PTR [ebx]
jl $LN4@xmlRegExec
cmp eax, DWORD PTR [ebx+4]
jg $LN4@xmlRegExec
mov eax, DWORD PTR tv1703[ebp]
$LN10@xmlRegExec:
; 3882 : int i;
; 3883 : int count;
; 3884 : xmlRegTransPtr t;
; 3885 : xmlRegCounterPtr counter;
; 3886 :
; 3887 : ret = 1;
; 3888 :
; 3889 : #ifdef DEBUG_PUSH
; 3890 : printf("testing all %d\n", trans->count);
; 3891 : #endif
; 3892 : /*
; 3893 : * Check all counted transitions from the current state
; 3894 : */
; 3895 : for (i = 0;i < exec->state->nbTrans;i++) {
inc edi
add edx, 20 ; 00000014H
cmp edi, eax
jl SHORT $LL12@xmlRegExec
mov ebx, DWORD PTR _value$1$[ebp]
$LN142@xmlRegExec:
; 4010 : if ((exec->callback != NULL) && (atom != NULL) &&
mov ecx, DWORD PTR _atom$1$[ebp]
$LN100@xmlRegExec:
mov eax, DWORD PTR [esi+12]
mov edx, DWORD PTR _data$1$[ebp]
test eax, eax
je SHORT $LN62@xmlRegExec
test ecx, ecx
je SHORT $LN62@xmlRegExec
test edx, edx
je SHORT $LN62@xmlRegExec
; 4011 : (data != NULL)) {
; 4012 : exec->callback(exec->data, atom->valuep,
push edx
push DWORD PTR [ecx+60]
push DWORD PTR [ecx+20]
push DWORD PTR [esi+16]
call eax
mov edx, DWORD PTR _data$1$[ebp]
add esp, 16 ; 00000010H
$LN62@xmlRegExec:
; 4013 : atom->data, data);
; 4014 : }
; 4015 : if (exec->state->nbTrans > exec->transno + 1) {
mov edi, DWORD PTR tv1817[ebp]
mov eax, DWORD PTR [esi+24]
inc eax
mov ecx, DWORD PTR [edi]
cmp DWORD PTR [ecx+24], eax
jle SHORT $LN63@xmlRegExec
; 4016 : if (exec->inputStackNr <= 0) {
cmp DWORD PTR [esi+52], 0
jg SHORT $LN64@xmlRegExec
; 4017 : xmlFARegExecSaveInputString(exec, value, data);
push edx
push ebx
push esi
call _xmlFARegExecSaveInputString
add esp, 12 ; 0000000cH
$LN64@xmlRegExec:
; 4018 : }
; 4019 : xmlFARegExecSave(exec);
push esi
call _xmlFARegExecSave
add esp, 4
$LN63@xmlRegExec:
; 4020 : }
; 4021 : if (trans->counter >= 0) {
mov edx, DWORD PTR _trans$1$[ebp]
mov ecx, DWORD PTR [edx+8]
test ecx, ecx
js SHORT $LN65@xmlRegExec
; 4022 : #ifdef DEBUG_PUSH
; 4023 : printf("Increasing count %d\n", trans->counter);
; 4024 : #endif
; 4025 : exec->counts[trans->counter]++;
mov eax, DWORD PTR [esi+44]
inc DWORD PTR [eax+ecx*4]
$LN65@xmlRegExec:
; 4026 : }
; 4027 : if ((trans->count >= 0) &&
mov ecx, DWORD PTR [edx+12]
cmp ecx, 1193045 ; 00123455H
ja SHORT $LN66@xmlRegExec
; 4028 : (trans->count < REGEXP_ALL_COUNTER)) {
; 4029 : #ifdef DEBUG_REGEXP_EXEC
; 4030 : printf("resetting count %d on transition\n",
; 4031 : trans->count);
; 4032 : #endif
; 4033 : exec->counts[trans->count] = 0;
mov eax, DWORD PTR [esi+44]
mov DWORD PTR [eax+ecx*4], 0
$LN66@xmlRegExec:
; 4034 : }
; 4035 : #ifdef DEBUG_PUSH
; 4036 : printf("entering state %d\n", trans->to);
; 4037 : #endif
; 4038 : if ((exec->comp->states[trans->to] != NULL) &&
mov eax, DWORD PTR [esi+8]
mov ecx, DWORD PTR [edx+4]
mov eax, DWORD PTR [eax+8]
mov eax, DWORD PTR [eax+ecx*4]
test eax, eax
je SHORT $LN67@xmlRegExec
cmp DWORD PTR [eax], 4
jne SHORT $LN67@xmlRegExec
; 4039 : (exec->comp->states[trans->to]->type ==
; 4040 : XML_REGEXP_SINK_STATE)) {
; 4041 : /*
; 4042 : * entering a sink state, save the current state as error
; 4043 : * state.
; 4044 : */
; 4045 : if (exec->errString != NULL)
mov eax, DWORD PTR [esi+80]
test eax, eax
je SHORT $LN68@xmlRegExec
; 4046 : xmlFree(exec->errString);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN68@xmlRegExec:
; 4047 : exec->errString = xmlStrdup(value);
push ebx
call _xmlStrdup
mov DWORD PTR [esi+80], eax
; 4048 : exec->errState = exec->state;
mov eax, DWORD PTR [edi]
mov DWORD PTR [esi+76], eax
; 4049 : memcpy(exec->errCounts, exec->counts,
mov eax, DWORD PTR [esi+8]
mov eax, DWORD PTR [eax+20]
shl eax, 2
push eax
push DWORD PTR [esi+44]
push DWORD PTR [esi+84]
call _memcpy
mov edx, DWORD PTR _trans$1$[ebp]
add esp, 16 ; 00000010H
$LN67@xmlRegExec:
; 4050 : exec->comp->nbCounters * sizeof(int));
; 4051 : }
; 4052 : exec->state = exec->comp->states[trans->to];
mov eax, DWORD PTR [esi+8]
mov ecx, DWORD PTR [edx+4]
mov eax, DWORD PTR [eax+8]
mov eax, DWORD PTR [eax+ecx*4]
mov DWORD PTR [edi], eax
; 4053 : exec->transno = 0;
mov DWORD PTR [esi+24], 0
; 4054 : if (trans->atom != NULL) {
cmp DWORD PTR [edx], 0
je $progress$152
; 4055 : if (exec->inputStack != NULL) {
mov eax, DWORD PTR [esi+68]
test eax, eax
je $LN70@xmlRegExec
; 4056 : exec->index++;
inc DWORD PTR [esi+56]
mov ecx, DWORD PTR [esi+56]
; 4057 : if (exec->index < exec->inputStackNr) {
cmp ecx, DWORD PTR [esi+52]
jge $LN70@xmlRegExec
; 4058 : value = exec->inputStack[exec->index].value;
mov edx, DWORD PTR [eax+ecx*8]
; 4059 : data = exec->inputStack[exec->index].data;
mov eax, DWORD PTR [eax+ecx*8+4]
mov DWORD PTR _value$1$[ebp], edx
mov DWORD PTR _data$1$[ebp], eax
; 4060 : #ifdef DEBUG_PUSH
; 4061 : printf("value loaded: %s\n", value);
; 4062 : #endif
; 4063 : } else {
jmp $progress$152
$LN35@xmlRegExec:
; 3902 : ret = 0;
; 3903 : break;
; 3904 : }
; 3905 : }
; 3906 : } else if (trans->count >= 0) {
test edi, edi
js SHORT $LN41@xmlRegExec
; 3907 : int count;
; 3908 : xmlRegCounterPtr counter;
; 3909 :
; 3910 : /*
; 3911 : * A counted transition.
; 3912 : */
; 3913 :
; 3914 : count = exec->counts[trans->count];
mov eax, DWORD PTR [esi+44]
mov ecx, DWORD PTR [eax+edi*4]
; 3915 : counter = &exec->comp->counters[trans->count];
mov eax, DWORD PTR [esi+8]
mov eax, DWORD PTR [eax+24]
; 3916 : #ifdef DEBUG_PUSH
; 3917 : printf("testing count %d: val %d, min %d, max %d\n",
; 3918 : trans->count, count, counter->min, counter->max);
; 3919 : #endif
; 3920 : ret = ((count >= counter->min) && (count <= counter->max));
cmp ecx, DWORD PTR [eax+edi*8]
jl $LN4@xmlRegExec
cmp ecx, DWORD PTR [eax+edi*8+4]
jle $LN142@xmlRegExec
jmp $LN4@xmlRegExec
$LN41@xmlRegExec:
; 3921 : } else if (atom == NULL) {
test eax, eax
je $LN98@xmlRegExec
; 3924 : break;
; 3925 : } else if (value != NULL) {
test ebx, ebx
je $LN4@xmlRegExec
; 3926 : ret = xmlRegStrEqualWildcard(atom->valuep, value);
push ebx
push DWORD PTR [eax+20]
call _xmlRegStrEqualWildcard
; 3927 : if (atom->neg) {
mov edx, DWORD PTR _atom$1$[ebp]
add esp, 8
mov edi, eax
cmp DWORD PTR [edx+28], 0
je SHORT $LN47@xmlRegExec
; 3928 : ret = !ret;
xor ecx, ecx
test edi, edi
sete cl
; 3929 : if (!compound)
cmp DWORD PTR _compound$[ebp], 0
mov edi, ecx
je $LN4@xmlRegExec
$LN47@xmlRegExec:
; 3930 : ret = 0;
; 3931 : }
; 3932 : if ((ret == 1) && (trans->counter >= 0)) {
cmp edi, 1
jne $LN120@xmlRegExec
mov eax, DWORD PTR _trans$1$[ebp]
mov edx, DWORD PTR [eax+8]
test edx, edx
js SHORT $LN131@xmlRegExec
; 3933 : xmlRegCounterPtr counter;
; 3934 : int count;
; 3935 :
; 3936 : count = exec->counts[trans->counter];
; 3937 : counter = &exec->comp->counters[trans->counter];
; 3938 : if (count >= counter->max)
mov eax, DWORD PTR [esi+8]
mov ecx, DWORD PTR [eax+24]
mov eax, DWORD PTR [esi+44]
mov eax, DWORD PTR [eax+edx*4]
cmp eax, DWORD PTR [ecx+edx*8+4]
jge $LN4@xmlRegExec
mov eax, DWORD PTR _trans$1$[ebp]
$LN131@xmlRegExec:
; 3939 : ret = 0;
; 3940 : }
; 3941 :
; 3942 : if ((ret == 1) && (atom->min > 0) && (atom->max > 0)) {
mov ecx, DWORD PTR _atom$1$[ebp]
cmp DWORD PTR [ecx+12], 0
jle $LN100@xmlRegExec
cmp DWORD PTR [ecx+16], 0
jle $LN100@xmlRegExec
; 3943 : xmlRegStatePtr to = exec->comp->states[trans->to];
mov ecx, DWORD PTR [eax+4]
mov eax, DWORD PTR [esi+8]
mov eax, DWORD PTR [eax+8]
mov eax, DWORD PTR [eax+ecx*4]
mov DWORD PTR _to$1$[ebp], eax
; 3944 :
; 3945 : /*
; 3946 : * this is a multiple input sequence
; 3947 : */
; 3948 : if (exec->state->nbTrans > exec->transno + 1) {
mov eax, DWORD PTR tv1817[ebp]
mov ecx, DWORD PTR [eax]
mov eax, DWORD PTR [esi+24]
inc eax
cmp DWORD PTR [ecx+24], eax
jle SHORT $LN51@xmlRegExec
; 3949 : if (exec->inputStackNr <= 0) {
cmp DWORD PTR [esi+52], 0
jg SHORT $LN52@xmlRegExec
; 3950 : xmlFARegExecSaveInputString(exec, value, data);
push DWORD PTR _data$1$[ebp]
push ebx
push esi
call _xmlFARegExecSaveInputString
add esp, 12 ; 0000000cH
$LN52@xmlRegExec:
; 3951 : }
; 3952 : xmlFARegExecSave(exec);
push esi
call _xmlFARegExecSave
add esp, 4
$LN51@xmlRegExec:
; 3953 : }
; 3954 : exec->transcount = 1;
; 3955 : do {
; 3956 : /*
; 3957 : * Try to progress as much as possible on the input
; 3958 : */
; 3959 : if (exec->transcount == atom->max) {
mov edx, DWORD PTR _atom$1$[ebp]
mov ecx, 1
mov DWORD PTR [esi+28], 1
cmp DWORD PTR [edx+16], ecx
je $LN14@xmlRegExec
npad 3
$LL15@xmlRegExec:
; 3960 : break;
; 3961 : }
; 3962 : exec->index++;
inc DWORD PTR [esi+56]
mov edx, DWORD PTR [esi+56]
; 3963 : value = exec->inputStack[exec->index].value;
mov eax, DWORD PTR [esi+68]
mov ebx, DWORD PTR [eax+edx*8]
; 3964 : data = exec->inputStack[exec->index].data;
mov eax, DWORD PTR [eax+edx*8+4]
mov DWORD PTR _value$1$[ebp], ebx
mov DWORD PTR _data$1$[ebp], eax
; 3965 : #ifdef DEBUG_PUSH
; 3966 : printf("value loaded: %s\n", value);
; 3967 : #endif
; 3968 :
; 3969 : /*
; 3970 : * End of input: stop here
; 3971 : */
; 3972 : if (value == NULL) {
test ebx, ebx
je SHORT $LN97@xmlRegExec
; 3974 : break;
; 3975 : }
; 3976 : if (exec->transcount >= atom->min) {
mov eax, DWORD PTR _atom$1$[ebp]
cmp ecx, DWORD PTR [eax+12]
jl SHORT $LN129@xmlRegExec
; 3977 : int transno = exec->transno;
; 3978 : xmlRegStatePtr state = exec->state;
; 3979 :
; 3980 : /*
; 3981 : * The transition is acceptable save it
; 3982 : */
; 3983 : exec->transno = -1; /* trick */
; 3984 : exec->state = to;
; 3985 : if (exec->inputStackNr <= 0) {
cmp DWORD PTR [esi+52], 0
mov ecx, DWORD PTR tv1817[ebp]
mov edi, DWORD PTR [esi+24]
mov eax, DWORD PTR _to$1$[ebp]
mov DWORD PTR [esi+24], -1
mov ebx, DWORD PTR [ecx]
mov DWORD PTR [ecx], eax
jg SHORT $LN56@xmlRegExec
; 3986 : xmlFARegExecSaveInputString(exec, value, data);
push DWORD PTR _data$1$[ebp]
push DWORD PTR _value$1$[ebp]
push esi
call _xmlFARegExecSaveInputString
add esp, 12 ; 0000000cH
$LN56@xmlRegExec:
; 3987 : }
; 3988 : xmlFARegExecSave(exec);
push esi
call _xmlFARegExecSave
; 3989 : exec->transno = transno;
; 3990 : exec->state = state;
mov eax, DWORD PTR tv1817[ebp]
add esp, 4
mov DWORD PTR [esi+24], edi
mov DWORD PTR [eax], ebx
mov ebx, DWORD PTR _value$1$[ebp]
mov eax, DWORD PTR _atom$1$[ebp]
$LN129@xmlRegExec:
; 3991 : }
; 3992 : ret = xmlStrEqual(value, atom->valuep);
push DWORD PTR [eax+20]
push ebx
call _xmlStrEqual
; 3993 : exec->transcount++;
mov ecx, DWORD PTR [esi+28]
mov edi, eax
inc ecx
add esp, 8
mov DWORD PTR [esi+28], ecx
; 3994 : } while (ret == 1);
cmp edi, 1
jne SHORT $LN137@xmlRegExec
; 3953 : }
; 3954 : exec->transcount = 1;
; 3955 : do {
; 3956 : /*
; 3957 : * Try to progress as much as possible on the input
; 3958 : */
; 3959 : if (exec->transcount == atom->max) {
mov eax, DWORD PTR _atom$1$[ebp]
cmp ecx, DWORD PTR [eax+16]
jne $LL15@xmlRegExec
jmp SHORT $LN137@xmlRegExec
$LN97@xmlRegExec:
; 3973 : exec->index --;
lea eax, DWORD PTR [edx-1]
mov DWORD PTR [esi+56], eax
$LN137@xmlRegExec:
; 3995 : if (exec->transcount < atom->min)
; 3996 : ret = 0;
; 3997 :
; 3998 : /*
; 3999 : * If the last check failed but one transition was found
; 4000 : * possible, rollback
; 4001 : */
; 4002 : if (ret < 0)
mov edx, DWORD PTR _atom$1$[ebp]
$LN14@xmlRegExec:
xor eax, eax
cmp ecx, DWORD PTR [edx+12]
cmovge eax, edi
; 4003 : ret = 0;
; 4004 : if (ret == 0) {
xor edi, edi
test eax, eax
cmovns edi, eax
test edi, edi
je SHORT $LN99@xmlRegExec
; 4006 : }
; 4007 : }
; 4008 : }
; 4009 : if (ret == 1) {
cmp edi, 1
je $LN142@xmlRegExec
$LN120@xmlRegExec:
; 4064 : value = NULL;
; 4065 : data = NULL;
; 4066 : #ifdef DEBUG_PUSH
; 4067 : printf("end of input\n");
; 4068 : #endif
; 4069 : }
; 4070 : } else {
; 4071 : value = NULL;
; 4072 : data = NULL;
; 4073 : #ifdef DEBUG_PUSH
; 4074 : printf("end of input\n");
; 4075 : #endif
; 4076 : }
; 4077 : }
; 4078 : goto progress;
; 4079 : } else if (ret < 0) {
test edi, edi
js SHORT $LN101@xmlRegExec
$LN4@xmlRegExec:
; 3837 : for (;exec->transno < exec->state->nbTrans;exec->transno++) {
mov eax, DWORD PTR [esi+24]
mov ecx, DWORD PTR tv1817[ebp]
inc eax
mov DWORD PTR [esi+24], eax
mov ecx, DWORD PTR [ecx]
cmp eax, DWORD PTR [ecx+24]
jge SHORT $LN5@xmlRegExec
mov ebx, DWORD PTR _value$1$[ebp]
jmp $LL6@xmlRegExec
$LN99@xmlRegExec:
; 4005 : goto rollback;
mov edi, DWORD PTR tv1817[ebp]
jmp $rollback$151
$LN70@xmlRegExec:
; 4110 : #ifdef DEBUG_PUSH
; 4111 : printf("value loaded: %s\n", value);
; 4112 : #endif
; 4113 : }
; 4114 : }
; 4115 : continue;
; 4116 : progress:
; 4117 : progress = 1;
mov DWORD PTR _data$1$[ebp], 0
mov DWORD PTR _value$1$[ebp], 0
$progress$152:
mov DWORD PTR _progress$1$[ebp], 1
$LN134@xmlRegExec:
; 3818 : #ifdef DEBUG_PUSH
; 3819 : printf("value loaded: %s\n", value);
; 3820 : #endif
; 3821 : }
; 3822 :
; 3823 : while ((exec->status == 0) &&
mov ebx, DWORD PTR _value$1$[ebp]
$LN80@xmlRegExec:
mov ecx, DWORD PTR [esi]
mov eax, ecx
mov edi, DWORD PTR _final$1$[ebp]
test ecx, ecx
je $LL2@xmlRegExec
$LN3@xmlRegExec:
; 4118 : continue;
; 4119 : }
; 4120 : if (exec->status == 0) {
test ecx, ecx
jne $LN81@xmlRegExec
; 4121 : return(exec->state->type == XML_REGEXP_FINAL_STATE);
mov ecx, DWORD PTR [esi+20]
xor eax, eax
pop ebx
pop edi
; 4129 : }
pop esi
cmp DWORD PTR [ecx], 2
sete al
mov esp, ebp
pop ebp
ret 0
$LN101@xmlRegExec:
; 4080 : exec->status = -4;
mov DWORD PTR [esi], -4 ; fffffffcH
jmp SHORT $LN5@xmlRegExec
$LN98@xmlRegExec:
; 3922 : fprintf(stderr, "epsilon transition left at runtime\n");
push OFFSET ??_C@_0CE@CMNJHAKA@epsilon?5transition?5left?5at?5runt@
push 2
call DWORD PTR __imp____acrt_iob_func
add esp, 4
push eax
call _fprintf
add esp, 8
; 3923 : exec->status = -2;
mov DWORD PTR [esi], -2 ; fffffffeH
$LN5@xmlRegExec:
; 4081 : break;
; 4082 : }
; 4083 : }
; 4084 : if ((exec->transno != 0) || (exec->state->nbTrans == 0)) {
cmp DWORD PTR [esi+24], 0
mov eax, DWORD PTR tv1817[ebp]
mov edi, eax
jne SHORT $LN135@xmlRegExec
mov eax, DWORD PTR [eax]
cmp DWORD PTR [eax+24], 0
jne SHORT $LN134@xmlRegExec
$LN135@xmlRegExec:
; 4085 : rollback:
; 4086 : /*
; 4087 : * if we didn't yet rollback on the current input
; 4088 : * store the current state as the error state.
; 4089 : */
; 4090 : if ((progress) && (exec->state != NULL) &&
mov ebx, DWORD PTR _value$1$[ebp]
$rollback$151:
cmp DWORD PTR _progress$1$[ebp], 0
je SHORT $LN79@xmlRegExec
mov eax, DWORD PTR [edi]
test eax, eax
je SHORT $LN79@xmlRegExec
cmp DWORD PTR [eax], 4
je SHORT $LN79@xmlRegExec
; 4091 : (exec->state->type != XML_REGEXP_SINK_STATE)) {
; 4092 : progress = 0;
; 4093 : if (exec->errString != NULL)
mov eax, DWORD PTR [esi+80]
mov DWORD PTR _progress$1$[ebp], 0
test eax, eax
je SHORT $LN78@xmlRegExec
; 4094 : xmlFree(exec->errString);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN78@xmlRegExec:
; 4095 : exec->errString = xmlStrdup(value);
push ebx
call _xmlStrdup
mov DWORD PTR [esi+80], eax
add esp, 4
; 4096 : exec->errState = exec->state;
mov eax, DWORD PTR [edi]
mov DWORD PTR [esi+76], eax
; 4097 : if (exec->comp->nbCounters)
mov eax, DWORD PTR [esi+8]
mov eax, DWORD PTR [eax+20]
test eax, eax
je SHORT $LN79@xmlRegExec
; 4098 : memcpy(exec->errCounts, exec->counts,
shl eax, 2
push eax
push DWORD PTR [esi+44]
push DWORD PTR [esi+84]
call _memcpy
add esp, 12 ; 0000000cH
$LN79@xmlRegExec:
; 4099 : exec->comp->nbCounters * sizeof(int));
; 4100 : }
; 4101 :
; 4102 : /*
; 4103 : * Failed to find a way out
; 4104 : */
; 4105 : exec->determinist = 0;
; 4106 : xmlFARegExecRollBack(exec);
push esi
mov DWORD PTR [esi+4], 0
call _xmlFARegExecRollBack
; 4107 : if ((exec->inputStack != NULL ) && (exec->status == 0)) {
mov ecx, DWORD PTR [esi+68]
add esp, 4
test ecx, ecx
je $LN80@xmlRegExec
cmp DWORD PTR [esi], 0
jne $LN80@xmlRegExec
; 4108 : value = exec->inputStack[exec->index].value;
mov eax, DWORD PTR [esi+56]
mov ebx, DWORD PTR [ecx+eax*8]
; 4109 : data = exec->inputStack[exec->index].data;
mov edx, DWORD PTR [ecx+eax*8+4]
mov DWORD PTR _value$1$[ebp], ebx
mov DWORD PTR _data$1$[ebp], edx
jmp $LN80@xmlRegExec
$LN81@xmlRegExec:
pop ebx
pop edi
; 4122 : }
; 4123 : #ifdef DEBUG_ERR
; 4124 : if (exec->status < 0) {
; 4125 : testerr(exec);
; 4126 : }
; 4127 : #endif
; 4128 : return(exec->status);
mov eax, ecx
; 4129 : }
pop esi
mov esp, ebp
pop ebp
ret 0
$LN132@xmlRegExec:
pop edi
; 3794 : return(-1);
or eax, -1
; 4129 : }
pop esi
mov esp, ebp
pop ebp
ret 0
_xmlRegExecPushStringInternal ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegCompactPushString
_TEXT SEGMENT
_state$1$ = -4 ; size = 4
_exec$ = 8 ; size = 4
tv425 = 12 ; size = 4
_comp$ = 12 ; size = 4
_value$ = 16 ; size = 4
_data$ = 20 ; size = 4
_xmlRegCompactPushString PROC ; COMDAT
; 3703 : void *data) {
push ebp
mov ebp, esp
push ecx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _exec$[ebp]
mov esi, DWORD PTR _comp$[ebp]
mov edi, DWORD PTR [eax+56]
mov DWORD PTR _state$1$[ebp], edi
test esi, esi
je $LN6@xmlRegComp
; 3704 : int state = exec->index;
; 3705 : int i, target;
; 3706 :
; 3707 : if ((comp == NULL) || (comp->compact == NULL) || (comp->stringMap == NULL))
mov ecx, DWORD PTR [esi+40]
test ecx, ecx
je $LN6@xmlRegComp
cmp DWORD PTR [esi+52], 0
je $LN6@xmlRegComp
; 3709 :
; 3710 : if (value == NULL) {
mov edx, DWORD PTR _value$[ebp]
mov eax, DWORD PTR [esi+48]
push ebx
test edx, edx
jne SHORT $LN7@xmlRegComp
; 3711 : /*
; 3712 : * are we at a final state ?
; 3713 : */
; 3714 : if (comp->compact[state * (comp->nbstrings + 1)] ==
inc eax
imul eax, edi
cmp DWORD PTR [ecx+eax*4], 2
jmp $LN26@xmlRegComp
$LN7@xmlRegComp:
; 3715 : XML_REGEXP_FINAL_STATE)
; 3716 : return(1);
; 3717 : return(0);
; 3718 : }
; 3719 :
; 3720 : #ifdef DEBUG_PUSH
; 3721 : printf("value pushed: %s\n", value);
; 3722 : #endif
; 3723 :
; 3724 : /*
; 3725 : * Examine all outside transitions from current state
; 3726 : */
; 3727 : for (i = 0;i < comp->nbstrings;i++) {
xor ebx, ebx
test eax, eax
jle $error$28
npad 5
$LL4@xmlRegComp:
; 3728 : target = comp->compact[state * (comp->nbstrings + 1) + i + 1];
lea ecx, DWORD PTR [eax+1]
mov eax, DWORD PTR [esi+40]
imul ecx, edi
add ecx, ebx
mov edi, DWORD PTR [eax+ecx*4+4]
; 3729 : if ((target > 0) && (target <= comp->nbstates)) {
test edi, edi
jle SHORT $LN2@xmlRegComp
cmp edi, DWORD PTR [esi+36]
jg SHORT $LN2@xmlRegComp
; 3730 : target--; /* to avoid 0 */
; 3731 : if (xmlRegStrEqualWildcard(comp->stringMap[i], value)) {
mov eax, DWORD PTR [esi+52]
dec edi
push edx
push DWORD PTR [eax+ebx*4]
call _xmlRegStrEqualWildcard
add esp, 8
test eax, eax
jne SHORT $LN17@xmlRegComp
mov edx, DWORD PTR _value$[ebp]
$LN2@xmlRegComp:
; 3715 : XML_REGEXP_FINAL_STATE)
; 3716 : return(1);
; 3717 : return(0);
; 3718 : }
; 3719 :
; 3720 : #ifdef DEBUG_PUSH
; 3721 : printf("value pushed: %s\n", value);
; 3722 : #endif
; 3723 :
; 3724 : /*
; 3725 : * Examine all outside transitions from current state
; 3726 : */
; 3727 : for (i = 0;i < comp->nbstrings;i++) {
mov eax, DWORD PTR [esi+48]
inc ebx
mov edi, DWORD PTR _state$1$[ebp]
cmp ebx, eax
jge SHORT $error$28
jmp SHORT $LL4@xmlRegComp
$LN17@xmlRegComp:
; 3732 : exec->index = target;
mov ecx, DWORD PTR _exec$[ebp]
; 3733 : if ((exec->callback != NULL) && (comp->transdata != NULL)) {
mov eax, DWORD PTR [ecx+12]
mov DWORD PTR [ecx+56], edi
mov DWORD PTR tv425[ebp], eax
test eax, eax
je SHORT $LN11@xmlRegComp
mov edx, DWORD PTR [esi+44]
test edx, edx
je SHORT $LN11@xmlRegComp
; 3734 : exec->callback(exec->data, value,
mov eax, DWORD PTR [esi+48]
imul eax, DWORD PTR _state$1$[ebp]
push DWORD PTR _data$[ebp]
add eax, ebx
push DWORD PTR [edx+eax*4]
push DWORD PTR _value$[ebp]
push DWORD PTR [ecx+16]
call DWORD PTR tv425[ebp]
add esp, 16 ; 00000010H
$LN11@xmlRegComp:
; 3735 : comp->transdata[state * comp->nbstrings + i], data);
; 3736 : }
; 3737 : #ifdef DEBUG_PUSH
; 3738 : printf("entering state %d\n", target);
; 3739 : #endif
; 3740 : if (comp->compact[target * (comp->nbstrings + 1)] ==
mov ecx, DWORD PTR [esi+48]
mov eax, DWORD PTR [esi+40]
inc ecx
imul ecx, edi
mov eax, DWORD PTR [eax+ecx*4]
cmp eax, 4
je SHORT $LN24@xmlRegComp
; 3741 : XML_REGEXP_SINK_STATE)
; 3742 : goto error;
; 3743 :
; 3744 : if (comp->compact[target * (comp->nbstrings + 1)] ==
cmp eax, 2
$LN26@xmlRegComp:
; 3745 : XML_REGEXP_FINAL_STATE)
; 3746 : return(1);
jne SHORT $LN13@xmlRegComp
pop ebx
pop edi
mov eax, 1
; 3768 : }
pop esi
mov esp, ebp
pop ebp
ret 0
$LN13@xmlRegComp:
pop ebx
pop edi
; 3747 : return(0);
xor eax, eax
; 3768 : }
pop esi
mov esp, ebp
pop ebp
ret 0
$LN24@xmlRegComp:
; 3735 : comp->transdata[state * comp->nbstrings + i], data);
; 3736 : }
; 3737 : #ifdef DEBUG_PUSH
; 3738 : printf("entering state %d\n", target);
; 3739 : #endif
; 3740 : if (comp->compact[target * (comp->nbstrings + 1)] ==
mov edi, DWORD PTR _state$1$[ebp]
$error$28:
; 3748 : }
; 3749 : }
; 3750 : }
; 3751 : /*
; 3752 : * Failed to find an exit transition out from current state for the
; 3753 : * current token
; 3754 : */
; 3755 : #ifdef DEBUG_PUSH
; 3756 : printf("failed to find a transition for %s on state %d\n", value, state);
; 3757 : #endif
; 3758 : error:
; 3759 : if (exec->errString != NULL)
mov ebx, DWORD PTR _exec$[ebp]
mov eax, DWORD PTR [ebx+80]
test eax, eax
je SHORT $LN14@xmlRegComp
; 3760 : xmlFree(exec->errString);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN14@xmlRegComp:
; 3761 : exec->errString = xmlStrdup(value);
push DWORD PTR _value$[ebp]
call _xmlStrdup
add esp, 4
mov DWORD PTR [ebx+80], eax
; 3762 : exec->errStateNo = state;
mov DWORD PTR [ebx+72], edi
; 3763 : exec->status = -1;
; 3764 : #ifdef DEBUG_ERR
; 3765 : testerr(exec);
; 3766 : #endif
; 3767 : return(-1);
or eax, -1
mov DWORD PTR [ebx], -1
pop ebx
pop edi
; 3768 : }
pop esi
mov esp, ebp
pop ebp
ret 0
$LN6@xmlRegComp:
pop edi
; 3708 : return(-1);
or eax, -1
; 3768 : }
pop esi
mov esp, ebp
pop ebp
ret 0
_xmlRegCompactPushString ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFARegExecSaveInputString
_TEXT SEGMENT
_exec$ = 8 ; size = 4
_value$ = 12 ; size = 4
_data$ = 16 ; size = 4
_xmlFARegExecSaveInputString PROC ; COMDAT
; 3604 : void *data) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _exec$[ebp]
mov ecx, DWORD PTR [esi+48]
test ecx, ecx
jne SHORT $LN2@xmlFARegEx
; 3605 : #ifdef DEBUG_PUSH
; 3606 : printf("saving value: %d:%s\n", exec->inputStackNr, value);
; 3607 : #endif
; 3608 : if (exec->inputStackMax == 0) {
; 3609 : exec->inputStackMax = 4;
push 32 ; 00000020H
mov DWORD PTR [esi+48], 4
; 3610 : exec->inputStack = (xmlRegInputTokenPtr)
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR [esi+68], eax
; 3611 : xmlMalloc(exec->inputStackMax * sizeof(xmlRegInputToken));
; 3612 : if (exec->inputStack == NULL) {
test eax, eax
jne $LN5@xmlFARegEx
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
push OFFSET ??_C@_0BF@FEDDAGIG@pushing?5input?5string@
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push eax
push eax
push eax
push eax
push OFFSET ??_C@_0BF@FEDDAGIG@pushing?5input?5string@
push eax
push eax
push 3
push 2
push 14 ; 0000000eH
push eax
push eax
push eax
push eax
push eax
call ___xmlRaiseError
add esp, 68 ; 00000044H
; 3613 : xmlRegexpErrMemory(NULL, "pushing input string");
; 3614 : exec->inputStackMax = 0;
mov DWORD PTR [esi+48], 0
pop esi
; 3635 : }
pop ebp
ret 0
$LN2@xmlFARegEx:
; 3615 : return;
; 3616 : }
; 3617 : } else if (exec->inputStackNr + 1 >= exec->inputStackMax) {
mov eax, DWORD PTR [esi+52]
inc eax
cmp eax, ecx
jl SHORT $LN5@xmlFARegEx
; 3618 : xmlRegInputTokenPtr tmp;
; 3619 :
; 3620 : exec->inputStackMax *= 2;
lea eax, DWORD PTR [ecx+ecx]
mov DWORD PTR [esi+48], eax
; 3621 : tmp = (xmlRegInputTokenPtr) xmlRealloc(exec->inputStack,
shl eax, 3
push eax
push DWORD PTR [esi+68]
call DWORD PTR _xmlRealloc
add esp, 8
; 3622 : exec->inputStackMax * sizeof(xmlRegInputToken));
; 3623 : if (tmp == NULL) {
test eax, eax
jne SHORT $LN6@xmlFARegEx
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
push OFFSET ??_C@_0BF@FEDDAGIG@pushing?5input?5string@
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push eax
push eax
push eax
push eax
push OFFSET ??_C@_0BF@FEDDAGIG@pushing?5input?5string@
push eax
push eax
push 3
push 2
push 14 ; 0000000eH
push eax
push eax
push eax
push eax
push eax
call ___xmlRaiseError
; 3624 : xmlRegexpErrMemory(NULL, "pushing input string");
; 3625 : exec->inputStackMax /= 2;
mov eax, DWORD PTR [esi+48]
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
add esp, 68 ; 00000044H
; 3624 : xmlRegexpErrMemory(NULL, "pushing input string");
; 3625 : exec->inputStackMax /= 2;
cdq
sub eax, edx
sar eax, 1
mov DWORD PTR [esi+48], eax
pop esi
; 3635 : }
pop ebp
ret 0
$LN6@xmlFARegEx:
; 3626 : return;
; 3627 : }
; 3628 : exec->inputStack = tmp;
mov DWORD PTR [esi+68], eax
$LN5@xmlFARegEx:
; 3629 : }
; 3630 : exec->inputStack[exec->inputStackNr].value = xmlStrdup(value);
push DWORD PTR _value$[ebp]
call _xmlStrdup
mov edx, DWORD PTR [esi+52]
add esp, 4
mov ecx, DWORD PTR [esi+68]
mov DWORD PTR [ecx+edx*8], eax
; 3631 : exec->inputStack[exec->inputStackNr].data = data;
mov edx, DWORD PTR [esi+52]
mov ecx, DWORD PTR [esi+68]
mov eax, DWORD PTR _data$[ebp]
mov DWORD PTR [ecx+edx*8+4], eax
; 3632 : exec->inputStackNr++;
inc DWORD PTR [esi+52]
mov ecx, DWORD PTR [esi+52]
; 3633 : exec->inputStack[exec->inputStackNr].value = NULL;
mov eax, DWORD PTR [esi+68]
mov DWORD PTR [eax+ecx*8], 0
; 3634 : exec->inputStack[exec->inputStackNr].data = NULL;
mov ecx, DWORD PTR [esi+52]
mov eax, DWORD PTR [esi+68]
pop esi
mov DWORD PTR [eax+ecx*8+4], 0
; 3635 : }
pop ebp
ret 0
_xmlFARegExecSaveInputString ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFARegExec
_TEXT SEGMENT
_execval$ = -128 ; size = 92
_to$1$ = -36 ; size = 4
_atom$2$ = -32 ; size = 4
tv1144 = -28 ; size = 4
_ret$1$ = -24 ; size = 4
_trans$2$ = -20 ; size = 4
_deter$1$ = -16 ; size = 4
_len$ = -12 ; size = 4
_execval$5$ = -8 ; size = 4
_execval$1$ = -4 ; size = 4
_comp$ = 8 ; size = 4
_content$ = 12 ; size = 4
_xmlFARegExec PROC ; COMDAT
; 3194 : xmlFARegExec(xmlRegexpPtr comp, const xmlChar *content) {
push ebp
mov ebp, esp
sub esp, 128 ; 00000080H
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov ecx, DWORD PTR _comp$[ebp]
xor ebx, ebx
mov esi, DWORD PTR _content$[ebp]
xor edi, edi
mov DWORD PTR _execval$[ebp+8], ecx
mov DWORD PTR _execval$[ebp+64], esi
lea eax, DWORD PTR [ecx+8]
mov DWORD PTR _execval$[ebp+56], ebx
mov ecx, DWORD PTR [ecx+20]
mov DWORD PTR tv1144[ebp], eax
mov eax, DWORD PTR [eax]
mov DWORD PTR _execval$[ebp+88], ebx
mov DWORD PTR _execval$[ebp+4], 1
mov DWORD PTR _execval$[ebp+32], ebx
mov eax, DWORD PTR [eax]
mov DWORD PTR _execval$[ebp+36], ebx
mov DWORD PTR _execval$[ebp+40], ebx
mov DWORD PTR _execval$[ebp], ebx
mov DWORD PTR _execval$1$[ebp], eax
mov DWORD PTR _execval$[ebp+20], eax
mov DWORD PTR _execval$5$[ebp], edi
mov DWORD PTR _execval$[ebp+24], edi
mov DWORD PTR _execval$[ebp+28], ebx
mov DWORD PTR _execval$[ebp+68], ebx
mov DWORD PTR _execval$[ebp+48], ebx
test ecx, ecx
jle SHORT $LN13@xmlFARegEx
; 3195 : xmlRegExecCtxt execval;
; 3196 : xmlRegExecCtxtPtr exec = &execval;
; 3197 : int ret, codepoint = 0, len, deter;
; 3198 :
; 3199 : exec->inputString = content;
; 3200 : exec->index = 0;
; 3201 : exec->nbPush = 0;
; 3202 : exec->determinist = 1;
; 3203 : exec->maxRollbacks = 0;
; 3204 : exec->nbRollbacks = 0;
; 3205 : exec->rollbacks = NULL;
; 3206 : exec->status = 0;
; 3207 : exec->comp = comp;
; 3208 : exec->state = comp->states[0];
; 3209 : exec->transno = 0;
; 3210 : exec->transcount = 0;
; 3211 : exec->inputStack = NULL;
; 3212 : exec->inputStackMax = 0;
; 3213 : if (comp->nbCounters > 0) {
; 3214 : exec->counts = (int *) xmlMalloc(comp->nbCounters * sizeof(int));
lea eax, DWORD PTR [ecx*4]
push eax
call DWORD PTR _xmlMalloc
mov esi, eax
add esp, 4
mov DWORD PTR _execval$[ebp+44], esi
; 3215 : if (exec->counts == NULL) {
test esi, esi
jne SHORT $LN15@xmlFARegEx
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
push OFFSET ??_C@_0P@IJHGICCJ@running?5regexp@
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push eax
push eax
push eax
push eax
push OFFSET ??_C@_0P@IJHGICCJ@running?5regexp@
push eax
push eax
push 3
push 2
push 14 ; 0000000eH
push eax
push eax
push eax
push eax
push eax
call ___xmlRaiseError
add esp, 68 ; 00000044H
$LN112@xmlFARegEx:
pop edi
; 3488 : }
pop esi
or eax, -1
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN15@xmlFARegEx:
; 3216 : xmlRegexpErrMemory(NULL, "running regexp");
; 3217 : return(-1);
; 3218 : }
; 3219 : memset(exec->counts, 0, comp->nbCounters * sizeof(int));
mov eax, DWORD PTR _comp$[ebp]
mov eax, DWORD PTR [eax+20]
shl eax, 2
push eax
push 0
push esi
call _memset
; 3220 : } else
mov edx, DWORD PTR _execval$[ebp+44]
add esp, 12 ; 0000000cH
mov eax, DWORD PTR _execval$1$[ebp]
mov esi, DWORD PTR _content$[ebp]
jmp SHORT $LL2@xmlFARegEx
$LN13@xmlFARegEx:
; 3221 : exec->counts = NULL;
xor edx, edx
mov DWORD PTR _execval$[ebp+44], edx
$LL2@xmlFARegEx:
; 3222 : while ((exec->status == 0) && (exec->state != NULL) &&
test eax, eax
je $error$157
cmp BYTE PTR [esi+ebx], 0
jne SHORT $LN16@xmlFARegEx
cmp DWORD PTR [eax], 2
je $error$157
$LN16@xmlFARegEx:
; 3223 : ((exec->inputString[exec->index] != 0) ||
; 3224 : ((exec->state != NULL) &&
; 3225 : (exec->state->type != XML_REGEXP_FINAL_STATE)))) {
; 3226 : xmlRegTransPtr trans;
; 3227 : xmlRegAtomPtr atom;
; 3228 :
; 3229 : /*
; 3230 : * If end of input on non-terminal state, rollback, however we may
; 3231 : * still have epsilon like transition for counted transitions
; 3232 : * on counters, in that case don't break too early. Additionally,
; 3233 : * if we are working on a range like "AB{0,2}", where B is not present,
; 3234 : * we don't want to break.
; 3235 : */
; 3236 : len = 1;
mov DWORD PTR _len$[ebp], 1
; 3237 : if ((exec->inputString[exec->index] == 0) && (exec->counts == NULL)) {
cmp BYTE PTR [esi+ebx], 0
jne SHORT $LN19@xmlFARegEx
test edx, edx
jne SHORT $LN19@xmlFARegEx
; 3238 : /*
; 3239 : * if there is a transition, we must check if
; 3240 : * atom allows minOccurs of 0
; 3241 : */
; 3242 : if (exec->transno < exec->state->nbTrans) {
cmp edi, DWORD PTR [eax+24]
jge $rollback$158
; 3243 : trans = &exec->state->trans[exec->transno];
mov eax, DWORD PTR [eax+28]
lea ecx, DWORD PTR [edi+edi*4]
; 3244 : if (trans->to >=0) {
cmp DWORD PTR [eax+ecx*4+4], edx
jl SHORT $LN142@xmlFARegEx
; 3245 : atom = trans->atom;
mov eax, DWORD PTR [eax+ecx*4]
; 3246 : if (!((atom->min == 0) && (atom->max > 0)))
cmp DWORD PTR [eax+12], edx
jne $rollback$158
cmp DWORD PTR [eax+16], edx
jle $rollback$158
$LN142@xmlFARegEx:
; 3247 : goto rollback;
; 3248 : }
; 3249 : } else
; 3250 : goto rollback;
; 3251 : }
; 3252 :
; 3253 : exec->transcount = 0;
mov eax, DWORD PTR _execval$1$[ebp]
$LN19@xmlFARegEx:
mov DWORD PTR _execval$[ebp+28], 0
; 3254 : for (;exec->transno < exec->state->nbTrans;exec->transno++) {
cmp edi, DWORD PTR [eax+24]
jge $LN135@xmlFARegEx
npad 5
$LL6@xmlFARegEx:
; 3255 : trans = &exec->state->trans[exec->transno];
mov eax, DWORD PTR [eax+28]
lea ecx, DWORD PTR [edi+edi*4]
; 3256 : if (trans->to < 0)
cmp DWORD PTR [eax+ecx*4+4], 0
lea eax, DWORD PTR [eax+ecx*4]
mov DWORD PTR _trans$2$[ebp], eax
jl $LN4@xmlFARegEx
; 3257 : continue;
; 3258 : atom = trans->atom;
; 3259 : ret = 0;
; 3260 : deter = 1;
; 3261 : if (trans->count >= 0) {
mov ecx, DWORD PTR [eax+12]
mov esi, DWORD PTR [eax]
mov DWORD PTR _atom$2$[ebp], esi
mov DWORD PTR _deter$1$[ebp], 1
test ecx, ecx
js SHORT $LN24@xmlFARegEx
; 3262 : int count;
; 3263 : xmlRegCounterPtr counter;
; 3264 :
; 3265 : if (exec->counts == NULL) {
test edx, edx
je $LN92@xmlFARegEx
; 3266 : exec->status = -1;
; 3267 : goto error;
; 3268 : }
; 3269 : /*
; 3270 : * A counted transition.
; 3271 : */
; 3272 :
; 3273 : count = exec->counts[trans->count];
; 3274 : counter = &exec->comp->counters[trans->count];
mov eax, DWORD PTR _comp$[ebp]
mov esi, DWORD PTR [edx+ecx*4]
mov eax, DWORD PTR [eax+24]
lea eax, DWORD PTR [eax+ecx*8]
; 3275 : #ifdef DEBUG_REGEXP_EXEC
; 3276 : printf("testing count %d: val %d, min %d, max %d\n",
; 3277 : trans->count, count, counter->min, counter->max);
; 3278 : #endif
; 3279 : ret = ((count >= counter->min) && (count <= counter->max));
mov ecx, DWORD PTR [eax]
cmp esi, ecx
jl $LN4@xmlFARegEx
mov eax, DWORD PTR [eax+4]
cmp esi, eax
jg $LN4@xmlFARegEx
; 3280 : if ((ret) && (counter->min != counter->max))
cmp ecx, eax
je $LN148@xmlFARegEx
; 3281 : deter = 0;
xor eax, eax
; 3282 : } else if (atom == NULL) {
jmp $LN105@xmlFARegEx
$LN24@xmlFARegEx:
test esi, esi
je $LN86@xmlFARegEx
; 3285 : break;
; 3286 : } else if (exec->inputString[exec->index] != 0) {
mov eax, DWORD PTR _content$[ebp]
add eax, ebx
cmp BYTE PTR [eax], 0
je $LN30@xmlFARegEx
; 3287 : codepoint = CUR_SCHAR(&(exec->inputString[exec->index]), len);
lea ecx, DWORD PTR _len$[ebp]
push ecx
push eax
push 0
call _xmlStringCurrentChar
; 3288 : ret = xmlRegCheckCharacter(atom, codepoint);
push eax
push esi
call _xmlRegCheckCharacter
mov ecx, eax
add esp, 20 ; 00000014H
mov DWORD PTR _ret$1$[ebp], ecx
; 3289 : if ((ret == 1) && (atom->min >= 0) && (atom->max > 0)) {
cmp ecx, 1
jne $LN32@xmlFARegEx
cmp DWORD PTR [esi+12], 0
jl $LN148@xmlFARegEx
cmp DWORD PTR [esi+16], 0
jle $LN148@xmlFARegEx
; 3290 : xmlRegStatePtr to = comp->states[trans->to];
mov edx, DWORD PTR _trans$2$[ebp]
mov eax, DWORD PTR tv1144[ebp]
mov ecx, DWORD PTR [edx+4]
mov eax, DWORD PTR [eax]
mov eax, DWORD PTR [eax+ecx*4]
; 3291 :
; 3292 : /*
; 3293 : * this is a multiple input sequence
; 3294 : * If there is a counter associated increment it now.
; 3295 : * before potentially saving and rollback
; 3296 : * do not increment if the counter is already over the
; 3297 : * maximum limit in which case get to next transition
; 3298 : */
; 3299 : if (trans->counter >= 0) {
mov ecx, DWORD PTR [edx+8]
mov DWORD PTR _to$1$[ebp], eax
test ecx, ecx
js SHORT $LN34@xmlFARegEx
; 3300 : xmlRegCounterPtr counter;
; 3301 :
; 3302 : if ((exec->counts == NULL) ||
; 3303 : (exec->comp == NULL) ||
mov edx, DWORD PTR _execval$[ebp+44]
test edx, edx
je $LN92@xmlFARegEx
mov eax, DWORD PTR _comp$[ebp]
test eax, eax
je $LN92@xmlFARegEx
mov eax, DWORD PTR [eax+24]
test eax, eax
je $LN92@xmlFARegEx
; 3304 : (exec->comp->counters == NULL)) {
; 3305 : exec->status = -1;
; 3306 : goto error;
; 3307 : }
; 3308 : counter = &exec->comp->counters[trans->counter];
; 3309 : if (exec->counts[trans->counter] >= counter->max)
mov esi, DWORD PTR _trans$2$[ebp]
lea ecx, DWORD PTR [edx+ecx*4]
mov edx, DWORD PTR [ecx]
mov edi, DWORD PTR [esi+8]
mov esi, DWORD PTR _atom$2$[ebp]
cmp edx, DWORD PTR [eax+edi*8+4]
mov edi, DWORD PTR _execval$5$[ebp]
mov edx, DWORD PTR _execval$[ebp+44]
jge $LN4@xmlFARegEx
; 3310 : continue; /* for loop on transitions */
; 3311 :
; 3312 : #ifdef DEBUG_REGEXP_EXEC
; 3313 : printf("Increasing count %d\n", trans->counter);
; 3314 : #endif
; 3315 : exec->counts[trans->counter]++;
inc DWORD PTR [ecx]
$LN34@xmlFARegEx:
; 3316 : }
; 3317 : if (exec->state->nbTrans > exec->transno + 1) {
mov edx, DWORD PTR _execval$1$[ebp]
lea eax, DWORD PTR [edi+1]
cmp DWORD PTR [edx+24], eax
jle SHORT $LN137@xmlFARegEx
; 3318 : xmlFARegExecSave(exec);
lea eax, DWORD PTR _execval$[ebp]
push eax
call _xmlFARegExecSave
mov eax, DWORD PTR _execval$[ebp+64]
add esp, 4
mov ecx, DWORD PTR _execval$[ebp+24]
mov edx, DWORD PTR _execval$[ebp+20]
mov ebx, DWORD PTR _execval$[ebp+56]
mov DWORD PTR _content$[ebp], eax
mov DWORD PTR _execval$5$[ebp], ecx
mov DWORD PTR _execval$1$[ebp], edx
jmp SHORT $LN38@xmlFARegEx
$LN137@xmlFARegEx:
; 3316 : }
; 3317 : if (exec->state->nbTrans > exec->transno + 1) {
mov ecx, DWORD PTR _execval$5$[ebp]
$LN38@xmlFARegEx:
; 3319 : }
; 3320 : exec->transcount = 1;
mov edi, 1
mov DWORD PTR _execval$[ebp+28], edi
$LL9@xmlFARegEx:
; 3321 : do {
; 3322 : /*
; 3323 : * Try to progress as much as possible on the input
; 3324 : */
; 3325 : if (exec->transcount == atom->max) {
cmp edi, DWORD PTR [esi+16]
je SHORT $LN8@xmlFARegEx
; 3326 : break;
; 3327 : }
; 3328 : exec->index += len;
add ebx, DWORD PTR _len$[ebp]
; 3329 : /*
; 3330 : * End of input: stop here
; 3331 : */
; 3332 : if (exec->inputString[exec->index] == 0) {
mov eax, DWORD PTR _content$[ebp]
mov DWORD PTR _execval$[ebp+56], ebx
cmp BYTE PTR [eax+ebx], 0
je SHORT $LN84@xmlFARegEx
; 3334 : break;
; 3335 : }
; 3336 : if (exec->transcount >= atom->min) {
cmp edi, DWORD PTR [esi+12]
jl SHORT $LN41@xmlFARegEx
; 3337 : int transno = exec->transno;
; 3338 : xmlRegStatePtr state = exec->state;
; 3339 :
; 3340 : /*
; 3341 : * The transition is acceptable save it
; 3342 : */
; 3343 : exec->transno = -1; /* trick */
; 3344 : exec->state = to;
mov eax, DWORD PTR _to$1$[ebp]
mov DWORD PTR _execval$[ebp+20], eax
; 3345 : xmlFARegExecSave(exec);
lea eax, DWORD PTR _execval$[ebp]
push eax
mov DWORD PTR _execval$5$[ebp], ecx
mov DWORD PTR _execval$1$[ebp], edx
mov DWORD PTR _execval$[ebp+24], -1
call _xmlFARegExecSave
; 3346 : exec->transno = transno;
mov eax, DWORD PTR _execval$5$[ebp]
add esp, 4
; 3347 : exec->state = state;
mov ebx, DWORD PTR _execval$[ebp+56]
mov edi, DWORD PTR _execval$[ebp+28]
mov DWORD PTR _execval$[ebp+24], eax
mov eax, DWORD PTR _execval$1$[ebp]
mov DWORD PTR _execval$[ebp+20], eax
mov eax, DWORD PTR _execval$[ebp+64]
mov DWORD PTR _content$[ebp], eax
$LN41@xmlFARegEx:
; 3348 : }
; 3349 : codepoint = CUR_SCHAR(&(exec->inputString[exec->index]),
lea ecx, DWORD PTR _len$[ebp]
add eax, ebx
push ecx
push eax
push 0
call _xmlStringCurrentChar
; 3350 : len);
; 3351 : ret = xmlRegCheckCharacter(atom, codepoint);
push eax
push esi
call _xmlRegCheckCharacter
; 3352 : exec->transcount++;
inc edi
mov DWORD PTR _ret$1$[ebp], eax
add esp, 20 ; 00000014H
mov DWORD PTR _execval$[ebp+28], edi
; 3353 : } while (ret == 1);
cmp eax, 1
jne SHORT $LN8@xmlFARegEx
mov ecx, DWORD PTR _execval$5$[ebp]
mov edx, DWORD PTR _execval$1$[ebp]
jmp SHORT $LL9@xmlFARegEx
$LN84@xmlFARegEx:
; 3333 : exec->index -= len;
sub ebx, DWORD PTR _len$[ebp]
mov DWORD PTR _execval$[ebp+56], ebx
$LN8@xmlFARegEx:
; 3354 : if (exec->transcount < atom->min)
; 3355 : ret = 0;
; 3356 :
; 3357 : /*
; 3358 : * If the last check failed but one transition was found
; 3359 : * possible, rollback
; 3360 : */
; 3361 : if (ret < 0)
xor eax, eax
cmp edi, DWORD PTR [esi+12]
cmovge eax, DWORD PTR _ret$1$[ebp]
; 3362 : ret = 0;
; 3363 : if (ret == 0) {
xor ecx, ecx
test eax, eax
cmovns ecx, eax
test ecx, ecx
je $rollback$158
; 3364 : goto rollback;
; 3365 : }
; 3366 : if (trans->counter >= 0) {
mov eax, DWORD PTR _trans$2$[ebp]
mov eax, DWORD PTR [eax+8]
test eax, eax
js SHORT $LN45@xmlFARegEx
; 3367 : if (exec->counts == NULL) {
mov edx, DWORD PTR _execval$[ebp+44]
test edx, edx
je $LN92@xmlFARegEx
; 3368 : exec->status = -1;
; 3369 : goto error;
; 3370 : }
; 3371 : #ifdef DEBUG_REGEXP_EXEC
; 3372 : printf("Decreasing count %d\n", trans->counter);
; 3373 : #endif
; 3374 : exec->counts[trans->counter]--;
dec DWORD PTR [edx+eax*4]
$LN45@xmlFARegEx:
; 3375 : }
mov eax, DWORD PTR _execval$[ebp+8]
mov edi, DWORD PTR _execval$5$[ebp]
mov DWORD PTR _comp$[ebp], eax
$LN132@xmlFARegEx:
; 3387 : /* another spot to match when minOccurs is 0 */
; 3388 : exec->transcount = 1;
; 3389 : len = 0;
; 3390 : ret = 1;
; 3391 : }
; 3392 : if (ret == 1) {
cmp ecx, 1
je SHORT $LN148@xmlFARegEx
; 3445 : } else if (ret < 0) {
test ecx, ecx
js $LN91@xmlFARegEx
$LN141@xmlFARegEx:
; 3254 : for (;exec->transno < exec->state->nbTrans;exec->transno++) {
mov edx, DWORD PTR _execval$[ebp+44]
jmp $LN4@xmlFARegEx
$LN32@xmlFARegEx:
; 3376 : } else if ((ret == 0) && (atom->min == 0) && (atom->max > 0)) {
test ecx, ecx
jne SHORT $LN132@xmlFARegEx
cmp DWORD PTR [esi+12], ecx
jne SHORT $LN141@xmlFARegEx
cmp DWORD PTR [esi+16], ecx
jle SHORT $LN141@xmlFARegEx
; 3377 : /*
; 3378 : * we don't match on the codepoint, but minOccurs of 0
; 3379 : * says that's ok. Setting len to 0 inhibits stepping
; 3380 : * over the codepoint.
; 3381 : */
; 3382 : exec->transcount = 1;
; 3383 : len = 0;
; 3384 : ret = 1;
; 3385 : }
jmp SHORT $LN155@xmlFARegEx
$LN30@xmlFARegEx:
; 3386 : } else if ((atom->min == 0) && (atom->max > 0)) {
cmp DWORD PTR [esi+12], 0
jne $LN4@xmlFARegEx
cmp DWORD PTR [esi+16], 0
jle $LN4@xmlFARegEx
$LN155@xmlFARegEx:
; 3393 : if ((trans->nd == 1) ||
mov DWORD PTR _len$[ebp], 0
mov DWORD PTR _execval$[ebp+28], 1
$LN148@xmlFARegEx:
mov eax, DWORD PTR _deter$1$[ebp]
$LN105@xmlFARegEx:
mov esi, DWORD PTR _trans$2$[ebp]
cmp DWORD PTR [esi+16], 1
je SHORT $LN111@xmlFARegEx
cmp DWORD PTR [esi+12], 0
jl SHORT $LN145@xmlFARegEx
test eax, eax
jne SHORT $LN145@xmlFARegEx
mov ecx, DWORD PTR _execval$1$[ebp]
lea eax, DWORD PTR [edi+1]
cmp DWORD PTR [ecx+24], eax
jle SHORT $LN145@xmlFARegEx
$LN111@xmlFARegEx:
; 3394 : ((trans->count >= 0) && (deter == 0) &&
; 3395 : (exec->state->nbTrans > exec->transno + 1))) {
; 3396 : #ifdef DEBUG_REGEXP_EXEC
; 3397 : if (trans->nd == 1)
; 3398 : printf("Saving on nd transition atom %d for %c at %d\n",
; 3399 : trans->atom->no, codepoint, exec->index);
; 3400 : else
; 3401 : printf("Saving on counted transition count %d for %c at %d\n",
; 3402 : trans->count, codepoint, exec->index);
; 3403 : #endif
; 3404 : xmlFARegExecSave(exec);
lea eax, DWORD PTR _execval$[ebp]
push eax
call _xmlFARegExecSave
mov eax, DWORD PTR _execval$[ebp+64]
add esp, 4
mov ebx, DWORD PTR _execval$[ebp+56]
mov edi, DWORD PTR _execval$[ebp+24]
mov DWORD PTR _content$[ebp], eax
mov eax, DWORD PTR _execval$[ebp+20]
mov DWORD PTR _execval$1$[ebp], eax
mov eax, DWORD PTR _execval$[ebp+8]
mov DWORD PTR _comp$[ebp], eax
jmp SHORT $LN51@xmlFARegEx
$LN145@xmlFARegEx:
; 3405 : }
; 3406 : if (trans->counter >= 0) {
mov eax, DWORD PTR _comp$[ebp]
$LN51@xmlFARegEx:
mov ecx, DWORD PTR [esi+8]
mov edx, DWORD PTR _execval$[ebp+44]
test ecx, ecx
js SHORT $LN53@xmlFARegEx
; 3407 : xmlRegCounterPtr counter;
; 3408 :
; 3409 : /* make sure we don't go over the counter maximum value */
; 3410 : if ((exec->counts == NULL) ||
; 3411 : (exec->comp == NULL) ||
test edx, edx
je $LN92@xmlFARegEx
test eax, eax
je $LN92@xmlFARegEx
mov esi, DWORD PTR [eax+24]
test esi, esi
je $LN92@xmlFARegEx
; 3412 : (exec->comp->counters == NULL)) {
; 3413 : exec->status = -1;
; 3414 : goto error;
; 3415 : }
; 3416 : counter = &exec->comp->counters[trans->counter];
; 3417 : if (exec->counts[trans->counter] >= counter->max)
mov eax, DWORD PTR [edx+ecx*4]
cmp eax, DWORD PTR [esi+ecx*8+4]
jl SHORT $LN56@xmlFARegEx
$LN4@xmlFARegEx:
; 3254 : for (;exec->transno < exec->state->nbTrans;exec->transno++) {
mov eax, DWORD PTR _execval$1$[ebp]
inc edi
mov DWORD PTR _execval$5$[ebp], edi
mov DWORD PTR _execval$[ebp+24], edi
cmp edi, DWORD PTR [eax+24]
jl $LL6@xmlFARegEx
jmp SHORT $LN135@xmlFARegEx
$LN91@xmlFARegEx:
; 3446 : exec->status = -4;
mov DWORD PTR _execval$[ebp], -4 ; fffffffcH
jmp SHORT $LN154@xmlFARegEx
$LN56@xmlFARegEx:
; 3418 : continue; /* for loop on transitions */
; 3419 : #ifdef DEBUG_REGEXP_EXEC
; 3420 : printf("Increasing count %d\n", trans->counter);
; 3421 : #endif
; 3422 : exec->counts[trans->counter]++;
inc DWORD PTR [edx+ecx*4]
mov esi, DWORD PTR _trans$2$[ebp]
$LN53@xmlFARegEx:
; 3423 : }
; 3424 : if ((trans->count >= 0) &&
mov eax, DWORD PTR [esi+12]
cmp eax, 1193045 ; 00123455H
ja SHORT $LN57@xmlFARegEx
; 3425 : (trans->count < REGEXP_ALL_COUNTER)) {
; 3426 : if (exec->counts == NULL) {
test edx, edx
je $LN92@xmlFARegEx
; 3428 : goto error;
; 3429 : }
; 3430 : #ifdef DEBUG_REGEXP_EXEC
; 3431 : printf("resetting count %d on transition\n",
; 3432 : trans->count);
; 3433 : #endif
; 3434 : exec->counts[trans->count] = 0;
mov DWORD PTR [edx+eax*4], 0
$LN57@xmlFARegEx:
; 3435 : }
; 3436 : #ifdef DEBUG_REGEXP_EXEC
; 3437 : printf("entering state %d\n", trans->to);
; 3438 : #endif
; 3439 : exec->state = comp->states[trans->to];
mov eax, DWORD PTR tv1144[ebp]
; 3440 : exec->transno = 0;
xor edi, edi
mov ecx, DWORD PTR [esi+4]
; 3441 : if (trans->atom != NULL) {
cmp DWORD PTR [esi], edi
mov esi, DWORD PTR _content$[ebp]
mov eax, DWORD PTR [eax]
mov DWORD PTR _execval$5$[ebp], edi
mov DWORD PTR _execval$[ebp+24], edi
mov eax, DWORD PTR [eax+ecx*4]
mov DWORD PTR _execval$1$[ebp], eax
mov DWORD PTR _execval$[ebp+20], eax
je SHORT $progress$159
; 3442 : exec->index += len;
add ebx, DWORD PTR _len$[ebp]
mov DWORD PTR _execval$[ebp+56], ebx
; 3443 : }
; 3444 : goto progress;
jmp SHORT $progress$159
$LN86@xmlFARegEx:
; 3283 : fprintf(stderr, "epsilon transition left at runtime\n");
push OFFSET ??_C@_0CE@CMNJHAKA@epsilon?5transition?5left?5at?5runt@
push 2
call DWORD PTR __imp____acrt_iob_func
add esp, 4
push eax
call _fprintf
add esp, 8
; 3284 : exec->status = -2;
mov DWORD PTR _execval$[ebp], -2 ; fffffffeH
$LN154@xmlFARegEx:
; 3447 : break;
; 3448 : }
; 3449 : }
; 3450 : if ((exec->transno != 0) || (exec->state->nbTrans == 0)) {
mov eax, DWORD PTR _execval$1$[ebp]
$LN135@xmlFARegEx:
test edi, edi
jne SHORT $rollback$158
cmp DWORD PTR [eax+24], edi
jne SHORT $LN146@xmlFARegEx
$rollback$158:
; 3451 : rollback:
; 3452 : /*
; 3453 : * Failed to find a way out
; 3454 : */
; 3455 : exec->determinist = 0;
; 3456 : #ifdef DEBUG_REGEXP_EXEC
; 3457 : printf("rollback from state %d on %d:%c\n", exec->state->no,
; 3458 : codepoint,codepoint);
; 3459 : #endif
; 3460 : xmlFARegExecRollBack(exec);
lea eax, DWORD PTR _execval$[ebp]
mov DWORD PTR _execval$[ebp+4], 0
push eax
call _xmlFARegExecRollBack
mov esi, DWORD PTR _execval$[ebp+64]
add esp, 4
mov edi, DWORD PTR _execval$[ebp+24]
mov eax, DWORD PTR _execval$[ebp+20]
mov ecx, DWORD PTR _execval$[ebp+8]
mov ebx, DWORD PTR _execval$[ebp+56]
mov DWORD PTR _content$[ebp], esi
mov DWORD PTR _execval$5$[ebp], edi
mov DWORD PTR _execval$1$[ebp], eax
mov DWORD PTR _comp$[ebp], ecx
jmp SHORT $progress$159
$LN146@xmlFARegEx:
; 3447 : break;
; 3448 : }
; 3449 : }
; 3450 : if ((exec->transno != 0) || (exec->state->nbTrans == 0)) {
mov esi, DWORD PTR _content$[ebp]
$progress$159:
; 3222 : while ((exec->status == 0) && (exec->state != NULL) &&
cmp DWORD PTR _execval$[ebp], 0
jne SHORT $error$157
mov edx, DWORD PTR _execval$[ebp+44]
jmp $LL2@xmlFARegEx
$LN92@xmlFARegEx:
; 3427 : exec->status = -1;
mov DWORD PTR _execval$[ebp], -1
$error$157:
; 3461 : }
; 3462 : progress:
; 3463 : continue;
; 3464 : }
; 3465 : error:
; 3466 : if (exec->rollbacks != NULL) {
mov eax, DWORD PTR _execval$[ebp+40]
mov esi, DWORD PTR _execval$[ebp+44]
test eax, eax
je SHORT $LN63@xmlFARegEx
; 3467 : if (exec->counts != NULL) {
test esi, esi
je SHORT $LN11@xmlFARegEx
; 3468 : int i;
; 3469 :
; 3470 : for (i = 0;i < exec->maxRollbacks;i++)
mov ebx, DWORD PTR _execval$[ebp+32]
test ebx, ebx
jle SHORT $LN11@xmlFARegEx
lea edi, DWORD PTR [eax+12]
npad 3
$LL12@xmlFARegEx:
; 3471 : if (exec->rollbacks[i].counts != NULL)
mov eax, DWORD PTR [edi]
test eax, eax
je SHORT $LN10@xmlFARegEx
; 3472 : xmlFree(exec->rollbacks[i].counts);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN10@xmlFARegEx:
; 3468 : int i;
; 3469 :
; 3470 : for (i = 0;i < exec->maxRollbacks;i++)
add edi, 16 ; 00000010H
sub ebx, 1
jne SHORT $LL12@xmlFARegEx
mov eax, DWORD PTR _execval$[ebp+40]
$LN11@xmlFARegEx:
; 3473 : }
; 3474 : xmlFree(exec->rollbacks);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN63@xmlFARegEx:
; 3475 : }
; 3476 : if (exec->state == NULL)
cmp DWORD PTR _execval$1$[ebp], 0
je $LN112@xmlFARegEx
; 3477 : return(-1);
; 3478 : if (exec->counts != NULL)
test esi, esi
je SHORT $LN67@xmlFARegEx
; 3479 : xmlFree(exec->counts);
push esi
call DWORD PTR _xmlFree
add esp, 4
$LN67@xmlFARegEx:
; 3480 : if (exec->status == 0)
cmp DWORD PTR _execval$[ebp], 0
jne SHORT $LN68@xmlFARegEx
; 3488 : }
pop edi
pop esi
mov eax, 1
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN68@xmlFARegEx:
; 3481 : return(1);
; 3482 : if (exec->status == -1) {
cmp DWORD PTR _execval$[ebp], -1
jne SHORT $LN69@xmlFARegEx
; 3483 : if (exec->nbPush > MAX_PUSH)
cmp DWORD PTR _execval$[ebp+88], 10000000 ; 00989680H
jg $LN112@xmlFARegEx
; 3488 : }
pop edi
pop esi
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN69@xmlFARegEx:
; 3484 : return(-1);
; 3485 : return(0);
; 3486 : }
; 3487 : return(exec->status);
mov eax, DWORD PTR _execval$[ebp]
pop edi
; 3488 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
_xmlFARegExec ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFARegExecRollBack
_TEXT SEGMENT
_exec$ = 8 ; size = 4
_xmlFARegExecRollBack PROC ; COMDAT
; 3157 : xmlFARegExecRollBack(xmlRegExecCtxtPtr exec) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _exec$[ebp]
mov edx, DWORD PTR [esi+36]
test edx, edx
jg SHORT $LN2@xmlFARegEx
; 3158 : if (exec->nbRollbacks <= 0) {
; 3159 : exec->status = -1;
mov DWORD PTR [esi], -1
pop esi
; 3177 : exec->comp->nbCounters * sizeof(int));
; 3178 : }
; 3179 : }
; 3180 :
; 3181 : #ifdef DEBUG_REGEXP_EXEC
; 3182 : printf("restored ");
; 3183 : xmlFARegDebugExec(exec);
; 3184 : #endif
; 3185 : }
pop ebp
ret 0
$LN2@xmlFARegEx:
; 3160 : #ifdef DEBUG_REGEXP_EXEC
; 3161 : printf("rollback failed on empty stack\n");
; 3162 : #endif
; 3163 : return;
; 3164 : }
; 3165 : exec->nbRollbacks--;
; 3166 : exec->state = exec->rollbacks[exec->nbRollbacks].state;
mov ecx, DWORD PTR [esi+40]
dec edx
mov DWORD PTR [esi+36], edx
mov eax, edx
add eax, eax
; 3167 : exec->index = exec->rollbacks[exec->nbRollbacks].index;
add edx, edx
mov eax, DWORD PTR [ecx+eax*8]
mov DWORD PTR [esi+20], eax
mov eax, DWORD PTR [ecx+edx*8+4]
mov DWORD PTR [esi+56], eax
; 3168 : exec->transno = exec->rollbacks[exec->nbRollbacks].nextbranch;
mov eax, DWORD PTR [ecx+edx*8+8]
mov DWORD PTR [esi+24], eax
; 3169 : if (exec->comp->nbCounters > 0) {
mov eax, DWORD PTR [esi+8]
mov eax, DWORD PTR [eax+20]
test eax, eax
jle SHORT $LN5@xmlFARegEx
; 3170 : if (exec->rollbacks[exec->nbRollbacks].counts == NULL) {
mov edx, DWORD PTR [ecx+edx*8+12]
test edx, edx
jne SHORT $LN4@xmlFARegEx
; 3171 : fprintf(stderr, "exec save: allocation failed");
push OFFSET ??_C@_0BN@CPBANDJM@exec?5save?3?5allocation?5failed@
push 2
call DWORD PTR __imp____acrt_iob_func
add esp, 4
push eax
call _fprintf
add esp, 8
; 3172 : exec->status = -6;
mov DWORD PTR [esi], -6 ; fffffffaH
pop esi
; 3177 : exec->comp->nbCounters * sizeof(int));
; 3178 : }
; 3179 : }
; 3180 :
; 3181 : #ifdef DEBUG_REGEXP_EXEC
; 3182 : printf("restored ");
; 3183 : xmlFARegDebugExec(exec);
; 3184 : #endif
; 3185 : }
pop ebp
ret 0
$LN4@xmlFARegEx:
; 3173 : return;
; 3174 : }
; 3175 : if (exec->counts) {
mov ecx, DWORD PTR [esi+44]
test ecx, ecx
je SHORT $LN5@xmlFARegEx
; 3176 : memcpy(exec->counts, exec->rollbacks[exec->nbRollbacks].counts,
shl eax, 2
push eax
push edx
push ecx
call _memcpy
add esp, 12 ; 0000000cH
$LN5@xmlFARegEx:
pop esi
; 3177 : exec->comp->nbCounters * sizeof(int));
; 3178 : }
; 3179 : }
; 3180 :
; 3181 : #ifdef DEBUG_REGEXP_EXEC
; 3182 : printf("restored ");
; 3183 : xmlFARegDebugExec(exec);
; 3184 : #endif
; 3185 : }
pop ebp
ret 0
_xmlFARegExecRollBack ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFARegExecSave
_TEXT SEGMENT
_exec$ = 8 ; size = 4
_xmlFARegExecSave PROC ; COMDAT
; 3096 : xmlFARegExecSave(xmlRegExecCtxtPtr exec) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _exec$[ebp]
mov eax, DWORD PTR [esi+88]
cmp eax, 10000000 ; 00989680H
jg $LN1@xmlFARegEx
; 3097 : #ifdef DEBUG_REGEXP_EXEC
; 3098 : printf("saving ");
; 3099 : exec->transno++;
; 3100 : xmlFARegDebugExec(exec);
; 3101 : exec->transno--;
; 3102 : #endif
; 3103 : #ifdef MAX_PUSH
; 3104 : if (exec->nbPush > MAX_PUSH) {
; 3105 : return;
; 3106 : }
; 3107 : exec->nbPush++;
; 3108 : #endif
; 3109 :
; 3110 : if (exec->maxRollbacks == 0) {
push edi
mov edi, DWORD PTR [esi+32]
inc eax
mov DWORD PTR [esi+88], eax
test edi, edi
jne SHORT $LN3@xmlFARegEx
; 3111 : exec->maxRollbacks = 4;
; 3112 : exec->rollbacks = (xmlRegExecRollback *) xmlMalloc(exec->maxRollbacks *
push 64 ; 00000040H
mov DWORD PTR [esi+32], 4
call DWORD PTR _xmlMalloc
mov ecx, eax
add esp, 4
mov DWORD PTR [esi+40], ecx
; 3113 : sizeof(xmlRegExecRollback));
; 3114 : if (exec->rollbacks == NULL) {
test ecx, ecx
jne SHORT $LN5@xmlFARegEx
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
push OFFSET ??_C@_0O@PEGCJGLF@saving?5regexp@
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push eax
push eax
push eax
push eax
push OFFSET ??_C@_0O@PEGCJGLF@saving?5regexp@
push eax
push eax
push 3
push 2
push 14 ; 0000000eH
push eax
push eax
push eax
push eax
push eax
call ___xmlRaiseError
add esp, 68 ; 00000044H
; 3115 : xmlRegexpErrMemory(NULL, "saving regexp");
; 3116 : exec->maxRollbacks = 0;
mov DWORD PTR [esi+32], edi
pop edi
pop esi
; 3154 : }
pop ebp
ret 0
$LN5@xmlFARegEx:
; 3117 : return;
; 3118 : }
; 3119 : memset(exec->rollbacks, 0,
mov eax, DWORD PTR [esi+32]
shl eax, 4
push eax
push 0
push ecx
jmp SHORT $LN21@xmlFARegEx
$LN3@xmlFARegEx:
; 3120 : exec->maxRollbacks * sizeof(xmlRegExecRollback));
; 3121 : } else if (exec->nbRollbacks >= exec->maxRollbacks) {
cmp DWORD PTR [esi+36], edi
jl SHORT $LN6@xmlFARegEx
; 3122 : xmlRegExecRollback *tmp;
; 3123 : int len = exec->maxRollbacks;
; 3124 :
; 3125 : exec->maxRollbacks *= 2;
lea eax, DWORD PTR [edi+edi]
mov DWORD PTR [esi+32], eax
; 3126 : tmp = (xmlRegExecRollback *) xmlRealloc(exec->rollbacks,
shl eax, 4
push eax
push DWORD PTR [esi+40]
call DWORD PTR _xmlRealloc
mov ecx, eax
add esp, 8
; 3127 : exec->maxRollbacks * sizeof(xmlRegExecRollback));
; 3128 : if (tmp == NULL) {
test ecx, ecx
jne SHORT $LN7@xmlFARegEx
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
push OFFSET ??_C@_0O@PEGCJGLF@saving?5regexp@
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push eax
push eax
push eax
push eax
push OFFSET ??_C@_0O@PEGCJGLF@saving?5regexp@
push eax
push eax
push 3
push 2
push 14 ; 0000000eH
push eax
push eax
push eax
push eax
push eax
call ___xmlRaiseError
; 3129 : xmlRegexpErrMemory(NULL, "saving regexp");
; 3130 : exec->maxRollbacks /= 2;
mov eax, DWORD PTR [esi+32]
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
add esp, 68 ; 00000044H
; 3129 : xmlRegexpErrMemory(NULL, "saving regexp");
; 3130 : exec->maxRollbacks /= 2;
cdq
sub eax, edx
sar eax, 1
pop edi
mov DWORD PTR [esi+32], eax
pop esi
; 3154 : }
pop ebp
ret 0
$LN7@xmlFARegEx:
; 3131 : return;
; 3132 : }
; 3133 : exec->rollbacks = tmp;
; 3134 : tmp = &exec->rollbacks[len];
; 3135 : memset(tmp, 0, (exec->maxRollbacks - len) * sizeof(xmlRegExecRollback));
mov eax, DWORD PTR [esi+32]
sub eax, edi
mov DWORD PTR [esi+40], ecx
shl eax, 4
push eax
shl edi, 4
push 0
add edi, ecx
push edi
$LN21@xmlFARegEx:
; 3136 : }
; 3137 : exec->rollbacks[exec->nbRollbacks].state = exec->state;
call _memset
add esp, 12 ; 0000000cH
$LN6@xmlFARegEx:
mov edx, DWORD PTR [esi+36]
mov ecx, DWORD PTR [esi+40]
add edx, edx
mov eax, DWORD PTR [esi+20]
push ebx
mov DWORD PTR [ecx+edx*8], eax
; 3138 : exec->rollbacks[exec->nbRollbacks].index = exec->index;
mov edx, DWORD PTR [esi+36]
mov ecx, DWORD PTR [esi+40]
add edx, edx
mov eax, DWORD PTR [esi+56]
mov DWORD PTR [ecx+edx*8+4], eax
; 3139 : exec->rollbacks[exec->nbRollbacks].nextbranch = exec->transno + 1;
mov ecx, DWORD PTR [esi+36]
mov edx, DWORD PTR [esi+24]
add ecx, ecx
mov eax, DWORD PTR [esi+40]
inc edx
mov DWORD PTR [eax+ecx*8+8], edx
; 3140 : if (exec->comp->nbCounters > 0) {
mov edi, DWORD PTR [esi+8]
mov ebx, DWORD PTR [edi+20]
test ebx, ebx
jle SHORT $LN8@xmlFARegEx
; 3141 : if (exec->rollbacks[exec->nbRollbacks].counts == NULL) {
mov ecx, DWORD PTR [esi+36]
mov eax, ecx
mov edx, DWORD PTR [esi+40]
add eax, eax
cmp DWORD PTR [edx+eax*8+12], 0
jne SHORT $LN10@xmlFARegEx
; 3142 : exec->rollbacks[exec->nbRollbacks].counts = (int *)
lea eax, DWORD PTR [ebx*4]
push eax
call DWORD PTR _xmlMalloc
mov edx, DWORD PTR [esi+36]
add esp, 4
mov ecx, DWORD PTR [esi+40]
add edx, edx
mov DWORD PTR [ecx+edx*8+12], eax
; 3143 : xmlMalloc(exec->comp->nbCounters * sizeof(int));
; 3144 : if (exec->rollbacks[exec->nbRollbacks].counts == NULL) {
mov ecx, DWORD PTR [esi+36]
mov eax, ecx
mov edx, DWORD PTR [esi+40]
add eax, eax
cmp DWORD PTR [edx+eax*8+12], 0
jne SHORT $LN18@xmlFARegEx
; 3145 : xmlRegexpErrMemory(NULL, "saving regexp");
push OFFSET ??_C@_0O@PEGCJGLF@saving?5regexp@
push 0
call _xmlRegexpErrMemory
add esp, 8
; 3146 : exec->status = -5;
mov DWORD PTR [esi], -5 ; fffffffbH
pop ebx
pop edi
pop esi
; 3154 : }
pop ebp
ret 0
$LN18@xmlFARegEx:
mov edi, DWORD PTR [esi+8]
$LN10@xmlFARegEx:
; 3147 : return;
; 3148 : }
; 3149 : }
; 3150 : memcpy(exec->rollbacks[exec->nbRollbacks].counts, exec->counts,
mov eax, DWORD PTR [edi+20]
add ecx, ecx
shl eax, 2
push eax
push DWORD PTR [esi+44]
push DWORD PTR [edx+ecx*8+12]
call _memcpy
add esp, 12 ; 0000000cH
$LN8@xmlFARegEx:
; 3151 : exec->comp->nbCounters * sizeof(int));
; 3152 : }
; 3153 : exec->nbRollbacks++;
inc DWORD PTR [esi+36]
pop ebx
pop edi
$LN1@xmlFARegEx:
pop esi
; 3154 : }
pop ebp
ret 0
_xmlFARegExecSave ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFARecurseDeterminism
_TEXT SEGMENT
tv290 = -8 ; size = 4
_ret$1$ = -4 ; size = 4
_ctxt$ = 8 ; size = 4
_nbTrans$1$ = 12 ; size = 4
_state$ = 12 ; size = 4
_to$ = 16 ; size = 4
_atom$ = 20 ; size = 4
_xmlFARecurseDeterminism PROC ; COMDAT
; 2589 : int to, xmlRegAtomPtr atom) {
push ebp
mov ebp, esp
sub esp, 8
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR _state$[ebp]
mov ecx, 1
mov DWORD PTR _ret$1$[ebp], ecx
test edi, edi
je $LN18@xmlFARecur
; 2590 : int ret = 1;
; 2591 : int res;
; 2592 : int transnr, nbTrans;
; 2593 : xmlRegTransPtr t1;
; 2594 : int deep = 1;
; 2595 :
; 2596 : if (state == NULL)
; 2597 : return(ret);
; 2598 : if (state->markd == XML_REGEXP_MARK_VISITED)
cmp DWORD PTR [edi+8], 2
je $LN18@xmlFARecur
; 2602 : deep = 0;
; 2603 :
; 2604 : /*
; 2605 : * don't recurse on transitions potentially added in the course of
; 2606 : * the elimination.
; 2607 : */
; 2608 : nbTrans = state->nbTrans;
mov eax, DWORD PTR _ctxt$[ebp]
mov eax, DWORD PTR [eax+76]
not eax
and eax, ecx
mov DWORD PTR tv290[ebp], eax
mov eax, DWORD PTR [edi+24]
mov DWORD PTR _nbTrans$1$[ebp], eax
; 2609 : for (transnr = 0;transnr < nbTrans;transnr++) {
test eax, eax
jle $LN18@xmlFARecur
; 2599 : return(ret);
; 2600 :
; 2601 : if (ctxt->flags & AM_AUTOMATA_RNG)
push ebx
push esi
xor ebx, ebx
npad 3
$LL4@xmlFARecur:
; 2610 : t1 = &(state->trans[transnr]);
mov esi, DWORD PTR [edi+28]
add esi, ebx
; 2611 : /*
; 2612 : * check transitions conflicting with the one looked at
; 2613 : */
; 2614 : if (t1->atom == NULL) {
mov edx, DWORD PTR [esi]
mov eax, DWORD PTR [esi+4]
test edx, edx
jne SHORT $LN8@xmlFARecur
; 2615 : if (t1->to < 0)
test eax, eax
js SHORT $LN2@xmlFARecur
; 2616 : continue;
; 2617 : state->markd = XML_REGEXP_MARK_VISITED;
; 2618 : res = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
mov edx, DWORD PTR _ctxt$[ebp]
push DWORD PTR _atom$[ebp]
mov DWORD PTR [edi+8], 2
mov ecx, DWORD PTR [esi+4]
mov eax, DWORD PTR [edx+52]
push DWORD PTR _to$[ebp]
push DWORD PTR [eax+ecx*4]
push edx
call _xmlFARecurseDeterminism
add esp, 16 ; 00000010H
; 2619 : to, atom);
; 2620 : state->markd = 0;
mov DWORD PTR [edi+8], 0
; 2621 : if (res == 0) {
test eax, eax
jne SHORT $LN20@xmlFARecur
; 2622 : ret = 0;
xor ecx, ecx
mov DWORD PTR _ret$1$[ebp], ecx
; 2623 : /* t1->nd = 1; */
; 2624 : }
; 2625 : continue;
jmp SHORT $LN2@xmlFARecur
$LN8@xmlFARecur:
; 2626 : }
; 2627 : if (t1->to != to)
cmp eax, DWORD PTR _to$[ebp]
jne SHORT $LN2@xmlFARecur
; 2628 : continue;
; 2629 : if (xmlFACompareAtoms(t1->atom, atom, deep)) {
push DWORD PTR tv290[ebp]
push DWORD PTR _atom$[ebp]
push edx
call _xmlFACompareAtoms
add esp, 12 ; 0000000cH
test eax, eax
je SHORT $LN20@xmlFARecur
; 2630 : ret = 0;
xor ecx, ecx
; 2631 : /* mark the transition as non-deterministic */
; 2632 : t1->nd = 1;
mov DWORD PTR [esi+16], 1
mov DWORD PTR _ret$1$[ebp], ecx
jmp SHORT $LN2@xmlFARecur
$LN20@xmlFARecur:
; 2609 : for (transnr = 0;transnr < nbTrans;transnr++) {
mov ecx, DWORD PTR _ret$1$[ebp]
$LN2@xmlFARecur:
add ebx, 20 ; 00000014H
sub DWORD PTR _nbTrans$1$[ebp], 1
jne SHORT $LL4@xmlFARecur
pop esi
pop ebx
$LN18@xmlFARecur:
; 2633 : }
; 2634 : }
; 2635 : return(ret);
; 2636 : }
mov eax, ecx
pop edi
mov esp, ebp
pop ebp
ret 0
_xmlFARecurseDeterminism ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFACompareAtoms
_TEXT SEGMENT
_i$1$ = 8 ; size = 4
_atom1$ = 8 ; size = 4
_atom2$ = 12 ; size = 4
_deep$ = 16 ; size = 4
_xmlFACompareAtoms PROC ; COMDAT
; 2501 : xmlFACompareAtoms(xmlRegAtomPtr atom1, xmlRegAtomPtr atom2, int deep) {
push ebp
mov ebp, esp
push ebx
mov ebx, DWORD PTR _atom2$[ebp]
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push esi
mov esi, DWORD PTR _atom1$[ebp]
push edi
call @__CheckForDebuggerJustMyCode@4
mov edx, 1
cmp esi, ebx
je $LN14@xmlFACompa
; 2502 : int ret = 1;
; 2503 :
; 2504 : if (atom1 == atom2)
; 2505 : return(1);
; 2506 : if ((atom1 == NULL) || (atom2 == NULL))
test esi, esi
je $LN12@xmlFACompa
test ebx, ebx
je $LN12@xmlFACompa
; 2507 : return(0);
; 2508 :
; 2509 : if ((atom1->type == XML_REGEXP_ANYCHAR) ||
mov eax, DWORD PTR [esi+4]
cmp eax, 6
je $LN14@xmlFACompa
mov ecx, DWORD PTR [ebx+4]
cmp ecx, 6
je $LN14@xmlFACompa
; 2510 : (atom2->type == XML_REGEXP_ANYCHAR))
; 2511 : return(1);
; 2512 :
; 2513 : if (atom1->type > atom2->type) {
; 2514 : xmlRegAtomPtr tmp;
; 2515 : tmp = atom1;
; 2516 : atom1 = atom2;
; 2517 : atom2 = tmp;
; 2518 : }
; 2519 : if (atom1->type != atom2->type) {
cmp eax, ecx
mov edi, esi
cmovle edi, ebx
cmovle ebx, esi
mov eax, DWORD PTR [ebx+4]
mov ecx, DWORD PTR [edi+4]
cmp eax, ecx
je SHORT $LN44@xmlFACompa
; 2520 : ret = xmlFACompareAtomTypes(atom1->type, atom2->type);
push ecx
push eax
call _xmlFACompareAtomTypes
mov edx, eax
add esp, 8
; 2521 : /* if they can't intersect at the type level break now */
; 2522 : if (ret == 0)
test edx, edx
je $LN12@xmlFACompa
$LN44@xmlFACompa:
; 2523 : return(0);
; 2524 : }
; 2525 : switch (atom1->type) {
mov eax, DWORD PTR [ebx+4]
mov esi, 1
sub eax, 2
je $LN22@xmlFACompa
sub eax, esi
je SHORT $LN26@xmlFACompa
sub eax, 2
jne $not_determinist$48
; 2526 : case XML_REGEXP_STRING:
; 2527 : if (!deep)
cmp DWORD PTR _deep$[ebp], eax
jne SHORT $LN19@xmlFACompa
; 2528 : ret = (atom1->valuep != atom2->valuep);
mov eax, DWORD PTR [ebx+20]
xor edx, edx
cmp eax, DWORD PTR [edi+20]
setne dl
jmp $done$49
$LN19@xmlFACompa:
; 2529 : else
; 2530 : ret = xmlRegStrEqualWildcard((xmlChar *)atom1->valuep,
push DWORD PTR [edi+20]
push DWORD PTR [ebx+20]
call _xmlRegStrEqualWildcard
add esp, 8
mov edx, eax
; 2531 : (xmlChar *)atom2->valuep);
; 2532 : break;
jmp SHORT $done$49
$LN26@xmlFACompa:
; 2541 : ret = 1;
; 2542 : }
; 2543 : break;
; 2544 : case XML_REGEXP_RANGES:
; 2545 : if (atom2->type == XML_REGEXP_RANGES) {
cmp DWORD PTR [edi+4], 3
jne SHORT $done$49
; 2546 : int i, j, res;
; 2547 : xmlRegRangePtr r1, r2;
; 2548 :
; 2549 : /*
; 2550 : * need to check that none of the ranges eventually matches
; 2551 : */
; 2552 : for (i = 0;i < atom1->nbRanges;i++) {
xor ecx, ecx
mov DWORD PTR _i$1$[ebp], ecx
cmp DWORD PTR [ebx+52], ecx
jle SHORT $LN46@xmlFACompa
$LL6@xmlFACompa:
; 2553 : for (j = 0;j < atom2->nbRanges;j++) {
xor esi, esi
cmp DWORD PTR [edi+52], esi
jle SHORT $LN4@xmlFACompa
npad 1
$LL9@xmlFACompa:
; 2554 : r1 = atom1->ranges[i];
mov eax, DWORD PTR [ebx+56]
mov ecx, DWORD PTR [eax+ecx*4]
; 2555 : r2 = atom2->ranges[j];
mov eax, DWORD PTR [edi+56]
; 2556 : res = xmlFACompareRanges(r1, r2);
push DWORD PTR [eax+esi*4]
push ecx
call _xmlFACompareRanges
add esp, 8
; 2557 : if (res == 1) {
cmp eax, 1
je SHORT $LN35@xmlFACompa
; 2553 : for (j = 0;j < atom2->nbRanges;j++) {
mov ecx, DWORD PTR _i$1$[ebp]
inc esi
cmp esi, DWORD PTR [edi+52]
jl SHORT $LL9@xmlFACompa
$LN4@xmlFACompa:
; 2546 : int i, j, res;
; 2547 : xmlRegRangePtr r1, r2;
; 2548 :
; 2549 : /*
; 2550 : * need to check that none of the ranges eventually matches
; 2551 : */
; 2552 : for (i = 0;i < atom1->nbRanges;i++) {
inc ecx
mov DWORD PTR _i$1$[ebp], ecx
cmp ecx, DWORD PTR [ebx+52]
jl SHORT $LL6@xmlFACompa
$LN46@xmlFACompa:
; 2560 : }
; 2561 : }
; 2562 : }
; 2563 : ret = 0;
xor edx, edx
; 2564 : }
; 2565 : break;
jmp SHORT $done$49
$LN35@xmlFACompa:
; 2558 : ret = 1;
mov edx, 1
; 2559 : goto done;
jmp SHORT $done$49
$LN22@xmlFACompa:
; 2533 : case XML_REGEXP_EPSILON:
; 2534 : goto not_determinist;
; 2535 : case XML_REGEXP_CHARVAL:
; 2536 : if (atom2->type == XML_REGEXP_CHARVAL) {
cmp DWORD PTR [edi+4], 2
mov eax, DWORD PTR [ebx+32]
jne SHORT $LN23@xmlFACompa
; 2537 : ret = (atom1->codepoint == atom2->codepoint);
xor edx, edx
cmp eax, DWORD PTR [edi+32]
sete dl
; 2538 : } else {
jmp SHORT $done$49
$LN23@xmlFACompa:
; 2539 : ret = xmlRegCheckCharacter(atom2, atom1->codepoint);
push eax
push edi
call _xmlRegCheckCharacter
mov edx, eax
add esp, 8
; 2540 : if (ret < 0)
test edx, edx
cmovs edx, esi
$done$49:
; 2566 : default:
; 2567 : goto not_determinist;
; 2568 : }
; 2569 : done:
; 2570 : if (atom1->neg != atom2->neg) {
mov eax, DWORD PTR [ebx+28]
cmp eax, DWORD PTR [edi+28]
je SHORT $LN30@xmlFACompa
; 2571 : ret = !ret;
xor ecx, ecx
test edx, edx
sete cl
mov edx, ecx
$LN30@xmlFACompa:
; 2572 : }
; 2573 : if (ret == 0)
test edx, edx
je SHORT $LN12@xmlFACompa
mov esi, 1
$not_determinist$48:
pop edi
; 2574 : return(0);
; 2575 : not_determinist:
; 2576 : return(1);
mov eax, esi
; 2577 : }
pop esi
pop ebx
pop ebp
ret 0
$LN12@xmlFACompa:
pop edi
pop esi
xor eax, eax
pop ebx
pop ebp
ret 0
$LN14@xmlFACompa:
pop edi
pop esi
mov eax, edx
pop ebx
pop ebp
ret 0
_xmlFACompareAtoms ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAEqualAtoms
_TEXT SEGMENT
_atom1$ = 8 ; size = 4
_atom2$ = 12 ; size = 4
_deep$ = 16 ; size = 4
_xmlFAEqualAtoms PROC ; COMDAT
; 2456 : xmlFAEqualAtoms(xmlRegAtomPtr atom1, xmlRegAtomPtr atom2, int deep) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _atom1$[ebp]
xor ecx, ecx
mov edx, DWORD PTR _atom2$[ebp]
cmp eax, edx
jne SHORT $LN4@xmlFAEqual
; 2457 : int ret = 0;
; 2458 :
; 2459 : if (atom1 == atom2)
; 2460 : return(1);
mov eax, 1
; 2487 : }
pop ebp
ret 0
$LN4@xmlFAEqual:
push esi
; 2461 : if ((atom1 == NULL) || (atom2 == NULL))
test eax, eax
je SHORT $LN6@xmlFAEqual
test edx, edx
je SHORT $LN6@xmlFAEqual
; 2463 :
; 2464 : if (atom1->type != atom2->type)
mov esi, DWORD PTR [eax+4]
cmp esi, DWORD PTR [edx+4]
jne SHORT $LN6@xmlFAEqual
; 2465 : return(0);
; 2466 : switch (atom1->type) {
dec esi
cmp esi, 4
ja SHORT $LN14@xmlFAEqual
jmp DWORD PTR $LN18@xmlFAEqual[esi*4]
$LN9@xmlFAEqual:
; 2467 : case XML_REGEXP_EPSILON:
; 2468 : ret = 0;
; 2469 : break;
; 2470 : case XML_REGEXP_STRING:
; 2471 : if (!deep)
cmp DWORD PTR _deep$[ebp], ecx
jne SHORT $LN10@xmlFAEqual
; 2472 : ret = (atom1->valuep == atom2->valuep);
mov eax, DWORD PTR [eax+20]
xor ecx, ecx
cmp eax, DWORD PTR [edx+20]
pop esi
sete cl
; 2479 : break;
; 2480 : case XML_REGEXP_RANGES:
; 2481 : /* too hard to do in the general case */
; 2482 : ret = 0;
; 2483 : default:
; 2484 : break;
; 2485 : }
; 2486 : return(ret);
mov eax, ecx
; 2487 : }
pop ebp
ret 0
$LN10@xmlFAEqual:
; 2473 : else
; 2474 : ret = xmlStrEqual((xmlChar *)atom1->valuep,
push DWORD PTR [edx+20]
push DWORD PTR [eax+20]
call _xmlStrEqual
add esp, 8
mov ecx, eax
pop esi
; 2487 : }
pop ebp
ret 0
$LN12@xmlFAEqual:
; 2475 : (xmlChar *)atom2->valuep);
; 2476 : break;
; 2477 : case XML_REGEXP_CHARVAL:
; 2478 : ret = (atom1->codepoint == atom2->codepoint);
mov eax, DWORD PTR [eax+32]
xor ecx, ecx
cmp eax, DWORD PTR [edx+32]
pop esi
sete cl
; 2479 : break;
; 2480 : case XML_REGEXP_RANGES:
; 2481 : /* too hard to do in the general case */
; 2482 : ret = 0;
; 2483 : default:
; 2484 : break;
; 2485 : }
; 2486 : return(ret);
mov eax, ecx
; 2487 : }
pop ebp
ret 0
$LN13@xmlFAEqual:
; 2479 : break;
; 2480 : case XML_REGEXP_RANGES:
; 2481 : /* too hard to do in the general case */
; 2482 : ret = 0;
; 2483 : default:
; 2484 : break;
; 2485 : }
; 2486 : return(ret);
xor ecx, ecx
$LN14@xmlFAEqual:
mov eax, ecx
pop esi
; 2487 : }
pop ebp
ret 0
$LN6@xmlFAEqual:
; 2462 : return(0);
xor eax, eax
pop esi
; 2487 : }
pop ebp
ret 0
npad 2
$LN18@xmlFAEqual:
DD $LN13@xmlFAEqual
DD $LN12@xmlFAEqual
DD $LN13@xmlFAEqual
DD $LN14@xmlFAEqual
DD $LN9@xmlFAEqual
_xmlFAEqualAtoms ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFACompareAtomTypes
_TEXT SEGMENT
_type1$ = 8 ; size = 4
_type2$ = 12 ; size = 4
_xmlFACompareAtomTypes PROC ; COMDAT
; 2254 : xmlFACompareAtomTypes(xmlRegAtomType type1, xmlRegAtomType type2) {
push ebp
mov ebp, esp
push esi
mov esi, DWORD PTR _type2$[ebp]
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push edi
mov edi, DWORD PTR _type1$[ebp]
call @__CheckForDebuggerJustMyCode@4
cmp edi, 1
je $LN5@xmlFACompa
; 2255 : if ((type1 == XML_REGEXP_EPSILON) ||
; 2256 : (type1 == XML_REGEXP_CHARVAL) ||
; 2257 : (type1 == XML_REGEXP_RANGES) ||
; 2258 : (type1 == XML_REGEXP_SUBREG) ||
; 2259 : (type1 == XML_REGEXP_STRING) ||
cmp edi, 2
je $LN5@xmlFACompa
cmp edi, 3
je $LN5@xmlFACompa
cmp edi, 4
je $LN5@xmlFACompa
cmp edi, 5
je $LN5@xmlFACompa
cmp edi, 6
je $LN5@xmlFACompa
; 2262 : if ((type2 == XML_REGEXP_EPSILON) ||
; 2263 : (type2 == XML_REGEXP_CHARVAL) ||
; 2264 : (type2 == XML_REGEXP_RANGES) ||
; 2265 : (type2 == XML_REGEXP_SUBREG) ||
; 2266 : (type2 == XML_REGEXP_STRING) ||
cmp esi, 1
je $LN5@xmlFACompa
cmp esi, 2
je $LN5@xmlFACompa
cmp esi, 3
je $LN5@xmlFACompa
cmp esi, 4
je $LN5@xmlFACompa
cmp esi, 5
je $LN5@xmlFACompa
cmp esi, 6
je $LN5@xmlFACompa
; 2267 : (type2 == XML_REGEXP_ANYCHAR))
; 2268 : return(1);
; 2269 :
; 2270 : if (type1 == type2) return(1);
cmp edi, esi
je $LN5@xmlFACompa
; 2271 :
; 2272 : /* simplify subsequent compares by making sure type1 < type2 */
; 2273 : if (type1 > type2) {
; 2274 : xmlRegAtomType tmp = type1;
; 2275 : type1 = type2;
; 2276 : type2 = tmp;
; 2277 : }
; 2278 : switch (type1) {
mov ecx, edi
cmovle ecx, esi
cmovle esi, edi
add esi, -7 ; fffffff9H
cmp esi, 128 ; 00000080H
ja $LN5@xmlFACompa
movzx eax, BYTE PTR $LN75@xmlFACompa[esi]
jmp DWORD PTR $LN89@xmlFACompa[eax*4]
$LN10@xmlFACompa:
; 2279 : case XML_REGEXP_ANYSPACE: /* \s */
; 2280 : /* can't be a letter, number, mark, pontuation, symbol */
; 2281 : if ((type2 == XML_REGEXP_NOTSPACE) ||
; 2282 : ((type2 >= XML_REGEXP_LETTER) &&
; 2283 : (type2 <= XML_REGEXP_LETTER_OTHERS)) ||
; 2284 : ((type2 >= XML_REGEXP_NUMBER) &&
; 2285 : (type2 <= XML_REGEXP_NUMBER_OTHERS)) ||
; 2286 : ((type2 >= XML_REGEXP_MARK) &&
; 2287 : (type2 <= XML_REGEXP_MARK_ENCLOSING)) ||
; 2288 : ((type2 >= XML_REGEXP_PUNCT) &&
; 2289 : (type2 <= XML_REGEXP_PUNCT_OTHERS)) ||
cmp ecx, 8
je $LN72@xmlFACompa
cmp ecx, 100 ; 00000064H
jl SHORT $LN13@xmlFACompa
cmp ecx, 105 ; 00000069H
jle $LN72@xmlFACompa
$LN13@xmlFACompa:
cmp ecx, 110 ; 0000006eH
jl SHORT $LN14@xmlFACompa
cmp ecx, 113 ; 00000071H
jle $LN72@xmlFACompa
$LN14@xmlFACompa:
cmp ecx, 106 ; 0000006aH
jl SHORT $LN15@xmlFACompa
cmp ecx, 109 ; 0000006dH
jle $LN72@xmlFACompa
$LN15@xmlFACompa:
cmp ecx, 114 ; 00000072H
jl SHORT $LN16@xmlFACompa
cmp ecx, 121 ; 00000079H
jle $LN72@xmlFACompa
$LN16@xmlFACompa:
cmp ecx, 126 ; 0000007eH
jl $LN5@xmlFACompa
cmp ecx, 130 ; 00000082H
jle $LN72@xmlFACompa
; 2260 : (type1 == XML_REGEXP_ANYCHAR))
; 2261 : return(1);
pop edi
mov eax, 1
; 2438 : default:
; 2439 : break;
; 2440 : }
; 2441 : return(1);
; 2442 : }
pop esi
pop ebp
ret 0
$LN18@xmlFACompa:
; 2290 : ((type2 >= XML_REGEXP_SYMBOL) &&
; 2291 : (type2 <= XML_REGEXP_SYMBOL_OTHERS))
; 2292 : ) return(0);
; 2293 : break;
; 2294 : case XML_REGEXP_NOTSPACE: /* \S */
; 2295 : break;
; 2296 : case XML_REGEXP_INITNAME: /* \l */
; 2297 : /* can't be a number, mark, separator, pontuation, symbol or other */
; 2298 : if ((type2 == XML_REGEXP_NOTINITNAME) ||
; 2299 : ((type2 >= XML_REGEXP_NUMBER) &&
; 2300 : (type2 <= XML_REGEXP_NUMBER_OTHERS)) ||
; 2301 : ((type2 >= XML_REGEXP_MARK) &&
; 2302 : (type2 <= XML_REGEXP_MARK_ENCLOSING)) ||
; 2303 : ((type2 >= XML_REGEXP_SEPAR) &&
; 2304 : (type2 <= XML_REGEXP_SEPAR_PARA)) ||
; 2305 : ((type2 >= XML_REGEXP_PUNCT) &&
; 2306 : (type2 <= XML_REGEXP_PUNCT_OTHERS)) ||
; 2307 : ((type2 >= XML_REGEXP_SYMBOL) &&
; 2308 : (type2 <= XML_REGEXP_SYMBOL_OTHERS)) ||
cmp ecx, 10 ; 0000000aH
je $LN72@xmlFACompa
cmp ecx, 110 ; 0000006eH
jl SHORT $LN21@xmlFACompa
cmp ecx, 113 ; 00000071H
jle $LN72@xmlFACompa
$LN21@xmlFACompa:
cmp ecx, 106 ; 0000006aH
jl SHORT $LN22@xmlFACompa
cmp ecx, 109 ; 0000006dH
jle $LN72@xmlFACompa
$LN22@xmlFACompa:
cmp ecx, 122 ; 0000007aH
jl SHORT $LN23@xmlFACompa
cmp ecx, 125 ; 0000007dH
jle $LN72@xmlFACompa
$LN23@xmlFACompa:
cmp ecx, 114 ; 00000072H
jl SHORT $LN24@xmlFACompa
cmp ecx, 121 ; 00000079H
$LN81@xmlFACompa:
; 2260 : (type1 == XML_REGEXP_ANYCHAR))
; 2261 : return(1);
jle $LN72@xmlFACompa
$LN24@xmlFACompa:
cmp ecx, 126 ; 0000007eH
jl SHORT $LN25@xmlFACompa
cmp ecx, 130 ; 00000082H
jle $LN72@xmlFACompa
$LN25@xmlFACompa:
cmp ecx, 131 ; 00000083H
jl SHORT $LN5@xmlFACompa
cmp ecx, 135 ; 00000087H
jle SHORT $LN72@xmlFACompa
pop edi
mov eax, 1
; 2438 : default:
; 2439 : break;
; 2440 : }
; 2441 : return(1);
; 2442 : }
pop esi
pop ebp
ret 0
$LN27@xmlFACompa:
; 2309 : ((type2 >= XML_REGEXP_OTHER) &&
; 2310 : (type2 <= XML_REGEXP_OTHER_NA))
; 2311 : ) return(0);
; 2312 : break;
; 2313 : case XML_REGEXP_NOTINITNAME: /* \L */
; 2314 : break;
; 2315 : case XML_REGEXP_NAMECHAR: /* \c */
; 2316 : /* can't be a mark, separator, pontuation, symbol or other */
; 2317 : if ((type2 == XML_REGEXP_NOTNAMECHAR) ||
; 2318 : ((type2 >= XML_REGEXP_MARK) &&
; 2319 : (type2 <= XML_REGEXP_MARK_ENCLOSING)) ||
; 2320 : ((type2 >= XML_REGEXP_PUNCT) &&
; 2321 : (type2 <= XML_REGEXP_PUNCT_OTHERS)) ||
; 2322 : ((type2 >= XML_REGEXP_SEPAR) &&
; 2323 : (type2 <= XML_REGEXP_SEPAR_PARA)) ||
; 2324 : ((type2 >= XML_REGEXP_SYMBOL) &&
; 2325 : (type2 <= XML_REGEXP_SYMBOL_OTHERS)) ||
cmp ecx, 12 ; 0000000cH
$LN87@xmlFACompa:
; 2260 : (type1 == XML_REGEXP_ANYCHAR))
; 2261 : return(1);
je SHORT $LN72@xmlFACompa
$LN38@xmlFACompa:
cmp ecx, 106 ; 0000006aH
jl SHORT $LN30@xmlFACompa
cmp ecx, 109 ; 0000006dH
jle SHORT $LN72@xmlFACompa
$LN30@xmlFACompa:
cmp ecx, 114 ; 00000072H
jl SHORT $LN31@xmlFACompa
cmp ecx, 121 ; 00000079H
jle SHORT $LN72@xmlFACompa
$LN31@xmlFACompa:
cmp ecx, 122 ; 0000007aH
jl SHORT $LN24@xmlFACompa
cmp ecx, 125 ; 0000007dH
jmp SHORT $LN81@xmlFACompa
$LN35@xmlFACompa:
; 2326 : ((type2 >= XML_REGEXP_OTHER) &&
; 2327 : (type2 <= XML_REGEXP_OTHER_NA))
; 2328 : ) return(0);
; 2329 : break;
; 2330 : case XML_REGEXP_NOTNAMECHAR: /* \C */
; 2331 : break;
; 2332 : case XML_REGEXP_DECIMAL: /* \d */
; 2333 : /* can't be a letter, mark, separator, pontuation, symbol or other */
; 2334 : if ((type2 == XML_REGEXP_NOTDECIMAL) ||
; 2335 : (type2 == XML_REGEXP_REALCHAR) ||
; 2336 : ((type2 >= XML_REGEXP_LETTER) &&
; 2337 : (type2 <= XML_REGEXP_LETTER_OTHERS)) ||
; 2338 : ((type2 >= XML_REGEXP_MARK) &&
; 2339 : (type2 <= XML_REGEXP_MARK_ENCLOSING)) ||
; 2340 : ((type2 >= XML_REGEXP_PUNCT) &&
; 2341 : (type2 <= XML_REGEXP_PUNCT_OTHERS)) ||
; 2342 : ((type2 >= XML_REGEXP_SEPAR) &&
; 2343 : (type2 <= XML_REGEXP_SEPAR_PARA)) ||
; 2344 : ((type2 >= XML_REGEXP_SYMBOL) &&
; 2345 : (type2 <= XML_REGEXP_SYMBOL_OTHERS)) ||
cmp ecx, 14 ; 0000000eH
je SHORT $LN72@xmlFACompa
cmp ecx, 15 ; 0000000fH
je SHORT $LN72@xmlFACompa
cmp ecx, 100 ; 00000064H
jl SHORT $LN38@xmlFACompa
cmp ecx, 105 ; 00000069H
jle SHORT $LN72@xmlFACompa
; 2260 : (type1 == XML_REGEXP_ANYCHAR))
; 2261 : return(1);
jmp SHORT $LN38@xmlFACompa
$LN44@xmlFACompa:
; 2346 : ((type2 >= XML_REGEXP_OTHER) &&
; 2347 : (type2 <= XML_REGEXP_OTHER_NA))
; 2348 : )return(0);
; 2349 : break;
; 2350 : case XML_REGEXP_NOTDECIMAL: /* \D */
; 2351 : break;
; 2352 : case XML_REGEXP_REALCHAR: /* \w */
; 2353 : /* can't be a mark, separator, pontuation, symbol or other */
; 2354 : if ((type2 == XML_REGEXP_NOTDECIMAL) ||
; 2355 : ((type2 >= XML_REGEXP_MARK) &&
; 2356 : (type2 <= XML_REGEXP_MARK_ENCLOSING)) ||
; 2357 : ((type2 >= XML_REGEXP_PUNCT) &&
; 2358 : (type2 <= XML_REGEXP_PUNCT_OTHERS)) ||
; 2359 : ((type2 >= XML_REGEXP_SEPAR) &&
; 2360 : (type2 <= XML_REGEXP_SEPAR_PARA)) ||
; 2361 : ((type2 >= XML_REGEXP_SYMBOL) &&
; 2362 : (type2 <= XML_REGEXP_SYMBOL_OTHERS)) ||
cmp ecx, 14 ; 0000000eH
; 2363 : ((type2 >= XML_REGEXP_OTHER) &&
; 2364 : (type2 <= XML_REGEXP_OTHER_NA))
; 2365 : )return(0);
; 2366 : break;
jmp SHORT $LN87@xmlFACompa
$LN52@xmlFACompa:
; 2367 : case XML_REGEXP_NOTREALCHAR: /* \W */
; 2368 : break;
; 2369 : /*
; 2370 : * at that point we know both type 1 and type2 are from
; 2371 : * character categories are ordered and are different,
; 2372 : * it becomes simple because this is a partition
; 2373 : */
; 2374 : case XML_REGEXP_LETTER:
; 2375 : if (type2 <= XML_REGEXP_LETTER_OTHERS)
cmp ecx, 105 ; 00000069H
$LN77@xmlFACompa:
; 2260 : (type1 == XML_REGEXP_ANYCHAR))
; 2261 : return(1);
jg SHORT $LN72@xmlFACompa
$LN5@xmlFACompa:
pop edi
mov eax, 1
; 2438 : default:
; 2439 : break;
; 2440 : }
; 2441 : return(1);
; 2442 : }
pop esi
pop ebp
ret 0
$LN55@xmlFACompa:
; 2376 : return(1);
; 2377 : return(0);
; 2378 : case XML_REGEXP_LETTER_UPPERCASE:
; 2379 : case XML_REGEXP_LETTER_LOWERCASE:
; 2380 : case XML_REGEXP_LETTER_TITLECASE:
; 2381 : case XML_REGEXP_LETTER_MODIFIER:
; 2382 : case XML_REGEXP_LETTER_OTHERS:
; 2383 : return(0);
; 2384 : case XML_REGEXP_MARK:
; 2385 : if (type2 <= XML_REGEXP_MARK_ENCLOSING)
cmp ecx, 109 ; 0000006dH
jmp SHORT $LN77@xmlFACompa
$LN58@xmlFACompa:
; 2386 : return(1);
; 2387 : return(0);
; 2388 : case XML_REGEXP_MARK_NONSPACING:
; 2389 : case XML_REGEXP_MARK_SPACECOMBINING:
; 2390 : case XML_REGEXP_MARK_ENCLOSING:
; 2391 : return(0);
; 2392 : case XML_REGEXP_NUMBER:
; 2393 : if (type2 <= XML_REGEXP_NUMBER_OTHERS)
cmp ecx, 113 ; 00000071H
jmp SHORT $LN77@xmlFACompa
$LN61@xmlFACompa:
; 2394 : return(1);
; 2395 : return(0);
; 2396 : case XML_REGEXP_NUMBER_DECIMAL:
; 2397 : case XML_REGEXP_NUMBER_LETTER:
; 2398 : case XML_REGEXP_NUMBER_OTHERS:
; 2399 : return(0);
; 2400 : case XML_REGEXP_PUNCT:
; 2401 : if (type2 <= XML_REGEXP_PUNCT_OTHERS)
cmp ecx, 121 ; 00000079H
jmp SHORT $LN77@xmlFACompa
$LN64@xmlFACompa:
; 2402 : return(1);
; 2403 : return(0);
; 2404 : case XML_REGEXP_PUNCT_CONNECTOR:
; 2405 : case XML_REGEXP_PUNCT_DASH:
; 2406 : case XML_REGEXP_PUNCT_OPEN:
; 2407 : case XML_REGEXP_PUNCT_CLOSE:
; 2408 : case XML_REGEXP_PUNCT_INITQUOTE:
; 2409 : case XML_REGEXP_PUNCT_FINQUOTE:
; 2410 : case XML_REGEXP_PUNCT_OTHERS:
; 2411 : return(0);
; 2412 : case XML_REGEXP_SEPAR:
; 2413 : if (type2 <= XML_REGEXP_SEPAR_PARA)
cmp ecx, 125 ; 0000007dH
jmp SHORT $LN77@xmlFACompa
$LN67@xmlFACompa:
; 2414 : return(1);
; 2415 : return(0);
; 2416 : case XML_REGEXP_SEPAR_SPACE:
; 2417 : case XML_REGEXP_SEPAR_LINE:
; 2418 : case XML_REGEXP_SEPAR_PARA:
; 2419 : return(0);
; 2420 : case XML_REGEXP_SYMBOL:
; 2421 : if (type2 <= XML_REGEXP_SYMBOL_OTHERS)
cmp ecx, 130 ; 00000082H
jmp SHORT $LN77@xmlFACompa
$LN70@xmlFACompa:
; 2422 : return(1);
; 2423 : return(0);
; 2424 : case XML_REGEXP_SYMBOL_MATH:
; 2425 : case XML_REGEXP_SYMBOL_CURRENCY:
; 2426 : case XML_REGEXP_SYMBOL_MODIFIER:
; 2427 : case XML_REGEXP_SYMBOL_OTHERS:
; 2428 : return(0);
; 2429 : case XML_REGEXP_OTHER:
; 2430 : if (type2 <= XML_REGEXP_OTHER_NA)
cmp ecx, 135 ; 00000087H
jle SHORT $LN5@xmlFACompa
$LN72@xmlFACompa:
pop edi
; 2431 : return(1);
; 2432 : return(0);
; 2433 : case XML_REGEXP_OTHER_CONTROL:
; 2434 : case XML_REGEXP_OTHER_FORMAT:
; 2435 : case XML_REGEXP_OTHER_PRIVATE:
; 2436 : case XML_REGEXP_OTHER_NA:
; 2437 : return(0);
xor eax, eax
; 2438 : default:
; 2439 : break;
; 2440 : }
; 2441 : return(1);
; 2442 : }
pop esi
pop ebp
ret 0
npad 2
$LN89@xmlFACompa:
DD $LN10@xmlFACompa
DD $LN18@xmlFACompa
DD $LN27@xmlFACompa
DD $LN35@xmlFACompa
DD $LN44@xmlFACompa
DD $LN52@xmlFACompa
DD $LN72@xmlFACompa
DD $LN55@xmlFACompa
DD $LN58@xmlFACompa
DD $LN61@xmlFACompa
DD $LN64@xmlFACompa
DD $LN67@xmlFACompa
DD $LN70@xmlFACompa
DD $LN5@xmlFACompa
$LN75@xmlFACompa:
DB 0
DB 13 ; 0000000dH
DB 1
DB 13 ; 0000000dH
DB 2
DB 13 ; 0000000dH
DB 3
DB 13 ; 0000000dH
DB 4
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 13 ; 0000000dH
DB 5
DB 6
DB 6
DB 6
DB 6
DB 6
DB 7
DB 6
DB 6
DB 6
DB 8
DB 6
DB 6
DB 6
DB 9
DB 6
DB 6
DB 6
DB 6
DB 6
DB 6
DB 6
DB 10 ; 0000000aH
DB 6
DB 6
DB 6
DB 11 ; 0000000bH
DB 6
DB 6
DB 6
DB 6
DB 12 ; 0000000cH
DB 6
DB 6
DB 6
DB 6
_xmlFACompareAtomTypes ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFACompareRanges
_TEXT SEGMENT
_neg$1$ = 8 ; size = 4
_range1$ = 8 ; size = 4
_range2$ = 12 ; size = 4
_xmlFACompareRanges PROC ; COMDAT
; 2081 : xmlFACompareRanges(xmlRegRangePtr range1, xmlRegRangePtr range2) {
push ebp
mov ebp, esp
push ebx
mov ebx, DWORD PTR _range2$[ebp]
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push esi
mov esi, DWORD PTR _range1$[ebp]
push edi
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR [esi+4]
cmp eax, 3
je $LN8@xmlFACompa
; 2082 : int ret = 0;
; 2083 :
; 2084 : if ((range1->type == XML_REGEXP_RANGES) ||
; 2085 : (range2->type == XML_REGEXP_RANGES) ||
; 2086 : (range2->type == XML_REGEXP_SUBREG) ||
; 2087 : (range1->type == XML_REGEXP_SUBREG) ||
; 2088 : (range1->type == XML_REGEXP_STRING) ||
mov ecx, DWORD PTR [ebx+4]
cmp ecx, 3
je $LN8@xmlFACompa
cmp ecx, 4
je $LN8@xmlFACompa
cmp eax, 4
je $LN8@xmlFACompa
cmp eax, 5
je $LN8@xmlFACompa
cmp ecx, 5
je $LN8@xmlFACompa
; 2089 : (range2->type == XML_REGEXP_STRING))
; 2090 : return(-1);
; 2091 :
; 2092 : /* put them in order */
; 2093 : if (range1->type > range2->type) {
; 2094 : xmlRegRangePtr tmp;
; 2095 :
; 2096 : tmp = range1;
; 2097 : range1 = range2;
; 2098 : range2 = tmp;
; 2099 : }
; 2100 : if ((range1->type == XML_REGEXP_ANYCHAR) ||
cmp eax, ecx
mov edi, esi
cmovle edi, ebx
cmovle ebx, esi
mov eax, DWORD PTR [ebx+4]
cmp eax, 6
je $LN12@xmlFACompa
mov ecx, DWORD PTR [edi+4]
cmp ecx, 6
je $LN12@xmlFACompa
; 2101 : (range2->type == XML_REGEXP_ANYCHAR)) {
; 2102 : ret = 1;
; 2103 : } else if ((range1->type == XML_REGEXP_EPSILON) ||
cmp eax, 1
je $LN15@xmlFACompa
cmp ecx, 1
je $LN15@xmlFACompa
; 2104 : (range2->type == XML_REGEXP_EPSILON)) {
; 2105 : return(0);
; 2106 : } else if (range1->type == range2->type) {
cmp eax, ecx
jne SHORT $LN16@xmlFACompa
; 2107 : if (range1->type != XML_REGEXP_CHARVAL)
cmp eax, 2
jne $LN12@xmlFACompa
; 2108 : ret = 1;
; 2109 : else if ((range1->end < range2->start) ||
mov eax, DWORD PTR [ebx+12]
cmp eax, DWORD PTR [edi+8]
jl $LN49@xmlFACompa
mov eax, DWORD PTR [edi+12]
cmp eax, DWORD PTR [ebx+8]
jge $LN12@xmlFACompa
; 2110 : (range2->end < range1->start))
; 2111 : ret = 0;
xor edx, edx
; 2112 : else
; 2113 : ret = 1;
; 2114 : } else if (range1->type == XML_REGEXP_CHARVAL) {
jmp $LN73@xmlFACompa
$LN16@xmlFACompa:
cmp eax, 2
jne SHORT $LN23@xmlFACompa
; 2115 : int codepoint;
; 2116 : int neg = 0;
xor eax, eax
; 2117 :
; 2118 : /*
; 2119 : * just check all codepoints in the range for acceptance,
; 2120 : * this is usually way cheaper since done only once at
; 2121 : * compilation than testing over and over at runtime or
; 2122 : * pushing too many states when evaluating.
; 2123 : */
; 2124 : if (((range1->neg == 0) && (range2->neg != 0)) ||
cmp DWORD PTR [ebx], 0
mov DWORD PTR _neg$1$[ebp], eax
mov eax, DWORD PTR [edi]
jne SHORT $LN86@xmlFACompa
test eax, eax
jne SHORT $LN87@xmlFACompa
jmp SHORT $LN25@xmlFACompa
$LN86@xmlFACompa:
test eax, eax
jne SHORT $LN25@xmlFACompa
$LN87@xmlFACompa:
; 2125 : ((range1->neg != 0) && (range2->neg == 0)))
; 2126 : neg = 1;
mov DWORD PTR _neg$1$[ebp], 1
$LN25@xmlFACompa:
; 2127 :
; 2128 : for (codepoint = range1->start;codepoint <= range1->end ;codepoint++) {
mov esi, DWORD PTR [ebx+8]
cmp esi, DWORD PTR [ebx+12]
jg SHORT $LN15@xmlFACompa
npad 4
$LL4@xmlFACompa:
; 2129 : ret = xmlRegCheckCharacterRange(range2->type, codepoint,
push DWORD PTR [edi+16]
push DWORD PTR [edi+12]
push DWORD PTR [edi+8]
push 0
push esi
push DWORD PTR [edi+4]
call _xmlRegCheckCharacterRange
add esp, 24 ; 00000018H
; 2130 : 0, range2->start, range2->end,
; 2131 : range2->blockName);
; 2132 : if (ret < 0)
test eax, eax
js $LN8@xmlFACompa
; 2133 : return(-1);
; 2134 : if (((neg == 1) && (ret == 0)) ||
mov ecx, DWORD PTR _neg$1$[ebp]
cmp ecx, 1
jne SHORT $LN31@xmlFACompa
test eax, eax
jmp SHORT $LN89@xmlFACompa
$LN31@xmlFACompa:
test ecx, ecx
jne SHORT $LN2@xmlFACompa
cmp eax, 1
$LN89@xmlFACompa:
; 2127 :
; 2128 : for (codepoint = range1->start;codepoint <= range1->end ;codepoint++) {
je $LN34@xmlFACompa
$LN2@xmlFACompa:
inc esi
cmp esi, DWORD PTR [ebx+12]
jle SHORT $LL4@xmlFACompa
$LN15@xmlFACompa:
pop edi
; 2240 : return(ret);
; 2241 : }
pop esi
xor eax, eax
pop ebx
pop ebp
ret 0
$LN23@xmlFACompa:
; 2135 : ((neg == 0) && (ret == 1)))
; 2136 : return(1);
; 2137 : }
; 2138 : return(0);
; 2139 : } else if ((range1->type == XML_REGEXP_BLOCK_NAME) ||
cmp eax, 136 ; 00000088H
je $LN34@xmlFACompa
cmp ecx, 136 ; 00000088H
je $LN34@xmlFACompa
; 2140 : (range2->type == XML_REGEXP_BLOCK_NAME)) {
; 2141 : if (range1->type == range2->type) {
; 2142 : ret = xmlStrEqual(range1->blockName, range2->blockName);
; 2143 : } else {
; 2144 : /*
; 2145 : * comparing a block range with anything else is way
; 2146 : * too costly, and maintining the table is like too much
; 2147 : * memory too, so let's force the automata to save state
; 2148 : * here.
; 2149 : */
; 2150 : return(1);
; 2151 : }
; 2152 : } else if ((range1->type < XML_REGEXP_LETTER) ||
cmp eax, 100 ; 00000064H
jl $LN39@xmlFACompa
cmp ecx, 100 ; 00000064H
jl $LN39@xmlFACompa
; 2174 : ret = 0;
; 2175 : /* range1->type < range2->type here */
; 2176 : switch (range1->type) {
add eax, -100 ; ffffff9cH
xor edx, edx
cmp eax, 31 ; 0000001fH
ja $LN71@xmlFACompa
movzx eax, BYTE PTR $LN88@xmlFACompa[eax]
jmp DWORD PTR $LN92@xmlFACompa[eax*4]
$LN50@xmlFACompa:
; 2177 : case XML_REGEXP_LETTER:
; 2178 : /* all disjoint except in the subgroups */
; 2179 : if ((range2->type == XML_REGEXP_LETTER_UPPERCASE) ||
; 2180 : (range2->type == XML_REGEXP_LETTER_LOWERCASE) ||
; 2181 : (range2->type == XML_REGEXP_LETTER_TITLECASE) ||
; 2182 : (range2->type == XML_REGEXP_LETTER_MODIFIER) ||
cmp ecx, 101 ; 00000065H
je SHORT $LN12@xmlFACompa
cmp ecx, 102 ; 00000066H
je SHORT $LN12@xmlFACompa
cmp ecx, 103 ; 00000067H
je SHORT $LN12@xmlFACompa
cmp ecx, 104 ; 00000068H
je SHORT $LN12@xmlFACompa
cmp ecx, 105 ; 00000069H
$LN90@xmlFACompa:
; 2231 : else {
; 2232 : /* safety net ! */
; 2233 : return(1);
; 2234 : }
; 2235 : }
; 2236 : }
; 2237 : if (((range1->neg == 0) && (range2->neg != 0)) ||
jne SHORT $LN73@xmlFACompa
$LN12@xmlFACompa:
mov edx, 1
$LN73@xmlFACompa:
cmp DWORD PTR [ebx], 0
mov eax, DWORD PTR [edi]
jne $LN85@xmlFACompa
test eax, eax
jne $LN75@xmlFACompa
; 2240 : return(ret);
; 2241 : }
pop edi
pop esi
mov eax, edx
pop ebx
pop ebp
ret 0
$LN53@xmlFACompa:
; 2183 : (range2->type == XML_REGEXP_LETTER_OTHERS))
; 2184 : ret = 1;
; 2185 : break;
; 2186 : case XML_REGEXP_MARK:
; 2187 : if ((range2->type == XML_REGEXP_MARK_NONSPACING) ||
; 2188 : (range2->type == XML_REGEXP_MARK_SPACECOMBINING) ||
cmp ecx, 107 ; 0000006bH
je SHORT $LN12@xmlFACompa
cmp ecx, 108 ; 0000006cH
je SHORT $LN12@xmlFACompa
cmp ecx, 109 ; 0000006dH
; 2189 : (range2->type == XML_REGEXP_MARK_ENCLOSING))
; 2190 : ret = 1;
; 2191 : break;
jmp SHORT $LN90@xmlFACompa
$LN56@xmlFACompa:
; 2192 : case XML_REGEXP_NUMBER:
; 2193 : if ((range2->type == XML_REGEXP_NUMBER_DECIMAL) ||
; 2194 : (range2->type == XML_REGEXP_NUMBER_LETTER) ||
cmp ecx, 111 ; 0000006fH
je SHORT $LN12@xmlFACompa
cmp ecx, 112 ; 00000070H
je SHORT $LN12@xmlFACompa
cmp ecx, 113 ; 00000071H
; 2195 : (range2->type == XML_REGEXP_NUMBER_OTHERS))
; 2196 : ret = 1;
; 2197 : break;
jmp SHORT $LN90@xmlFACompa
$LN59@xmlFACompa:
; 2198 : case XML_REGEXP_PUNCT:
; 2199 : if ((range2->type == XML_REGEXP_PUNCT_CONNECTOR) ||
; 2200 : (range2->type == XML_REGEXP_PUNCT_DASH) ||
; 2201 : (range2->type == XML_REGEXP_PUNCT_OPEN) ||
; 2202 : (range2->type == XML_REGEXP_PUNCT_CLOSE) ||
; 2203 : (range2->type == XML_REGEXP_PUNCT_INITQUOTE) ||
; 2204 : (range2->type == XML_REGEXP_PUNCT_FINQUOTE) ||
cmp ecx, 115 ; 00000073H
je SHORT $LN12@xmlFACompa
cmp ecx, 116 ; 00000074H
je SHORT $LN12@xmlFACompa
cmp ecx, 117 ; 00000075H
je SHORT $LN12@xmlFACompa
cmp ecx, 118 ; 00000076H
je SHORT $LN12@xmlFACompa
cmp ecx, 119 ; 00000077H
je SHORT $LN12@xmlFACompa
cmp ecx, 120 ; 00000078H
je SHORT $LN12@xmlFACompa
cmp ecx, 121 ; 00000079H
; 2205 : (range2->type == XML_REGEXP_PUNCT_OTHERS))
; 2206 : ret = 1;
; 2207 : break;
jmp SHORT $LN90@xmlFACompa
$LN62@xmlFACompa:
; 2208 : case XML_REGEXP_SEPAR:
; 2209 : if ((range2->type == XML_REGEXP_SEPAR_SPACE) ||
; 2210 : (range2->type == XML_REGEXP_SEPAR_LINE) ||
cmp ecx, 123 ; 0000007bH
je SHORT $LN12@xmlFACompa
cmp ecx, 124 ; 0000007cH
je SHORT $LN12@xmlFACompa
cmp ecx, 125 ; 0000007dH
; 2211 : (range2->type == XML_REGEXP_SEPAR_PARA))
; 2212 : ret = 1;
; 2213 : break;
jmp SHORT $LN90@xmlFACompa
$LN65@xmlFACompa:
; 2214 : case XML_REGEXP_SYMBOL:
; 2215 : if ((range2->type == XML_REGEXP_SYMBOL_MATH) ||
; 2216 : (range2->type == XML_REGEXP_SYMBOL_CURRENCY) ||
; 2217 : (range2->type == XML_REGEXP_SYMBOL_MODIFIER) ||
cmp ecx, 127 ; 0000007fH
je SHORT $LN12@xmlFACompa
cmp ecx, 128 ; 00000080H
je SHORT $LN12@xmlFACompa
cmp ecx, 129 ; 00000081H
je $LN12@xmlFACompa
cmp ecx, 130 ; 00000082H
; 2218 : (range2->type == XML_REGEXP_SYMBOL_OTHERS))
; 2219 : ret = 1;
; 2220 : break;
jmp $LN90@xmlFACompa
$LN68@xmlFACompa:
; 2221 : case XML_REGEXP_OTHER:
; 2222 : if ((range2->type == XML_REGEXP_OTHER_CONTROL) ||
; 2223 : (range2->type == XML_REGEXP_OTHER_FORMAT) ||
cmp ecx, 132 ; 00000084H
je $LN12@xmlFACompa
cmp ecx, 133 ; 00000085H
je $LN12@xmlFACompa
cmp ecx, 134 ; 00000086H
; 2224 : (range2->type == XML_REGEXP_OTHER_PRIVATE))
; 2225 : ret = 1;
; 2226 : break;
jmp $LN90@xmlFACompa
$LN71@xmlFACompa:
; 2227 : default:
; 2228 : if ((range2->type >= XML_REGEXP_LETTER) &&
cmp ecx, 136 ; 00000088H
jge SHORT $LN34@xmlFACompa
; 2229 : (range2->type < XML_REGEXP_BLOCK_NAME))
; 2230 : ret = 0;
xor edx, edx
jmp $LN73@xmlFACompa
$LN39@xmlFACompa:
; 2153 : (range2->type < XML_REGEXP_LETTER)) {
; 2154 : if ((range1->type == XML_REGEXP_ANYSPACE) &&
cmp eax, 7
jne SHORT $LN40@xmlFACompa
cmp ecx, 8
je SHORT $LN49@xmlFACompa
$LN40@xmlFACompa:
; 2155 : (range2->type == XML_REGEXP_NOTSPACE))
; 2156 : ret = 0;
; 2157 : else if ((range1->type == XML_REGEXP_INITNAME) &&
cmp eax, 9
jne SHORT $LN42@xmlFACompa
cmp ecx, 10 ; 0000000aH
je SHORT $LN49@xmlFACompa
$LN42@xmlFACompa:
; 2158 : (range2->type == XML_REGEXP_NOTINITNAME))
; 2159 : ret = 0;
; 2160 : else if ((range1->type == XML_REGEXP_NAMECHAR) &&
cmp eax, 11 ; 0000000bH
jne SHORT $LN44@xmlFACompa
cmp ecx, 12 ; 0000000cH
je SHORT $LN49@xmlFACompa
$LN44@xmlFACompa:
; 2161 : (range2->type == XML_REGEXP_NOTNAMECHAR))
; 2162 : ret = 0;
; 2163 : else if ((range1->type == XML_REGEXP_DECIMAL) &&
cmp eax, 13 ; 0000000dH
jne SHORT $LN46@xmlFACompa
cmp ecx, 14 ; 0000000eH
je SHORT $LN49@xmlFACompa
$LN46@xmlFACompa:
; 2164 : (range2->type == XML_REGEXP_NOTDECIMAL))
; 2165 : ret = 0;
; 2166 : else if ((range1->type == XML_REGEXP_REALCHAR) &&
cmp eax, 15 ; 0000000fH
jne SHORT $LN34@xmlFACompa
cmp ecx, 16 ; 00000010H
jne SHORT $LN34@xmlFACompa
$LN49@xmlFACompa:
; 2167 : (range2->type == XML_REGEXP_NOTREALCHAR))
; 2168 : ret = 0;
; 2169 : else {
; 2170 : /* same thing to limit complexity */
; 2171 : return(1);
; 2172 : }
; 2173 : } else {
xor edx, edx
jmp $LN73@xmlFACompa
$LN34@xmlFACompa:
pop edi
; 2240 : return(ret);
; 2241 : }
pop esi
mov eax, 1
pop ebx
pop ebp
ret 0
$LN85@xmlFACompa:
; 2231 : else {
; 2232 : /* safety net ! */
; 2233 : return(1);
; 2234 : }
; 2235 : }
; 2236 : }
; 2237 : if (((range1->neg == 0) && (range2->neg != 0)) ||
test eax, eax
jne SHORT $LN74@xmlFACompa
$LN75@xmlFACompa:
; 2238 : ((range1->neg != 0) && (range2->neg == 0)))
; 2239 : ret = !ret;
xor eax, eax
test edx, edx
sete al
mov edx, eax
$LN74@xmlFACompa:
; 2240 : return(ret);
; 2241 : }
pop edi
pop esi
mov eax, edx
pop ebx
pop ebp
ret 0
$LN8@xmlFACompa:
pop edi
pop esi
or eax, -1
pop ebx
pop ebp
ret 0
npad 1
$LN92@xmlFACompa:
DD $LN50@xmlFACompa
DD $LN53@xmlFACompa
DD $LN56@xmlFACompa
DD $LN59@xmlFACompa
DD $LN62@xmlFACompa
DD $LN65@xmlFACompa
DD $LN68@xmlFACompa
DD $LN71@xmlFACompa
$LN88@xmlFACompa:
DB 0
DB 7
DB 7
DB 7
DB 7
DB 7
DB 1
DB 7
DB 7
DB 7
DB 2
DB 7
DB 7
DB 7
DB 3
DB 7
DB 7
DB 7
DB 7
DB 7
DB 7
DB 7
DB 4
DB 7
DB 7
DB 7
DB 5
DB 7
DB 7
DB 7
DB 7
DB 6
_xmlFACompareRanges ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAEliminateEpsilonTransitions
_TEXT SEGMENT
_state$1$ = -16 ; size = 4
_newto$1$ = -12 ; size = 4
_has_epsilon$1$ = -12 ; size = 4
_i$1$ = -8 ; size = 4
_statenr$1$ = -4 ; size = 4
_target$1$ = -4 ; size = 4
_statenr$2$ = -4 ; size = 4
_ctxt$ = 8 ; size = 4
_xmlFAEliminateEpsilonTransitions PROC ; COMDAT
; 1929 : xmlFAEliminateEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
sub esp, 16 ; 00000010H
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov edx, DWORD PTR _ctxt$[ebp]
cmp DWORD PTR [edx+52], 0
je $LN29@xmlFAElimi
; 1869 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
mov eax, DWORD PTR [edx+48]
push ebx
xor ebx, ebx
mov DWORD PTR _statenr$1$[ebp], ebx
push esi
push edi
test eax, eax
jle $LN54@xmlFAElimi
$LL55@xmlFAElimi:
; 1870 : state = ctxt->states[statenr];
mov eax, DWORD PTR [edx+52]
mov ecx, DWORD PTR [eax+ebx*4]
mov DWORD PTR _state$1$[ebp], ecx
; 1871 : if (state == NULL)
test ecx, ecx
je $LN53@xmlFAElimi
; 1872 : continue;
; 1873 : if (state->nbTrans != 1)
cmp DWORD PTR [ecx+24], 1
jne $LN53@xmlFAElimi
; 1874 : continue;
; 1875 : if (state->type == XML_REGEXP_UNREACH_STATE)
mov edi, DWORD PTR [ecx]
cmp edi, 5
je $LN53@xmlFAElimi
; 1876 : continue;
; 1877 : /* is the only transition out a basic transition */
; 1878 : if ((state->trans[0].atom == NULL) &&
; 1879 : (state->trans[0].to >= 0) &&
; 1880 : (state->trans[0].to != statenr) &&
; 1881 : (state->trans[0].counter < 0) &&
mov eax, DWORD PTR [ecx+28]
cmp DWORD PTR [eax], 0
jne $LN53@xmlFAElimi
mov esi, DWORD PTR [eax+4]
mov DWORD PTR _newto$1$[ebp], esi
test esi, esi
js $LN53@xmlFAElimi
cmp esi, ebx
je $LN53@xmlFAElimi
cmp DWORD PTR [eax+8], 0
jge $LN53@xmlFAElimi
cmp DWORD PTR [eax+12], 0
jge $LN53@xmlFAElimi
; 1882 : (state->trans[0].count < 0)) {
; 1883 : newto = state->trans[0].to;
; 1884 :
; 1885 : if (state->type == XML_REGEXP_START_STATE) {
cmp edi, 1
je $LN53@xmlFAElimi
; 1886 : #ifdef DEBUG_REGEXP_GRAPH
; 1887 : printf("Found simple epsilon trans from start %d to %d\n",
; 1888 : statenr, newto);
; 1889 : #endif
; 1890 : } else {
; 1891 : #ifdef DEBUG_REGEXP_GRAPH
; 1892 : printf("Found simple epsilon trans from %d to %d\n",
; 1893 : statenr, newto);
; 1894 : #endif
; 1895 : for (i = 0;i < state->nbTransTo;i++) {
xor esi, esi
mov DWORD PTR _i$1$[ebp], esi
cmp DWORD PTR [ecx+36], esi
jle $LN57@xmlFAElimi
$LL58@xmlFAElimi:
; 1896 : tmp = ctxt->states[state->transTo[i]];
mov eax, DWORD PTR [ecx+40]
; 1897 : for (j = 0;j < tmp->nbTrans;j++) {
xor ebx, ebx
mov ecx, DWORD PTR [eax+esi*4]
mov eax, DWORD PTR [edx+52]
mov edi, DWORD PTR [eax+ecx*4]
cmp DWORD PTR [edi+24], ebx
jle SHORT $LN56@xmlFAElimi
mov ecx, DWORD PTR _statenr$1$[ebp]
; 1896 : tmp = ctxt->states[state->transTo[i]];
xor esi, esi
npad 5
$LL61@xmlFAElimi:
; 1898 : if (tmp->trans[j].to == statenr) {
mov eax, DWORD PTR [edi+28]
cmp DWORD PTR [esi+eax+4], ecx
jne SHORT $LN59@xmlFAElimi
; 1899 : #ifdef DEBUG_REGEXP_GRAPH
; 1900 : printf("Changed transition %d on %d to go to %d\n",
; 1901 : j, tmp->no, newto);
; 1902 : #endif
; 1903 : tmp->trans[j].to = -1;
mov DWORD PTR [esi+eax+4], -1
; 1904 : xmlRegStateAddTrans(ctxt, tmp, tmp->trans[j].atom,
mov ecx, DWORD PTR [edi+28]
mov eax, DWORD PTR [edx+52]
mov edx, DWORD PTR _newto$1$[ebp]
push DWORD PTR [ecx+esi+12]
push DWORD PTR [ecx+esi+8]
push DWORD PTR [eax+edx*4]
mov edx, DWORD PTR _ctxt$[ebp]
push DWORD PTR [ecx+esi]
push edi
push edx
call _xmlRegStateAddTrans
mov edx, DWORD PTR _ctxt$[ebp]
add esp, 24 ; 00000018H
mov ecx, DWORD PTR _statenr$1$[ebp]
$LN59@xmlFAElimi:
; 1897 : for (j = 0;j < tmp->nbTrans;j++) {
inc ebx
add esi, 20 ; 00000014H
cmp ebx, DWORD PTR [edi+24]
jl SHORT $LL61@xmlFAElimi
mov esi, DWORD PTR _i$1$[ebp]
$LN56@xmlFAElimi:
; 1886 : #ifdef DEBUG_REGEXP_GRAPH
; 1887 : printf("Found simple epsilon trans from start %d to %d\n",
; 1888 : statenr, newto);
; 1889 : #endif
; 1890 : } else {
; 1891 : #ifdef DEBUG_REGEXP_GRAPH
; 1892 : printf("Found simple epsilon trans from %d to %d\n",
; 1893 : statenr, newto);
; 1894 : #endif
; 1895 : for (i = 0;i < state->nbTransTo;i++) {
mov ecx, DWORD PTR _state$1$[ebp]
inc esi
mov DWORD PTR _i$1$[ebp], esi
cmp esi, DWORD PTR [ecx+36]
jl SHORT $LL58@xmlFAElimi
mov edi, DWORD PTR [ecx]
mov ebx, DWORD PTR _statenr$1$[ebp]
$LN57@xmlFAElimi:
; 1905 : ctxt->states[newto],
; 1906 : tmp->trans[j].counter,
; 1907 : tmp->trans[j].count);
; 1908 : }
; 1909 : }
; 1910 : }
; 1911 : if (state->type == XML_REGEXP_FINAL_STATE)
cmp edi, 2
jne SHORT $LN69@xmlFAElimi
; 1912 : ctxt->states[newto]->type = XML_REGEXP_FINAL_STATE;
mov eax, DWORD PTR [edx+52]
mov esi, DWORD PTR _newto$1$[ebp]
mov eax, DWORD PTR [eax+esi*4]
mov DWORD PTR [eax], edi
$LN69@xmlFAElimi:
; 1913 : /* eliminate the transition completely */
; 1914 : state->nbTrans = 0;
mov DWORD PTR [ecx+24], 0
; 1915 :
; 1916 : state->type = XML_REGEXP_UNREACH_STATE;
mov DWORD PTR [ecx], 5
$LN53@xmlFAElimi:
; 906 : }
; 907 :
; 908 : /**
; 909 : * xmlRegFreeParserCtxt:
; 910 : * @ctxt: the regexp parser context
; 911 : *
; 912 : * Free a regexp parser context
; 913 : */
; 914 : static void
; 915 : xmlRegFreeParserCtxt(xmlRegParserCtxtPtr ctxt) {
; 916 : int i;
; 917 : if (ctxt == NULL)
; 918 : return;
; 919 :
; 920 : if (ctxt->string != NULL)
; 921 : xmlFree(ctxt->string);
; 922 : if (ctxt->states != NULL) {
; 923 : for (i = 0;i < ctxt->nbStates;i++)
; 924 : xmlRegFreeState(ctxt->states[i]);
; 925 : xmlFree(ctxt->states);
; 926 : }
; 927 : if (ctxt->atoms != NULL) {
; 928 : for (i = 0;i < ctxt->nbAtoms;i++)
; 929 : xmlRegFreeAtom(ctxt->atoms[i]);
; 930 : xmlFree(ctxt->atoms);
; 931 : }
; 932 : if (ctxt->counters != NULL)
; 933 : xmlFree(ctxt->counters);
; 934 : xmlFree(ctxt);
; 935 : }
; 936 :
; 937 : /************************************************************************
; 938 : * *
; 939 : * Display of Data structures *
; 940 : * *
; 941 : ************************************************************************/
; 942 :
; 943 : static void
; 944 : xmlRegPrintAtomType(FILE *output, xmlRegAtomType type) {
; 945 : switch (type) {
; 946 : case XML_REGEXP_EPSILON:
; 947 : fprintf(output, "epsilon "); break;
; 948 : case XML_REGEXP_CHARVAL:
; 949 : fprintf(output, "charval "); break;
; 950 : case XML_REGEXP_RANGES:
; 951 : fprintf(output, "ranges "); break;
; 952 : case XML_REGEXP_SUBREG:
; 953 : fprintf(output, "subexpr "); break;
; 954 : case XML_REGEXP_STRING:
; 955 : fprintf(output, "string "); break;
; 956 : case XML_REGEXP_ANYCHAR:
; 957 : fprintf(output, "anychar "); break;
; 958 : case XML_REGEXP_ANYSPACE:
; 959 : fprintf(output, "anyspace "); break;
; 960 : case XML_REGEXP_NOTSPACE:
; 961 : fprintf(output, "notspace "); break;
; 962 : case XML_REGEXP_INITNAME:
; 963 : fprintf(output, "initname "); break;
; 964 : case XML_REGEXP_NOTINITNAME:
; 965 : fprintf(output, "notinitname "); break;
; 966 : case XML_REGEXP_NAMECHAR:
; 967 : fprintf(output, "namechar "); break;
; 968 : case XML_REGEXP_NOTNAMECHAR:
; 969 : fprintf(output, "notnamechar "); break;
; 970 : case XML_REGEXP_DECIMAL:
; 971 : fprintf(output, "decimal "); break;
; 972 : case XML_REGEXP_NOTDECIMAL:
; 973 : fprintf(output, "notdecimal "); break;
; 974 : case XML_REGEXP_REALCHAR:
; 975 : fprintf(output, "realchar "); break;
; 976 : case XML_REGEXP_NOTREALCHAR:
; 977 : fprintf(output, "notrealchar "); break;
; 978 : case XML_REGEXP_LETTER:
; 979 : fprintf(output, "LETTER "); break;
; 980 : case XML_REGEXP_LETTER_UPPERCASE:
; 981 : fprintf(output, "LETTER_UPPERCASE "); break;
; 982 : case XML_REGEXP_LETTER_LOWERCASE:
; 983 : fprintf(output, "LETTER_LOWERCASE "); break;
; 984 : case XML_REGEXP_LETTER_TITLECASE:
; 985 : fprintf(output, "LETTER_TITLECASE "); break;
; 986 : case XML_REGEXP_LETTER_MODIFIER:
; 987 : fprintf(output, "LETTER_MODIFIER "); break;
; 988 : case XML_REGEXP_LETTER_OTHERS:
; 989 : fprintf(output, "LETTER_OTHERS "); break;
; 990 : case XML_REGEXP_MARK:
; 991 : fprintf(output, "MARK "); break;
; 992 : case XML_REGEXP_MARK_NONSPACING:
; 993 : fprintf(output, "MARK_NONSPACING "); break;
; 994 : case XML_REGEXP_MARK_SPACECOMBINING:
; 995 : fprintf(output, "MARK_SPACECOMBINING "); break;
; 996 : case XML_REGEXP_MARK_ENCLOSING:
; 997 : fprintf(output, "MARK_ENCLOSING "); break;
; 998 : case XML_REGEXP_NUMBER:
; 999 : fprintf(output, "NUMBER "); break;
; 1000 : case XML_REGEXP_NUMBER_DECIMAL:
; 1001 : fprintf(output, "NUMBER_DECIMAL "); break;
; 1002 : case XML_REGEXP_NUMBER_LETTER:
; 1003 : fprintf(output, "NUMBER_LETTER "); break;
; 1004 : case XML_REGEXP_NUMBER_OTHERS:
; 1005 : fprintf(output, "NUMBER_OTHERS "); break;
; 1006 : case XML_REGEXP_PUNCT:
; 1007 : fprintf(output, "PUNCT "); break;
; 1008 : case XML_REGEXP_PUNCT_CONNECTOR:
; 1009 : fprintf(output, "PUNCT_CONNECTOR "); break;
; 1010 : case XML_REGEXP_PUNCT_DASH:
; 1011 : fprintf(output, "PUNCT_DASH "); break;
; 1012 : case XML_REGEXP_PUNCT_OPEN:
; 1013 : fprintf(output, "PUNCT_OPEN "); break;
; 1014 : case XML_REGEXP_PUNCT_CLOSE:
; 1015 : fprintf(output, "PUNCT_CLOSE "); break;
; 1016 : case XML_REGEXP_PUNCT_INITQUOTE:
; 1017 : fprintf(output, "PUNCT_INITQUOTE "); break;
; 1018 : case XML_REGEXP_PUNCT_FINQUOTE:
; 1019 : fprintf(output, "PUNCT_FINQUOTE "); break;
; 1020 : case XML_REGEXP_PUNCT_OTHERS:
; 1021 : fprintf(output, "PUNCT_OTHERS "); break;
; 1022 : case XML_REGEXP_SEPAR:
; 1023 : fprintf(output, "SEPAR "); break;
; 1024 : case XML_REGEXP_SEPAR_SPACE:
; 1025 : fprintf(output, "SEPAR_SPACE "); break;
; 1026 : case XML_REGEXP_SEPAR_LINE:
; 1027 : fprintf(output, "SEPAR_LINE "); break;
; 1028 : case XML_REGEXP_SEPAR_PARA:
; 1029 : fprintf(output, "SEPAR_PARA "); break;
; 1030 : case XML_REGEXP_SYMBOL:
; 1031 : fprintf(output, "SYMBOL "); break;
; 1032 : case XML_REGEXP_SYMBOL_MATH:
; 1033 : fprintf(output, "SYMBOL_MATH "); break;
; 1034 : case XML_REGEXP_SYMBOL_CURRENCY:
; 1035 : fprintf(output, "SYMBOL_CURRENCY "); break;
; 1036 : case XML_REGEXP_SYMBOL_MODIFIER:
; 1037 : fprintf(output, "SYMBOL_MODIFIER "); break;
; 1038 : case XML_REGEXP_SYMBOL_OTHERS:
; 1039 : fprintf(output, "SYMBOL_OTHERS "); break;
; 1040 : case XML_REGEXP_OTHER:
; 1041 : fprintf(output, "OTHER "); break;
; 1042 : case XML_REGEXP_OTHER_CONTROL:
; 1043 : fprintf(output, "OTHER_CONTROL "); break;
; 1044 : case XML_REGEXP_OTHER_FORMAT:
; 1045 : fprintf(output, "OTHER_FORMAT "); break;
; 1046 : case XML_REGEXP_OTHER_PRIVATE:
; 1047 : fprintf(output, "OTHER_PRIVATE "); break;
; 1048 : case XML_REGEXP_OTHER_NA:
; 1049 : fprintf(output, "OTHER_NA "); break;
; 1050 : case XML_REGEXP_BLOCK_NAME:
; 1051 : fprintf(output, "BLOCK "); break;
; 1052 : }
; 1053 : }
; 1054 :
; 1055 : static void
; 1056 : xmlRegPrintQuantType(FILE *output, xmlRegQuantType type) {
; 1057 : switch (type) {
; 1058 : case XML_REGEXP_QUANT_EPSILON:
; 1059 : fprintf(output, "epsilon "); break;
; 1060 : case XML_REGEXP_QUANT_ONCE:
; 1061 : fprintf(output, "once "); break;
; 1062 : case XML_REGEXP_QUANT_OPT:
; 1063 : fprintf(output, "? "); break;
; 1064 : case XML_REGEXP_QUANT_MULT:
; 1065 : fprintf(output, "* "); break;
; 1066 : case XML_REGEXP_QUANT_PLUS:
; 1067 : fprintf(output, "+ "); break;
; 1068 : case XML_REGEXP_QUANT_RANGE:
; 1069 : fprintf(output, "range "); break;
; 1070 : case XML_REGEXP_QUANT_ONCEONLY:
; 1071 : fprintf(output, "onceonly "); break;
; 1072 : case XML_REGEXP_QUANT_ALL:
; 1073 : fprintf(output, "all "); break;
; 1074 : }
; 1075 : }
; 1076 : static void
; 1077 : xmlRegPrintRange(FILE *output, xmlRegRangePtr range) {
; 1078 : fprintf(output, " range: ");
; 1079 : if (range->neg)
; 1080 : fprintf(output, "negative ");
; 1081 : xmlRegPrintAtomType(output, range->type);
; 1082 : fprintf(output, "%c - %c\n", range->start, range->end);
; 1083 : }
; 1084 :
; 1085 : static void
; 1086 : xmlRegPrintAtom(FILE *output, xmlRegAtomPtr atom) {
; 1087 : fprintf(output, " atom: ");
; 1088 : if (atom == NULL) {
; 1089 : fprintf(output, "NULL\n");
; 1090 : return;
; 1091 : }
; 1092 : if (atom->neg)
; 1093 : fprintf(output, "not ");
; 1094 : xmlRegPrintAtomType(output, atom->type);
; 1095 : xmlRegPrintQuantType(output, atom->quant);
; 1096 : if (atom->quant == XML_REGEXP_QUANT_RANGE)
; 1097 : fprintf(output, "%d-%d ", atom->min, atom->max);
; 1098 : if (atom->type == XML_REGEXP_STRING)
; 1099 : fprintf(output, "'%s' ", (char *) atom->valuep);
; 1100 : if (atom->type == XML_REGEXP_CHARVAL)
; 1101 : fprintf(output, "char %c\n", atom->codepoint);
; 1102 : else if (atom->type == XML_REGEXP_RANGES) {
; 1103 : int i;
; 1104 : fprintf(output, "%d entries\n", atom->nbRanges);
; 1105 : for (i = 0; i < atom->nbRanges;i++)
; 1106 : xmlRegPrintRange(output, atom->ranges[i]);
; 1107 : } else if (atom->type == XML_REGEXP_SUBREG) {
; 1108 : fprintf(output, "start %d end %d\n", atom->start->no, atom->stop->no);
; 1109 : } else {
; 1110 : fprintf(output, "\n");
; 1111 : }
; 1112 : }
; 1113 :
; 1114 : static void
; 1115 : xmlRegPrintTrans(FILE *output, xmlRegTransPtr trans) {
; 1116 : fprintf(output, " trans: ");
; 1117 : if (trans == NULL) {
; 1118 : fprintf(output, "NULL\n");
; 1119 : return;
; 1120 : }
; 1121 : if (trans->to < 0) {
; 1122 : fprintf(output, "removed\n");
; 1123 : return;
; 1124 : }
; 1125 : if (trans->nd != 0) {
; 1126 : if (trans->nd == 2)
; 1127 : fprintf(output, "last not determinist, ");
; 1128 : else
; 1129 : fprintf(output, "not determinist, ");
; 1130 : }
; 1131 : if (trans->counter >= 0) {
; 1132 : fprintf(output, "counted %d, ", trans->counter);
; 1133 : }
; 1134 : if (trans->count == REGEXP_ALL_COUNTER) {
; 1135 : fprintf(output, "all transition, ");
; 1136 : } else if (trans->count >= 0) {
; 1137 : fprintf(output, "count based %d, ", trans->count);
; 1138 : }
; 1139 : if (trans->atom == NULL) {
; 1140 : fprintf(output, "epsilon to %d\n", trans->to);
; 1141 : return;
; 1142 : }
; 1143 : if (trans->atom->type == XML_REGEXP_CHARVAL)
; 1144 : fprintf(output, "char %c ", trans->atom->codepoint);
; 1145 : fprintf(output, "atom %d, to %d\n", trans->atom->no, trans->to);
; 1146 : }
; 1147 :
; 1148 : static void
; 1149 : xmlRegPrintState(FILE *output, xmlRegStatePtr state) {
; 1150 : int i;
; 1151 :
; 1152 : fprintf(output, " state: ");
; 1153 : if (state == NULL) {
; 1154 : fprintf(output, "NULL\n");
; 1155 : return;
; 1156 : }
; 1157 : if (state->type == XML_REGEXP_START_STATE)
; 1158 : fprintf(output, "START ");
; 1159 : if (state->type == XML_REGEXP_FINAL_STATE)
; 1160 : fprintf(output, "FINAL ");
; 1161 :
; 1162 : fprintf(output, "%d, %d transitions:\n", state->no, state->nbTrans);
; 1163 : for (i = 0;i < state->nbTrans; i++) {
; 1164 : xmlRegPrintTrans(output, &(state->trans[i]));
; 1165 : }
; 1166 : }
; 1167 :
; 1168 : #ifdef DEBUG_REGEXP_GRAPH
; 1169 : static void
; 1170 : xmlRegPrintCtxt(FILE *output, xmlRegParserCtxtPtr ctxt) {
; 1171 : int i;
; 1172 :
; 1173 : fprintf(output, " ctxt: ");
; 1174 : if (ctxt == NULL) {
; 1175 : fprintf(output, "NULL\n");
; 1176 : return;
; 1177 : }
; 1178 : fprintf(output, "'%s' ", ctxt->string);
; 1179 : if (ctxt->error)
; 1180 : fprintf(output, "error ");
; 1181 : if (ctxt->neg)
; 1182 : fprintf(output, "neg ");
; 1183 : fprintf(output, "\n");
; 1184 : fprintf(output, "%d atoms:\n", ctxt->nbAtoms);
; 1185 : for (i = 0;i < ctxt->nbAtoms; i++) {
; 1186 : fprintf(output, " %02d ", i);
; 1187 : xmlRegPrintAtom(output, ctxt->atoms[i]);
; 1188 : }
; 1189 : if (ctxt->atom != NULL) {
; 1190 : fprintf(output, "current atom:\n");
; 1191 : xmlRegPrintAtom(output, ctxt->atom);
; 1192 : }
; 1193 : fprintf(output, "%d states:", ctxt->nbStates);
; 1194 : if (ctxt->start != NULL)
; 1195 : fprintf(output, " start: %d", ctxt->start->no);
; 1196 : if (ctxt->end != NULL)
; 1197 : fprintf(output, " end: %d", ctxt->end->no);
; 1198 : fprintf(output, "\n");
; 1199 : for (i = 0;i < ctxt->nbStates; i++) {
; 1200 : xmlRegPrintState(output, ctxt->states[i]);
; 1201 : }
; 1202 : fprintf(output, "%d counters:\n", ctxt->nbCounters);
; 1203 : for (i = 0;i < ctxt->nbCounters; i++) {
; 1204 : fprintf(output, " %d: min %d max %d\n", i, ctxt->counters[i].min,
; 1205 : ctxt->counters[i].max);
; 1206 : }
; 1207 : }
; 1208 : #endif
; 1209 :
; 1210 : /************************************************************************
; 1211 : * *
; 1212 : * Finite Automata structures manipulations *
; 1213 : * *
; 1214 : ************************************************************************/
; 1215 :
; 1216 : static void
; 1217 : xmlRegAtomAddRange(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom,
; 1218 : int neg, xmlRegAtomType type, int start, int end,
; 1219 : xmlChar *blockName) {
; 1220 : xmlRegRangePtr range;
; 1221 :
; 1222 : if (atom == NULL) {
; 1223 : ERROR("add range: atom is NULL");
; 1224 : return;
; 1225 : }
; 1226 : if (atom->type != XML_REGEXP_RANGES) {
; 1227 : ERROR("add range: atom is not ranges");
; 1228 : return;
; 1229 : }
; 1230 : if (atom->maxRanges == 0) {
; 1231 : atom->maxRanges = 4;
; 1232 : atom->ranges = (xmlRegRangePtr *) xmlMalloc(atom->maxRanges *
; 1233 : sizeof(xmlRegRangePtr));
; 1234 : if (atom->ranges == NULL) {
; 1235 : xmlRegexpErrMemory(ctxt, "adding ranges");
; 1236 : atom->maxRanges = 0;
; 1237 : return;
; 1238 : }
; 1239 : } else if (atom->nbRanges >= atom->maxRanges) {
; 1240 : xmlRegRangePtr *tmp;
; 1241 : atom->maxRanges *= 2;
; 1242 : tmp = (xmlRegRangePtr *) xmlRealloc(atom->ranges, atom->maxRanges *
; 1243 : sizeof(xmlRegRangePtr));
; 1244 : if (tmp == NULL) {
; 1245 : xmlRegexpErrMemory(ctxt, "adding ranges");
; 1246 : atom->maxRanges /= 2;
; 1247 : return;
; 1248 : }
; 1249 : atom->ranges = tmp;
; 1250 : }
; 1251 : range = xmlRegNewRange(ctxt, neg, type, start, end);
; 1252 : if (range == NULL)
; 1253 : return;
; 1254 : range->blockName = blockName;
; 1255 : atom->ranges[atom->nbRanges++] = range;
; 1256 :
; 1257 : }
; 1258 :
; 1259 : static int
; 1260 : xmlRegGetCounter(xmlRegParserCtxtPtr ctxt) {
; 1261 : if (ctxt->maxCounters == 0) {
; 1262 : ctxt->maxCounters = 4;
; 1263 : ctxt->counters = (xmlRegCounter *) xmlMalloc(ctxt->maxCounters *
; 1264 : sizeof(xmlRegCounter));
; 1265 : if (ctxt->counters == NULL) {
; 1266 : xmlRegexpErrMemory(ctxt, "allocating counter");
; 1267 : ctxt->maxCounters = 0;
; 1268 : return(-1);
; 1269 : }
; 1270 : } else if (ctxt->nbCounters >= ctxt->maxCounters) {
; 1271 : xmlRegCounter *tmp;
; 1272 : ctxt->maxCounters *= 2;
; 1273 : tmp = (xmlRegCounter *) xmlRealloc(ctxt->counters, ctxt->maxCounters *
; 1274 : sizeof(xmlRegCounter));
; 1275 : if (tmp == NULL) {
; 1276 : xmlRegexpErrMemory(ctxt, "allocating counter");
; 1277 : ctxt->maxCounters /= 2;
; 1278 : return(-1);
; 1279 : }
; 1280 : ctxt->counters = tmp;
; 1281 : }
; 1282 : ctxt->counters[ctxt->nbCounters].min = -1;
; 1283 : ctxt->counters[ctxt->nbCounters].max = -1;
; 1284 : return(ctxt->nbCounters++);
; 1285 : }
; 1286 :
; 1287 : static int
; 1288 : xmlRegAtomPush(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
; 1289 : if (atom == NULL) {
; 1290 : ERROR("atom push: atom is NULL");
; 1291 : return(-1);
; 1292 : }
; 1293 : if (ctxt->maxAtoms == 0) {
; 1294 : ctxt->maxAtoms = 4;
; 1295 : ctxt->atoms = (xmlRegAtomPtr *) xmlMalloc(ctxt->maxAtoms *
; 1296 : sizeof(xmlRegAtomPtr));
; 1297 : if (ctxt->atoms == NULL) {
; 1298 : xmlRegexpErrMemory(ctxt, "pushing atom");
; 1299 : ctxt->maxAtoms = 0;
; 1300 : return(-1);
; 1301 : }
; 1302 : } else if (ctxt->nbAtoms >= ctxt->maxAtoms) {
; 1303 : xmlRegAtomPtr *tmp;
; 1304 : ctxt->maxAtoms *= 2;
; 1305 : tmp = (xmlRegAtomPtr *) xmlRealloc(ctxt->atoms, ctxt->maxAtoms *
; 1306 : sizeof(xmlRegAtomPtr));
; 1307 : if (tmp == NULL) {
; 1308 : xmlRegexpErrMemory(ctxt, "allocating counter");
; 1309 : ctxt->maxAtoms /= 2;
; 1310 : return(-1);
; 1311 : }
; 1312 : ctxt->atoms = tmp;
; 1313 : }
; 1314 : atom->no = ctxt->nbAtoms;
; 1315 : ctxt->atoms[ctxt->nbAtoms++] = atom;
; 1316 : return(0);
; 1317 : }
; 1318 :
; 1319 : static void
; 1320 : xmlRegStateAddTransTo(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr target,
; 1321 : int from) {
; 1322 : if (target->maxTransTo == 0) {
; 1323 : target->maxTransTo = 8;
; 1324 : target->transTo = (int *) xmlMalloc(target->maxTransTo *
; 1325 : sizeof(int));
; 1326 : if (target->transTo == NULL) {
; 1327 : xmlRegexpErrMemory(ctxt, "adding transition");
; 1328 : target->maxTransTo = 0;
; 1329 : return;
; 1330 : }
; 1331 : } else if (target->nbTransTo >= target->maxTransTo) {
; 1332 : int *tmp;
; 1333 : target->maxTransTo *= 2;
; 1334 : tmp = (int *) xmlRealloc(target->transTo, target->maxTransTo *
; 1335 : sizeof(int));
; 1336 : if (tmp == NULL) {
; 1337 : xmlRegexpErrMemory(ctxt, "adding transition");
; 1338 : target->maxTransTo /= 2;
; 1339 : return;
; 1340 : }
; 1341 : target->transTo = tmp;
; 1342 : }
; 1343 : target->transTo[target->nbTransTo] = from;
; 1344 : target->nbTransTo++;
; 1345 : }
; 1346 :
; 1347 : static void
; 1348 : xmlRegStateAddTrans(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state,
; 1349 : xmlRegAtomPtr atom, xmlRegStatePtr target,
; 1350 : int counter, int count) {
; 1351 :
; 1352 : int nrtrans;
; 1353 :
; 1354 : if (state == NULL) {
; 1355 : ERROR("add state: state is NULL");
; 1356 : return;
; 1357 : }
; 1358 : if (target == NULL) {
; 1359 : ERROR("add state: target is NULL");
; 1360 : return;
; 1361 : }
; 1362 : /*
; 1363 : * Other routines follow the philosophy 'When in doubt, add a transition'
; 1364 : * so we check here whether such a transition is already present and, if
; 1365 : * so, silently ignore this request.
; 1366 : */
; 1367 :
; 1368 : for (nrtrans = state->nbTrans - 1; nrtrans >= 0; nrtrans--) {
; 1369 : xmlRegTransPtr trans = &(state->trans[nrtrans]);
; 1370 : if ((trans->atom == atom) &&
; 1371 : (trans->to == target->no) &&
; 1372 : (trans->counter == counter) &&
; 1373 : (trans->count == count)) {
; 1374 : #ifdef DEBUG_REGEXP_GRAPH
; 1375 : printf("Ignoring duplicate transition from %d to %d\n",
; 1376 : state->no, target->no);
; 1377 : #endif
; 1378 : return;
; 1379 : }
; 1380 : }
; 1381 :
; 1382 : if (state->maxTrans == 0) {
; 1383 : state->maxTrans = 8;
; 1384 : state->trans = (xmlRegTrans *) xmlMalloc(state->maxTrans *
; 1385 : sizeof(xmlRegTrans));
; 1386 : if (state->trans == NULL) {
; 1387 : xmlRegexpErrMemory(ctxt, "adding transition");
; 1388 : state->maxTrans = 0;
; 1389 : return;
; 1390 : }
; 1391 : } else if (state->nbTrans >= state->maxTrans) {
; 1392 : xmlRegTrans *tmp;
; 1393 : state->maxTrans *= 2;
; 1394 : tmp = (xmlRegTrans *) xmlRealloc(state->trans, state->maxTrans *
; 1395 : sizeof(xmlRegTrans));
; 1396 : if (tmp == NULL) {
; 1397 : xmlRegexpErrMemory(ctxt, "adding transition");
; 1398 : state->maxTrans /= 2;
; 1399 : return;
; 1400 : }
; 1401 : state->trans = tmp;
; 1402 : }
; 1403 : #ifdef DEBUG_REGEXP_GRAPH
; 1404 : printf("Add trans from %d to %d ", state->no, target->no);
; 1405 : if (count == REGEXP_ALL_COUNTER)
; 1406 : printf("all transition\n");
; 1407 : else if (count >= 0)
; 1408 : printf("count based %d\n", count);
; 1409 : else if (counter >= 0)
; 1410 : printf("counted %d\n", counter);
; 1411 : else if (atom == NULL)
; 1412 : printf("epsilon transition\n");
; 1413 : else if (atom != NULL)
; 1414 : xmlRegPrintAtom(stdout, atom);
; 1415 : #endif
; 1416 :
; 1417 : state->trans[state->nbTrans].atom = atom;
; 1418 : state->trans[state->nbTrans].to = target->no;
; 1419 : state->trans[state->nbTrans].counter = counter;
; 1420 : state->trans[state->nbTrans].count = count;
; 1421 : state->trans[state->nbTrans].nd = 0;
; 1422 : state->nbTrans++;
; 1423 : xmlRegStateAddTransTo(ctxt, target, state->no);
; 1424 : }
; 1425 :
; 1426 : static int
; 1427 : xmlRegStatePush(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state) {
; 1428 : if (state == NULL) return(-1);
; 1429 : if (ctxt->maxStates == 0) {
; 1430 : ctxt->maxStates = 4;
; 1431 : ctxt->states = (xmlRegStatePtr *) xmlMalloc(ctxt->maxStates *
; 1432 : sizeof(xmlRegStatePtr));
; 1433 : if (ctxt->states == NULL) {
; 1434 : xmlRegexpErrMemory(ctxt, "adding state");
; 1435 : ctxt->maxStates = 0;
; 1436 : return(-1);
; 1437 : }
; 1438 : } else if (ctxt->nbStates >= ctxt->maxStates) {
; 1439 : xmlRegStatePtr *tmp;
; 1440 : ctxt->maxStates *= 2;
; 1441 : tmp = (xmlRegStatePtr *) xmlRealloc(ctxt->states, ctxt->maxStates *
; 1442 : sizeof(xmlRegStatePtr));
; 1443 : if (tmp == NULL) {
; 1444 : xmlRegexpErrMemory(ctxt, "adding state");
; 1445 : ctxt->maxStates /= 2;
; 1446 : return(-1);
; 1447 : }
; 1448 : ctxt->states = tmp;
; 1449 : }
; 1450 : state->no = ctxt->nbStates;
; 1451 : ctxt->states[ctxt->nbStates++] = state;
; 1452 : return(0);
; 1453 : }
; 1454 :
; 1455 : /**
; 1456 : * xmlFAGenerateAllTransition:
; 1457 : * @ctxt: a regexp parser context
; 1458 : * @from: the from state
; 1459 : * @to: the target state or NULL for building a new one
; 1460 : * @lax:
; 1461 : *
; 1462 : */
; 1463 : static void
; 1464 : xmlFAGenerateAllTransition(xmlRegParserCtxtPtr ctxt,
; 1465 : xmlRegStatePtr from, xmlRegStatePtr to,
; 1466 : int lax) {
; 1467 : if (to == NULL) {
; 1468 : to = xmlRegNewState(ctxt);
; 1469 : xmlRegStatePush(ctxt, to);
; 1470 : ctxt->state = to;
; 1471 : }
; 1472 : if (lax)
; 1473 : xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_LAX_COUNTER);
; 1474 : else
; 1475 : xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_COUNTER);
; 1476 : }
; 1477 :
; 1478 : /**
; 1479 : * xmlFAGenerateEpsilonTransition:
; 1480 : * @ctxt: a regexp parser context
; 1481 : * @from: the from state
; 1482 : * @to: the target state or NULL for building a new one
; 1483 : *
; 1484 : */
; 1485 : static void
; 1486 : xmlFAGenerateEpsilonTransition(xmlRegParserCtxtPtr ctxt,
; 1487 : xmlRegStatePtr from, xmlRegStatePtr to) {
; 1488 : if (to == NULL) {
; 1489 : to = xmlRegNewState(ctxt);
; 1490 : xmlRegStatePush(ctxt, to);
; 1491 : ctxt->state = to;
; 1492 : }
; 1493 : xmlRegStateAddTrans(ctxt, from, NULL, to, -1, -1);
; 1494 : }
; 1495 :
; 1496 : /**
; 1497 : * xmlFAGenerateCountedEpsilonTransition:
; 1498 : * @ctxt: a regexp parser context
; 1499 : * @from: the from state
; 1500 : * @to: the target state or NULL for building a new one
; 1501 : * counter: the counter for that transition
; 1502 : *
; 1503 : */
; 1504 : static void
; 1505 : xmlFAGenerateCountedEpsilonTransition(xmlRegParserCtxtPtr ctxt,
; 1506 : xmlRegStatePtr from, xmlRegStatePtr to, int counter) {
; 1507 : if (to == NULL) {
; 1508 : to = xmlRegNewState(ctxt);
; 1509 : xmlRegStatePush(ctxt, to);
; 1510 : ctxt->state = to;
; 1511 : }
; 1512 : xmlRegStateAddTrans(ctxt, from, NULL, to, counter, -1);
; 1513 : }
; 1514 :
; 1515 : /**
; 1516 : * xmlFAGenerateCountedTransition:
; 1517 : * @ctxt: a regexp parser context
; 1518 : * @from: the from state
; 1519 : * @to: the target state or NULL for building a new one
; 1520 : * counter: the counter for that transition
; 1521 : *
; 1522 : */
; 1523 : static void
; 1524 : xmlFAGenerateCountedTransition(xmlRegParserCtxtPtr ctxt,
; 1525 : xmlRegStatePtr from, xmlRegStatePtr to, int counter) {
; 1526 : if (to == NULL) {
; 1527 : to = xmlRegNewState(ctxt);
; 1528 : xmlRegStatePush(ctxt, to);
; 1529 : ctxt->state = to;
; 1530 : }
; 1531 : xmlRegStateAddTrans(ctxt, from, NULL, to, -1, counter);
; 1532 : }
; 1533 :
; 1534 : /**
; 1535 : * xmlFAGenerateTransitions:
; 1536 : * @ctxt: a regexp parser context
; 1537 : * @from: the from state
; 1538 : * @to: the target state or NULL for building a new one
; 1539 : * @atom: the atom generating the transition
; 1540 : *
; 1541 : * Returns 0 if success and -1 in case of error.
; 1542 : */
; 1543 : static int
; 1544 : xmlFAGenerateTransitions(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr from,
; 1545 : xmlRegStatePtr to, xmlRegAtomPtr atom) {
; 1546 : xmlRegStatePtr end;
; 1547 : int nullable = 0;
; 1548 :
; 1549 : if (atom == NULL) {
; 1550 : ERROR("genrate transition: atom == NULL");
; 1551 : return(-1);
; 1552 : }
; 1553 : if (atom->type == XML_REGEXP_SUBREG) {
; 1554 : /*
; 1555 : * this is a subexpression handling one should not need to
; 1556 : * create a new node except for XML_REGEXP_QUANT_RANGE.
; 1557 : */
; 1558 : if (xmlRegAtomPush(ctxt, atom) < 0) {
; 1559 : return(-1);
; 1560 : }
; 1561 : if ((to != NULL) && (atom->stop != to) &&
; 1562 : (atom->quant != XML_REGEXP_QUANT_RANGE)) {
; 1563 : /*
; 1564 : * Generate an epsilon transition to link to the target
; 1565 : */
; 1566 : xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
; 1567 : #ifdef DV
; 1568 : } else if ((to == NULL) && (atom->quant != XML_REGEXP_QUANT_RANGE) &&
; 1569 : (atom->quant != XML_REGEXP_QUANT_ONCE)) {
; 1570 : to = xmlRegNewState(ctxt);
; 1571 : xmlRegStatePush(ctxt, to);
; 1572 : ctxt->state = to;
; 1573 : xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
; 1574 : #endif
; 1575 : }
; 1576 : switch (atom->quant) {
; 1577 : case XML_REGEXP_QUANT_OPT:
; 1578 : atom->quant = XML_REGEXP_QUANT_ONCE;
; 1579 : /*
; 1580 : * transition done to the state after end of atom.
; 1581 : * 1. set transition from atom start to new state
; 1582 : * 2. set transition from atom end to this state.
; 1583 : */
; 1584 : if (to == NULL) {
; 1585 : xmlFAGenerateEpsilonTransition(ctxt, atom->start, 0);
; 1586 : xmlFAGenerateEpsilonTransition(ctxt, atom->stop,
; 1587 : ctxt->state);
; 1588 : } else {
; 1589 : xmlFAGenerateEpsilonTransition(ctxt, atom->start, to);
; 1590 : }
; 1591 : break;
; 1592 : case XML_REGEXP_QUANT_MULT:
; 1593 : atom->quant = XML_REGEXP_QUANT_ONCE;
; 1594 : xmlFAGenerateEpsilonTransition(ctxt, atom->start, atom->stop);
; 1595 : xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
; 1596 : break;
; 1597 : case XML_REGEXP_QUANT_PLUS:
; 1598 : atom->quant = XML_REGEXP_QUANT_ONCE;
; 1599 : xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
; 1600 : break;
; 1601 : case XML_REGEXP_QUANT_RANGE: {
; 1602 : int counter;
; 1603 : xmlRegStatePtr inter, newstate;
; 1604 :
; 1605 : /*
; 1606 : * create the final state now if needed
; 1607 : */
; 1608 : if (to != NULL) {
; 1609 : newstate = to;
; 1610 : } else {
; 1611 : newstate = xmlRegNewState(ctxt);
; 1612 : xmlRegStatePush(ctxt, newstate);
; 1613 : }
; 1614 :
; 1615 : /*
; 1616 : * The principle here is to use counted transition
; 1617 : * to avoid explosion in the number of states in the
; 1618 : * graph. This is clearly more complex but should not
; 1619 : * be exploitable at runtime.
; 1620 : */
; 1621 : if ((atom->min == 0) && (atom->start0 == NULL)) {
; 1622 : xmlRegAtomPtr copy;
; 1623 : /*
; 1624 : * duplicate a transition based on atom to count next
; 1625 : * occurences after 1. We cannot loop to atom->start
; 1626 : * directly because we need an epsilon transition to
; 1627 : * newstate.
; 1628 : */
; 1629 : /* ???? For some reason it seems we never reach that
; 1630 : case, I suppose this got optimized out before when
; 1631 : building the automata */
; 1632 : copy = xmlRegCopyAtom(ctxt, atom);
; 1633 : if (copy == NULL)
; 1634 : return(-1);
; 1635 : copy->quant = XML_REGEXP_QUANT_ONCE;
; 1636 : copy->min = 0;
; 1637 : copy->max = 0;
; 1638 :
; 1639 : if (xmlFAGenerateTransitions(ctxt, atom->start, NULL, copy)
; 1640 : < 0)
; 1641 : return(-1);
; 1642 : inter = ctxt->state;
; 1643 : counter = xmlRegGetCounter(ctxt);
; 1644 : ctxt->counters[counter].min = atom->min - 1;
; 1645 : ctxt->counters[counter].max = atom->max - 1;
; 1646 : /* count the number of times we see it again */
; 1647 : xmlFAGenerateCountedEpsilonTransition(ctxt, inter,
; 1648 : atom->stop, counter);
; 1649 : /* allow a way out based on the count */
; 1650 : xmlFAGenerateCountedTransition(ctxt, inter,
; 1651 : newstate, counter);
; 1652 : /* and also allow a direct exit for 0 */
; 1653 : xmlFAGenerateEpsilonTransition(ctxt, atom->start,
; 1654 : newstate);
; 1655 : } else {
; 1656 : /*
; 1657 : * either we need the atom at least once or there
; 1658 : * is an atom->start0 allowing to easilly plug the
; 1659 : * epsilon transition.
; 1660 : */
; 1661 : counter = xmlRegGetCounter(ctxt);
; 1662 : ctxt->counters[counter].min = atom->min - 1;
; 1663 : ctxt->counters[counter].max = atom->max - 1;
; 1664 : /* count the number of times we see it again */
; 1665 : xmlFAGenerateCountedEpsilonTransition(ctxt, atom->stop,
; 1666 : atom->start, counter);
; 1667 : /* allow a way out based on the count */
; 1668 : xmlFAGenerateCountedTransition(ctxt, atom->stop,
; 1669 : newstate, counter);
; 1670 : /* and if needed allow a direct exit for 0 */
; 1671 : if (atom->min == 0)
; 1672 : xmlFAGenerateEpsilonTransition(ctxt, atom->start0,
; 1673 : newstate);
; 1674 :
; 1675 : }
; 1676 : atom->min = 0;
; 1677 : atom->max = 0;
; 1678 : atom->quant = XML_REGEXP_QUANT_ONCE;
; 1679 : ctxt->state = newstate;
; 1680 : }
; 1681 : default:
; 1682 : break;
; 1683 : }
; 1684 : return(0);
; 1685 : }
; 1686 : if ((atom->min == 0) && (atom->max == 0) &&
; 1687 : (atom->quant == XML_REGEXP_QUANT_RANGE)) {
; 1688 : /*
; 1689 : * we can discard the atom and generate an epsilon transition instead
; 1690 : */
; 1691 : if (to == NULL) {
; 1692 : to = xmlRegNewState(ctxt);
; 1693 : if (to != NULL)
; 1694 : xmlRegStatePush(ctxt, to);
; 1695 : else {
; 1696 : return(-1);
; 1697 : }
; 1698 : }
; 1699 : xmlFAGenerateEpsilonTransition(ctxt, from, to);
; 1700 : ctxt->state = to;
; 1701 : xmlRegFreeAtom(atom);
; 1702 : return(0);
; 1703 : }
; 1704 : if (to == NULL) {
; 1705 : to = xmlRegNewState(ctxt);
; 1706 : if (to != NULL)
; 1707 : xmlRegStatePush(ctxt, to);
; 1708 : else {
; 1709 : return(-1);
; 1710 : }
; 1711 : }
; 1712 : end = to;
; 1713 : if ((atom->quant == XML_REGEXP_QUANT_MULT) ||
; 1714 : (atom->quant == XML_REGEXP_QUANT_PLUS)) {
; 1715 : /*
; 1716 : * Do not pollute the target state by adding transitions from
; 1717 : * it as it is likely to be the shared target of multiple branches.
; 1718 : * So isolate with an epsilon transition.
; 1719 : */
; 1720 : xmlRegStatePtr tmp;
; 1721 :
; 1722 : tmp = xmlRegNewState(ctxt);
; 1723 : if (tmp != NULL)
; 1724 : xmlRegStatePush(ctxt, tmp);
; 1725 : else {
; 1726 : return(-1);
; 1727 : }
; 1728 : xmlFAGenerateEpsilonTransition(ctxt, tmp, to);
; 1729 : to = tmp;
; 1730 : }
; 1731 : if (xmlRegAtomPush(ctxt, atom) < 0) {
; 1732 : return(-1);
; 1733 : }
; 1734 : if ((atom->quant == XML_REGEXP_QUANT_RANGE) &&
; 1735 : (atom->min == 0) && (atom->max > 0)) {
; 1736 : nullable = 1;
; 1737 : atom->min = 1;
; 1738 : if (atom->max == 1)
; 1739 : atom->quant = XML_REGEXP_QUANT_OPT;
; 1740 : }
; 1741 : xmlRegStateAddTrans(ctxt, from, atom, to, -1, -1);
; 1742 : ctxt->state = end;
; 1743 : switch (atom->quant) {
; 1744 : case XML_REGEXP_QUANT_OPT:
; 1745 : atom->quant = XML_REGEXP_QUANT_ONCE;
; 1746 : xmlFAGenerateEpsilonTransition(ctxt, from, to);
; 1747 : break;
; 1748 : case XML_REGEXP_QUANT_MULT:
; 1749 : atom->quant = XML_REGEXP_QUANT_ONCE;
; 1750 : xmlFAGenerateEpsilonTransition(ctxt, from, to);
; 1751 : xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
; 1752 : break;
; 1753 : case XML_REGEXP_QUANT_PLUS:
; 1754 : atom->quant = XML_REGEXP_QUANT_ONCE;
; 1755 : xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
; 1756 : break;
; 1757 : case XML_REGEXP_QUANT_RANGE:
; 1758 : if (nullable)
; 1759 : xmlFAGenerateEpsilonTransition(ctxt, from, to);
; 1760 : break;
; 1761 : default:
; 1762 : break;
; 1763 : }
; 1764 : return(0);
; 1765 : }
; 1766 :
; 1767 : /**
; 1768 : * xmlFAReduceEpsilonTransitions:
; 1769 : * @ctxt: a regexp parser context
; 1770 : * @fromnr: the from state
; 1771 : * @tonr: the to state
; 1772 : * @counter: should that transition be associated to a counted
; 1773 : *
; 1774 : */
; 1775 : static void
; 1776 : xmlFAReduceEpsilonTransitions(xmlRegParserCtxtPtr ctxt, int fromnr,
; 1777 : int tonr, int counter) {
; 1778 : int transnr;
; 1779 : xmlRegStatePtr from;
; 1780 : xmlRegStatePtr to;
; 1781 :
; 1782 : #ifdef DEBUG_REGEXP_GRAPH
; 1783 : printf("xmlFAReduceEpsilonTransitions(%d, %d)\n", fromnr, tonr);
; 1784 : #endif
; 1785 : from = ctxt->states[fromnr];
; 1786 : if (from == NULL)
; 1787 : return;
; 1788 : to = ctxt->states[tonr];
; 1789 : if (to == NULL)
; 1790 : return;
; 1791 : if ((to->mark == XML_REGEXP_MARK_START) ||
; 1792 : (to->mark == XML_REGEXP_MARK_VISITED))
; 1793 : return;
; 1794 :
; 1795 : to->mark = XML_REGEXP_MARK_VISITED;
; 1796 : if (to->type == XML_REGEXP_FINAL_STATE) {
; 1797 : #ifdef DEBUG_REGEXP_GRAPH
; 1798 : printf("State %d is final, so %d becomes final\n", tonr, fromnr);
; 1799 : #endif
; 1800 : from->type = XML_REGEXP_FINAL_STATE;
; 1801 : }
; 1802 : for (transnr = 0;transnr < to->nbTrans;transnr++) {
; 1803 : if (to->trans[transnr].to < 0)
; 1804 : continue;
; 1805 : if (to->trans[transnr].atom == NULL) {
; 1806 : /*
; 1807 : * Don't remove counted transitions
; 1808 : * Don't loop either
; 1809 : */
; 1810 : if (to->trans[transnr].to != fromnr) {
; 1811 : if (to->trans[transnr].count >= 0) {
; 1812 : int newto = to->trans[transnr].to;
; 1813 :
; 1814 : xmlRegStateAddTrans(ctxt, from, NULL,
; 1815 : ctxt->states[newto],
; 1816 : -1, to->trans[transnr].count);
; 1817 : } else {
; 1818 : #ifdef DEBUG_REGEXP_GRAPH
; 1819 : printf("Found epsilon trans %d from %d to %d\n",
; 1820 : transnr, tonr, to->trans[transnr].to);
; 1821 : #endif
; 1822 : if (to->trans[transnr].counter >= 0) {
; 1823 : xmlFAReduceEpsilonTransitions(ctxt, fromnr,
; 1824 : to->trans[transnr].to,
; 1825 : to->trans[transnr].counter);
; 1826 : } else {
; 1827 : xmlFAReduceEpsilonTransitions(ctxt, fromnr,
; 1828 : to->trans[transnr].to,
; 1829 : counter);
; 1830 : }
; 1831 : }
; 1832 : }
; 1833 : } else {
; 1834 : int newto = to->trans[transnr].to;
; 1835 :
; 1836 : if (to->trans[transnr].counter >= 0) {
; 1837 : xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
; 1838 : ctxt->states[newto],
; 1839 : to->trans[transnr].counter, -1);
; 1840 : } else {
; 1841 : xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
; 1842 : ctxt->states[newto], counter, -1);
; 1843 : }
; 1844 : }
; 1845 : }
; 1846 : to->mark = XML_REGEXP_MARK_NORMAL;
; 1847 : }
; 1848 :
; 1849 : /**
; 1850 : * xmlFAEliminateSimpleEpsilonTransitions:
; 1851 : * @ctxt: a regexp parser context
; 1852 : *
; 1853 : * Eliminating general epsilon transitions can get costly in the general
; 1854 : * algorithm due to the large amount of generated new transitions and
; 1855 : * associated comparisons. However for simple epsilon transition used just
; 1856 : * to separate building blocks when generating the automata this can be
; 1857 : * reduced to state elimination:
; 1858 : * - if there exists an epsilon from X to Y
; 1859 : * - if there is no other transition from X
; 1860 : * then X and Y are semantically equivalent and X can be eliminated
; 1861 : * If X is the start state then make Y the start state, else replace the
; 1862 : * target of all transitions to X by transitions to Y.
; 1863 : */
; 1864 : static void
; 1865 : xmlFAEliminateSimpleEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
; 1866 : int statenr, i, j, newto;
; 1867 : xmlRegStatePtr state, tmp;
; 1868 :
; 1869 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
mov eax, DWORD PTR [edx+48]
inc ebx
mov DWORD PTR _statenr$1$[ebp], ebx
cmp ebx, eax
jl $LL55@xmlFAElimi
$LN54@xmlFAElimi:
; 1930 : int statenr, transnr;
; 1931 : xmlRegStatePtr state;
; 1932 : int has_epsilon;
; 1933 :
; 1934 : if (ctxt->states == NULL) return;
; 1935 :
; 1936 : /*
; 1937 : * Eliminate simple epsilon transition and the associated unreachable
; 1938 : * states.
; 1939 : */
; 1940 : xmlFAEliminateSimpleEpsilonTransitions(ctxt);
; 1941 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
xor edi, edi
test eax, eax
jle SHORT $LN3@xmlFAElimi
npad 6
$LL4@xmlFAElimi:
; 1942 : state = ctxt->states[statenr];
mov eax, DWORD PTR [edx+52]
mov esi, DWORD PTR [eax+edi*4]
; 1943 : if ((state != NULL) && (state->type == XML_REGEXP_UNREACH_STATE)) {
test esi, esi
je SHORT $LN2@xmlFAElimi
cmp DWORD PTR [esi], 5
jne SHORT $LN2@xmlFAElimi
; 901 : if (state->trans != NULL)
mov eax, DWORD PTR [esi+28]
test eax, eax
je SHORT $LN73@xmlFAElimi
; 902 : xmlFree(state->trans);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN73@xmlFAElimi:
; 903 : if (state->transTo != NULL)
mov eax, DWORD PTR [esi+40]
test eax, eax
je SHORT $LN74@xmlFAElimi
; 904 : xmlFree(state->transTo);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN74@xmlFAElimi:
; 905 : xmlFree(state);
push esi
call DWORD PTR _xmlFree
; 1944 : #ifdef DEBUG_REGEXP_GRAPH
; 1945 : printf("Removed unreachable state %d\n", statenr);
; 1946 : #endif
; 1947 : xmlRegFreeState(state);
; 1948 : ctxt->states[statenr] = NULL;
mov edx, DWORD PTR _ctxt$[ebp]
; 905 : xmlFree(state);
add esp, 4
; 1944 : #ifdef DEBUG_REGEXP_GRAPH
; 1945 : printf("Removed unreachable state %d\n", statenr);
; 1946 : #endif
; 1947 : xmlRegFreeState(state);
; 1948 : ctxt->states[statenr] = NULL;
mov eax, DWORD PTR [edx+52]
mov DWORD PTR [eax+edi*4], 0
$LN2@xmlFAElimi:
; 1930 : int statenr, transnr;
; 1931 : xmlRegStatePtr state;
; 1932 : int has_epsilon;
; 1933 :
; 1934 : if (ctxt->states == NULL) return;
; 1935 :
; 1936 : /*
; 1937 : * Eliminate simple epsilon transition and the associated unreachable
; 1938 : * states.
; 1939 : */
; 1940 : xmlFAEliminateSimpleEpsilonTransitions(ctxt);
; 1941 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
mov eax, DWORD PTR [edx+48]
inc edi
cmp edi, eax
jl SHORT $LL4@xmlFAElimi
$LN3@xmlFAElimi:
; 1949 : }
; 1950 : }
; 1951 :
; 1952 : has_epsilon = 0;
; 1953 :
; 1954 : /*
; 1955 : * Build the completed transitions bypassing the epsilons
; 1956 : * Use a marking algorithm to avoid loops
; 1957 : * Mark sink states too.
; 1958 : * Process from the latests states backward to the start when
; 1959 : * there is long cascading epsilon chains this minimize the
; 1960 : * recursions and transition compares when adding the new ones
; 1961 : */
; 1962 : for (statenr = ctxt->nbStates - 1;statenr >= 0;statenr--) {
lea ecx, DWORD PTR [eax-1]
xor ebx, ebx
mov DWORD PTR _has_epsilon$1$[ebp], ebx
mov DWORD PTR _statenr$2$[ebp], ecx
test ecx, ecx
js $LN6@xmlFAElimi
$LL7@xmlFAElimi:
; 1963 : state = ctxt->states[statenr];
mov eax, DWORD PTR [edx+52]
mov esi, DWORD PTR [eax+ecx*4]
; 1964 : if (state == NULL)
test esi, esi
je $LN5@xmlFAElimi
; 1965 : continue;
; 1966 : if ((state->nbTrans == 0) &&
mov eax, DWORD PTR [esi+24]
test eax, eax
jne SHORT $LN34@xmlFAElimi
cmp DWORD PTR [esi], 2
je SHORT $LN34@xmlFAElimi
; 1967 : (state->type != XML_REGEXP_FINAL_STATE)) {
; 1968 : state->type = XML_REGEXP_SINK_STATE;
mov DWORD PTR [esi], 4
$LN34@xmlFAElimi:
; 1969 : }
; 1970 : for (transnr = 0;transnr < state->nbTrans;transnr++) {
xor ebx, ebx
test eax, eax
jle SHORT $LN5@xmlFAElimi
xor edi, edi
npad 5
$LL10@xmlFAElimi:
; 1971 : if ((state->trans[transnr].atom == NULL) &&
mov eax, DWORD PTR [esi+28]
cmp DWORD PTR [edi+eax], 0
jne SHORT $LN8@xmlFAElimi
mov ecx, DWORD PTR [edi+eax+4]
test ecx, ecx
js SHORT $LN8@xmlFAElimi
; 1972 : (state->trans[transnr].to >= 0)) {
; 1973 : if (state->trans[transnr].to == statenr) {
cmp ecx, DWORD PTR _statenr$2$[ebp]
jne SHORT $LN36@xmlFAElimi
; 1974 : state->trans[transnr].to = -1;
mov DWORD PTR [edi+eax+4], -1
jmp SHORT $LN8@xmlFAElimi
$LN36@xmlFAElimi:
; 1975 : #ifdef DEBUG_REGEXP_GRAPH
; 1976 : printf("Removed loopback epsilon trans %d on %d\n",
; 1977 : transnr, statenr);
; 1978 : #endif
; 1979 : } else if (state->trans[transnr].count < 0) {
cmp DWORD PTR [edi+eax+12], 0
jge SHORT $LN8@xmlFAElimi
; 1980 : int newto = state->trans[transnr].to;
; 1981 :
; 1982 : #ifdef DEBUG_REGEXP_GRAPH
; 1983 : printf("Found epsilon trans %d from %d to %d\n",
; 1984 : transnr, statenr, newto);
; 1985 : #endif
; 1986 : has_epsilon = 1;
; 1987 : state->trans[transnr].to = -2;
mov DWORD PTR [edi+eax+4], -2 ; fffffffeH
; 1988 : state->mark = XML_REGEXP_MARK_START;
; 1989 : xmlFAReduceEpsilonTransitions(ctxt, statenr,
mov eax, DWORD PTR [esi+28]
mov DWORD PTR [esi+4], 1
mov DWORD PTR _has_epsilon$1$[ebp], 1
push DWORD PTR [edi+eax+8]
push ecx
push DWORD PTR _statenr$2$[ebp]
push edx
call _xmlFAReduceEpsilonTransitions
mov edx, DWORD PTR _ctxt$[ebp]
add esp, 16 ; 00000010H
; 1990 : newto, state->trans[transnr].counter);
; 1991 : state->mark = XML_REGEXP_MARK_NORMAL;
mov DWORD PTR [esi+4], 0
$LN8@xmlFAElimi:
; 1969 : }
; 1970 : for (transnr = 0;transnr < state->nbTrans;transnr++) {
inc ebx
add edi, 20 ; 00000014H
cmp ebx, DWORD PTR [esi+24]
jl SHORT $LL10@xmlFAElimi
mov ecx, DWORD PTR _statenr$2$[ebp]
$LN5@xmlFAElimi:
; 1949 : }
; 1950 : }
; 1951 :
; 1952 : has_epsilon = 0;
; 1953 :
; 1954 : /*
; 1955 : * Build the completed transitions bypassing the epsilons
; 1956 : * Use a marking algorithm to avoid loops
; 1957 : * Mark sink states too.
; 1958 : * Process from the latests states backward to the start when
; 1959 : * there is long cascading epsilon chains this minimize the
; 1960 : * recursions and transition compares when adding the new ones
; 1961 : */
; 1962 : for (statenr = ctxt->nbStates - 1;statenr >= 0;statenr--) {
sub ecx, 1
mov DWORD PTR _statenr$2$[ebp], ecx
jns $LL7@xmlFAElimi
mov eax, DWORD PTR [edx+48]
mov ebx, DWORD PTR _has_epsilon$1$[ebp]
$LN6@xmlFAElimi:
; 1992 : #ifdef DEBUG_REGEXP_GRAPH
; 1993 : } else {
; 1994 : printf("Found counted transition %d on %d\n",
; 1995 : transnr, statenr);
; 1996 : #endif
; 1997 : }
; 1998 : }
; 1999 : }
; 2000 : }
; 2001 : /*
; 2002 : * Eliminate the epsilon transitions
; 2003 : */
; 2004 : if (has_epsilon) {
mov ecx, eax
test ebx, ebx
je SHORT $LN12@xmlFAElimi
; 2005 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
xor ebx, ebx
test eax, eax
jle SHORT $LN12@xmlFAElimi
$LL13@xmlFAElimi:
; 2006 : state = ctxt->states[statenr];
mov eax, DWORD PTR [edx+52]
mov edi, DWORD PTR [eax+ebx*4]
; 2007 : if (state == NULL)
test edi, edi
je SHORT $LN11@xmlFAElimi
; 2008 : continue;
; 2009 : for (transnr = 0;transnr < state->nbTrans;transnr++) {
xor ecx, ecx
cmp DWORD PTR [edi+24], ecx
jle SHORT $LN11@xmlFAElimi
xor esi, esi
$LL16@xmlFAElimi:
; 2010 : xmlRegTransPtr trans = &(state->trans[transnr]);
mov eax, DWORD PTR [edi+28]
add eax, esi
; 2011 : if ((trans->atom == NULL) &&
; 2012 : (trans->count < 0) &&
cmp DWORD PTR [eax], 0
jne SHORT $LN14@xmlFAElimi
cmp DWORD PTR [eax+12], 0
jge SHORT $LN14@xmlFAElimi
cmp DWORD PTR [eax+4], 0
jl SHORT $LN14@xmlFAElimi
; 2013 : (trans->to >= 0)) {
; 2014 : trans->to = -1;
mov DWORD PTR [eax+4], -1
$LN14@xmlFAElimi:
; 2008 : continue;
; 2009 : for (transnr = 0;transnr < state->nbTrans;transnr++) {
inc ecx
add esi, 20 ; 00000014H
cmp ecx, DWORD PTR [edi+24]
jl SHORT $LL16@xmlFAElimi
$LN11@xmlFAElimi:
; 2005 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
mov ecx, DWORD PTR [edx+48]
inc ebx
cmp ebx, ecx
jl SHORT $LL13@xmlFAElimi
$LN12@xmlFAElimi:
; 2015 : }
; 2016 : }
; 2017 : }
; 2018 : }
; 2019 :
; 2020 : /*
; 2021 : * Use this pass to detect unreachable states too
; 2022 : */
; 2023 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
xor esi, esi
test ecx, ecx
jle SHORT $LN18@xmlFAElimi
npad 4
$LL19@xmlFAElimi:
; 2024 : state = ctxt->states[statenr];
mov eax, DWORD PTR [edx+52]
mov eax, DWORD PTR [eax+esi*4]
; 2025 : if (state != NULL)
test eax, eax
je SHORT $LN17@xmlFAElimi
; 2026 : state->reached = XML_REGEXP_MARK_NORMAL;
mov DWORD PTR [eax+12], 0
$LN17@xmlFAElimi:
; 2015 : }
; 2016 : }
; 2017 : }
; 2018 : }
; 2019 :
; 2020 : /*
; 2021 : * Use this pass to detect unreachable states too
; 2022 : */
; 2023 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
mov ecx, DWORD PTR [edx+48]
inc esi
cmp esi, ecx
jl SHORT $LL19@xmlFAElimi
$LN18@xmlFAElimi:
; 2027 : }
; 2028 : state = ctxt->states[0];
mov eax, DWORD PTR [edx+52]
mov edi, DWORD PTR [eax]
; 2029 : if (state != NULL)
test edi, edi
je $LN21@xmlFAElimi
; 2030 : state->reached = XML_REGEXP_MARK_START;
mov DWORD PTR [edi+12], 1
mov ecx, DWORD PTR [edx+48]
$LL20@xmlFAElimi:
; 2031 : while (state != NULL) {
; 2032 : xmlRegStatePtr target = NULL;
xor ebx, ebx
; 2033 : state->reached = XML_REGEXP_MARK_VISITED;
mov DWORD PTR [edi+12], 2
; 2034 : /*
; 2035 : * Mark all states reachable from the current reachable state
; 2036 : */
; 2037 : for (transnr = 0;transnr < state->nbTrans;transnr++) {
xor ecx, ecx
mov DWORD PTR _target$1$[ebp], ebx
cmp DWORD PTR [edi+24], ecx
jle SHORT $LN138@xmlFAElimi
; 2031 : while (state != NULL) {
; 2032 : xmlRegStatePtr target = NULL;
xor esi, esi
$LL24@xmlFAElimi:
; 2038 : if ((state->trans[transnr].to >= 0) &&
mov eax, DWORD PTR [edi+28]
mov ebx, DWORD PTR [esi+eax+4]
test ebx, ebx
js SHORT $LN143@xmlFAElimi
cmp DWORD PTR [esi+eax], 0
jne SHORT $LN45@xmlFAElimi
cmp DWORD PTR [esi+eax+12], 0
jl SHORT $LN143@xmlFAElimi
$LN45@xmlFAElimi:
; 2039 : ((state->trans[transnr].atom != NULL) ||
; 2040 : (state->trans[transnr].count >= 0))) {
; 2041 : int newto = state->trans[transnr].to;
; 2042 :
; 2043 : if (ctxt->states[newto] == NULL)
mov eax, DWORD PTR [edx+52]
mov eax, DWORD PTR [eax+ebx*4]
test eax, eax
je SHORT $LN143@xmlFAElimi
; 2044 : continue;
; 2045 : if (ctxt->states[newto]->reached == XML_REGEXP_MARK_NORMAL) {
cmp DWORD PTR [eax+12], 0
jne SHORT $LN143@xmlFAElimi
; 2046 : ctxt->states[newto]->reached = XML_REGEXP_MARK_START;
mov DWORD PTR [eax+12], 1
; 2047 : target = ctxt->states[newto];
mov eax, DWORD PTR [edx+52]
mov ebx, DWORD PTR [eax+ebx*4]
mov DWORD PTR _target$1$[ebp], ebx
jmp SHORT $LN22@xmlFAElimi
$LN143@xmlFAElimi:
; 2034 : /*
; 2035 : * Mark all states reachable from the current reachable state
; 2036 : */
; 2037 : for (transnr = 0;transnr < state->nbTrans;transnr++) {
mov ebx, DWORD PTR _target$1$[ebp]
$LN22@xmlFAElimi:
inc ecx
add esi, 20 ; 00000014H
cmp ecx, DWORD PTR [edi+24]
jl SHORT $LL24@xmlFAElimi
; 2048 : }
; 2049 : }
; 2050 : }
; 2051 :
; 2052 : /*
; 2053 : * find the next accessible state not explored
; 2054 : */
; 2055 : if (target == NULL) {
test ebx, ebx
jne SHORT $LN139@xmlFAElimi
$LN138@xmlFAElimi:
; 2056 : for (statenr = 1;statenr < ctxt->nbStates;statenr++) {
mov edi, DWORD PTR [edx+48]
mov esi, 1
cmp edi, esi
jle SHORT $LN139@xmlFAElimi
; 2057 : state = ctxt->states[statenr];
mov eax, DWORD PTR [edx+52]
add eax, 4
$LL27@xmlFAElimi:
mov ecx, DWORD PTR [eax]
; 2058 : if ((state != NULL) && (state->reached ==
test ecx, ecx
je SHORT $LN25@xmlFAElimi
cmp DWORD PTR [ecx+12], 1
je SHORT $LN94@xmlFAElimi
$LN25@xmlFAElimi:
; 2056 : for (statenr = 1;statenr < ctxt->nbStates;statenr++) {
inc esi
add eax, 4
cmp esi, edi
jl SHORT $LL27@xmlFAElimi
jmp SHORT $LN139@xmlFAElimi
$LN94@xmlFAElimi:
; 2059 : XML_REGEXP_MARK_START)) {
; 2060 : target = state;
mov ebx, ecx
$LN139@xmlFAElimi:
; 2061 : break;
; 2062 : }
; 2063 : }
; 2064 : }
; 2065 : state = target;
mov edi, ebx
test ebx, ebx
jne $LL20@xmlFAElimi
mov ecx, DWORD PTR [edx+48]
$LN21@xmlFAElimi:
; 2066 : }
; 2067 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
xor edi, edi
test ecx, ecx
jle SHORT $LN144@xmlFAElimi
npad 4
$LL30@xmlFAElimi:
; 2068 : state = ctxt->states[statenr];
mov eax, DWORD PTR [edx+52]
mov esi, DWORD PTR [eax+edi*4]
; 2069 : if ((state != NULL) && (state->reached == XML_REGEXP_MARK_NORMAL)) {
test esi, esi
je SHORT $LN28@xmlFAElimi
cmp DWORD PTR [esi+12], 0
jne SHORT $LN28@xmlFAElimi
; 901 : if (state->trans != NULL)
mov eax, DWORD PTR [esi+28]
test eax, eax
je SHORT $LN78@xmlFAElimi
; 902 : xmlFree(state->trans);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN78@xmlFAElimi:
; 903 : if (state->transTo != NULL)
mov eax, DWORD PTR [esi+40]
test eax, eax
je SHORT $LN79@xmlFAElimi
; 904 : xmlFree(state->transTo);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN79@xmlFAElimi:
; 905 : xmlFree(state);
push esi
call DWORD PTR _xmlFree
; 2070 : #ifdef DEBUG_REGEXP_GRAPH
; 2071 : printf("Removed unreachable state %d\n", statenr);
; 2072 : #endif
; 2073 : xmlRegFreeState(state);
; 2074 : ctxt->states[statenr] = NULL;
mov edx, DWORD PTR _ctxt$[ebp]
; 905 : xmlFree(state);
add esp, 4
; 2070 : #ifdef DEBUG_REGEXP_GRAPH
; 2071 : printf("Removed unreachable state %d\n", statenr);
; 2072 : #endif
; 2073 : xmlRegFreeState(state);
; 2074 : ctxt->states[statenr] = NULL;
mov eax, DWORD PTR [edx+52]
mov DWORD PTR [eax+edi*4], 0
$LN28@xmlFAElimi:
; 2066 : }
; 2067 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
inc edi
cmp edi, DWORD PTR [edx+48]
jl SHORT $LL30@xmlFAElimi
$LN144@xmlFAElimi:
pop edi
pop esi
pop ebx
$LN29@xmlFAElimi:
; 2075 : }
; 2076 : }
; 2077 :
; 2078 : }
mov esp, ebp
pop ebp
ret 0
_xmlFAEliminateEpsilonTransitions ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAEliminateSimpleEpsilonTransitions
_TEXT SEGMENT
_state$1$ = -16 ; size = 4
_statenr$1$ = -12 ; size = 4
_newto$1$ = -8 ; size = 4
_i$1$ = -4 ; size = 4
_ctxt$ = 8 ; size = 4
_xmlFAEliminateSimpleEpsilonTransitions PROC ; COMDAT
; 1865 : xmlFAEliminateSimpleEpsilonTransitions(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
sub esp, 16 ; 00000010H
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
xor edx, edx
mov DWORD PTR _statenr$1$[ebp], edx
cmp DWORD PTR [esi+48], edx
jle $LN3@xmlFAElimi
push ebx
push edi
$LL4@xmlFAElimi:
; 1870 : state = ctxt->states[statenr];
mov eax, DWORD PTR [esi+52]
mov ecx, DWORD PTR [eax+edx*4]
mov DWORD PTR _state$1$[ebp], ecx
; 1871 : if (state == NULL)
test ecx, ecx
je $LN2@xmlFAElimi
; 1872 : continue;
; 1873 : if (state->nbTrans != 1)
cmp DWORD PTR [ecx+24], 1
jne $LN2@xmlFAElimi
; 1874 : continue;
; 1875 : if (state->type == XML_REGEXP_UNREACH_STATE)
mov edi, DWORD PTR [ecx]
cmp edi, 5
je $LN2@xmlFAElimi
; 1876 : continue;
; 1877 : /* is the only transition out a basic transition */
; 1878 : if ((state->trans[0].atom == NULL) &&
; 1879 : (state->trans[0].to >= 0) &&
; 1880 : (state->trans[0].to != statenr) &&
; 1881 : (state->trans[0].counter < 0) &&
mov eax, DWORD PTR [ecx+28]
cmp DWORD PTR [eax], 0
jne $LN2@xmlFAElimi
mov ebx, DWORD PTR [eax+4]
mov DWORD PTR _newto$1$[ebp], ebx
test ebx, ebx
js $LN2@xmlFAElimi
cmp ebx, edx
je $LN2@xmlFAElimi
cmp DWORD PTR [eax+8], 0
jge $LN2@xmlFAElimi
cmp DWORD PTR [eax+12], 0
jge $LN2@xmlFAElimi
; 1882 : (state->trans[0].count < 0)) {
; 1883 : newto = state->trans[0].to;
; 1884 :
; 1885 : if (state->type == XML_REGEXP_START_STATE) {
cmp edi, 1
je $LN2@xmlFAElimi
; 1886 : #ifdef DEBUG_REGEXP_GRAPH
; 1887 : printf("Found simple epsilon trans from start %d to %d\n",
; 1888 : statenr, newto);
; 1889 : #endif
; 1890 : } else {
; 1891 : #ifdef DEBUG_REGEXP_GRAPH
; 1892 : printf("Found simple epsilon trans from %d to %d\n",
; 1893 : statenr, newto);
; 1894 : #endif
; 1895 : for (i = 0;i < state->nbTransTo;i++) {
xor ebx, ebx
mov DWORD PTR _i$1$[ebp], ebx
cmp DWORD PTR [ecx+36], ebx
jle SHORT $LN6@xmlFAElimi
$LL7@xmlFAElimi:
; 1896 : tmp = ctxt->states[state->transTo[i]];
mov eax, DWORD PTR [ecx+40]
mov ecx, DWORD PTR [eax+ebx*4]
; 1897 : for (j = 0;j < tmp->nbTrans;j++) {
xor ebx, ebx
mov eax, DWORD PTR [esi+52]
mov edi, DWORD PTR [eax+ecx*4]
cmp DWORD PTR [edi+24], ebx
jle SHORT $LN5@xmlFAElimi
; 1896 : tmp = ctxt->states[state->transTo[i]];
xor esi, esi
npad 8
$LL10@xmlFAElimi:
; 1898 : if (tmp->trans[j].to == statenr) {
mov eax, DWORD PTR [edi+28]
cmp DWORD PTR [eax+esi+4], edx
jne SHORT $LN8@xmlFAElimi
; 1899 : #ifdef DEBUG_REGEXP_GRAPH
; 1900 : printf("Changed transition %d on %d to go to %d\n",
; 1901 : j, tmp->no, newto);
; 1902 : #endif
; 1903 : tmp->trans[j].to = -1;
; 1904 : xmlRegStateAddTrans(ctxt, tmp, tmp->trans[j].atom,
mov edx, DWORD PTR _ctxt$[ebp]
mov DWORD PTR [eax+esi+4], -1
mov ecx, DWORD PTR [edi+28]
mov eax, DWORD PTR [edx+52]
mov edx, DWORD PTR _newto$1$[ebp]
push DWORD PTR [ecx+esi+12]
push DWORD PTR [ecx+esi+8]
push DWORD PTR [eax+edx*4]
mov edx, DWORD PTR _ctxt$[ebp]
push DWORD PTR [ecx+esi]
push edi
push edx
call _xmlRegStateAddTrans
mov edx, DWORD PTR _statenr$1$[ebp]
add esp, 24 ; 00000018H
$LN8@xmlFAElimi:
; 1897 : for (j = 0;j < tmp->nbTrans;j++) {
inc ebx
add esi, 20 ; 00000014H
cmp ebx, DWORD PTR [edi+24]
jl SHORT $LL10@xmlFAElimi
mov esi, DWORD PTR _ctxt$[ebp]
$LN5@xmlFAElimi:
; 1886 : #ifdef DEBUG_REGEXP_GRAPH
; 1887 : printf("Found simple epsilon trans from start %d to %d\n",
; 1888 : statenr, newto);
; 1889 : #endif
; 1890 : } else {
; 1891 : #ifdef DEBUG_REGEXP_GRAPH
; 1892 : printf("Found simple epsilon trans from %d to %d\n",
; 1893 : statenr, newto);
; 1894 : #endif
; 1895 : for (i = 0;i < state->nbTransTo;i++) {
mov ebx, DWORD PTR _i$1$[ebp]
mov ecx, DWORD PTR _state$1$[ebp]
inc ebx
mov DWORD PTR _i$1$[ebp], ebx
cmp ebx, DWORD PTR [ecx+36]
jl SHORT $LL7@xmlFAElimi
mov edi, DWORD PTR [ecx]
$LN6@xmlFAElimi:
; 1905 : ctxt->states[newto],
; 1906 : tmp->trans[j].counter,
; 1907 : tmp->trans[j].count);
; 1908 : }
; 1909 : }
; 1910 : }
; 1911 : if (state->type == XML_REGEXP_FINAL_STATE)
cmp edi, 2
jne SHORT $LN18@xmlFAElimi
; 1912 : ctxt->states[newto]->type = XML_REGEXP_FINAL_STATE;
mov eax, DWORD PTR [esi+52]
mov ebx, DWORD PTR _newto$1$[ebp]
mov eax, DWORD PTR [eax+ebx*4]
mov DWORD PTR [eax], edi
$LN18@xmlFAElimi:
; 1913 : /* eliminate the transition completely */
; 1914 : state->nbTrans = 0;
mov DWORD PTR [ecx+24], 0
; 1915 :
; 1916 : state->type = XML_REGEXP_UNREACH_STATE;
mov DWORD PTR [ecx], 5
$LN2@xmlFAElimi:
; 1866 : int statenr, i, j, newto;
; 1867 : xmlRegStatePtr state, tmp;
; 1868 :
; 1869 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
inc edx
mov DWORD PTR _statenr$1$[ebp], edx
cmp edx, DWORD PTR [esi+48]
jl $LL4@xmlFAElimi
pop edi
pop ebx
$LN3@xmlFAElimi:
pop esi
; 1917 :
; 1918 : }
; 1919 :
; 1920 : }
; 1921 : }
; 1922 : }
mov esp, ebp
pop ebp
ret 0
_xmlFAEliminateSimpleEpsilonTransitions ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAReduceEpsilonTransitions
_TEXT SEGMENT
tv632 = -8 ; size = 4
_transnr$1$ = -4 ; size = 4
_from$1$ = 8 ; size = 4
_ctxt$ = 8 ; size = 4
_fromnr$ = 12 ; size = 4
_tonr$ = 16 ; size = 4
_counter$ = 20 ; size = 4
_xmlFAReduceEpsilonTransitions PROC ; COMDAT
; 1777 : int tonr, int counter) {
push ebp
mov ebp, esp
sub esp, 8
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
mov eax, DWORD PTR _fromnr$[ebp]
mov edi, DWORD PTR [esi+52]
mov ebx, DWORD PTR [edi+eax*4]
mov DWORD PTR _from$1$[ebp], ebx
test ebx, ebx
je $LN8@xmlFAReduc
; 1778 : int transnr;
; 1779 : xmlRegStatePtr from;
; 1780 : xmlRegStatePtr to;
; 1781 :
; 1782 : #ifdef DEBUG_REGEXP_GRAPH
; 1783 : printf("xmlFAReduceEpsilonTransitions(%d, %d)\n", fromnr, tonr);
; 1784 : #endif
; 1785 : from = ctxt->states[fromnr];
; 1786 : if (from == NULL)
; 1787 : return;
; 1788 : to = ctxt->states[tonr];
mov eax, DWORD PTR _tonr$[ebp]
mov edi, DWORD PTR [edi+eax*4]
; 1789 : if (to == NULL)
test edi, edi
je $LN8@xmlFAReduc
; 1790 : return;
; 1791 : if ((to->mark == XML_REGEXP_MARK_START) ||
mov eax, DWORD PTR [edi+4]
cmp eax, 1
je $LN8@xmlFAReduc
cmp eax, 2
je $LN8@xmlFAReduc
; 1792 : (to->mark == XML_REGEXP_MARK_VISITED))
; 1793 : return;
; 1794 :
; 1795 : to->mark = XML_REGEXP_MARK_VISITED;
; 1796 : if (to->type == XML_REGEXP_FINAL_STATE) {
cmp DWORD PTR [edi], 2
mov DWORD PTR [edi+4], 2
jne SHORT $LN9@xmlFAReduc
; 1797 : #ifdef DEBUG_REGEXP_GRAPH
; 1798 : printf("State %d is final, so %d becomes final\n", tonr, fromnr);
; 1799 : #endif
; 1800 : from->type = XML_REGEXP_FINAL_STATE;
mov DWORD PTR [ebx], 2
$LN9@xmlFAReduc:
; 1801 : }
; 1802 : for (transnr = 0;transnr < to->nbTrans;transnr++) {
cmp DWORD PTR [edi+24], 0
mov DWORD PTR _transnr$1$[ebp], 0
jle $LN3@xmlFAReduc
xor ecx, ecx
mov DWORD PTR tv632[ebp], ecx
$LL4@xmlFAReduc:
; 1803 : if (to->trans[transnr].to < 0)
mov eax, DWORD PTR [edi+28]
add eax, ecx
mov ecx, DWORD PTR [eax+4]
test ecx, ecx
js SHORT $LN2@xmlFAReduc
; 1804 : continue;
; 1805 : if (to->trans[transnr].atom == NULL) {
mov edx, DWORD PTR [eax]
test edx, edx
jne SHORT $LN11@xmlFAReduc
; 1806 : /*
; 1807 : * Don't remove counted transitions
; 1808 : * Don't loop either
; 1809 : */
; 1810 : if (to->trans[transnr].to != fromnr) {
cmp ecx, DWORD PTR _fromnr$[ebp]
je SHORT $LN2@xmlFAReduc
; 1811 : if (to->trans[transnr].count >= 0) {
mov edx, DWORD PTR [eax+12]
test edx, edx
js SHORT $LN14@xmlFAReduc
; 1812 : int newto = to->trans[transnr].to;
; 1813 :
; 1814 : xmlRegStateAddTrans(ctxt, from, NULL,
mov eax, DWORD PTR [esi+52]
push edx
push -1
push DWORD PTR [eax+ecx*4]
push 0
; 1815 : ctxt->states[newto],
; 1816 : -1, to->trans[transnr].count);
; 1817 : } else {
jmp SHORT $LN25@xmlFAReduc
$LN14@xmlFAReduc:
; 1818 : #ifdef DEBUG_REGEXP_GRAPH
; 1819 : printf("Found epsilon trans %d from %d to %d\n",
; 1820 : transnr, tonr, to->trans[transnr].to);
; 1821 : #endif
; 1822 : if (to->trans[transnr].counter >= 0) {
mov eax, DWORD PTR [eax+8]
test eax, eax
js SHORT $LN16@xmlFAReduc
; 1823 : xmlFAReduceEpsilonTransitions(ctxt, fromnr,
push eax
push ecx
push DWORD PTR _fromnr$[ebp]
push esi
call _xmlFAReduceEpsilonTransitions
add esp, 16 ; 00000010H
; 1824 : to->trans[transnr].to,
; 1825 : to->trans[transnr].counter);
; 1826 : } else {
jmp SHORT $LN2@xmlFAReduc
$LN16@xmlFAReduc:
; 1827 : xmlFAReduceEpsilonTransitions(ctxt, fromnr,
push DWORD PTR _counter$[ebp]
push ecx
push DWORD PTR _fromnr$[ebp]
push esi
call _xmlFAReduceEpsilonTransitions
add esp, 16 ; 00000010H
; 1828 : to->trans[transnr].to,
; 1829 : counter);
; 1830 : }
; 1831 : }
; 1832 : }
; 1833 : } else {
jmp SHORT $LN2@xmlFAReduc
$LN11@xmlFAReduc:
; 1834 : int newto = to->trans[transnr].to;
; 1835 :
; 1836 : if (to->trans[transnr].counter >= 0) {
mov ebx, DWORD PTR [eax+8]
mov eax, DWORD PTR [esi+52]
push -1
mov eax, DWORD PTR [eax+ecx*4]
test ebx, ebx
js SHORT $LN18@xmlFAReduc
; 1837 : xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
push ebx
; 1838 : ctxt->states[newto],
; 1839 : to->trans[transnr].counter, -1);
; 1840 : } else {
jmp SHORT $LN26@xmlFAReduc
$LN18@xmlFAReduc:
; 1841 : xmlRegStateAddTrans(ctxt, from, to->trans[transnr].atom,
push DWORD PTR _counter$[ebp]
$LN26@xmlFAReduc:
; 1801 : }
; 1802 : for (transnr = 0;transnr < to->nbTrans;transnr++) {
mov ebx, DWORD PTR _from$1$[ebp]
push eax
push edx
$LN25@xmlFAReduc:
push ebx
push esi
call _xmlRegStateAddTrans
add esp, 24 ; 00000018H
$LN2@xmlFAReduc:
mov eax, DWORD PTR _transnr$1$[ebp]
mov ecx, DWORD PTR tv632[ebp]
inc eax
add ecx, 20 ; 00000014H
mov DWORD PTR _transnr$1$[ebp], eax
mov DWORD PTR tv632[ebp], ecx
cmp eax, DWORD PTR [edi+24]
jl $LL4@xmlFAReduc
$LN3@xmlFAReduc:
; 1842 : ctxt->states[newto], counter, -1);
; 1843 : }
; 1844 : }
; 1845 : }
; 1846 : to->mark = XML_REGEXP_MARK_NORMAL;
mov DWORD PTR [edi+4], 0
$LN8@xmlFAReduc:
pop edi
; 1847 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
_xmlFAReduceEpsilonTransitions ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAGenerateTransitions
_TEXT SEGMENT
_end$1$ = -8 ; size = 4
_nullable$1$ = -4 ; size = 4
_ctxt$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_tmp$1$ = 20 ; size = 4
_newstate$1$ = 20 ; size = 4
_atom$ = 20 ; size = 4
_xmlFAGenerateTransitions PROC ; COMDAT
; 1545 : xmlRegStatePtr to, xmlRegAtomPtr atom) {
push ebp
mov ebp, esp
sub esp, 8
push ebx
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov ebx, DWORD PTR _atom$[ebp]
mov DWORD PTR _nullable$1$[ebp], 0
test ebx, ebx
jne SHORT $LN6@xmlFAGener
; 1546 : xmlRegStatePtr end;
; 1547 : int nullable = 0;
; 1548 :
; 1549 : if (atom == NULL) {
; 1550 : ERROR("genrate transition: atom == NULL");
mov eax, DWORD PTR _ctxt$[ebp]
push OFFSET ??_C@_0CB@LMLDANHN@genrate?5transition?3?5atom?5?$DN?$DN?5NUL@
push eax
mov DWORD PTR [eax+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
; 1551 : return(-1);
or eax, -1
pop ebx
; 1765 : }
mov esp, ebp
pop ebp
ret 0
$LN6@xmlFAGener:
; 1552 : }
; 1553 : if (atom->type == XML_REGEXP_SUBREG) {
cmp DWORD PTR [ebx+4], 4
push esi
push edi
jne $LN7@xmlFAGener
; 1554 : /*
; 1555 : * this is a subexpression handling one should not need to
; 1556 : * create a new node except for XML_REGEXP_QUANT_RANGE.
; 1557 : */
; 1558 : if (xmlRegAtomPush(ctxt, atom) < 0) {
mov edi, DWORD PTR _ctxt$[ebp]
push ebx
push edi
call _xmlRegAtomPush
add esp, 8
test eax, eax
js $LN33@xmlFAGener
; 1559 : return(-1);
; 1560 : }
; 1561 : if ((to != NULL) && (atom->stop != to) &&
mov esi, DWORD PTR _to$[ebp]
mov DWORD PTR _newstate$1$[ebp], esi
test esi, esi
je SHORT $LN9@xmlFAGener
mov eax, DWORD PTR [ebx+44]
cmp eax, esi
je SHORT $LN9@xmlFAGener
cmp DWORD PTR [ebx+8], 8
je SHORT $LN9@xmlFAGener
; 1562 : (atom->quant != XML_REGEXP_QUANT_RANGE)) {
; 1563 : /*
; 1564 : * Generate an epsilon transition to link to the target
; 1565 : */
; 1566 : xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
push esi
push eax
push edi
call _xmlFAGenerateEpsilonTransition
add esp, 12 ; 0000000cH
$LN9@xmlFAGener:
; 1567 : #ifdef DV
; 1568 : } else if ((to == NULL) && (atom->quant != XML_REGEXP_QUANT_RANGE) &&
; 1569 : (atom->quant != XML_REGEXP_QUANT_ONCE)) {
; 1570 : to = xmlRegNewState(ctxt);
; 1571 : xmlRegStatePush(ctxt, to);
; 1572 : ctxt->state = to;
; 1573 : xmlFAGenerateEpsilonTransition(ctxt, atom->stop, to);
; 1574 : #endif
; 1575 : }
; 1576 : switch (atom->quant) {
mov eax, DWORD PTR [ebx+8]
add eax, -3 ; fffffffdH
cmp eax, 5
ja $LN23@xmlFAGener
jmp DWORD PTR $LN51@xmlFAGener[eax*4]
$LN10@xmlFAGener:
; 1577 : case XML_REGEXP_QUANT_OPT:
; 1578 : atom->quant = XML_REGEXP_QUANT_ONCE;
mov eax, DWORD PTR [ebx+36]
mov DWORD PTR [ebx+8], 2
; 1579 : /*
; 1580 : * transition done to the state after end of atom.
; 1581 : * 1. set transition from atom start to new state
; 1582 : * 2. set transition from atom end to this state.
; 1583 : */
; 1584 : if (to == NULL) {
test esi, esi
jne SHORT $LN11@xmlFAGener
; 1585 : xmlFAGenerateEpsilonTransition(ctxt, atom->start, 0);
push esi
push eax
push edi
call _xmlFAGenerateEpsilonTransition
; 1586 : xmlFAGenerateEpsilonTransition(ctxt, atom->stop,
mov eax, DWORD PTR [ebx+44]
add esp, 12 ; 0000000cH
mov esi, DWORD PTR [edi+24]
$LN11@xmlFAGener:
; 1587 : ctxt->state);
; 1588 : } else {
; 1589 : xmlFAGenerateEpsilonTransition(ctxt, atom->start, to);
; 1590 : }
; 1591 : break;
push esi
push eax
push edi
call _xmlFAGenerateEpsilonTransition
add esp, 12 ; 0000000cH
; 1680 : }
; 1681 : default:
; 1682 : break;
; 1683 : }
; 1684 : return(0);
xor eax, eax
pop edi
pop esi
pop ebx
; 1765 : }
mov esp, ebp
pop ebp
ret 0
$LN13@xmlFAGener:
; 1592 : case XML_REGEXP_QUANT_MULT:
; 1593 : atom->quant = XML_REGEXP_QUANT_ONCE;
; 1594 : xmlFAGenerateEpsilonTransition(ctxt, atom->start, atom->stop);
push DWORD PTR [ebx+44]
mov DWORD PTR [ebx+8], 2
push DWORD PTR [ebx+36]
push edi
call _xmlFAGenerateEpsilonTransition
; 1595 : xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
push DWORD PTR [ebx+36]
push DWORD PTR [ebx+44]
push edi
call _xmlFAGenerateEpsilonTransition
add esp, 24 ; 00000018H
; 1680 : }
; 1681 : default:
; 1682 : break;
; 1683 : }
; 1684 : return(0);
xor eax, eax
pop edi
pop esi
pop ebx
; 1765 : }
mov esp, ebp
pop ebp
ret 0
$LN14@xmlFAGener:
; 1596 : break;
; 1597 : case XML_REGEXP_QUANT_PLUS:
; 1598 : atom->quant = XML_REGEXP_QUANT_ONCE;
; 1599 : xmlFAGenerateEpsilonTransition(ctxt, atom->stop, atom->start);
push DWORD PTR [ebx+36]
mov DWORD PTR [ebx+8], 2
push DWORD PTR [ebx+44]
push edi
call _xmlFAGenerateEpsilonTransition
add esp, 12 ; 0000000cH
; 1680 : }
; 1681 : default:
; 1682 : break;
; 1683 : }
; 1684 : return(0);
xor eax, eax
pop edi
pop esi
pop ebx
; 1765 : }
mov esp, ebp
pop ebp
ret 0
$LN15@xmlFAGener:
; 1600 : break;
; 1601 : case XML_REGEXP_QUANT_RANGE: {
; 1602 : int counter;
; 1603 : xmlRegStatePtr inter, newstate;
; 1604 :
; 1605 : /*
; 1606 : * create the final state now if needed
; 1607 : */
; 1608 : if (to != NULL) {
test esi, esi
jne SHORT $LN17@xmlFAGener
; 1609 : newstate = to;
; 1610 : } else {
; 1611 : newstate = xmlRegNewState(ctxt);
push edi
call _xmlRegNewState
; 1612 : xmlRegStatePush(ctxt, newstate);
push eax
push edi
mov DWORD PTR _newstate$1$[ebp], eax
call _xmlRegStatePush
add esp, 12 ; 0000000cH
$LN17@xmlFAGener:
; 1613 : }
; 1614 :
; 1615 : /*
; 1616 : * The principle here is to use counted transition
; 1617 : * to avoid explosion in the number of states in the
; 1618 : * graph. This is clearly more complex but should not
; 1619 : * be exploitable at runtime.
; 1620 : */
; 1621 : if ((atom->min == 0) && (atom->start0 == NULL)) {
cmp DWORD PTR [ebx+12], 0
jne $LN46@xmlFAGener
cmp DWORD PTR [ebx+40], 0
jne $LN46@xmlFAGener
; 1622 : xmlRegAtomPtr copy;
; 1623 : /*
; 1624 : * duplicate a transition based on atom to count next
; 1625 : * occurences after 1. We cannot loop to atom->start
; 1626 : * directly because we need an epsilon transition to
; 1627 : * newstate.
; 1628 : */
; 1629 : /* ???? For some reason it seems we never reach that
; 1630 : case, I suppose this got optimized out before when
; 1631 : building the automata */
; 1632 : copy = xmlRegCopyAtom(ctxt, atom);
push ebx
push edi
call _xmlRegCopyAtom
add esp, 8
; 1633 : if (copy == NULL)
test eax, eax
je $LN33@xmlFAGener
; 1634 : return(-1);
; 1635 : copy->quant = XML_REGEXP_QUANT_ONCE;
; 1636 : copy->min = 0;
; 1637 : copy->max = 0;
; 1638 :
; 1639 : if (xmlFAGenerateTransitions(ctxt, atom->start, NULL, copy)
; 1640 : < 0)
push eax
push 0
mov DWORD PTR [eax+8], 2
mov DWORD PTR [eax+12], 0
mov DWORD PTR [eax+16], 0
push DWORD PTR [ebx+36]
push edi
call _xmlFAGenerateTransitions
add esp, 16 ; 00000010H
test eax, eax
js $LN33@xmlFAGener
; 1641 : return(-1);
; 1642 : inter = ctxt->state;
; 1643 : counter = xmlRegGetCounter(ctxt);
push DWORD PTR _ctxt$[ebp]
mov edi, DWORD PTR [edi+24]
call _xmlRegGetCounter
; 1644 : ctxt->counters[counter].min = atom->min - 1;
mov edx, DWORD PTR [ebx+12]
mov esi, eax
mov eax, DWORD PTR _ctxt$[ebp]
dec edx
; 1645 : ctxt->counters[counter].max = atom->max - 1;
; 1646 : /* count the number of times we see it again */
; 1647 : xmlFAGenerateCountedEpsilonTransition(ctxt, inter,
push esi
mov ecx, DWORD PTR [eax+64]
mov DWORD PTR [ecx+esi*8], edx
mov ecx, DWORD PTR [ebx+16]
mov eax, DWORD PTR [eax+64]
dec ecx
mov DWORD PTR [eax+esi*8+4], ecx
push DWORD PTR [ebx+44]
push edi
push DWORD PTR _ctxt$[ebp]
call _xmlFAGenerateCountedEpsilonTransition
; 1648 : atom->stop, counter);
; 1649 : /* allow a way out based on the count */
; 1650 : xmlFAGenerateCountedTransition(ctxt, inter,
push esi
mov esi, DWORD PTR _newstate$1$[ebp]
push esi
push edi
mov edi, DWORD PTR _ctxt$[ebp]
push edi
call _xmlFAGenerateCountedTransition
; 1651 : newstate, counter);
; 1652 : /* and also allow a direct exit for 0 */
; 1653 : xmlFAGenerateEpsilonTransition(ctxt, atom->start,
push esi
push DWORD PTR [ebx+36]
push edi
call _xmlFAGenerateEpsilonTransition
add esp, 48 ; 00000030H
; 1654 : newstate);
; 1655 : } else {
jmp SHORT $LN22@xmlFAGener
$LN46@xmlFAGener:
; 1656 : /*
; 1657 : * either we need the atom at least once or there
; 1658 : * is an atom->start0 allowing to easilly plug the
; 1659 : * epsilon transition.
; 1660 : */
; 1661 : counter = xmlRegGetCounter(ctxt);
push edi
call _xmlRegGetCounter
; 1662 : ctxt->counters[counter].min = atom->min - 1;
mov ecx, DWORD PTR [edi+64]
mov esi, eax
mov edx, DWORD PTR [ebx+12]
dec edx
; 1663 : ctxt->counters[counter].max = atom->max - 1;
; 1664 : /* count the number of times we see it again */
; 1665 : xmlFAGenerateCountedEpsilonTransition(ctxt, atom->stop,
push esi
mov DWORD PTR [ecx+esi*8], edx
mov ecx, DWORD PTR [ebx+16]
mov eax, DWORD PTR [edi+64]
dec ecx
mov DWORD PTR [eax+esi*8+4], ecx
push DWORD PTR [ebx+36]
push DWORD PTR [ebx+44]
push edi
call _xmlFAGenerateCountedEpsilonTransition
; 1666 : atom->start, counter);
; 1667 : /* allow a way out based on the count */
; 1668 : xmlFAGenerateCountedTransition(ctxt, atom->stop,
push esi
mov esi, DWORD PTR _newstate$1$[ebp]
push esi
push DWORD PTR [ebx+44]
push edi
call _xmlFAGenerateCountedTransition
add esp, 36 ; 00000024H
; 1669 : newstate, counter);
; 1670 : /* and if needed allow a direct exit for 0 */
; 1671 : if (atom->min == 0)
cmp DWORD PTR [ebx+12], 0
jne SHORT $LN22@xmlFAGener
; 1672 : xmlFAGenerateEpsilonTransition(ctxt, atom->start0,
push esi
push DWORD PTR [ebx+40]
push edi
call _xmlFAGenerateEpsilonTransition
add esp, 12 ; 0000000cH
$LN22@xmlFAGener:
; 1673 : newstate);
; 1674 :
; 1675 : }
; 1676 : atom->min = 0;
mov DWORD PTR [ebx+12], 0
; 1677 : atom->max = 0;
mov DWORD PTR [ebx+16], 0
; 1678 : atom->quant = XML_REGEXP_QUANT_ONCE;
mov DWORD PTR [ebx+8], 2
; 1679 : ctxt->state = newstate;
mov DWORD PTR [edi+24], esi
$LN23@xmlFAGener:
; 1680 : }
; 1681 : default:
; 1682 : break;
; 1683 : }
; 1684 : return(0);
pop edi
pop esi
xor eax, eax
pop ebx
; 1765 : }
mov esp, ebp
pop ebp
ret 0
$LN7@xmlFAGener:
; 1685 : }
; 1686 : if ((atom->min == 0) && (atom->max == 0) &&
cmp DWORD PTR [ebx+12], 0
jne SHORT $LN24@xmlFAGener
cmp DWORD PTR [ebx+16], 0
jne SHORT $LN24@xmlFAGener
cmp DWORD PTR [ebx+8], 8
jne SHORT $LN24@xmlFAGener
; 1687 : (atom->quant == XML_REGEXP_QUANT_RANGE)) {
; 1688 : /*
; 1689 : * we can discard the atom and generate an epsilon transition instead
; 1690 : */
; 1691 : if (to == NULL) {
mov esi, DWORD PTR _to$[ebp]
mov edi, DWORD PTR _ctxt$[ebp]
test esi, esi
jne SHORT $LN27@xmlFAGener
; 1692 : to = xmlRegNewState(ctxt);
push edi
call _xmlRegNewState
mov esi, eax
add esp, 4
; 1693 : if (to != NULL)
test esi, esi
je $LN33@xmlFAGener
; 1694 : xmlRegStatePush(ctxt, to);
push esi
push edi
call _xmlRegStatePush
add esp, 8
$LN27@xmlFAGener:
; 1695 : else {
; 1696 : return(-1);
; 1697 : }
; 1698 : }
; 1699 : xmlFAGenerateEpsilonTransition(ctxt, from, to);
push esi
push DWORD PTR _from$[ebp]
push edi
call _xmlFAGenerateEpsilonTransition
; 1700 : ctxt->state = to;
; 1701 : xmlRegFreeAtom(atom);
push ebx
mov DWORD PTR [edi+24], esi
call _xmlRegFreeAtom
add esp, 16 ; 00000010H
; 1702 : return(0);
xor eax, eax
pop edi
pop esi
pop ebx
; 1765 : }
mov esp, ebp
pop ebp
ret 0
$LN24@xmlFAGener:
; 1703 : }
; 1704 : if (to == NULL) {
mov esi, DWORD PTR _to$[ebp]
mov edi, DWORD PTR _ctxt$[ebp]
test esi, esi
jne SHORT $LN30@xmlFAGener
; 1705 : to = xmlRegNewState(ctxt);
push edi
call _xmlRegNewState
mov esi, eax
add esp, 4
; 1706 : if (to != NULL)
test esi, esi
je $LN33@xmlFAGener
; 1707 : xmlRegStatePush(ctxt, to);
push esi
push edi
call _xmlRegStatePush
add esp, 8
$LN30@xmlFAGener:
; 1708 : else {
; 1709 : return(-1);
; 1710 : }
; 1711 : }
; 1712 : end = to;
; 1713 : if ((atom->quant == XML_REGEXP_QUANT_MULT) ||
mov eax, DWORD PTR [ebx+8]
mov DWORD PTR _end$1$[ebp], esi
cmp eax, 4
je SHORT $LN32@xmlFAGener
cmp eax, 5
jne SHORT $LN31@xmlFAGener
$LN32@xmlFAGener:
; 1714 : (atom->quant == XML_REGEXP_QUANT_PLUS)) {
; 1715 : /*
; 1716 : * Do not pollute the target state by adding transitions from
; 1717 : * it as it is likely to be the shared target of multiple branches.
; 1718 : * So isolate with an epsilon transition.
; 1719 : */
; 1720 : xmlRegStatePtr tmp;
; 1721 :
; 1722 : tmp = xmlRegNewState(ctxt);
push edi
call _xmlRegNewState
add esp, 4
mov DWORD PTR _tmp$1$[ebp], eax
; 1723 : if (tmp != NULL)
test eax, eax
je $LN33@xmlFAGener
; 1724 : xmlRegStatePush(ctxt, tmp);
push eax
push edi
call _xmlRegStatePush
; 1727 : }
; 1728 : xmlFAGenerateEpsilonTransition(ctxt, tmp, to);
push esi
mov esi, DWORD PTR _tmp$1$[ebp]
push esi
push edi
call _xmlFAGenerateEpsilonTransition
add esp, 20 ; 00000014H
$LN31@xmlFAGener:
; 1729 : to = tmp;
; 1730 : }
; 1731 : if (xmlRegAtomPush(ctxt, atom) < 0) {
push ebx
push edi
call _xmlRegAtomPush
add esp, 8
test eax, eax
js $LN33@xmlFAGener
; 1732 : return(-1);
; 1733 : }
; 1734 : if ((atom->quant == XML_REGEXP_QUANT_RANGE) &&
; 1735 : (atom->min == 0) && (atom->max > 0)) {
cmp DWORD PTR [ebx+8], 8
jne SHORT $LN37@xmlFAGener
cmp DWORD PTR [ebx+12], 0
jne SHORT $LN37@xmlFAGener
mov eax, DWORD PTR [ebx+16]
test eax, eax
jle SHORT $LN37@xmlFAGener
; 1736 : nullable = 1;
mov DWORD PTR _nullable$1$[ebp], 1
; 1737 : atom->min = 1;
mov DWORD PTR [ebx+12], 1
; 1738 : if (atom->max == 1)
cmp eax, 1
jne SHORT $LN37@xmlFAGener
; 1739 : atom->quant = XML_REGEXP_QUANT_OPT;
mov DWORD PTR [ebx+8], 3
$LN37@xmlFAGener:
; 1740 : }
; 1741 : xmlRegStateAddTrans(ctxt, from, atom, to, -1, -1);
push -1
push -1
push esi
push ebx
push DWORD PTR _from$[ebp]
push edi
call _xmlRegStateAddTrans
; 1742 : ctxt->state = end;
mov eax, DWORD PTR _end$1$[ebp]
add esp, 24 ; 00000018H
mov DWORD PTR [edi+24], eax
; 1743 : switch (atom->quant) {
mov eax, DWORD PTR [ebx+8]
add eax, -3 ; fffffffdH
cmp eax, 5
ja SHORT $LN42@xmlFAGener
jmp DWORD PTR $LN52@xmlFAGener[eax*4]
$LN38@xmlFAGener:
; 1744 : case XML_REGEXP_QUANT_OPT:
; 1745 : atom->quant = XML_REGEXP_QUANT_ONCE;
mov DWORD PTR [ebx+8], 2
; 1746 : xmlFAGenerateEpsilonTransition(ctxt, from, to);
; 1747 : break;
jmp SHORT $LN49@xmlFAGener
$LN39@xmlFAGener:
; 1748 : case XML_REGEXP_QUANT_MULT:
; 1749 : atom->quant = XML_REGEXP_QUANT_ONCE;
; 1750 : xmlFAGenerateEpsilonTransition(ctxt, from, to);
mov eax, DWORD PTR _from$[ebp]
push esi
push eax
push edi
mov DWORD PTR [ebx+8], 2
call _xmlFAGenerateEpsilonTransition
; 1751 : xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
push -1
push -1
push esi
push ebx
push esi
push edi
call _xmlRegStateAddTrans
add esp, 36 ; 00000024H
; 1759 : xmlFAGenerateEpsilonTransition(ctxt, from, to);
; 1760 : break;
; 1761 : default:
; 1762 : break;
; 1763 : }
; 1764 : return(0);
xor eax, eax
pop edi
pop esi
pop ebx
; 1765 : }
mov esp, ebp
pop ebp
ret 0
$LN40@xmlFAGener:
; 1752 : break;
; 1753 : case XML_REGEXP_QUANT_PLUS:
; 1754 : atom->quant = XML_REGEXP_QUANT_ONCE;
; 1755 : xmlRegStateAddTrans(ctxt, to, atom, to, -1, -1);
push -1
push -1
push esi
push ebx
push esi
push edi
mov DWORD PTR [ebx+8], 2
call _xmlRegStateAddTrans
add esp, 24 ; 00000018H
; 1759 : xmlFAGenerateEpsilonTransition(ctxt, from, to);
; 1760 : break;
; 1761 : default:
; 1762 : break;
; 1763 : }
; 1764 : return(0);
xor eax, eax
pop edi
pop esi
pop ebx
; 1765 : }
mov esp, ebp
pop ebp
ret 0
$LN41@xmlFAGener:
; 1756 : break;
; 1757 : case XML_REGEXP_QUANT_RANGE:
; 1758 : if (nullable)
cmp DWORD PTR _nullable$1$[ebp], 0
je SHORT $LN42@xmlFAGener
$LN49@xmlFAGener:
; 1759 : xmlFAGenerateEpsilonTransition(ctxt, from, to);
; 1760 : break;
; 1761 : default:
; 1762 : break;
; 1763 : }
; 1764 : return(0);
mov eax, DWORD PTR _from$[ebp]
push esi
push eax
push edi
call _xmlFAGenerateEpsilonTransition
add esp, 12 ; 0000000cH
$LN42@xmlFAGener:
pop edi
pop esi
xor eax, eax
pop ebx
; 1765 : }
mov esp, ebp
pop ebp
ret 0
$LN33@xmlFAGener:
pop edi
pop esi
; 1725 : else {
; 1726 : return(-1);
or eax, -1
pop ebx
; 1765 : }
mov esp, ebp
pop ebp
ret 0
npad 3
$LN51@xmlFAGener:
DD $LN10@xmlFAGener
DD $LN13@xmlFAGener
DD $LN14@xmlFAGener
DD $LN23@xmlFAGener
DD $LN23@xmlFAGener
DD $LN15@xmlFAGener
$LN52@xmlFAGener:
DD $LN38@xmlFAGener
DD $LN39@xmlFAGener
DD $LN40@xmlFAGener
DD $LN42@xmlFAGener
DD $LN42@xmlFAGener
DD $LN41@xmlFAGener
_xmlFAGenerateTransitions ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAGenerateCountedTransition
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_counter$ = 20 ; size = 4
_xmlFAGenerateCountedTransition PROC ; COMDAT
; 1525 : xmlRegStatePtr from, xmlRegStatePtr to, int counter) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _to$[ebp]
mov edi, DWORD PTR _ctxt$[ebp]
test esi, esi
jne SHORT $LN2@xmlFAGener
; 1526 : if (to == NULL) {
; 1527 : to = xmlRegNewState(ctxt);
push edi
call _xmlRegNewState
mov esi, eax
; 1528 : xmlRegStatePush(ctxt, to);
push esi
push edi
call _xmlRegStatePush
add esp, 12 ; 0000000cH
; 1529 : ctxt->state = to;
mov DWORD PTR [edi+24], esi
$LN2@xmlFAGener:
; 1530 : }
; 1531 : xmlRegStateAddTrans(ctxt, from, NULL, to, -1, counter);
push DWORD PTR _counter$[ebp]
push -1
push esi
push 0
push DWORD PTR _from$[ebp]
push edi
call _xmlRegStateAddTrans
add esp, 24 ; 00000018H
pop edi
pop esi
; 1532 : }
pop ebp
ret 0
_xmlFAGenerateCountedTransition ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAGenerateCountedEpsilonTransition
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_counter$ = 20 ; size = 4
_xmlFAGenerateCountedEpsilonTransition PROC ; COMDAT
; 1506 : xmlRegStatePtr from, xmlRegStatePtr to, int counter) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _to$[ebp]
mov edi, DWORD PTR _ctxt$[ebp]
test esi, esi
jne SHORT $LN2@xmlFAGener
; 1507 : if (to == NULL) {
; 1508 : to = xmlRegNewState(ctxt);
push edi
call _xmlRegNewState
mov esi, eax
; 1509 : xmlRegStatePush(ctxt, to);
push esi
push edi
call _xmlRegStatePush
add esp, 12 ; 0000000cH
; 1510 : ctxt->state = to;
mov DWORD PTR [edi+24], esi
$LN2@xmlFAGener:
; 1511 : }
; 1512 : xmlRegStateAddTrans(ctxt, from, NULL, to, counter, -1);
push -1
push DWORD PTR _counter$[ebp]
push esi
push 0
push DWORD PTR _from$[ebp]
push edi
call _xmlRegStateAddTrans
add esp, 24 ; 00000018H
pop edi
pop esi
; 1513 : }
pop ebp
ret 0
_xmlFAGenerateCountedEpsilonTransition ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAGenerateEpsilonTransition
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_xmlFAGenerateEpsilonTransition PROC ; COMDAT
; 1487 : xmlRegStatePtr from, xmlRegStatePtr to) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _to$[ebp]
mov edi, DWORD PTR _ctxt$[ebp]
test esi, esi
jne SHORT $LN2@xmlFAGener
; 1488 : if (to == NULL) {
; 1489 : to = xmlRegNewState(ctxt);
push edi
call _xmlRegNewState
mov esi, eax
; 1490 : xmlRegStatePush(ctxt, to);
push esi
push edi
call _xmlRegStatePush
add esp, 12 ; 0000000cH
; 1491 : ctxt->state = to;
mov DWORD PTR [edi+24], esi
$LN2@xmlFAGener:
; 1492 : }
; 1493 : xmlRegStateAddTrans(ctxt, from, NULL, to, -1, -1);
push -1
push -1
push esi
push 0
push DWORD PTR _from$[ebp]
push edi
call _xmlRegStateAddTrans
add esp, 24 ; 00000018H
pop edi
pop esi
; 1494 : }
pop ebp
ret 0
_xmlFAGenerateEpsilonTransition ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAGenerateAllTransition
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_lax$ = 20 ; size = 4
_xmlFAGenerateAllTransition PROC ; COMDAT
; 1466 : int lax) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _to$[ebp]
mov edi, DWORD PTR _ctxt$[ebp]
test esi, esi
jne SHORT $LN2@xmlFAGener
; 1467 : if (to == NULL) {
; 1468 : to = xmlRegNewState(ctxt);
push edi
call _xmlRegNewState
mov esi, eax
; 1469 : xmlRegStatePush(ctxt, to);
push esi
push edi
call _xmlRegStatePush
add esp, 12 ; 0000000cH
; 1470 : ctxt->state = to;
mov DWORD PTR [edi+24], esi
$LN2@xmlFAGener:
; 1471 : }
; 1472 : if (lax)
; 1473 : xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_LAX_COUNTER);
; 1474 : else
; 1475 : xmlRegStateAddTrans(ctxt, from, NULL, to, -1, REGEXP_ALL_COUNTER);
; 1476 : }
xor ecx, ecx
cmp DWORD PTR _lax$[ebp], ecx
setne cl
add ecx, 1193046 ; 00123456H
push ecx
push -1
push esi
push 0
push DWORD PTR _from$[ebp]
push edi
call _xmlRegStateAddTrans
add esp, 24 ; 00000018H
pop edi
pop esi
pop ebp
ret 0
_xmlFAGenerateAllTransition ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegStatePush
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_state$ = 12 ; size = 4
_xmlRegStatePush PROC ; COMDAT
; 1427 : xmlRegStatePush(xmlRegParserCtxtPtr ctxt, xmlRegStatePtr state) {
push ebp
mov ebp, esp
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR _state$[ebp]
test edi, edi
jne SHORT $LN2@xmlRegStat
; 1428 : if (state == NULL) return(-1);
or eax, -1
pop edi
; 1453 : }
pop ebp
ret 0
$LN2@xmlRegStat:
push esi
; 1429 : if (ctxt->maxStates == 0) {
mov esi, DWORD PTR _ctxt$[ebp]
mov eax, DWORD PTR [esi+44]
test eax, eax
jne SHORT $LN3@xmlRegStat
; 1430 : ctxt->maxStates = 4;
; 1431 : ctxt->states = (xmlRegStatePtr *) xmlMalloc(ctxt->maxStates *
push 16 ; 00000010H
mov DWORD PTR [esi+44], 4
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR [esi+52], eax
; 1432 : sizeof(xmlRegStatePtr));
; 1433 : if (ctxt->states == NULL) {
test eax, eax
jne SHORT $LN6@xmlRegStat
; 1434 : xmlRegexpErrMemory(ctxt, "adding state");
push OFFSET ??_C@_0N@NHLBLLB@adding?5state@
push esi
call _xmlRegexpErrMemory
add esp, 8
; 1435 : ctxt->maxStates = 0;
mov DWORD PTR [esi+44], 0
; 1436 : return(-1);
or eax, -1
pop esi
pop edi
; 1453 : }
pop ebp
ret 0
$LN3@xmlRegStat:
; 1437 : }
; 1438 : } else if (ctxt->nbStates >= ctxt->maxStates) {
cmp DWORD PTR [esi+48], eax
jl SHORT $LN6@xmlRegStat
; 1439 : xmlRegStatePtr *tmp;
; 1440 : ctxt->maxStates *= 2;
add eax, eax
mov DWORD PTR [esi+44], eax
; 1441 : tmp = (xmlRegStatePtr *) xmlRealloc(ctxt->states, ctxt->maxStates *
shl eax, 2
push eax
push DWORD PTR [esi+52]
call DWORD PTR _xmlRealloc
add esp, 8
; 1442 : sizeof(xmlRegStatePtr));
; 1443 : if (tmp == NULL) {
test eax, eax
jne SHORT $LN7@xmlRegStat
; 1444 : xmlRegexpErrMemory(ctxt, "adding state");
push OFFSET ??_C@_0N@NHLBLLB@adding?5state@
push esi
call _xmlRegexpErrMemory
; 1445 : ctxt->maxStates /= 2;
mov eax, DWORD PTR [esi+44]
add esp, 8
cdq
sub eax, edx
sar eax, 1
mov DWORD PTR [esi+44], eax
; 1446 : return(-1);
or eax, -1
pop esi
pop edi
; 1453 : }
pop ebp
ret 0
$LN7@xmlRegStat:
; 1447 : }
; 1448 : ctxt->states = tmp;
mov DWORD PTR [esi+52], eax
$LN6@xmlRegStat:
; 1449 : }
; 1450 : state->no = ctxt->nbStates;
mov eax, DWORD PTR [esi+48]
mov DWORD PTR [edi+16], eax
; 1451 : ctxt->states[ctxt->nbStates++] = state;
mov ecx, DWORD PTR [esi+48]
mov eax, DWORD PTR [esi+52]
mov DWORD PTR [eax+ecx*4], edi
inc DWORD PTR [esi+48]
; 1452 : return(0);
xor eax, eax
pop esi
pop edi
; 1453 : }
pop ebp
ret 0
_xmlRegStatePush ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegStateAddTrans
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_state$ = 12 ; size = 4
_atom$ = 16 ; size = 4
_target$ = 20 ; size = 4
_counter$ = 24 ; size = 4
_count$ = 28 ; size = 4
_xmlRegStateAddTrans PROC ; COMDAT
; 1350 : int counter, int count) {
push ebp
mov ebp, esp
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR _state$[ebp]
test edi, edi
jne SHORT $LN5@xmlRegStat
; 1351 :
; 1352 : int nrtrans;
; 1353 :
; 1354 : if (state == NULL) {
; 1355 : ERROR("add state: state is NULL");
mov eax, DWORD PTR _ctxt$[ebp]
push OFFSET ??_C@_0BJ@KPILLGIF@add?5state?3?5state?5is?5NULL@
push eax
mov DWORD PTR [eax+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop edi
; 1424 : }
pop ebp
ret 0
$LN5@xmlRegStat:
push esi
; 1356 : return;
; 1357 : }
; 1358 : if (target == NULL) {
mov esi, DWORD PTR _target$[ebp]
test esi, esi
jne SHORT $LN6@xmlRegStat
; 1359 : ERROR("add state: target is NULL");
mov eax, DWORD PTR _ctxt$[ebp]
push OFFSET ??_C@_0BK@PPLNMJBI@add?5state?3?5target?5is?5NULL@
push eax
mov DWORD PTR [eax+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop esi
pop edi
; 1424 : }
pop ebp
ret 0
$LN6@xmlRegStat:
; 1360 : return;
; 1361 : }
; 1362 : /*
; 1363 : * Other routines follow the philosophy 'When in doubt, add a transition'
; 1364 : * so we check here whether such a transition is already present and, if
; 1365 : * so, silently ignore this request.
; 1366 : */
; 1367 :
; 1368 : for (nrtrans = state->nbTrans - 1; nrtrans >= 0; nrtrans--) {
mov ecx, DWORD PTR [edi+24]
push ebx
mov ebx, DWORD PTR _count$[ebp]
lea edx, DWORD PTR [ecx-1]
test edx, edx
js SHORT $LN3@xmlRegStat
; 1369 : xmlRegTransPtr trans = &(state->trans[nrtrans]);
mov eax, DWORD PTR [edi+28]
lea ecx, DWORD PTR [edx+edx*4]
lea eax, DWORD PTR [eax+ecx*4]
mov ecx, DWORD PTR _atom$[ebp]
npad 2
$LL4@xmlRegStat:
; 1370 : if ((trans->atom == atom) &&
; 1371 : (trans->to == target->no) &&
; 1372 : (trans->counter == counter) &&
cmp DWORD PTR [eax], ecx
jne SHORT $LN2@xmlRegStat
mov ecx, DWORD PTR [eax+4]
cmp ecx, DWORD PTR [esi+16]
jne SHORT $LN27@xmlRegStat
mov ecx, DWORD PTR _counter$[ebp]
cmp DWORD PTR [eax+8], ecx
jne SHORT $LN27@xmlRegStat
cmp DWORD PTR [eax+12], ebx
je $LN29@xmlRegStat
$LN27@xmlRegStat:
; 1360 : return;
; 1361 : }
; 1362 : /*
; 1363 : * Other routines follow the philosophy 'When in doubt, add a transition'
; 1364 : * so we check here whether such a transition is already present and, if
; 1365 : * so, silently ignore this request.
; 1366 : */
; 1367 :
; 1368 : for (nrtrans = state->nbTrans - 1; nrtrans >= 0; nrtrans--) {
mov ecx, DWORD PTR _atom$[ebp]
$LN2@xmlRegStat:
sub eax, 20 ; 00000014H
sub edx, 1
jns SHORT $LL4@xmlRegStat
mov ecx, DWORD PTR [edi+24]
$LN3@xmlRegStat:
; 1373 : (trans->count == count)) {
; 1374 : #ifdef DEBUG_REGEXP_GRAPH
; 1375 : printf("Ignoring duplicate transition from %d to %d\n",
; 1376 : state->no, target->no);
; 1377 : #endif
; 1378 : return;
; 1379 : }
; 1380 : }
; 1381 :
; 1382 : if (state->maxTrans == 0) {
mov eax, DWORD PTR [edi+20]
test eax, eax
jne SHORT $LN8@xmlRegStat
; 1383 : state->maxTrans = 8;
; 1384 : state->trans = (xmlRegTrans *) xmlMalloc(state->maxTrans *
push 160 ; 000000a0H
mov DWORD PTR [edi+20], 8
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR [edi+28], eax
; 1385 : sizeof(xmlRegTrans));
; 1386 : if (state->trans == NULL) {
test eax, eax
jne SHORT $LN11@xmlRegStat
; 1387 : xmlRegexpErrMemory(ctxt, "adding transition");
push OFFSET ??_C@_0BC@FHJHIDDF@adding?5transition@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
add esp, 8
; 1388 : state->maxTrans = 0;
mov DWORD PTR [edi+20], 0
pop ebx
pop esi
pop edi
; 1424 : }
pop ebp
ret 0
$LN8@xmlRegStat:
; 1389 : return;
; 1390 : }
; 1391 : } else if (state->nbTrans >= state->maxTrans) {
cmp ecx, eax
jl SHORT $LN11@xmlRegStat
; 1392 : xmlRegTrans *tmp;
; 1393 : state->maxTrans *= 2;
add eax, eax
mov DWORD PTR [edi+20], eax
; 1394 : tmp = (xmlRegTrans *) xmlRealloc(state->trans, state->maxTrans *
lea eax, DWORD PTR [eax+eax*4]
shl eax, 2
push eax
push DWORD PTR [edi+28]
call DWORD PTR _xmlRealloc
add esp, 8
; 1395 : sizeof(xmlRegTrans));
; 1396 : if (tmp == NULL) {
test eax, eax
jne SHORT $LN12@xmlRegStat
; 1397 : xmlRegexpErrMemory(ctxt, "adding transition");
push OFFSET ??_C@_0BC@FHJHIDDF@adding?5transition@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
; 1398 : state->maxTrans /= 2;
mov eax, DWORD PTR [edi+20]
add esp, 8
cdq
sub eax, edx
sar eax, 1
pop ebx
pop esi
mov DWORD PTR [edi+20], eax
pop edi
; 1424 : }
pop ebp
ret 0
$LN12@xmlRegStat:
; 1399 : return;
; 1400 : }
; 1401 : state->trans = tmp;
mov DWORD PTR [edi+28], eax
$LN11@xmlRegStat:
; 1402 : }
; 1403 : #ifdef DEBUG_REGEXP_GRAPH
; 1404 : printf("Add trans from %d to %d ", state->no, target->no);
; 1405 : if (count == REGEXP_ALL_COUNTER)
; 1406 : printf("all transition\n");
; 1407 : else if (count >= 0)
; 1408 : printf("count based %d\n", count);
; 1409 : else if (counter >= 0)
; 1410 : printf("counted %d\n", counter);
; 1411 : else if (atom == NULL)
; 1412 : printf("epsilon transition\n");
; 1413 : else if (atom != NULL)
; 1414 : xmlRegPrintAtom(stdout, atom);
; 1415 : #endif
; 1416 :
; 1417 : state->trans[state->nbTrans].atom = atom;
mov eax, DWORD PTR [edi+24]
mov edx, DWORD PTR _atom$[ebp]
lea ecx, DWORD PTR [eax+eax*4]
mov eax, DWORD PTR [edi+28]
mov DWORD PTR [eax+ecx*4], edx
; 1418 : state->trans[state->nbTrans].to = target->no;
mov eax, DWORD PTR [edi+24]
mov ecx, DWORD PTR [edi+28]
lea edx, DWORD PTR [eax+eax*4]
mov eax, DWORD PTR [esi+16]
mov DWORD PTR [ecx+edx*4+4], eax
; 1419 : state->trans[state->nbTrans].counter = counter;
mov eax, DWORD PTR [edi+24]
mov edx, DWORD PTR _counter$[ebp]
lea ecx, DWORD PTR [eax+eax*4]
mov eax, DWORD PTR [edi+28]
mov DWORD PTR [eax+ecx*4+8], edx
; 1420 : state->trans[state->nbTrans].count = count;
mov eax, DWORD PTR [edi+24]
lea ecx, DWORD PTR [eax+eax*4]
mov eax, DWORD PTR [edi+28]
mov DWORD PTR [eax+ecx*4+12], ebx
; 1421 : state->trans[state->nbTrans].nd = 0;
mov eax, DWORD PTR [edi+24]
lea ecx, DWORD PTR [eax+eax*4]
mov eax, DWORD PTR [edi+28]
mov DWORD PTR [eax+ecx*4+16], 0
; 1422 : state->nbTrans++;
inc DWORD PTR [edi+24]
; 1322 : if (target->maxTransTo == 0) {
mov eax, DWORD PTR [esi+32]
; 1423 : xmlRegStateAddTransTo(ctxt, target, state->no);
mov edi, DWORD PTR [edi+16]
; 1322 : if (target->maxTransTo == 0) {
test eax, eax
jne SHORT $LN15@xmlRegStat
; 1323 : target->maxTransTo = 8;
; 1324 : target->transTo = (int *) xmlMalloc(target->maxTransTo *
push 32 ; 00000020H
mov DWORD PTR [esi+32], 8
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR [esi+40], eax
; 1325 : sizeof(int));
; 1326 : if (target->transTo == NULL) {
test eax, eax
jne SHORT $LN18@xmlRegStat
; 1327 : xmlRegexpErrMemory(ctxt, "adding transition");
push OFFSET ??_C@_0BC@FHJHIDDF@adding?5transition@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
add esp, 8
; 1328 : target->maxTransTo = 0;
mov DWORD PTR [esi+32], 0
pop ebx
pop esi
pop edi
; 1424 : }
pop ebp
ret 0
$LN15@xmlRegStat:
; 1331 : } else if (target->nbTransTo >= target->maxTransTo) {
cmp DWORD PTR [esi+36], eax
jl SHORT $LN18@xmlRegStat
; 1332 : int *tmp;
; 1333 : target->maxTransTo *= 2;
add eax, eax
mov DWORD PTR [esi+32], eax
; 1334 : tmp = (int *) xmlRealloc(target->transTo, target->maxTransTo *
shl eax, 2
push eax
push DWORD PTR [esi+40]
call DWORD PTR _xmlRealloc
add esp, 8
; 1335 : sizeof(int));
; 1336 : if (tmp == NULL) {
test eax, eax
jne SHORT $LN19@xmlRegStat
; 1337 : xmlRegexpErrMemory(ctxt, "adding transition");
push OFFSET ??_C@_0BC@FHJHIDDF@adding?5transition@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
; 1338 : target->maxTransTo /= 2;
mov eax, DWORD PTR [esi+32]
add esp, 8
cdq
sub eax, edx
sar eax, 1
pop ebx
mov DWORD PTR [esi+32], eax
pop esi
pop edi
; 1424 : }
pop ebp
ret 0
$LN19@xmlRegStat:
; 1341 : target->transTo = tmp;
mov DWORD PTR [esi+40], eax
$LN18@xmlRegStat:
; 1342 : }
; 1343 : target->transTo[target->nbTransTo] = from;
mov ecx, DWORD PTR [esi+36]
mov eax, DWORD PTR [esi+40]
mov DWORD PTR [eax+ecx*4], edi
; 1344 : target->nbTransTo++;
inc DWORD PTR [esi+36]
$LN29@xmlRegStat:
pop ebx
pop esi
pop edi
; 1424 : }
pop ebp
ret 0
_xmlRegStateAddTrans ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegStateAddTransTo
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_target$ = 12 ; size = 4
_from$ = 16 ; size = 4
_xmlRegStateAddTransTo PROC ; COMDAT
; 1321 : int from) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _target$[ebp]
mov eax, DWORD PTR [esi+32]
test eax, eax
jne SHORT $LN2@xmlRegStat
; 1322 : if (target->maxTransTo == 0) {
; 1323 : target->maxTransTo = 8;
push 32 ; 00000020H
mov DWORD PTR [esi+32], 8
; 1324 : target->transTo = (int *) xmlMalloc(target->maxTransTo *
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR [esi+40], eax
; 1325 : sizeof(int));
; 1326 : if (target->transTo == NULL) {
test eax, eax
jne SHORT $LN5@xmlRegStat
; 1327 : xmlRegexpErrMemory(ctxt, "adding transition");
push OFFSET ??_C@_0BC@FHJHIDDF@adding?5transition@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
add esp, 8
; 1328 : target->maxTransTo = 0;
mov DWORD PTR [esi+32], 0
pop esi
; 1345 : }
pop ebp
ret 0
$LN2@xmlRegStat:
; 1329 : return;
; 1330 : }
; 1331 : } else if (target->nbTransTo >= target->maxTransTo) {
cmp DWORD PTR [esi+36], eax
jl SHORT $LN5@xmlRegStat
; 1332 : int *tmp;
; 1333 : target->maxTransTo *= 2;
add eax, eax
mov DWORD PTR [esi+32], eax
; 1334 : tmp = (int *) xmlRealloc(target->transTo, target->maxTransTo *
shl eax, 2
push eax
push DWORD PTR [esi+40]
call DWORD PTR _xmlRealloc
add esp, 8
; 1335 : sizeof(int));
; 1336 : if (tmp == NULL) {
test eax, eax
jne SHORT $LN6@xmlRegStat
; 1337 : xmlRegexpErrMemory(ctxt, "adding transition");
push OFFSET ??_C@_0BC@FHJHIDDF@adding?5transition@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
; 1338 : target->maxTransTo /= 2;
mov eax, DWORD PTR [esi+32]
add esp, 8
cdq
sub eax, edx
sar eax, 1
mov DWORD PTR [esi+32], eax
pop esi
; 1345 : }
pop ebp
ret 0
$LN6@xmlRegStat:
; 1339 : return;
; 1340 : }
; 1341 : target->transTo = tmp;
mov DWORD PTR [esi+40], eax
$LN5@xmlRegStat:
; 1342 : }
; 1343 : target->transTo[target->nbTransTo] = from;
mov edx, DWORD PTR [esi+36]
mov ecx, DWORD PTR [esi+40]
mov eax, DWORD PTR _from$[ebp]
mov DWORD PTR [ecx+edx*4], eax
; 1344 : target->nbTransTo++;
inc DWORD PTR [esi+36]
pop esi
; 1345 : }
pop ebp
ret 0
_xmlRegStateAddTransTo ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegAtomPush
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_atom$ = 12 ; size = 4
_xmlRegAtomPush PROC ; COMDAT
; 1288 : xmlRegAtomPush(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
push ebp
mov ebp, esp
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR _atom$[ebp]
test edi, edi
jne SHORT $LN2@xmlRegAtom
; 1289 : if (atom == NULL) {
; 1290 : ERROR("atom push: atom is NULL");
mov eax, DWORD PTR _ctxt$[ebp]
push OFFSET ??_C@_0BI@LIIKMBAE@atom?5push?3?5atom?5is?5NULL@
push eax
mov DWORD PTR [eax+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
; 1291 : return(-1);
or eax, -1
pop edi
; 1317 : }
pop ebp
ret 0
$LN2@xmlRegAtom:
push esi
; 1292 : }
; 1293 : if (ctxt->maxAtoms == 0) {
mov esi, DWORD PTR _ctxt$[ebp]
mov eax, DWORD PTR [esi+32]
test eax, eax
jne SHORT $LN3@xmlRegAtom
; 1294 : ctxt->maxAtoms = 4;
; 1295 : ctxt->atoms = (xmlRegAtomPtr *) xmlMalloc(ctxt->maxAtoms *
push 16 ; 00000010H
mov DWORD PTR [esi+32], 4
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR [esi+40], eax
; 1296 : sizeof(xmlRegAtomPtr));
; 1297 : if (ctxt->atoms == NULL) {
test eax, eax
jne SHORT $LN6@xmlRegAtom
; 1298 : xmlRegexpErrMemory(ctxt, "pushing atom");
push OFFSET ??_C@_0N@PMKNEBIB@pushing?5atom@
push esi
call _xmlRegexpErrMemory
add esp, 8
; 1299 : ctxt->maxAtoms = 0;
mov DWORD PTR [esi+32], 0
; 1300 : return(-1);
or eax, -1
pop esi
pop edi
; 1317 : }
pop ebp
ret 0
$LN3@xmlRegAtom:
; 1301 : }
; 1302 : } else if (ctxt->nbAtoms >= ctxt->maxAtoms) {
cmp DWORD PTR [esi+36], eax
jl SHORT $LN6@xmlRegAtom
; 1303 : xmlRegAtomPtr *tmp;
; 1304 : ctxt->maxAtoms *= 2;
add eax, eax
mov DWORD PTR [esi+32], eax
; 1305 : tmp = (xmlRegAtomPtr *) xmlRealloc(ctxt->atoms, ctxt->maxAtoms *
shl eax, 2
push eax
push DWORD PTR [esi+40]
call DWORD PTR _xmlRealloc
add esp, 8
; 1306 : sizeof(xmlRegAtomPtr));
; 1307 : if (tmp == NULL) {
test eax, eax
jne SHORT $LN7@xmlRegAtom
; 1308 : xmlRegexpErrMemory(ctxt, "allocating counter");
push OFFSET ??_C@_0BD@OEINICOI@allocating?5counter@
push esi
call _xmlRegexpErrMemory
; 1309 : ctxt->maxAtoms /= 2;
mov eax, DWORD PTR [esi+32]
add esp, 8
cdq
sub eax, edx
sar eax, 1
mov DWORD PTR [esi+32], eax
; 1310 : return(-1);
or eax, -1
pop esi
pop edi
; 1317 : }
pop ebp
ret 0
$LN7@xmlRegAtom:
; 1311 : }
; 1312 : ctxt->atoms = tmp;
mov DWORD PTR [esi+40], eax
$LN6@xmlRegAtom:
; 1313 : }
; 1314 : atom->no = ctxt->nbAtoms;
mov eax, DWORD PTR [esi+36]
mov DWORD PTR [edi], eax
; 1315 : ctxt->atoms[ctxt->nbAtoms++] = atom;
mov ecx, DWORD PTR [esi+36]
mov eax, DWORD PTR [esi+40]
mov DWORD PTR [eax+ecx*4], edi
inc DWORD PTR [esi+36]
; 1316 : return(0);
xor eax, eax
pop esi
pop edi
; 1317 : }
pop ebp
ret 0
_xmlRegAtomPush ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegGetCounter
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlRegGetCounter PROC ; COMDAT
; 1260 : xmlRegGetCounter(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
mov eax, DWORD PTR [esi+56]
test eax, eax
jne SHORT $LN2@xmlRegGetC
; 1261 : if (ctxt->maxCounters == 0) {
; 1262 : ctxt->maxCounters = 4;
push 32 ; 00000020H
mov DWORD PTR [esi+56], 4
; 1263 : ctxt->counters = (xmlRegCounter *) xmlMalloc(ctxt->maxCounters *
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR [esi+64], eax
; 1264 : sizeof(xmlRegCounter));
; 1265 : if (ctxt->counters == NULL) {
test eax, eax
jne SHORT $LN5@xmlRegGetC
; 1266 : xmlRegexpErrMemory(ctxt, "allocating counter");
push OFFSET ??_C@_0BD@OEINICOI@allocating?5counter@
push esi
call _xmlRegexpErrMemory
add esp, 8
; 1267 : ctxt->maxCounters = 0;
mov DWORD PTR [esi+56], 0
; 1268 : return(-1);
or eax, -1
pop esi
; 1285 : }
pop ebp
ret 0
$LN2@xmlRegGetC:
; 1269 : }
; 1270 : } else if (ctxt->nbCounters >= ctxt->maxCounters) {
cmp DWORD PTR [esi+60], eax
jl SHORT $LN5@xmlRegGetC
; 1271 : xmlRegCounter *tmp;
; 1272 : ctxt->maxCounters *= 2;
add eax, eax
mov DWORD PTR [esi+56], eax
; 1273 : tmp = (xmlRegCounter *) xmlRealloc(ctxt->counters, ctxt->maxCounters *
shl eax, 3
push eax
push DWORD PTR [esi+64]
call DWORD PTR _xmlRealloc
add esp, 8
; 1274 : sizeof(xmlRegCounter));
; 1275 : if (tmp == NULL) {
test eax, eax
jne SHORT $LN6@xmlRegGetC
; 1276 : xmlRegexpErrMemory(ctxt, "allocating counter");
push OFFSET ??_C@_0BD@OEINICOI@allocating?5counter@
push esi
call _xmlRegexpErrMemory
; 1277 : ctxt->maxCounters /= 2;
mov eax, DWORD PTR [esi+56]
add esp, 8
cdq
sub eax, edx
sar eax, 1
mov DWORD PTR [esi+56], eax
; 1278 : return(-1);
or eax, -1
pop esi
; 1285 : }
pop ebp
ret 0
$LN6@xmlRegGetC:
; 1279 : }
; 1280 : ctxt->counters = tmp;
mov DWORD PTR [esi+64], eax
$LN5@xmlRegGetC:
; 1281 : }
; 1282 : ctxt->counters[ctxt->nbCounters].min = -1;
mov ecx, DWORD PTR [esi+60]
mov eax, DWORD PTR [esi+64]
mov DWORD PTR [eax+ecx*8], -1
; 1283 : ctxt->counters[ctxt->nbCounters].max = -1;
mov ecx, DWORD PTR [esi+60]
mov eax, DWORD PTR [esi+64]
mov DWORD PTR [eax+ecx*8+4], -1
; 1284 : return(ctxt->nbCounters++);
mov eax, DWORD PTR [esi+60]
lea ecx, DWORD PTR [eax+1]
mov DWORD PTR [esi+60], ecx
pop esi
; 1285 : }
pop ebp
ret 0
_xmlRegGetCounter ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegAtomAddRange
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_atom$ = 12 ; size = 4
_neg$ = 16 ; size = 4
_type$ = 20 ; size = 4
_start$ = 24 ; size = 4
_end$ = 28 ; size = 4
_blockName$ = 32 ; size = 4
_xmlRegAtomAddRange PROC ; COMDAT
; 1219 : xmlChar *blockName) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _atom$[ebp]
test esi, esi
jne SHORT $LN2@xmlRegAtom
; 1220 : xmlRegRangePtr range;
; 1221 :
; 1222 : if (atom == NULL) {
; 1223 : ERROR("add range: atom is NULL");
mov eax, DWORD PTR _ctxt$[ebp]
push OFFSET ??_C@_0BI@MEBKNK@add?5range?3?5atom?5is?5NULL@
push eax
mov DWORD PTR [eax+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop esi
; 1256 :
; 1257 : }
pop ebp
ret 0
$LN2@xmlRegAtom:
; 1224 : return;
; 1225 : }
; 1226 : if (atom->type != XML_REGEXP_RANGES) {
cmp DWORD PTR [esi+4], 3
je SHORT $LN3@xmlRegAtom
; 1227 : ERROR("add range: atom is not ranges");
mov eax, DWORD PTR _ctxt$[ebp]
push OFFSET ??_C@_0BO@PJJILLLG@add?5range?3?5atom?5is?5not?5ranges@
push eax
mov DWORD PTR [eax+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop esi
; 1256 :
; 1257 : }
pop ebp
ret 0
$LN3@xmlRegAtom:
; 1228 : return;
; 1229 : }
; 1230 : if (atom->maxRanges == 0) {
mov eax, DWORD PTR [esi+48]
test eax, eax
jne SHORT $LN4@xmlRegAtom
; 1231 : atom->maxRanges = 4;
; 1232 : atom->ranges = (xmlRegRangePtr *) xmlMalloc(atom->maxRanges *
push 16 ; 00000010H
mov DWORD PTR [esi+48], 4
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR [esi+56], eax
; 1233 : sizeof(xmlRegRangePtr));
; 1234 : if (atom->ranges == NULL) {
test eax, eax
jne SHORT $LN7@xmlRegAtom
; 1235 : xmlRegexpErrMemory(ctxt, "adding ranges");
push OFFSET ??_C@_0O@INOJCFAI@adding?5ranges@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
add esp, 8
; 1236 : atom->maxRanges = 0;
mov DWORD PTR [esi+48], 0
pop esi
; 1256 :
; 1257 : }
pop ebp
ret 0
$LN4@xmlRegAtom:
; 1237 : return;
; 1238 : }
; 1239 : } else if (atom->nbRanges >= atom->maxRanges) {
cmp DWORD PTR [esi+52], eax
jl SHORT $LN7@xmlRegAtom
; 1240 : xmlRegRangePtr *tmp;
; 1241 : atom->maxRanges *= 2;
add eax, eax
mov DWORD PTR [esi+48], eax
; 1242 : tmp = (xmlRegRangePtr *) xmlRealloc(atom->ranges, atom->maxRanges *
shl eax, 2
push eax
push DWORD PTR [esi+56]
call DWORD PTR _xmlRealloc
add esp, 8
; 1243 : sizeof(xmlRegRangePtr));
; 1244 : if (tmp == NULL) {
test eax, eax
jne SHORT $LN8@xmlRegAtom
; 1245 : xmlRegexpErrMemory(ctxt, "adding ranges");
push OFFSET ??_C@_0O@INOJCFAI@adding?5ranges@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
; 1246 : atom->maxRanges /= 2;
mov eax, DWORD PTR [esi+48]
add esp, 8
cdq
sub eax, edx
sar eax, 1
mov DWORD PTR [esi+48], eax
pop esi
; 1256 :
; 1257 : }
pop ebp
ret 0
$LN8@xmlRegAtom:
; 1247 : return;
; 1248 : }
; 1249 : atom->ranges = tmp;
mov DWORD PTR [esi+56], eax
$LN7@xmlRegAtom:
; 1250 : }
; 1251 : range = xmlRegNewRange(ctxt, neg, type, start, end);
push DWORD PTR _end$[ebp]
push DWORD PTR _start$[ebp]
push DWORD PTR _type$[ebp]
push DWORD PTR _neg$[ebp]
push DWORD PTR _ctxt$[ebp]
call _xmlRegNewRange
add esp, 20 ; 00000014H
; 1252 : if (range == NULL)
test eax, eax
je SHORT $LN1@xmlRegAtom
; 1253 : return;
; 1254 : range->blockName = blockName;
mov ecx, DWORD PTR _blockName$[ebp]
mov DWORD PTR [eax+16], ecx
; 1255 : atom->ranges[atom->nbRanges++] = range;
mov edx, DWORD PTR [esi+52]
mov ecx, DWORD PTR [esi+56]
mov DWORD PTR [ecx+edx*4], eax
inc DWORD PTR [esi+52]
$LN1@xmlRegAtom:
pop esi
; 1256 :
; 1257 : }
pop ebp
ret 0
_xmlRegAtomAddRange ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegPrintState
_TEXT SEGMENT
tv408 = -4 ; size = 4
_output$ = 8 ; size = 4
_i$1$ = 12 ; size = 4
_state$ = 12 ; size = 4
_xmlRegPrintState PROC ; COMDAT
; 1149 : xmlRegPrintState(FILE *output, xmlRegStatePtr state) {
push ebp
mov ebp, esp
push ecx
push ebx
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _output$[ebp]
push OFFSET ??_C@_08NOIFNCJM@?5state?3?5@
push esi
call _fprintf
mov ebx, DWORD PTR _state$[ebp]
add esp, 8
test ebx, ebx
jne SHORT $LN5@xmlRegPrin
; 1150 : int i;
; 1151 :
; 1152 : fprintf(output, " state: ");
; 1153 : if (state == NULL) {
; 1154 : fprintf(output, "NULL\n");
push OFFSET ??_C@_05NJDBAOFA@NULL?6@
push esi
call _fprintf
add esp, 8
pop esi
; 1165 : }
; 1166 : }
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN5@xmlRegPrin:
; 1155 : return;
; 1156 : }
; 1157 : if (state->type == XML_REGEXP_START_STATE)
mov eax, DWORD PTR [ebx]
cmp eax, 1
jne SHORT $LN6@xmlRegPrin
; 1158 : fprintf(output, "START ");
push OFFSET ??_C@_06BNBHINFE@START?5@
push esi
call _fprintf
mov eax, DWORD PTR [ebx]
add esp, 8
$LN6@xmlRegPrin:
; 1159 : if (state->type == XML_REGEXP_FINAL_STATE)
cmp eax, 2
jne SHORT $LN7@xmlRegPrin
; 1160 : fprintf(output, "FINAL ");
push OFFSET ??_C@_06EFHALCBA@FINAL?5@
push esi
call _fprintf
add esp, 8
$LN7@xmlRegPrin:
; 1161 :
; 1162 : fprintf(output, "%d, %d transitions:\n", state->no, state->nbTrans);
push DWORD PTR [ebx+24]
push DWORD PTR [ebx+16]
push OFFSET ??_C@_0BF@NHMHHIIL@?$CFd?0?5?$CFd?5transitions?3?6@
push esi
call _fprintf
add esp, 16 ; 00000010H
; 1163 : for (i = 0;i < state->nbTrans; i++) {
mov DWORD PTR _i$1$[ebp], 0
cmp DWORD PTR [ebx+24], 0
jle $LN3@xmlRegPrin
; 1161 :
; 1162 : fprintf(output, "%d, %d transitions:\n", state->no, state->nbTrans);
xor ecx, ecx
mov DWORD PTR tv408[ebp], ecx
push edi
$LL4@xmlRegPrin:
; 1164 : xmlRegPrintTrans(output, &(state->trans[i]));
mov edi, DWORD PTR [ebx+28]
; 1116 : fprintf(output, " trans: ");
push OFFSET ??_C@_09KCGMBGNH@?5?5trans?3?5@
push esi
; 1164 : xmlRegPrintTrans(output, &(state->trans[i]));
add edi, ecx
; 1116 : fprintf(output, " trans: ");
call _fprintf
add esp, 8
; 1117 : if (trans == NULL) {
test edi, edi
jne SHORT $LN10@xmlRegPrin
; 1118 : fprintf(output, "NULL\n");
push OFFSET ??_C@_05NJDBAOFA@NULL?6@
push esi
call _fprintf
add esp, 8
; 1119 : return;
jmp $LN2@xmlRegPrin
$LN10@xmlRegPrin:
; 1120 : }
; 1121 : if (trans->to < 0) {
cmp DWORD PTR [edi+4], 0
jge SHORT $LN11@xmlRegPrin
; 1122 : fprintf(output, "removed\n");
push OFFSET ??_C@_08IDDAKHFP@removed?6@
push esi
call _fprintf
add esp, 8
; 1123 : return;
jmp $LN2@xmlRegPrin
$LN11@xmlRegPrin:
; 1124 : }
; 1125 : if (trans->nd != 0) {
mov eax, DWORD PTR [edi+16]
test eax, eax
je SHORT $LN14@xmlRegPrin
; 1126 : if (trans->nd == 2)
cmp eax, 2
jne SHORT $LN13@xmlRegPrin
; 1127 : fprintf(output, "last not determinist, ");
push OFFSET ??_C@_0BH@PJNPIGKD@last?5not?5determinist?0?5@
jmp SHORT $LN26@xmlRegPrin
$LN13@xmlRegPrin:
; 1128 : else
; 1129 : fprintf(output, "not determinist, ");
push OFFSET ??_C@_0BC@EKCPHBCA@not?5determinist?0?5@
$LN26@xmlRegPrin:
; 1130 : }
; 1131 : if (trans->counter >= 0) {
push esi
call _fprintf
add esp, 8
$LN14@xmlRegPrin:
mov eax, DWORD PTR [edi+8]
test eax, eax
js SHORT $LN15@xmlRegPrin
; 1132 : fprintf(output, "counted %d, ", trans->counter);
push eax
push OFFSET ??_C@_0N@NIIDMCG@counted?5?$CFd?0?5@
push esi
call _fprintf
add esp, 12 ; 0000000cH
$LN15@xmlRegPrin:
; 1133 : }
; 1134 : if (trans->count == REGEXP_ALL_COUNTER) {
mov eax, DWORD PTR [edi+12]
cmp eax, 1193046 ; 00123456H
jne SHORT $LN16@xmlRegPrin
; 1135 : fprintf(output, "all transition, ");
push OFFSET ??_C@_0BB@CPMJDJHN@all?5transition?0?5@
push esi
call _fprintf
add esp, 8
jmp SHORT $LN18@xmlRegPrin
$LN16@xmlRegPrin:
; 1136 : } else if (trans->count >= 0) {
test eax, eax
js SHORT $LN18@xmlRegPrin
; 1137 : fprintf(output, "count based %d, ", trans->count);
push eax
push OFFSET ??_C@_0BB@LHHOLMKP@count?5based?5?$CFd?0?5@
push esi
call _fprintf
add esp, 12 ; 0000000cH
$LN18@xmlRegPrin:
; 1138 : }
; 1139 : if (trans->atom == NULL) {
mov eax, DWORD PTR [edi]
test eax, eax
jne SHORT $LN19@xmlRegPrin
; 1140 : fprintf(output, "epsilon to %d\n", trans->to);
push DWORD PTR [edi+4]
push OFFSET ??_C@_0P@BEFDCDEN@epsilon?5to?5?$CFd?6@
push esi
call _fprintf
add esp, 12 ; 0000000cH
; 1141 : return;
jmp SHORT $LN2@xmlRegPrin
$LN19@xmlRegPrin:
; 1142 : }
; 1143 : if (trans->atom->type == XML_REGEXP_CHARVAL)
cmp DWORD PTR [eax+4], 2
jne SHORT $LN20@xmlRegPrin
; 1144 : fprintf(output, "char %c ", trans->atom->codepoint);
push DWORD PTR [eax+32]
push OFFSET ??_C@_08JNAFCHHG@char?5?$CFc?5@
push esi
call _fprintf
mov eax, DWORD PTR [edi]
add esp, 12 ; 0000000cH
$LN20@xmlRegPrin:
; 1145 : fprintf(output, "atom %d, to %d\n", trans->atom->no, trans->to);
push DWORD PTR [edi+4]
push DWORD PTR [eax]
push OFFSET ??_C@_0BA@DDAHGLMD@atom?5?$CFd?0?5to?5?$CFd?6@
push esi
call _fprintf
add esp, 16 ; 00000010H
$LN2@xmlRegPrin:
; 1163 : for (i = 0;i < state->nbTrans; i++) {
mov eax, DWORD PTR _i$1$[ebp]
mov ecx, DWORD PTR tv408[ebp]
inc eax
add ecx, 20 ; 00000014H
mov DWORD PTR _i$1$[ebp], eax
mov DWORD PTR tv408[ebp], ecx
cmp eax, DWORD PTR [ebx+24]
jl $LL4@xmlRegPrin
pop edi
$LN3@xmlRegPrin:
pop esi
; 1165 : }
; 1166 : }
pop ebx
mov esp, ebp
pop ebp
ret 0
_xmlRegPrintState ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegPrintTrans
_TEXT SEGMENT
_output$ = 8 ; size = 4
_trans$ = 12 ; size = 4
_xmlRegPrintTrans PROC ; COMDAT
; 1115 : xmlRegPrintTrans(FILE *output, xmlRegTransPtr trans) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _output$[ebp]
push OFFSET ??_C@_09KCGMBGNH@?5?5trans?3?5@
push esi
call _fprintf
mov edi, DWORD PTR _trans$[ebp]
add esp, 8
test edi, edi
jne SHORT $LN2@xmlRegPrin
; 1116 : fprintf(output, " trans: ");
; 1117 : if (trans == NULL) {
; 1118 : fprintf(output, "NULL\n");
push OFFSET ??_C@_05NJDBAOFA@NULL?6@
push esi
call _fprintf
add esp, 8
pop edi
; 1146 : }
pop esi
pop ebp
ret 0
$LN2@xmlRegPrin:
; 1119 : return;
; 1120 : }
; 1121 : if (trans->to < 0) {
cmp DWORD PTR [edi+4], 0
jge SHORT $LN3@xmlRegPrin
; 1122 : fprintf(output, "removed\n");
push OFFSET ??_C@_08IDDAKHFP@removed?6@
push esi
call _fprintf
add esp, 8
pop edi
; 1146 : }
pop esi
pop ebp
ret 0
$LN3@xmlRegPrin:
; 1123 : return;
; 1124 : }
; 1125 : if (trans->nd != 0) {
mov eax, DWORD PTR [edi+16]
test eax, eax
je SHORT $LN6@xmlRegPrin
; 1126 : if (trans->nd == 2)
cmp eax, 2
jne SHORT $LN5@xmlRegPrin
; 1127 : fprintf(output, "last not determinist, ");
push OFFSET ??_C@_0BH@PJNPIGKD@last?5not?5determinist?0?5@
jmp SHORT $LN14@xmlRegPrin
$LN5@xmlRegPrin:
; 1128 : else
; 1129 : fprintf(output, "not determinist, ");
push OFFSET ??_C@_0BC@EKCPHBCA@not?5determinist?0?5@
$LN14@xmlRegPrin:
; 1130 : }
; 1131 : if (trans->counter >= 0) {
push esi
call _fprintf
add esp, 8
$LN6@xmlRegPrin:
mov eax, DWORD PTR [edi+8]
test eax, eax
js SHORT $LN7@xmlRegPrin
; 1132 : fprintf(output, "counted %d, ", trans->counter);
push eax
push OFFSET ??_C@_0N@NIIDMCG@counted?5?$CFd?0?5@
push esi
call _fprintf
add esp, 12 ; 0000000cH
$LN7@xmlRegPrin:
; 1133 : }
; 1134 : if (trans->count == REGEXP_ALL_COUNTER) {
mov eax, DWORD PTR [edi+12]
cmp eax, 1193046 ; 00123456H
jne SHORT $LN8@xmlRegPrin
; 1135 : fprintf(output, "all transition, ");
push OFFSET ??_C@_0BB@CPMJDJHN@all?5transition?0?5@
push esi
call _fprintf
add esp, 8
jmp SHORT $LN10@xmlRegPrin
$LN8@xmlRegPrin:
; 1136 : } else if (trans->count >= 0) {
test eax, eax
js SHORT $LN10@xmlRegPrin
; 1137 : fprintf(output, "count based %d, ", trans->count);
push eax
push OFFSET ??_C@_0BB@LHHOLMKP@count?5based?5?$CFd?0?5@
push esi
call _fprintf
add esp, 12 ; 0000000cH
$LN10@xmlRegPrin:
; 1138 : }
; 1139 : if (trans->atom == NULL) {
mov eax, DWORD PTR [edi]
test eax, eax
jne SHORT $LN11@xmlRegPrin
; 1140 : fprintf(output, "epsilon to %d\n", trans->to);
push DWORD PTR [edi+4]
push OFFSET ??_C@_0P@BEFDCDEN@epsilon?5to?5?$CFd?6@
push esi
call _fprintf
add esp, 12 ; 0000000cH
pop edi
; 1146 : }
pop esi
pop ebp
ret 0
$LN11@xmlRegPrin:
; 1141 : return;
; 1142 : }
; 1143 : if (trans->atom->type == XML_REGEXP_CHARVAL)
cmp DWORD PTR [eax+4], 2
jne SHORT $LN12@xmlRegPrin
; 1144 : fprintf(output, "char %c ", trans->atom->codepoint);
push DWORD PTR [eax+32]
push OFFSET ??_C@_08JNAFCHHG@char?5?$CFc?5@
push esi
call _fprintf
mov eax, DWORD PTR [edi]
add esp, 12 ; 0000000cH
$LN12@xmlRegPrin:
; 1145 : fprintf(output, "atom %d, to %d\n", trans->atom->no, trans->to);
push DWORD PTR [edi+4]
push DWORD PTR [eax]
push OFFSET ??_C@_0BA@DDAHGLMD@atom?5?$CFd?0?5to?5?$CFd?6@
push esi
call _fprintf
add esp, 16 ; 00000010H
pop edi
; 1146 : }
pop esi
pop ebp
ret 0
_xmlRegPrintTrans ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegPrintAtom
_TEXT SEGMENT
_output$ = 8 ; size = 4
_i$1$ = 12 ; size = 4
_atom$ = 12 ; size = 4
_xmlRegPrintAtom PROC ; COMDAT
; 1086 : xmlRegPrintAtom(FILE *output, xmlRegAtomPtr atom) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _output$[ebp]
push OFFSET ??_C@_07LAIPMBOA@?5atom?3?5@
push esi
call _fprintf
mov edi, DWORD PTR _atom$[ebp]
add esp, 8
test edi, edi
jne SHORT $LN5@xmlRegPrin
; 1111 : }
; 1112 : }
push OFFSET ??_C@_05NJDBAOFA@NULL?6@
push esi
call _fprintf
add esp, 8
pop edi
pop esi
pop ebp
ret 0
$LN5@xmlRegPrin:
; 1087 : fprintf(output, " atom: ");
; 1088 : if (atom == NULL) {
; 1089 : fprintf(output, "NULL\n");
; 1090 : return;
; 1091 : }
; 1092 : if (atom->neg)
cmp DWORD PTR [edi+28], 0
je SHORT $LN6@xmlRegPrin
; 1093 : fprintf(output, "not ");
push OFFSET ??_C@_04LKOGMCLF@not?5@
push esi
call _fprintf
add esp, 8
$LN6@xmlRegPrin:
; 1094 : xmlRegPrintAtomType(output, atom->type);
push DWORD PTR [edi+4]
push esi
call _xmlRegPrintAtomType
; 1057 : switch (type) {
mov eax, DWORD PTR [edi+8]
; 1094 : xmlRegPrintAtomType(output, atom->type);
add esp, 8
; 1057 : switch (type) {
dec eax
cmp eax, 7
ja SHORT $LN17@xmlRegPrin
jmp DWORD PTR $LN38@xmlRegPrin[eax*4]
$LN19@xmlRegPrin:
; 1058 : case XML_REGEXP_QUANT_EPSILON:
; 1059 : fprintf(output, "epsilon "); break;
push OFFSET ??_C@_08LJGDJFJP@epsilon?5@
jmp SHORT $LN36@xmlRegPrin
$LN20@xmlRegPrin:
; 1060 : case XML_REGEXP_QUANT_ONCE:
; 1061 : fprintf(output, "once "); break;
push OFFSET ??_C@_05GDJGFPHL@once?5@
jmp SHORT $LN36@xmlRegPrin
$LN21@xmlRegPrin:
; 1062 : case XML_REGEXP_QUANT_OPT:
; 1063 : fprintf(output, "? "); break;
push OFFSET ??_C@_02LKANKAOC@?$DP?5@
jmp SHORT $LN36@xmlRegPrin
$LN22@xmlRegPrin:
; 1064 : case XML_REGEXP_QUANT_MULT:
; 1065 : fprintf(output, "* "); break;
push OFFSET ??_C@_02KAOAMBHJ@?$CK?5@
jmp SHORT $LN36@xmlRegPrin
$LN23@xmlRegPrin:
; 1066 : case XML_REGEXP_QUANT_PLUS:
; 1067 : fprintf(output, "+ "); break;
push OFFSET ??_C@_02KBCCKLEO@?$CL?5@
jmp SHORT $LN36@xmlRegPrin
$LN24@xmlRegPrin:
; 1068 : case XML_REGEXP_QUANT_RANGE:
; 1069 : fprintf(output, "range "); break;
push OFFSET ??_C@_06IBKHBGID@range?5@
jmp SHORT $LN36@xmlRegPrin
$LN25@xmlRegPrin:
; 1070 : case XML_REGEXP_QUANT_ONCEONLY:
; 1071 : fprintf(output, "onceonly "); break;
push OFFSET ??_C@_09EPCGBNDN@onceonly?5@
jmp SHORT $LN36@xmlRegPrin
$LN26@xmlRegPrin:
; 1072 : case XML_REGEXP_QUANT_ALL:
; 1073 : fprintf(output, "all "); break;
push OFFSET ??_C@_04DIDGAIEC@all?5@
$LN36@xmlRegPrin:
; 1095 : xmlRegPrintQuantType(output, atom->quant);
; 1096 : if (atom->quant == XML_REGEXP_QUANT_RANGE)
push esi
call _fprintf
add esp, 8
$LN17@xmlRegPrin:
cmp DWORD PTR [edi+8], 8
jne SHORT $LN7@xmlRegPrin
; 1097 : fprintf(output, "%d-%d ", atom->min, atom->max);
push DWORD PTR [edi+16]
push DWORD PTR [edi+12]
push OFFSET ??_C@_06BIJEIIBB@?$CFd?9?$CFd?5@
push esi
call _fprintf
add esp, 16 ; 00000010H
$LN7@xmlRegPrin:
; 1098 : if (atom->type == XML_REGEXP_STRING)
mov eax, DWORD PTR [edi+4]
cmp eax, 5
jne SHORT $LN8@xmlRegPrin
; 1099 : fprintf(output, "'%s' ", (char *) atom->valuep);
push DWORD PTR [edi+20]
push OFFSET ??_C@_05IMLJLABD@?8?$CFs?8?5@
push esi
call _fprintf
mov eax, DWORD PTR [edi+4]
add esp, 12 ; 0000000cH
$LN8@xmlRegPrin:
; 1100 : if (atom->type == XML_REGEXP_CHARVAL)
cmp eax, 2
jne SHORT $LN9@xmlRegPrin
; 1101 : fprintf(output, "char %c\n", atom->codepoint);
push DWORD PTR [edi+32]
push OFFSET ??_C@_08PCGOOLFO@char?5?$CFc?6@
push esi
call _fprintf
add esp, 12 ; 0000000cH
pop edi
; 1111 : }
; 1112 : }
pop esi
pop ebp
ret 0
$LN9@xmlRegPrin:
; 1102 : else if (atom->type == XML_REGEXP_RANGES) {
cmp eax, 3
jne SHORT $LN11@xmlRegPrin
; 1103 : int i;
; 1104 : fprintf(output, "%d entries\n", atom->nbRanges);
push DWORD PTR [edi+52]
push OFFSET ??_C@_0M@BCDCHBAM@?$CFd?5entries?6@
push esi
call _fprintf
; 1105 : for (i = 0; i < atom->nbRanges;i++)
xor ecx, ecx
add esp, 12 ; 0000000cH
mov DWORD PTR _i$1$[ebp], ecx
cmp DWORD PTR [edi+52], ecx
jle $LN14@xmlRegPrin
push ebx
npad 3
$LL4@xmlRegPrin:
; 1106 : xmlRegPrintRange(output, atom->ranges[i]);
mov eax, DWORD PTR [edi+56]
; 1078 : fprintf(output, " range: ");
push OFFSET ??_C@_09LLABEBOE@?5?5range?3?5@
push esi
; 1106 : xmlRegPrintRange(output, atom->ranges[i]);
mov ebx, DWORD PTR [eax+ecx*4]
; 1078 : fprintf(output, " range: ");
call _fprintf
add esp, 8
; 1079 : if (range->neg)
cmp DWORD PTR [ebx], 0
je SHORT $LN29@xmlRegPrin
; 1080 : fprintf(output, "negative ");
push OFFSET ??_C@_09KDBNABJA@negative?5@
push esi
call _fprintf
add esp, 8
$LN29@xmlRegPrin:
; 1081 : xmlRegPrintAtomType(output, range->type);
push DWORD PTR [ebx+4]
push esi
call _xmlRegPrintAtomType
; 1082 : fprintf(output, "%c - %c\n", range->start, range->end);
push DWORD PTR [ebx+12]
push DWORD PTR [ebx+8]
push OFFSET ??_C@_08BNCIEJGK@?$CFc?5?9?5?$CFc?6@
push esi
call _fprintf
; 1105 : for (i = 0; i < atom->nbRanges;i++)
mov ecx, DWORD PTR _i$1$[ebp]
; 1082 : fprintf(output, "%c - %c\n", range->start, range->end);
add esp, 24 ; 00000018H
; 1105 : for (i = 0; i < atom->nbRanges;i++)
inc ecx
mov DWORD PTR _i$1$[ebp], ecx
cmp ecx, DWORD PTR [edi+52]
jl SHORT $LL4@xmlRegPrin
; 1107 : } else if (atom->type == XML_REGEXP_SUBREG) {
pop ebx
pop edi
; 1111 : }
; 1112 : }
pop esi
pop ebp
ret 0
$LN11@xmlRegPrin:
; 1107 : } else if (atom->type == XML_REGEXP_SUBREG) {
cmp eax, 4
jne SHORT $LN13@xmlRegPrin
; 1108 : fprintf(output, "start %d end %d\n", atom->start->no, atom->stop->no);
mov eax, DWORD PTR [edi+44]
push DWORD PTR [eax+16]
mov eax, DWORD PTR [edi+36]
push DWORD PTR [eax+16]
push OFFSET ??_C@_0BB@GBMGKEL@start?5?$CFd?5end?5?$CFd?6@
push esi
call _fprintf
add esp, 16 ; 00000010H
pop edi
; 1111 : }
; 1112 : }
pop esi
pop ebp
ret 0
$LN13@xmlRegPrin:
; 1109 : } else {
; 1110 : fprintf(output, "\n");
push OFFSET ??_C@_01EEMJAFIK@?6@
; 1111 : }
; 1112 : }
push esi
call _fprintf
add esp, 8
$LN14@xmlRegPrin:
pop edi
pop esi
pop ebp
ret 0
npad 2
$LN38@xmlRegPrin:
DD $LN19@xmlRegPrin
DD $LN20@xmlRegPrin
DD $LN21@xmlRegPrin
DD $LN22@xmlRegPrin
DD $LN23@xmlRegPrin
DD $LN25@xmlRegPrin
DD $LN26@xmlRegPrin
DD $LN24@xmlRegPrin
_xmlRegPrintAtom ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegPrintRange
_TEXT SEGMENT
_output$ = 8 ; size = 4
_range$ = 12 ; size = 4
_xmlRegPrintRange PROC ; COMDAT
; 1077 : xmlRegPrintRange(FILE *output, xmlRegRangePtr range) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _output$[ebp]
push OFFSET ??_C@_09LLABEBOE@?5?5range?3?5@
push esi
call _fprintf
mov edi, DWORD PTR _range$[ebp]
add esp, 8
cmp DWORD PTR [edi], 0
je SHORT $LN2@xmlRegPrin
; 1078 : fprintf(output, " range: ");
; 1079 : if (range->neg)
; 1080 : fprintf(output, "negative ");
push OFFSET ??_C@_09KDBNABJA@negative?5@
push esi
call _fprintf
add esp, 8
$LN2@xmlRegPrin:
; 1081 : xmlRegPrintAtomType(output, range->type);
push DWORD PTR [edi+4]
push esi
call _xmlRegPrintAtomType
; 1082 : fprintf(output, "%c - %c\n", range->start, range->end);
push DWORD PTR [edi+12]
push DWORD PTR [edi+8]
push OFFSET ??_C@_08BNCIEJGK@?$CFc?5?9?5?$CFc?6@
push esi
call _fprintf
add esp, 24 ; 00000018H
pop edi
pop esi
; 1083 : }
pop ebp
ret 0
_xmlRegPrintRange ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegPrintQuantType
_TEXT SEGMENT
_output$ = 8 ; size = 4
_type$ = 12 ; size = 4
_xmlRegPrintQuantType PROC ; COMDAT
; 1056 : xmlRegPrintQuantType(FILE *output, xmlRegQuantType type) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _type$[ebp]
dec eax
cmp eax, 7
ja SHORT $LN2@xmlRegPrin
; 1057 : switch (type) {
jmp DWORD PTR $LN16@xmlRegPrin[eax*4]
$LN4@xmlRegPrin:
; 1058 : case XML_REGEXP_QUANT_EPSILON:
; 1059 : fprintf(output, "epsilon "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_08LJGDJFJP@epsilon?5@
; 1074 : }
; 1075 : }
pop ebp
; 1058 : case XML_REGEXP_QUANT_EPSILON:
; 1059 : fprintf(output, "epsilon "); break;
jmp _fprintf
$LN5@xmlRegPrin:
; 1060 : case XML_REGEXP_QUANT_ONCE:
; 1061 : fprintf(output, "once "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_05GDJGFPHL@once?5@
; 1074 : }
; 1075 : }
pop ebp
; 1060 : case XML_REGEXP_QUANT_ONCE:
; 1061 : fprintf(output, "once "); break;
jmp _fprintf
$LN6@xmlRegPrin:
; 1062 : case XML_REGEXP_QUANT_OPT:
; 1063 : fprintf(output, "? "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_02LKANKAOC@?$DP?5@
; 1074 : }
; 1075 : }
pop ebp
; 1062 : case XML_REGEXP_QUANT_OPT:
; 1063 : fprintf(output, "? "); break;
jmp _fprintf
$LN7@xmlRegPrin:
; 1064 : case XML_REGEXP_QUANT_MULT:
; 1065 : fprintf(output, "* "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_02KAOAMBHJ@?$CK?5@
; 1074 : }
; 1075 : }
pop ebp
; 1064 : case XML_REGEXP_QUANT_MULT:
; 1065 : fprintf(output, "* "); break;
jmp _fprintf
$LN8@xmlRegPrin:
; 1066 : case XML_REGEXP_QUANT_PLUS:
; 1067 : fprintf(output, "+ "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_02KBCCKLEO@?$CL?5@
; 1074 : }
; 1075 : }
pop ebp
; 1066 : case XML_REGEXP_QUANT_PLUS:
; 1067 : fprintf(output, "+ "); break;
jmp _fprintf
$LN9@xmlRegPrin:
; 1068 : case XML_REGEXP_QUANT_RANGE:
; 1069 : fprintf(output, "range "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_06IBKHBGID@range?5@
; 1074 : }
; 1075 : }
pop ebp
; 1068 : case XML_REGEXP_QUANT_RANGE:
; 1069 : fprintf(output, "range "); break;
jmp _fprintf
$LN10@xmlRegPrin:
; 1070 : case XML_REGEXP_QUANT_ONCEONLY:
; 1071 : fprintf(output, "onceonly "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_09EPCGBNDN@onceonly?5@
; 1074 : }
; 1075 : }
pop ebp
; 1070 : case XML_REGEXP_QUANT_ONCEONLY:
; 1071 : fprintf(output, "onceonly "); break;
jmp _fprintf
$LN11@xmlRegPrin:
; 1072 : case XML_REGEXP_QUANT_ALL:
; 1073 : fprintf(output, "all "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_04DIDGAIEC@all?5@
; 1074 : }
; 1075 : }
pop ebp
; 1072 : case XML_REGEXP_QUANT_ALL:
; 1073 : fprintf(output, "all "); break;
jmp _fprintf
$LN2@xmlRegPrin:
; 1074 : }
; 1075 : }
pop ebp
ret 0
npad 1
$LN16@xmlRegPrin:
DD $LN4@xmlRegPrin
DD $LN5@xmlRegPrin
DD $LN6@xmlRegPrin
DD $LN7@xmlRegPrin
DD $LN8@xmlRegPrin
DD $LN10@xmlRegPrin
DD $LN11@xmlRegPrin
DD $LN9@xmlRegPrin
_xmlRegPrintQuantType ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegPrintAtomType
_TEXT SEGMENT
_output$ = 8 ; size = 4
_type$ = 12 ; size = 4
_xmlRegPrintAtomType PROC ; COMDAT
; 944 : xmlRegPrintAtomType(FILE *output, xmlRegAtomType type) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _type$[ebp]
dec eax
cmp eax, 135 ; 00000087H
ja $LN2@xmlRegPrin
; 945 : switch (type) {
movzx eax, BYTE PTR $LN58@xmlRegPrin[eax]
jmp DWORD PTR $LN62@xmlRegPrin[eax*4]
$LN4@xmlRegPrin:
; 946 : case XML_REGEXP_EPSILON:
; 947 : fprintf(output, "epsilon "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_08LJGDJFJP@epsilon?5@
; 1052 : }
; 1053 : }
pop ebp
; 946 : case XML_REGEXP_EPSILON:
; 947 : fprintf(output, "epsilon "); break;
jmp _fprintf
$LN5@xmlRegPrin:
; 948 : case XML_REGEXP_CHARVAL:
; 949 : fprintf(output, "charval "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_08DFHMJFEK@charval?5@
; 1052 : }
; 1053 : }
pop ebp
; 948 : case XML_REGEXP_CHARVAL:
; 949 : fprintf(output, "charval "); break;
jmp _fprintf
$LN6@xmlRegPrin:
; 950 : case XML_REGEXP_RANGES:
; 951 : fprintf(output, "ranges "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_07IPEOMBMH@ranges?5@
; 1052 : }
; 1053 : }
pop ebp
; 950 : case XML_REGEXP_RANGES:
; 951 : fprintf(output, "ranges "); break;
jmp _fprintf
$LN7@xmlRegPrin:
; 952 : case XML_REGEXP_SUBREG:
; 953 : fprintf(output, "subexpr "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_08BABENLJO@subexpr?5@
; 1052 : }
; 1053 : }
pop ebp
; 952 : case XML_REGEXP_SUBREG:
; 953 : fprintf(output, "subexpr "); break;
jmp _fprintf
$LN8@xmlRegPrin:
; 954 : case XML_REGEXP_STRING:
; 955 : fprintf(output, "string "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_07HBAIICBM@string?5@
; 1052 : }
; 1053 : }
pop ebp
; 954 : case XML_REGEXP_STRING:
; 955 : fprintf(output, "string "); break;
jmp _fprintf
$LN9@xmlRegPrin:
; 956 : case XML_REGEXP_ANYCHAR:
; 957 : fprintf(output, "anychar "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_08IIDGBAEF@anychar?5@
; 1052 : }
; 1053 : }
pop ebp
; 956 : case XML_REGEXP_ANYCHAR:
; 957 : fprintf(output, "anychar "); break;
jmp _fprintf
$LN10@xmlRegPrin:
; 958 : case XML_REGEXP_ANYSPACE:
; 959 : fprintf(output, "anyspace "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_09IFBFMEEE@anyspace?5@
; 1052 : }
; 1053 : }
pop ebp
; 958 : case XML_REGEXP_ANYSPACE:
; 959 : fprintf(output, "anyspace "); break;
jmp _fprintf
$LN11@xmlRegPrin:
; 960 : case XML_REGEXP_NOTSPACE:
; 961 : fprintf(output, "notspace "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_09PIGAJOFL@notspace?5@
; 1052 : }
; 1053 : }
pop ebp
; 960 : case XML_REGEXP_NOTSPACE:
; 961 : fprintf(output, "notspace "); break;
jmp _fprintf
$LN12@xmlRegPrin:
; 962 : case XML_REGEXP_INITNAME:
; 963 : fprintf(output, "initname "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_09PGNNJPMN@initname?5@
; 1052 : }
; 1053 : }
pop ebp
; 962 : case XML_REGEXP_INITNAME:
; 963 : fprintf(output, "initname "); break;
jmp _fprintf
$LN13@xmlRegPrin:
; 964 : case XML_REGEXP_NOTINITNAME:
; 965 : fprintf(output, "notinitname "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0N@PKALLFNP@notinitname?5@
; 1052 : }
; 1053 : }
pop ebp
; 964 : case XML_REGEXP_NOTINITNAME:
; 965 : fprintf(output, "notinitname "); break;
jmp _fprintf
$LN14@xmlRegPrin:
; 966 : case XML_REGEXP_NAMECHAR:
; 967 : fprintf(output, "namechar "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_09GMGKKJAH@namechar?5@
; 1052 : }
; 1053 : }
pop ebp
; 966 : case XML_REGEXP_NAMECHAR:
; 967 : fprintf(output, "namechar "); break;
jmp _fprintf
$LN15@xmlRegPrin:
; 968 : case XML_REGEXP_NOTNAMECHAR:
; 969 : fprintf(output, "notnamechar "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0N@GALMIDBF@notnamechar?5@
; 1052 : }
; 1053 : }
pop ebp
; 968 : case XML_REGEXP_NOTNAMECHAR:
; 969 : fprintf(output, "notnamechar "); break;
jmp _fprintf
$LN16@xmlRegPrin:
; 970 : case XML_REGEXP_DECIMAL:
; 971 : fprintf(output, "decimal "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_08CDKGKILA@decimal?5@
; 1052 : }
; 1053 : }
pop ebp
; 970 : case XML_REGEXP_DECIMAL:
; 971 : fprintf(output, "decimal "); break;
jmp _fprintf
$LN17@xmlRegPrin:
; 972 : case XML_REGEXP_NOTDECIMAL:
; 973 : fprintf(output, "notdecimal "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0M@EDJHICHL@notdecimal?5@
; 1052 : }
; 1053 : }
pop ebp
; 972 : case XML_REGEXP_NOTDECIMAL:
; 973 : fprintf(output, "notdecimal "); break;
jmp _fprintf
$LN18@xmlRegPrin:
; 974 : case XML_REGEXP_REALCHAR:
; 975 : fprintf(output, "realchar "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_09MOCDMJPB@realchar?5@
; 1052 : }
; 1053 : }
pop ebp
; 974 : case XML_REGEXP_REALCHAR:
; 975 : fprintf(output, "realchar "); break;
jmp _fprintf
$LN19@xmlRegPrin:
; 976 : case XML_REGEXP_NOTREALCHAR:
; 977 : fprintf(output, "notrealchar "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0N@MCPFODOD@notrealchar?5@
; 1052 : }
; 1053 : }
pop ebp
; 976 : case XML_REGEXP_NOTREALCHAR:
; 977 : fprintf(output, "notrealchar "); break;
jmp _fprintf
$LN20@xmlRegPrin:
; 978 : case XML_REGEXP_LETTER:
; 979 : fprintf(output, "LETTER "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_07POCGPIHD@LETTER?5@
; 1052 : }
; 1053 : }
pop ebp
; 978 : case XML_REGEXP_LETTER:
; 979 : fprintf(output, "LETTER "); break;
jmp _fprintf
$LN21@xmlRegPrin:
; 980 : case XML_REGEXP_LETTER_UPPERCASE:
; 981 : fprintf(output, "LETTER_UPPERCASE "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BC@KMHMCLHI@LETTER_UPPERCASE?5@
; 1052 : }
; 1053 : }
pop ebp
; 980 : case XML_REGEXP_LETTER_UPPERCASE:
; 981 : fprintf(output, "LETTER_UPPERCASE "); break;
jmp _fprintf
$LN22@xmlRegPrin:
; 982 : case XML_REGEXP_LETTER_LOWERCASE:
; 983 : fprintf(output, "LETTER_LOWERCASE "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BC@MLADGGJK@LETTER_LOWERCASE?5@
; 1052 : }
; 1053 : }
pop ebp
; 982 : case XML_REGEXP_LETTER_LOWERCASE:
; 983 : fprintf(output, "LETTER_LOWERCASE "); break;
jmp _fprintf
$LN23@xmlRegPrin:
; 984 : case XML_REGEXP_LETTER_TITLECASE:
; 985 : fprintf(output, "LETTER_TITLECASE "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BC@FGJDLGPN@LETTER_TITLECASE?5@
; 1052 : }
; 1053 : }
pop ebp
; 984 : case XML_REGEXP_LETTER_TITLECASE:
; 985 : fprintf(output, "LETTER_TITLECASE "); break;
jmp _fprintf
$LN24@xmlRegPrin:
; 986 : case XML_REGEXP_LETTER_MODIFIER:
; 987 : fprintf(output, "LETTER_MODIFIER "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BB@MHDADLFE@LETTER_MODIFIER?5@
; 1052 : }
; 1053 : }
pop ebp
; 986 : case XML_REGEXP_LETTER_MODIFIER:
; 987 : fprintf(output, "LETTER_MODIFIER "); break;
jmp _fprintf
$LN25@xmlRegPrin:
; 988 : case XML_REGEXP_LETTER_OTHERS:
; 989 : fprintf(output, "LETTER_OTHERS "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0P@ONCGNHEJ@LETTER_OTHERS?5@
; 1052 : }
; 1053 : }
pop ebp
; 988 : case XML_REGEXP_LETTER_OTHERS:
; 989 : fprintf(output, "LETTER_OTHERS "); break;
jmp _fprintf
$LN26@xmlRegPrin:
; 990 : case XML_REGEXP_MARK:
; 991 : fprintf(output, "MARK "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_05BACHLHLN@MARK?5@
; 1052 : }
; 1053 : }
pop ebp
; 990 : case XML_REGEXP_MARK:
; 991 : fprintf(output, "MARK "); break;
jmp _fprintf
$LN27@xmlRegPrin:
; 992 : case XML_REGEXP_MARK_NONSPACING:
; 993 : fprintf(output, "MARK_NONSPACING "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BB@FIDLEIEL@MARK_NONSPACING?5@
; 1052 : }
; 1053 : }
pop ebp
; 992 : case XML_REGEXP_MARK_NONSPACING:
; 993 : fprintf(output, "MARK_NONSPACING "); break;
jmp _fprintf
$LN28@xmlRegPrin:
; 994 : case XML_REGEXP_MARK_SPACECOMBINING:
; 995 : fprintf(output, "MARK_SPACECOMBINING "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BF@GJKDPMF@MARK_SPACECOMBINING?5@
; 1052 : }
; 1053 : }
pop ebp
; 994 : case XML_REGEXP_MARK_SPACECOMBINING:
; 995 : fprintf(output, "MARK_SPACECOMBINING "); break;
jmp _fprintf
$LN29@xmlRegPrin:
; 996 : case XML_REGEXP_MARK_ENCLOSING:
; 997 : fprintf(output, "MARK_ENCLOSING "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BA@NNNPPLBP@MARK_ENCLOSING?5@
; 1052 : }
; 1053 : }
pop ebp
; 996 : case XML_REGEXP_MARK_ENCLOSING:
; 997 : fprintf(output, "MARK_ENCLOSING "); break;
jmp _fprintf
$LN30@xmlRegPrin:
; 998 : case XML_REGEXP_NUMBER:
; 999 : fprintf(output, "NUMBER "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_07BAKEFCLB@NUMBER?5@
; 1052 : }
; 1053 : }
pop ebp
; 998 : case XML_REGEXP_NUMBER:
; 999 : fprintf(output, "NUMBER "); break;
jmp _fprintf
$LN31@xmlRegPrin:
; 1000 : case XML_REGEXP_NUMBER_DECIMAL:
; 1001 : fprintf(output, "NUMBER_DECIMAL "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BA@JLEBGNKM@NUMBER_DECIMAL?5@
; 1052 : }
; 1053 : }
pop ebp
; 1000 : case XML_REGEXP_NUMBER_DECIMAL:
; 1001 : fprintf(output, "NUMBER_DECIMAL "); break;
jmp _fprintf
$LN32@xmlRegPrin:
; 1002 : case XML_REGEXP_NUMBER_LETTER:
; 1003 : fprintf(output, "NUMBER_LETTER "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0P@FJBLFHMA@NUMBER_LETTER?5@
; 1052 : }
; 1053 : }
pop ebp
; 1002 : case XML_REGEXP_NUMBER_LETTER:
; 1003 : fprintf(output, "NUMBER_LETTER "); break;
jmp _fprintf
$LN33@xmlRegPrin:
; 1004 : case XML_REGEXP_NUMBER_OTHERS:
; 1005 : fprintf(output, "NUMBER_OTHERS "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0P@PDKFLOJK@NUMBER_OTHERS?5@
; 1052 : }
; 1053 : }
pop ebp
; 1004 : case XML_REGEXP_NUMBER_OTHERS:
; 1005 : fprintf(output, "NUMBER_OTHERS "); break;
jmp _fprintf
$LN34@xmlRegPrin:
; 1006 : case XML_REGEXP_PUNCT:
; 1007 : fprintf(output, "PUNCT "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_06INFGODEH@PUNCT?5@
; 1052 : }
; 1053 : }
pop ebp
; 1006 : case XML_REGEXP_PUNCT:
; 1007 : fprintf(output, "PUNCT "); break;
jmp _fprintf
$LN35@xmlRegPrin:
; 1008 : case XML_REGEXP_PUNCT_CONNECTOR:
; 1009 : fprintf(output, "PUNCT_CONNECTOR "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BB@DCHADIII@PUNCT_CONNECTOR?5@
; 1052 : }
; 1053 : }
pop ebp
; 1008 : case XML_REGEXP_PUNCT_CONNECTOR:
; 1009 : fprintf(output, "PUNCT_CONNECTOR "); break;
jmp _fprintf
$LN36@xmlRegPrin:
; 1010 : case XML_REGEXP_PUNCT_DASH:
; 1011 : fprintf(output, "PUNCT_DASH "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0M@BBMKBPFM@PUNCT_DASH?5@
; 1052 : }
; 1053 : }
pop ebp
; 1010 : case XML_REGEXP_PUNCT_DASH:
; 1011 : fprintf(output, "PUNCT_DASH "); break;
jmp _fprintf
$LN37@xmlRegPrin:
; 1012 : case XML_REGEXP_PUNCT_OPEN:
; 1013 : fprintf(output, "PUNCT_OPEN "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0M@FHHCCFFM@PUNCT_OPEN?5@
; 1052 : }
; 1053 : }
pop ebp
; 1012 : case XML_REGEXP_PUNCT_OPEN:
; 1013 : fprintf(output, "PUNCT_OPEN "); break;
jmp _fprintf
$LN38@xmlRegPrin:
; 1014 : case XML_REGEXP_PUNCT_CLOSE:
; 1015 : fprintf(output, "PUNCT_CLOSE "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0N@OCGFHNOE@PUNCT_CLOSE?5@
; 1052 : }
; 1053 : }
pop ebp
; 1014 : case XML_REGEXP_PUNCT_CLOSE:
; 1015 : fprintf(output, "PUNCT_CLOSE "); break;
jmp _fprintf
$LN39@xmlRegPrin:
; 1016 : case XML_REGEXP_PUNCT_INITQUOTE:
; 1017 : fprintf(output, "PUNCT_INITQUOTE "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BB@HJFINBLL@PUNCT_INITQUOTE?5@
; 1052 : }
; 1053 : }
pop ebp
; 1016 : case XML_REGEXP_PUNCT_INITQUOTE:
; 1017 : fprintf(output, "PUNCT_INITQUOTE "); break;
jmp _fprintf
$LN40@xmlRegPrin:
; 1018 : case XML_REGEXP_PUNCT_FINQUOTE:
; 1019 : fprintf(output, "PUNCT_FINQUOTE "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BA@EBCHGEDF@PUNCT_FINQUOTE?5@
; 1052 : }
; 1053 : }
pop ebp
; 1018 : case XML_REGEXP_PUNCT_FINQUOTE:
; 1019 : fprintf(output, "PUNCT_FINQUOTE "); break;
jmp _fprintf
$LN41@xmlRegPrin:
; 1020 : case XML_REGEXP_PUNCT_OTHERS:
; 1021 : fprintf(output, "PUNCT_OTHERS "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0O@FIEDELON@PUNCT_OTHERS?5@
; 1052 : }
; 1053 : }
pop ebp
; 1020 : case XML_REGEXP_PUNCT_OTHERS:
; 1021 : fprintf(output, "PUNCT_OTHERS "); break;
jmp _fprintf
$LN42@xmlRegPrin:
; 1022 : case XML_REGEXP_SEPAR:
; 1023 : fprintf(output, "SEPAR "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_06MODMGGJL@SEPAR?5@
; 1052 : }
; 1053 : }
pop ebp
; 1022 : case XML_REGEXP_SEPAR:
; 1023 : fprintf(output, "SEPAR "); break;
jmp _fprintf
$LN43@xmlRegPrin:
; 1024 : case XML_REGEXP_SEPAR_SPACE:
; 1025 : fprintf(output, "SEPAR_SPACE "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0N@CEDLANHM@SEPAR_SPACE?5@
; 1052 : }
; 1053 : }
pop ebp
; 1024 : case XML_REGEXP_SEPAR_SPACE:
; 1025 : fprintf(output, "SEPAR_SPACE "); break;
jmp _fprintf
$LN44@xmlRegPrin:
; 1026 : case XML_REGEXP_SEPAR_LINE:
; 1027 : fprintf(output, "SEPAR_LINE "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0M@GPNEEMIA@SEPAR_LINE?5@
; 1052 : }
; 1053 : }
pop ebp
; 1026 : case XML_REGEXP_SEPAR_LINE:
; 1027 : fprintf(output, "SEPAR_LINE "); break;
jmp _fprintf
$LN45@xmlRegPrin:
; 1028 : case XML_REGEXP_SEPAR_PARA:
; 1029 : fprintf(output, "SEPAR_PARA "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0M@DGHGIFFK@SEPAR_PARA?5@
; 1052 : }
; 1053 : }
pop ebp
; 1028 : case XML_REGEXP_SEPAR_PARA:
; 1029 : fprintf(output, "SEPAR_PARA "); break;
jmp _fprintf
$LN46@xmlRegPrin:
; 1030 : case XML_REGEXP_SYMBOL:
; 1031 : fprintf(output, "SYMBOL "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_07EJLPHCCB@SYMBOL?5@
; 1052 : }
; 1053 : }
pop ebp
; 1030 : case XML_REGEXP_SYMBOL:
; 1031 : fprintf(output, "SYMBOL "); break;
jmp _fprintf
$LN47@xmlRegPrin:
; 1032 : case XML_REGEXP_SYMBOL_MATH:
; 1033 : fprintf(output, "SYMBOL_MATH "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0N@LBDJILGE@SYMBOL_MATH?5@
; 1052 : }
; 1053 : }
pop ebp
; 1032 : case XML_REGEXP_SYMBOL_MATH:
; 1033 : fprintf(output, "SYMBOL_MATH "); break;
jmp _fprintf
$LN48@xmlRegPrin:
; 1034 : case XML_REGEXP_SYMBOL_CURRENCY:
; 1035 : fprintf(output, "SYMBOL_CURRENCY "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BB@MBFAMNND@SYMBOL_CURRENCY?5@
; 1052 : }
; 1053 : }
pop ebp
; 1034 : case XML_REGEXP_SYMBOL_CURRENCY:
; 1035 : fprintf(output, "SYMBOL_CURRENCY "); break;
jmp _fprintf
$LN49@xmlRegPrin:
; 1036 : case XML_REGEXP_SYMBOL_MODIFIER:
; 1037 : fprintf(output, "SYMBOL_MODIFIER "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0BB@CEPANLJE@SYMBOL_MODIFIER?5@
; 1052 : }
; 1053 : }
pop ebp
; 1036 : case XML_REGEXP_SYMBOL_MODIFIER:
; 1037 : fprintf(output, "SYMBOL_MODIFIER "); break;
jmp _fprintf
$LN50@xmlRegPrin:
; 1038 : case XML_REGEXP_SYMBOL_OTHERS:
; 1039 : fprintf(output, "SYMBOL_OTHERS "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0P@LKPECLCL@SYMBOL_OTHERS?5@
; 1052 : }
; 1053 : }
pop ebp
; 1038 : case XML_REGEXP_SYMBOL_OTHERS:
; 1039 : fprintf(output, "SYMBOL_OTHERS "); break;
jmp _fprintf
$LN51@xmlRegPrin:
; 1040 : case XML_REGEXP_OTHER:
; 1041 : fprintf(output, "OTHER "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_06HJDKAKAL@OTHER?5@
; 1052 : }
; 1053 : }
pop ebp
; 1040 : case XML_REGEXP_OTHER:
; 1041 : fprintf(output, "OTHER "); break;
jmp _fprintf
$LN52@xmlRegPrin:
; 1042 : case XML_REGEXP_OTHER_CONTROL:
; 1043 : fprintf(output, "OTHER_CONTROL "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0P@FGFCBEPI@OTHER_CONTROL?5@
; 1052 : }
; 1053 : }
pop ebp
; 1042 : case XML_REGEXP_OTHER_CONTROL:
; 1043 : fprintf(output, "OTHER_CONTROL "); break;
jmp _fprintf
$LN53@xmlRegPrin:
; 1044 : case XML_REGEXP_OTHER_FORMAT:
; 1045 : fprintf(output, "OTHER_FORMAT "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0O@BACNFCMB@OTHER_FORMAT?5@
; 1052 : }
; 1053 : }
pop ebp
; 1044 : case XML_REGEXP_OTHER_FORMAT:
; 1045 : fprintf(output, "OTHER_FORMAT "); break;
jmp _fprintf
$LN54@xmlRegPrin:
; 1046 : case XML_REGEXP_OTHER_PRIVATE:
; 1047 : fprintf(output, "OTHER_PRIVATE "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_0P@DEHNHHA@OTHER_PRIVATE?5@
; 1052 : }
; 1053 : }
pop ebp
; 1046 : case XML_REGEXP_OTHER_PRIVATE:
; 1047 : fprintf(output, "OTHER_PRIVATE "); break;
jmp _fprintf
$LN55@xmlRegPrin:
; 1048 : case XML_REGEXP_OTHER_NA:
; 1049 : fprintf(output, "OTHER_NA "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_09NECDEFOF@OTHER_NA?5@
; 1052 : }
; 1053 : }
pop ebp
; 1048 : case XML_REGEXP_OTHER_NA:
; 1049 : fprintf(output, "OTHER_NA "); break;
jmp _fprintf
$LN56@xmlRegPrin:
; 1050 : case XML_REGEXP_BLOCK_NAME:
; 1051 : fprintf(output, "BLOCK "); break;
mov DWORD PTR _type$[ebp], OFFSET ??_C@_06HDNEPAAO@BLOCK?5@
; 1052 : }
; 1053 : }
pop ebp
; 1050 : case XML_REGEXP_BLOCK_NAME:
; 1051 : fprintf(output, "BLOCK "); break;
jmp _fprintf
$LN2@xmlRegPrin:
; 1052 : }
; 1053 : }
pop ebp
ret 0
npad 3
$LN62@xmlRegPrin:
DD $LN4@xmlRegPrin
DD $LN5@xmlRegPrin
DD $LN6@xmlRegPrin
DD $LN7@xmlRegPrin
DD $LN8@xmlRegPrin
DD $LN9@xmlRegPrin
DD $LN10@xmlRegPrin
DD $LN11@xmlRegPrin
DD $LN12@xmlRegPrin
DD $LN13@xmlRegPrin
DD $LN14@xmlRegPrin
DD $LN15@xmlRegPrin
DD $LN16@xmlRegPrin
DD $LN17@xmlRegPrin
DD $LN18@xmlRegPrin
DD $LN19@xmlRegPrin
DD $LN20@xmlRegPrin
DD $LN21@xmlRegPrin
DD $LN22@xmlRegPrin
DD $LN23@xmlRegPrin
DD $LN24@xmlRegPrin
DD $LN25@xmlRegPrin
DD $LN26@xmlRegPrin
DD $LN27@xmlRegPrin
DD $LN28@xmlRegPrin
DD $LN29@xmlRegPrin
DD $LN30@xmlRegPrin
DD $LN31@xmlRegPrin
DD $LN32@xmlRegPrin
DD $LN33@xmlRegPrin
DD $LN34@xmlRegPrin
DD $LN35@xmlRegPrin
DD $LN36@xmlRegPrin
DD $LN37@xmlRegPrin
DD $LN38@xmlRegPrin
DD $LN39@xmlRegPrin
DD $LN40@xmlRegPrin
DD $LN41@xmlRegPrin
DD $LN42@xmlRegPrin
DD $LN43@xmlRegPrin
DD $LN44@xmlRegPrin
DD $LN45@xmlRegPrin
DD $LN46@xmlRegPrin
DD $LN47@xmlRegPrin
DD $LN48@xmlRegPrin
DD $LN49@xmlRegPrin
DD $LN50@xmlRegPrin
DD $LN51@xmlRegPrin
DD $LN52@xmlRegPrin
DD $LN53@xmlRegPrin
DD $LN54@xmlRegPrin
DD $LN55@xmlRegPrin
DD $LN56@xmlRegPrin
DD $LN2@xmlRegPrin
$LN58@xmlRegPrin:
DB 0
DB 1
DB 2
DB 3
DB 4
DB 5
DB 6
DB 7
DB 8
DB 9
DB 10 ; 0000000aH
DB 11 ; 0000000bH
DB 12 ; 0000000cH
DB 13 ; 0000000dH
DB 14 ; 0000000eH
DB 15 ; 0000000fH
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 53 ; 00000035H
DB 16 ; 00000010H
DB 17 ; 00000011H
DB 18 ; 00000012H
DB 19 ; 00000013H
DB 20 ; 00000014H
DB 21 ; 00000015H
DB 22 ; 00000016H
DB 23 ; 00000017H
DB 24 ; 00000018H
DB 25 ; 00000019H
DB 26 ; 0000001aH
DB 27 ; 0000001bH
DB 28 ; 0000001cH
DB 29 ; 0000001dH
DB 30 ; 0000001eH
DB 31 ; 0000001fH
DB 32 ; 00000020H
DB 33 ; 00000021H
DB 34 ; 00000022H
DB 35 ; 00000023H
DB 36 ; 00000024H
DB 37 ; 00000025H
DB 38 ; 00000026H
DB 39 ; 00000027H
DB 40 ; 00000028H
DB 41 ; 00000029H
DB 42 ; 0000002aH
DB 43 ; 0000002bH
DB 44 ; 0000002cH
DB 45 ; 0000002dH
DB 46 ; 0000002eH
DB 47 ; 0000002fH
DB 48 ; 00000030H
DB 49 ; 00000031H
DB 50 ; 00000032H
DB 51 ; 00000033H
DB 52 ; 00000034H
_xmlRegPrintAtomType ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegFreeParserCtxt
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlRegFreeParserCtxt PROC ; COMDAT
; 915 : xmlRegFreeParserCtxt(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
test esi, esi
je $LN1@xmlRegFree
; 916 : int i;
; 917 : if (ctxt == NULL)
; 918 : return;
; 919 :
; 920 : if (ctxt->string != NULL)
mov eax, DWORD PTR [esi]
test eax, eax
je SHORT $LN9@xmlRegFree
; 921 : xmlFree(ctxt->string);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN9@xmlRegFree:
; 922 : if (ctxt->states != NULL) {
cmp DWORD PTR [esi+52], 0
push edi
je SHORT $LN10@xmlRegFree
; 923 : for (i = 0;i < ctxt->nbStates;i++)
xor edi, edi
cmp DWORD PTR [esi+48], edi
jle SHORT $LN3@xmlRegFree
push ebx
$LL4@xmlRegFree:
; 924 : xmlRegFreeState(ctxt->states[i]);
mov eax, DWORD PTR [esi+52]
mov ebx, DWORD PTR [eax+edi*4]
; 898 : if (state == NULL)
test ebx, ebx
je SHORT $LN2@xmlRegFree
; 899 : return;
; 900 :
; 901 : if (state->trans != NULL)
mov eax, DWORD PTR [ebx+28]
test eax, eax
je SHORT $LN16@xmlRegFree
; 902 : xmlFree(state->trans);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN16@xmlRegFree:
; 903 : if (state->transTo != NULL)
mov eax, DWORD PTR [ebx+40]
test eax, eax
je SHORT $LN17@xmlRegFree
; 904 : xmlFree(state->transTo);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN17@xmlRegFree:
; 905 : xmlFree(state);
push ebx
call DWORD PTR _xmlFree
add esp, 4
$LN2@xmlRegFree:
; 923 : for (i = 0;i < ctxt->nbStates;i++)
inc edi
cmp edi, DWORD PTR [esi+48]
jl SHORT $LL4@xmlRegFree
pop ebx
$LN3@xmlRegFree:
; 925 : xmlFree(ctxt->states);
push DWORD PTR [esi+52]
call DWORD PTR _xmlFree
add esp, 4
$LN10@xmlRegFree:
; 926 : }
; 927 : if (ctxt->atoms != NULL) {
mov eax, DWORD PTR [esi+40]
test eax, eax
je SHORT $LN11@xmlRegFree
; 928 : for (i = 0;i < ctxt->nbAtoms;i++)
xor edi, edi
cmp DWORD PTR [esi+36], edi
jle SHORT $LN6@xmlRegFree
npad 1
$LL7@xmlRegFree:
; 929 : xmlRegFreeAtom(ctxt->atoms[i]);
mov eax, DWORD PTR [esi+40]
push DWORD PTR [eax+edi*4]
call _xmlRegFreeAtom
inc edi
add esp, 4
cmp edi, DWORD PTR [esi+36]
jl SHORT $LL7@xmlRegFree
mov eax, DWORD PTR [esi+40]
$LN6@xmlRegFree:
; 930 : xmlFree(ctxt->atoms);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN11@xmlRegFree:
; 931 : }
; 932 : if (ctxt->counters != NULL)
mov eax, DWORD PTR [esi+64]
pop edi
test eax, eax
je SHORT $LN12@xmlRegFree
; 933 : xmlFree(ctxt->counters);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN12@xmlRegFree:
; 934 : xmlFree(ctxt);
push esi
call DWORD PTR _xmlFree
add esp, 4
$LN1@xmlRegFree:
pop esi
; 935 : }
pop ebp
ret 0
_xmlRegFreeParserCtxt ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegNewState
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlRegNewState PROC ; COMDAT
; 876 : xmlRegNewState(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
push 44 ; 0000002cH
call DWORD PTR _xmlMalloc
add esp, 4
test eax, eax
jne SHORT $LN2@xmlRegNewS
; 381 : if (ctxt != NULL) {
mov eax, DWORD PTR _ctxt$[ebp]
xor ecx, ecx
test eax, eax
je SHORT $LN5@xmlRegNewS
; 382 : regexp = (const char *) ctxt->string;
mov ecx, DWORD PTR [eax]
; 383 : ctxt->error = XML_ERR_NO_MEMORY;
mov DWORD PTR [eax+8], 2
$LN5@xmlRegNewS:
; 384 : }
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
push OFFSET ??_C@_0BB@CKELLPME@allocating?5state@
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push 0
push 0
push 0
push ecx
push OFFSET ??_C@_0BB@CKELLPME@allocating?5state@
push 0
push 0
push 3
push 2
push 14 ; 0000000eH
push 0
push 0
push 0
push 0
push 0
call ___xmlRaiseError
add esp, 68 ; 00000044H
; 877 : xmlRegStatePtr ret;
; 878 :
; 879 : ret = (xmlRegStatePtr) xmlMalloc(sizeof(xmlRegState));
; 880 : if (ret == NULL) {
; 881 : xmlRegexpErrMemory(ctxt, "allocating state");
; 882 : return(NULL);
xor eax, eax
; 887 : return(ret);
; 888 : }
pop ebp
ret 0
$LN2@xmlRegNewS:
; 883 : }
; 884 : memset(ret, 0, sizeof(xmlRegState));
mov DWORD PTR [eax+8], 0
mov DWORD PTR [eax+12], 0
mov DWORD PTR [eax+16], 0
mov DWORD PTR [eax+20], 0
mov DWORD PTR [eax+24], 0
mov DWORD PTR [eax+28], 0
mov DWORD PTR [eax+32], 0
mov DWORD PTR [eax+36], 0
mov DWORD PTR [eax+40], 0
; 885 : ret->type = XML_REGEXP_TRANS_STATE;
mov DWORD PTR [eax], 3
; 886 : ret->mark = XML_REGEXP_MARK_NORMAL;
mov DWORD PTR [eax+4], 0
; 887 : return(ret);
; 888 : }
pop ebp
ret 0
_xmlRegNewState ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegCopyAtom
_TEXT SEGMENT
_range$1$ = -4 ; size = 4
_ctxt$ = 8 ; size = 4
_atom$ = 12 ; size = 4
_xmlRegCopyAtom PROC ; COMDAT
; 839 : xmlRegCopyAtom(xmlRegParserCtxtPtr ctxt, xmlRegAtomPtr atom) {
push ebp
mov ebp, esp
push ecx
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
push 64 ; 00000040H
call DWORD PTR _xmlMalloc
mov edi, eax
add esp, 4
test edi, edi
jne SHORT $LN5@xmlRegCopy
; 381 : if (ctxt != NULL) {
mov eax, DWORD PTR _ctxt$[ebp]
xor ecx, ecx
test eax, eax
je SHORT $LN11@xmlRegCopy
; 382 : regexp = (const char *) ctxt->string;
mov ecx, DWORD PTR [eax]
; 383 : ctxt->error = XML_ERR_NO_MEMORY;
mov DWORD PTR [eax+8], 2
$LN11@xmlRegCopy:
; 384 : }
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
push OFFSET ??_C@_0N@ECMBACNP@copying?5atom@
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push 0
push 0
push 0
push ecx
push OFFSET ??_C@_0N@ECMBACNP@copying?5atom@
push 0
push 0
push 3
push 2
push 14 ; 0000000eH
push 0
push 0
push 0
push 0
push 0
call ___xmlRaiseError
add esp, 68 ; 00000044H
; 840 : xmlRegAtomPtr ret;
; 841 :
; 842 : ret = (xmlRegAtomPtr) xmlMalloc(sizeof(xmlRegAtom));
; 843 : if (ret == NULL) {
; 844 : xmlRegexpErrMemory(ctxt, "copying atom");
; 845 : return(NULL);
xor eax, eax
pop edi
; 873 : }
mov esp, ebp
pop ebp
ret 0
$LN5@xmlRegCopy:
push ebx
push esi
; 846 : }
; 847 : memset(ret, 0, sizeof(xmlRegAtom));
push 64 ; 00000040H
push 0
push edi
call _memset
; 848 : ret->type = atom->type;
mov esi, DWORD PTR _atom$[ebp]
add esp, 12 ; 0000000cH
mov eax, DWORD PTR [esi+4]
mov DWORD PTR [edi+4], eax
; 849 : ret->quant = atom->quant;
mov eax, DWORD PTR [esi+8]
mov DWORD PTR [edi+8], eax
; 850 : ret->min = atom->min;
mov eax, DWORD PTR [esi+12]
mov DWORD PTR [edi+12], eax
; 851 : ret->max = atom->max;
mov eax, DWORD PTR [esi+16]
mov DWORD PTR [edi+16], eax
; 852 : if (atom->nbRanges > 0) {
mov eax, DWORD PTR [esi+52]
test eax, eax
jle $LN3@xmlRegCopy
; 853 : int i;
; 854 :
; 855 : ret->ranges = (xmlRegRangePtr *) xmlMalloc(sizeof(xmlRegRangePtr) *
shl eax, 2
push eax
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR [edi+56], eax
; 856 : atom->nbRanges);
; 857 : if (ret->ranges == NULL) {
test eax, eax
jne SHORT $LN7@xmlRegCopy
; 858 : xmlRegexpErrMemory(ctxt, "copying atom");
push OFFSET ??_C@_0N@ECMBACNP@copying?5atom@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
add esp, 8
$error$28:
; 869 :
; 870 : error:
; 871 : xmlRegFreeAtom(ret);
push edi
call _xmlRegFreeAtom
add esp, 4
; 872 : return(NULL);
xor eax, eax
pop esi
pop ebx
pop edi
; 873 : }
mov esp, ebp
pop ebp
ret 0
$LN7@xmlRegCopy:
; 859 : goto error;
; 860 : }
; 861 : for (i = 0;i < atom->nbRanges;i++) {
xor ebx, ebx
cmp DWORD PTR [esi+52], ebx
jle SHORT $LN3@xmlRegCopy
npad 3
$LL4@xmlRegCopy:
; 862 : ret->ranges[i] = xmlRegCopyRange(ctxt, atom->ranges[i]);
mov eax, DWORD PTR [esi+56]
mov eax, DWORD PTR [eax+ebx*4]
mov DWORD PTR _range$1$[ebp], eax
; 759 : if (range == NULL)
test eax, eax
je SHORT $LN26@xmlRegCopy
; 760 : return(NULL);
; 761 :
; 762 : ret = xmlRegNewRange(ctxt, range->neg, range->type, range->start,
push DWORD PTR [eax+12]
push DWORD PTR [eax+8]
push DWORD PTR [eax+4]
push DWORD PTR [eax]
push DWORD PTR _ctxt$[ebp]
call _xmlRegNewRange
mov esi, eax
add esp, 20 ; 00000014H
; 763 : range->end);
; 764 : if (ret == NULL)
test esi, esi
je SHORT $LN26@xmlRegCopy
; 765 : return(NULL);
; 766 : if (range->blockName != NULL) {
mov eax, DWORD PTR _range$1$[ebp]
mov eax, DWORD PTR [eax+16]
test eax, eax
je SHORT $LN17@xmlRegCopy
; 767 : ret->blockName = xmlStrdup(range->blockName);
push eax
call _xmlStrdup
add esp, 4
mov DWORD PTR [esi+16], eax
; 768 : if (ret->blockName == NULL) {
test eax, eax
jne SHORT $LN17@xmlRegCopy
; 769 : xmlRegexpErrMemory(ctxt, "allocating range");
push OFFSET ??_C@_0BB@PBEHJOM@allocating?5range@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
; 770 : xmlRegFreeRange(ret);
push esi
call _xmlRegFreeRange
add esp, 12 ; 0000000cH
$LN26@xmlRegCopy:
; 862 : ret->ranges[i] = xmlRegCopyRange(ctxt, atom->ranges[i]);
xor esi, esi
$LN17@xmlRegCopy:
mov eax, DWORD PTR [edi+56]
mov DWORD PTR [eax+ebx*4], esi
; 863 : if (ret->ranges[i] == NULL)
mov eax, DWORD PTR [edi+56]
cmp DWORD PTR [eax+ebx*4], 0
je $error$28
; 864 : goto error;
; 865 : ret->nbRanges = i + 1;
mov esi, DWORD PTR _atom$[ebp]
inc ebx
mov DWORD PTR [edi+52], ebx
cmp ebx, DWORD PTR [esi+52]
jl SHORT $LL4@xmlRegCopy
$LN3@xmlRegCopy:
pop esi
pop ebx
; 866 : }
; 867 : }
; 868 : return(ret);
mov eax, edi
pop edi
; 873 : }
mov esp, ebp
pop ebp
ret 0
_xmlRegCopyAtom ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegNewAtom
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_type$ = 12 ; size = 4
_xmlRegNewAtom PROC ; COMDAT
; 787 : xmlRegNewAtom(xmlRegParserCtxtPtr ctxt, xmlRegAtomType type) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
push 64 ; 00000040H
call DWORD PTR _xmlMalloc
add esp, 4
test eax, eax
jne SHORT $LN2@xmlRegNewA
; 381 : if (ctxt != NULL) {
mov eax, DWORD PTR _ctxt$[ebp]
xor ecx, ecx
test eax, eax
je SHORT $LN5@xmlRegNewA
; 382 : regexp = (const char *) ctxt->string;
mov ecx, DWORD PTR [eax]
; 383 : ctxt->error = XML_ERR_NO_MEMORY;
mov DWORD PTR [eax+8], 2
$LN5@xmlRegNewA:
; 384 : }
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
push OFFSET ??_C@_0BA@JCPCIFNM@allocating?5atom@
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push 0
push 0
push 0
push ecx
push OFFSET ??_C@_0BA@JCPCIFNM@allocating?5atom@
push 0
push 0
push 3
push 2
push 14 ; 0000000eH
push 0
push 0
push 0
push 0
push 0
call ___xmlRaiseError
add esp, 68 ; 00000044H
; 788 : xmlRegAtomPtr ret;
; 789 :
; 790 : ret = (xmlRegAtomPtr) xmlMalloc(sizeof(xmlRegAtom));
; 791 : if (ret == NULL) {
; 792 : xmlRegexpErrMemory(ctxt, "allocating atom");
; 793 : return(NULL);
xor eax, eax
; 800 : return(ret);
; 801 : }
pop ebp
ret 0
$LN2@xmlRegNewA:
; 794 : }
; 795 : memset(ret, 0, sizeof(xmlRegAtom));
; 796 : ret->type = type;
mov ecx, DWORD PTR _type$[ebp]
mov DWORD PTR [eax], 0
mov DWORD PTR [eax+20], 0
mov DWORD PTR [eax+24], 0
mov DWORD PTR [eax+28], 0
mov DWORD PTR [eax+32], 0
mov DWORD PTR [eax+36], 0
mov DWORD PTR [eax+40], 0
mov DWORD PTR [eax+44], 0
mov DWORD PTR [eax+48], 0
mov DWORD PTR [eax+52], 0
mov DWORD PTR [eax+56], 0
mov DWORD PTR [eax+60], 0
mov DWORD PTR [eax+4], ecx
; 797 : ret->quant = XML_REGEXP_QUANT_ONCE;
mov DWORD PTR [eax+8], 2
; 798 : ret->min = 0;
mov DWORD PTR [eax+12], 0
; 799 : ret->max = 0;
mov DWORD PTR [eax+16], 0
; 800 : return(ret);
; 801 : }
pop ebp
ret 0
_xmlRegNewAtom ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegCopyRange
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_range$ = 12 ; size = 4
_xmlRegCopyRange PROC ; COMDAT
; 756 : xmlRegCopyRange(xmlRegParserCtxtPtr ctxt, xmlRegRangePtr range) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _range$[ebp]
test esi, esi
je SHORT $LN7@xmlRegCopy
; 757 : xmlRegRangePtr ret;
; 758 :
; 759 : if (range == NULL)
; 760 : return(NULL);
; 761 :
; 762 : ret = xmlRegNewRange(ctxt, range->neg, range->type, range->start,
push DWORD PTR [esi+12]
push DWORD PTR [esi+8]
push DWORD PTR [esi+4]
push DWORD PTR [esi]
push DWORD PTR _ctxt$[ebp]
call _xmlRegNewRange
mov edi, eax
add esp, 20 ; 00000014H
; 763 : range->end);
; 764 : if (ret == NULL)
test edi, edi
je SHORT $LN7@xmlRegCopy
; 765 : return(NULL);
; 766 : if (range->blockName != NULL) {
mov eax, DWORD PTR [esi+16]
test eax, eax
je SHORT $LN5@xmlRegCopy
; 767 : ret->blockName = xmlStrdup(range->blockName);
push eax
call _xmlStrdup
add esp, 4
mov DWORD PTR [edi+16], eax
; 768 : if (ret->blockName == NULL) {
test eax, eax
jne SHORT $LN5@xmlRegCopy
; 769 : xmlRegexpErrMemory(ctxt, "allocating range");
push OFFSET ??_C@_0BB@PBEHJOM@allocating?5range@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
; 770 : xmlRegFreeRange(ret);
push edi
call _xmlRegFreeRange
add esp, 12 ; 0000000cH
$LN7@xmlRegCopy:
; 775 : }
pop edi
xor eax, eax
pop esi
pop ebp
ret 0
$LN5@xmlRegCopy:
; 771 : return(NULL);
; 772 : }
; 773 : }
; 774 : return(ret);
mov eax, edi
pop edi
; 775 : }
pop esi
pop ebp
ret 0
_xmlRegCopyRange ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegFreeRange
_TEXT SEGMENT
_range$ = 8 ; size = 4
_xmlRegFreeRange PROC ; COMDAT
; 738 : xmlRegFreeRange(xmlRegRangePtr range) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _range$[ebp]
test esi, esi
je SHORT $LN1@xmlRegFree
; 739 : if (range == NULL)
; 740 : return;
; 741 :
; 742 : if (range->blockName != NULL)
mov eax, DWORD PTR [esi+16]
test eax, eax
je SHORT $LN3@xmlRegFree
; 743 : xmlFree(range->blockName);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN3@xmlRegFree:
; 744 : xmlFree(range);
push esi
call DWORD PTR _xmlFree
add esp, 4
$LN1@xmlRegFree:
pop esi
; 745 : }
pop ebp
ret 0
_xmlRegFreeRange ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegNewRange
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_neg$ = 12 ; size = 4
_type$ = 16 ; size = 4
_start$ = 20 ; size = 4
_end$ = 24 ; size = 4
_xmlRegNewRange PROC ; COMDAT
; 716 : int neg, xmlRegAtomType type, int start, int end) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
push 20 ; 00000014H
call DWORD PTR _xmlMalloc
mov ecx, eax
add esp, 4
test ecx, ecx
jne SHORT $LN2@xmlRegNewR
; 381 : if (ctxt != NULL) {
mov eax, DWORD PTR _ctxt$[ebp]
test eax, eax
je SHORT $LN5@xmlRegNewR
; 382 : regexp = (const char *) ctxt->string;
mov ecx, DWORD PTR [eax]
; 383 : ctxt->error = XML_ERR_NO_MEMORY;
mov DWORD PTR [eax+8], 2
$LN5@xmlRegNewR:
; 384 : }
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
push OFFSET ??_C@_0BB@PBEHJOM@allocating?5range@
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push 0
push 0
push 0
push ecx
push OFFSET ??_C@_0BB@PBEHJOM@allocating?5range@
push 0
push 0
push 3
push 2
push 14 ; 0000000eH
push 0
push 0
push 0
push 0
push 0
call ___xmlRaiseError
add esp, 68 ; 00000044H
; 717 : xmlRegRangePtr ret;
; 718 :
; 719 : ret = (xmlRegRangePtr) xmlMalloc(sizeof(xmlRegRange));
; 720 : if (ret == NULL) {
; 721 : xmlRegexpErrMemory(ctxt, "allocating range");
; 722 : return(NULL);
xor eax, eax
; 729 : }
pop ebp
ret 0
$LN2@xmlRegNewR:
; 723 : }
; 724 : ret->neg = neg;
mov eax, DWORD PTR _neg$[ebp]
mov DWORD PTR [ecx], eax
; 725 : ret->type = type;
mov eax, DWORD PTR _type$[ebp]
mov DWORD PTR [ecx+4], eax
; 726 : ret->start = start;
mov eax, DWORD PTR _start$[ebp]
mov DWORD PTR [ecx+8], eax
; 727 : ret->end = end;
mov eax, DWORD PTR _end$[ebp]
mov DWORD PTR [ecx+12], eax
; 728 : return(ret);
mov eax, ecx
; 729 : }
pop ebp
ret 0
_xmlRegNewRange ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegNewParserCtxt
_TEXT SEGMENT
_string$ = 8 ; size = 4
_xmlRegNewParserCtxt PROC ; COMDAT
; 685 : xmlRegNewParserCtxt(const xmlChar *string) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
push 80 ; 00000050H
call DWORD PTR _xmlMalloc
mov esi, eax
add esp, 4
test esi, esi
jne SHORT $LN2@xmlRegNewP
pop esi
; 700 : }
pop ebp
ret 0
$LN2@xmlRegNewP:
; 686 : xmlRegParserCtxtPtr ret;
; 687 :
; 688 : ret = (xmlRegParserCtxtPtr) xmlMalloc(sizeof(xmlRegParserCtxt));
; 689 : if (ret == NULL)
; 690 : return(NULL);
; 691 : memset(ret, 0, sizeof(xmlRegParserCtxt));
push 80 ; 00000050H
push 0
push esi
call _memset
; 692 : if (string != NULL)
mov ecx, DWORD PTR _string$[ebp]
add esp, 12 ; 0000000cH
xor eax, eax
test ecx, ecx
je SHORT $LN3@xmlRegNewP
; 693 : ret->string = xmlStrdup(string);
push ecx
call _xmlStrdup
add esp, 4
mov DWORD PTR [esi], eax
$LN3@xmlRegNewP:
; 694 : ret->cur = ret->string;
mov DWORD PTR [esi+4], eax
; 695 : ret->neg = 0;
; 696 : ret->negs = 0;
; 697 : ret->error = 0;
; 698 : ret->determinist = -1;
; 699 : return(ret);
mov eax, esi
mov DWORD PTR [esi+12], 0
mov DWORD PTR [esi+72], 0
mov DWORD PTR [esi+8], 0
mov DWORD PTR [esi+68], -1
pop esi
; 700 : }
pop ebp
ret 0
_xmlRegNewParserCtxt ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegEpxFromParse
_TEXT SEGMENT
_stateno$1$ = -60 ; size = 4
tv1256 = -56 ; size = 4
_j$2$ = -52 ; size = 4
_atomno$1$ = -48 ; size = 4
_trans$1$ = -44 ; size = 4
tv1268 = -40 ; size = 4
_i$5$ = -36 ; size = 4
_i$2$ = -36 ; size = 4
_state$1$ = -32 ; size = 4
_transitions$1$ = -28 ; size = 4
_value$1$ = -28 ; size = 4
_ret$1$ = -24 ; size = 4
_transdata$1$ = -20 ; size = 4
tv1274 = -20 ; size = 4
_nbstates$1$ = -16 ; size = 4
_stringRemap$1$ = -12 ; size = 4
_stringMap$1$ = -8 ; size = 4
_stateRemap$1$ = -4 ; size = 4
_ctxt$ = 8 ; size = 4
_xmlRegEpxFromParse PROC ; COMDAT
; 430 : xmlRegEpxFromParse(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
sub esp, 60 ; 0000003cH
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
push 56 ; 00000038H
call DWORD PTR _xmlMalloc
mov edi, eax
add esp, 4
mov DWORD PTR _ret$1$[ebp], edi
test edi, edi
jne SHORT $LN32@xmlRegEpxF
; 381 : if (ctxt != NULL) {
mov eax, DWORD PTR _ctxt$[ebp]
xor ecx, ecx
test eax, eax
je SHORT $LN61@xmlRegEpxF
; 382 : regexp = (const char *) ctxt->string;
mov ecx, DWORD PTR [eax]
; 383 : ctxt->error = XML_ERR_NO_MEMORY;
mov DWORD PTR [eax+8], 2
$LN61@xmlRegEpxF:
; 384 : }
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
push OFFSET ??_C@_0BB@FJPDMDM@compiling?5regexp@
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push 0
push 0
push 0
push ecx
push OFFSET ??_C@_0BB@FJPDMDM@compiling?5regexp@
push 0
push 0
push 3
push 2
push 14 ; 0000000eH
push 0
push 0
push 0
push 0
push 0
call ___xmlRaiseError
add esp, 68 ; 00000044H
; 431 : xmlRegexpPtr ret;
; 432 :
; 433 : ret = (xmlRegexpPtr) xmlMalloc(sizeof(xmlRegexp));
; 434 : if (ret == NULL) {
; 435 : xmlRegexpErrMemory(ctxt, "compiling regexp");
; 436 : return(NULL);
xor eax, eax
pop edi
; 674 : }
mov esp, ebp
pop ebp
ret 0
$LN32@xmlRegEpxF:
push esi
; 437 : }
; 438 : memset(ret, 0, sizeof(xmlRegexp));
push 56 ; 00000038H
push 0
push edi
call _memset
; 439 : ret->string = ctxt->string;
mov esi, DWORD PTR _ctxt$[ebp]
add esp, 12 ; 0000000cH
mov eax, DWORD PTR [esi]
mov DWORD PTR [edi], eax
; 440 : ret->nbStates = ctxt->nbStates;
mov eax, DWORD PTR [esi+48]
mov DWORD PTR [edi+4], eax
; 441 : ret->states = ctxt->states;
mov eax, DWORD PTR [esi+52]
mov DWORD PTR [edi+8], eax
; 442 : ret->nbAtoms = ctxt->nbAtoms;
mov eax, DWORD PTR [esi+36]
mov DWORD PTR [edi+12], eax
; 443 : ret->atoms = ctxt->atoms;
mov eax, DWORD PTR [esi+40]
mov DWORD PTR [edi+16], eax
; 444 : ret->nbCounters = ctxt->nbCounters;
mov eax, DWORD PTR [esi+60]
mov DWORD PTR [edi+20], eax
; 445 : ret->counters = ctxt->counters;
mov eax, DWORD PTR [esi+64]
mov DWORD PTR [edi+24], eax
; 446 : ret->determinist = ctxt->determinist;
mov ecx, DWORD PTR [esi+68]
mov DWORD PTR [edi+28], ecx
; 447 : ret->flags = ctxt->flags;
mov eax, DWORD PTR [esi+76]
mov DWORD PTR [edi+32], eax
; 448 : if (ret->determinist == -1) {
cmp ecx, -1
jne SHORT $LN33@xmlRegEpxF
; 449 : xmlRegexpIsDeterminist(ret);
push edi
call _xmlRegexpIsDeterminist
mov ecx, DWORD PTR [edi+28]
add esp, 4
$LN33@xmlRegEpxF:
; 450 : }
; 451 :
; 452 : if ((ret->determinist != 0) &&
; 453 : (ret->nbCounters == 0) &&
; 454 : (ctxt->negs == 0) &&
; 455 : (ret->atoms != NULL) &&
; 456 : (ret->atoms[0] != NULL) &&
push ebx
test ecx, ecx
je $not_determ$118
cmp DWORD PTR [edi+20], 0
jne $not_determ$118
cmp DWORD PTR [esi+72], 0
jne $not_determ$118
mov eax, DWORD PTR [edi+16]
test eax, eax
je $not_determ$118
mov eax, DWORD PTR [eax]
test eax, eax
je $not_determ$118
cmp DWORD PTR [eax+4], 5
jne $not_determ$118
; 457 : (ret->atoms[0]->type == XML_REGEXP_STRING)) {
; 458 : int i, j, nbstates = 0, nbatoms = 0;
; 459 : int *stateRemap;
; 460 : int *stringRemap;
; 461 : int *transitions;
; 462 : void **transdata;
; 463 : xmlChar **stringMap;
; 464 : xmlChar *value;
; 465 :
; 466 : /*
; 467 : * Switch to a compact representation
; 468 : * 1/ counting the effective number of states left
; 469 : * 2/ counting the unique number of atoms, and check that
; 470 : * they are all of the string type
; 471 : * 3/ build a table state x atom for the transitions
; 472 : */
; 473 :
; 474 : stateRemap = xmlMalloc(ret->nbStates * sizeof(int));
mov eax, DWORD PTR [edi+4]
xor ebx, ebx
shl eax, 2
push eax
mov DWORD PTR _nbstates$1$[ebp], 0
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR _stateRemap$1$[ebp], eax
; 475 : if (stateRemap == NULL) {
test eax, eax
jne SHORT $LN35@xmlRegEpxF
; 476 : xmlRegexpErrMemory(ctxt, "compiling regexp");
push OFFSET ??_C@_0BB@FJPDMDM@compiling?5regexp@
push esi
call _xmlRegexpErrMemory
; 477 : xmlFree(ret);
push edi
call DWORD PTR _xmlFree
add esp, 12 ; 0000000cH
; 550 : return(NULL);
xor eax, eax
pop ebx
pop esi
pop edi
; 674 : }
mov esp, ebp
pop ebp
ret 0
$LN35@xmlRegEpxF:
; 478 : return(NULL);
; 479 : }
; 480 : for (i = 0;i < ret->nbStates;i++) {
xor esi, esi
cmp DWORD PTR [edi+4], ebx
jle SHORT $LN3@xmlRegEpxF
mov ebx, DWORD PTR _stateRemap$1$[ebp]
npad 6
$LL4@xmlRegEpxF:
; 481 : if (ret->states[i] != NULL) {
mov eax, DWORD PTR [edi+8]
or edx, -1
mov ecx, DWORD PTR [eax+esi*4]
test ecx, ecx
mov eax, DWORD PTR _nbstates$1$[ebp]
cmovne edx, eax
inc eax
test ecx, ecx
mov DWORD PTR [ebx+esi*4], edx
cmove eax, DWORD PTR _nbstates$1$[ebp]
inc esi
mov DWORD PTR _nbstates$1$[ebp], eax
cmp esi, DWORD PTR [edi+4]
jl SHORT $LL4@xmlRegEpxF
; 518 : stringMap[nbatoms] = xmlStrdup(value);
mov DWORD PTR _nbstates$1$[ebp], eax
xor ebx, ebx
$LN3@xmlRegEpxF:
; 482 : stateRemap[i] = nbstates;
; 483 : nbstates++;
; 484 : } else {
; 485 : stateRemap[i] = -1;
; 486 : }
; 487 : }
; 488 : #ifdef DEBUG_COMPACTION
; 489 : printf("Final: %d states\n", nbstates);
; 490 : #endif
; 491 : stringMap = xmlMalloc(ret->nbAtoms * sizeof(char *));
mov eax, DWORD PTR [edi+12]
shl eax, 2
push eax
call DWORD PTR _xmlMalloc
mov esi, eax
add esp, 4
mov DWORD PTR _stringMap$1$[ebp], esi
; 492 : if (stringMap == NULL) {
test esi, esi
jne SHORT $LN38@xmlRegEpxF
; 493 : xmlRegexpErrMemory(ctxt, "compiling regexp");
push OFFSET ??_C@_0BB@FJPDMDM@compiling?5regexp@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
; 494 : xmlFree(stateRemap);
push DWORD PTR _stateRemap$1$[ebp]
; 495 : xmlFree(ret);
; 496 : return(NULL);
jmp $LN115@xmlRegEpxF
$LN38@xmlRegEpxF:
; 497 : }
; 498 : stringRemap = xmlMalloc(ret->nbAtoms * sizeof(int));
mov eax, DWORD PTR [edi+12]
shl eax, 2
push eax
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR _stringRemap$1$[ebp], eax
; 499 : if (stringRemap == NULL) {
test eax, eax
jne SHORT $LN39@xmlRegEpxF
; 500 : xmlRegexpErrMemory(ctxt, "compiling regexp");
push OFFSET ??_C@_0BB@FJPDMDM@compiling?5regexp@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
; 501 : xmlFree(stringMap);
push esi
call DWORD PTR _xmlFree
; 502 : xmlFree(stateRemap);
push DWORD PTR _stateRemap$1$[ebp]
call DWORD PTR _xmlFree
; 503 : xmlFree(ret);
push edi
call DWORD PTR _xmlFree
add esp, 20 ; 00000014H
; 550 : return(NULL);
xor eax, eax
pop ebx
pop esi
pop edi
; 674 : }
mov esp, ebp
pop ebp
ret 0
$LN39@xmlRegEpxF:
; 504 : return(NULL);
; 505 : }
; 506 : for (i = 0;i < ret->nbAtoms;i++) {
xor eax, eax
mov DWORD PTR _i$2$[ebp], eax
cmp DWORD PTR [edi+12], eax
jle $LN6@xmlRegEpxF
npad 4
$LL7@xmlRegEpxF:
; 507 : if ((ret->atoms[i]->type == XML_REGEXP_STRING) &&
lea esi, DWORD PTR [eax*4]
mov eax, DWORD PTR [edi+16]
mov DWORD PTR tv1274[ebp], esi
mov eax, DWORD PTR [esi+eax]
cmp DWORD PTR [eax+4], 5
jne $LN40@xmlRegEpxF
cmp DWORD PTR [eax+8], 2
jne $LN40@xmlRegEpxF
; 508 : (ret->atoms[i]->quant == XML_REGEXP_QUANT_ONCE)) {
; 509 : value = ret->atoms[i]->valuep;
mov eax, DWORD PTR [eax+20]
; 510 : for (j = 0;j < nbatoms;j++) {
xor esi, esi
mov DWORD PTR _value$1$[ebp], eax
test ebx, ebx
jle SHORT $LN109@xmlRegEpxF
$LL10@xmlRegEpxF:
; 511 : if (xmlStrEqual(stringMap[j], value)) {
push eax
mov eax, DWORD PTR _stringMap$1$[ebp]
push DWORD PTR [eax+esi*4]
call _xmlStrEqual
add esp, 8
test eax, eax
jne $LN73@xmlRegEpxF
; 510 : for (j = 0;j < nbatoms;j++) {
mov eax, DWORD PTR _value$1$[ebp]
inc esi
cmp esi, ebx
jl SHORT $LL10@xmlRegEpxF
$LN109@xmlRegEpxF:
; 517 : stringRemap[i] = nbatoms;
mov ecx, DWORD PTR tv1274[ebp]
$LN106@xmlRegEpxF:
mov edx, DWORD PTR _stringRemap$1$[ebp]
; 518 : stringMap[nbatoms] = xmlStrdup(value);
push eax
mov DWORD PTR [ecx+edx], ebx
call _xmlStrdup
mov ecx, DWORD PTR _stringMap$1$[ebp]
add esp, 4
mov DWORD PTR [ecx+ebx*4], eax
; 519 : if (stringMap[nbatoms] == NULL) {
test eax, eax
je SHORT $LN74@xmlRegEpxF
; 527 : }
; 528 : nbatoms++;
inc ebx
$LN5@xmlRegEpxF:
; 504 : return(NULL);
; 505 : }
; 506 : for (i = 0;i < ret->nbAtoms;i++) {
mov eax, DWORD PTR _i$2$[ebp]
inc eax
mov DWORD PTR _i$2$[ebp], eax
cmp eax, DWORD PTR [edi+12]
jl SHORT $LL7@xmlRegEpxF
$LN6@xmlRegEpxF:
; 538 : }
; 539 : }
; 540 : #ifdef DEBUG_COMPACTION
; 541 : printf("Final: %d atoms\n", nbatoms);
; 542 : #endif
; 543 : transitions = (int *) xmlMalloc((nbstates + 1) *
mov eax, DWORD PTR _nbstates$1$[ebp]
lea esi, DWORD PTR [ebx+1]
inc eax
imul esi, eax
shl esi, 2
push esi
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR _transitions$1$[ebp], eax
; 544 : (nbatoms + 1) * sizeof(int));
; 545 : if (transitions == NULL) {
test eax, eax
jne $LN45@xmlRegEpxF
; 546 : xmlFree(stateRemap);
push DWORD PTR _stateRemap$1$[ebp]
call DWORD PTR _xmlFree
; 547 : xmlFree(stringRemap);
push DWORD PTR _stringRemap$1$[ebp]
call DWORD PTR _xmlFree
; 548 : xmlFree(stringMap);
push DWORD PTR _stringMap$1$[ebp]
$LN115@xmlRegEpxF:
call DWORD PTR _xmlFree
; 549 : xmlFree(ret);
push edi
call DWORD PTR _xmlFree
add esp, 16 ; 00000010H
; 550 : return(NULL);
xor eax, eax
pop ebx
pop esi
pop edi
; 674 : }
mov esp, ebp
pop ebp
ret 0
$LN73@xmlRegEpxF:
; 512 : stringRemap[i] = j;
mov ecx, DWORD PTR tv1274[ebp]
mov eax, DWORD PTR _stringRemap$1$[ebp]
mov DWORD PTR [ecx+eax], esi
; 513 : break;
; 514 : }
; 515 : }
; 516 : if (j >= nbatoms) {
cmp esi, ebx
jl SHORT $LN5@xmlRegEpxF
; 510 : for (j = 0;j < nbatoms;j++) {
mov eax, DWORD PTR _value$1$[ebp]
jmp $LN106@xmlRegEpxF
$LN74@xmlRegEpxF:
; 520 : for (i = 0;i < nbatoms;i++)
xor esi, esi
test ebx, ebx
jle SHORT $LN12@xmlRegEpxF
$LL13@xmlRegEpxF:
; 521 : xmlFree(stringMap[i]);
push DWORD PTR [ecx+esi*4]
call DWORD PTR _xmlFree
mov ecx, DWORD PTR _stringMap$1$[ebp]
inc esi
add esp, 4
cmp esi, ebx
jl SHORT $LL13@xmlRegEpxF
$LN12@xmlRegEpxF:
; 522 : xmlFree(stringRemap);
push DWORD PTR _stringRemap$1$[ebp]
call DWORD PTR _xmlFree
; 523 : xmlFree(stringMap);
push DWORD PTR _stringMap$1$[ebp]
call DWORD PTR _xmlFree
; 524 : xmlFree(stateRemap);
push DWORD PTR _stateRemap$1$[ebp]
; 525 : xmlFree(ret);
; 526 : return(NULL);
jmp SHORT $LN115@xmlRegEpxF
$LN40@xmlRegEpxF:
; 529 : }
; 530 : } else {
; 531 : xmlFree(stateRemap);
push DWORD PTR _stateRemap$1$[ebp]
call DWORD PTR _xmlFree
; 532 : xmlFree(stringRemap);
push DWORD PTR _stringRemap$1$[ebp]
call DWORD PTR _xmlFree
add esp, 8
xor esi, esi
; 533 : for (i = 0;i < nbatoms;i++)
test ebx, ebx
jle SHORT $LN15@xmlRegEpxF
mov edi, DWORD PTR _stringMap$1$[ebp]
npad 4
$LL16@xmlRegEpxF:
; 534 : xmlFree(stringMap[i]);
push DWORD PTR [edi+esi*4]
call DWORD PTR _xmlFree
inc esi
add esp, 4
cmp esi, ebx
jl SHORT $LL16@xmlRegEpxF
mov edi, DWORD PTR _ret$1$[ebp]
$LN15@xmlRegEpxF:
; 535 : xmlFree(stringMap);
push DWORD PTR _stringMap$1$[ebp]
call DWORD PTR _xmlFree
; 536 : xmlFree(ret);
push edi
call DWORD PTR _xmlFree
add esp, 8
; 537 : return(NULL);
xor eax, eax
pop ebx
pop esi
pop edi
; 674 : }
mov esp, ebp
pop ebp
ret 0
$LN45@xmlRegEpxF:
; 551 : }
; 552 : memset(transitions, 0, (nbstates + 1) * (nbatoms + 1) * sizeof(int));
push esi
push 0
push eax
call _memset
; 553 :
; 554 : /*
; 555 : * Allocate the transition table. The first entry for each
; 556 : * state corresponds to the state type.
; 557 : */
; 558 : transdata = NULL;
; 559 :
; 560 : for (i = 0;i < ret->nbStates;i++) {
xor ecx, ecx
xor esi, esi
add esp, 12 ; 0000000cH
mov DWORD PTR _transdata$1$[ebp], esi
mov DWORD PTR _i$5$[ebp], ecx
cmp DWORD PTR [edi+4], ecx
jle $LN108@xmlRegEpxF
mov eax, DWORD PTR _stateRemap$1$[ebp]
$LL19@xmlRegEpxF:
; 561 : int stateno, atomno, targetno, prev;
; 562 : xmlRegStatePtr state;
; 563 : xmlRegTransPtr trans;
; 564 :
; 565 : stateno = stateRemap[i];
mov ecx, DWORD PTR [eax+ecx*4]
; 566 : if (stateno == -1)
cmp ecx, -1
je $LN17@xmlRegEpxF
; 567 : continue;
; 568 : state = ret->states[i];
mov eax, DWORD PTR [edi+8]
mov edx, DWORD PTR _i$5$[ebp]
; 569 :
; 570 : transitions[stateno * (nbatoms + 1)] = state->type;
mov edi, DWORD PTR _transitions$1$[ebp]
; 571 :
; 572 : for (j = 0;j < state->nbTrans;j++) {
mov DWORD PTR _j$2$[ebp], 0
mov edx, DWORD PTR [eax+edx*4]
lea eax, DWORD PTR [ebx+1]
imul eax, ecx
mov DWORD PTR _state$1$[ebp], edx
mov DWORD PTR tv1268[ebp], eax
mov eax, DWORD PTR [edx]
mov edx, DWORD PTR tv1268[ebp]
mov DWORD PTR [edi+edx*4], eax
mov eax, DWORD PTR _state$1$[ebp]
mov edi, DWORD PTR _ret$1$[ebp]
cmp DWORD PTR [eax+24], 0
jle $LN111@xmlRegEpxF
; 621 : transdata[stateno * nbatoms + atomno] =
imul ecx, ebx
mov DWORD PTR _stateno$1$[ebp], ecx
xor ecx, ecx
mov DWORD PTR tv1256[ebp], ecx
$LL22@xmlRegEpxF:
; 573 : trans = &(state->trans[j]);
mov eax, DWORD PTR [eax+28]
add eax, ecx
mov DWORD PTR _trans$1$[ebp], eax
; 574 : if ((trans->to == -1) || (trans->atom == NULL))
mov ecx, DWORD PTR [eax+4]
cmp ecx, -1
je $LN20@xmlRegEpxF
mov edx, DWORD PTR [eax]
test edx, edx
je $LN20@xmlRegEpxF
; 575 : continue;
; 576 : atomno = stringRemap[trans->atom->no];
; 577 : if ((trans->atom->data != NULL) && (transdata == NULL)) {
cmp DWORD PTR [edx+60], 0
mov edi, DWORD PTR _stringRemap$1$[ebp]
mov eax, DWORD PTR [edx]
mov eax, DWORD PTR [edi+eax*4]
mov edi, DWORD PTR _ret$1$[ebp]
mov DWORD PTR _atomno$1$[ebp], eax
je SHORT $LN51@xmlRegEpxF
test esi, esi
jne SHORT $LN51@xmlRegEpxF
; 578 : transdata = (void **) xmlMalloc(nbstates * nbatoms *
mov esi, ebx
imul esi, DWORD PTR _nbstates$1$[ebp]
shl esi, 2
push esi
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR _transdata$1$[ebp], eax
; 579 : sizeof(void *));
; 580 : if (transdata != NULL)
test eax, eax
je SHORT $LN50@xmlRegEpxF
; 581 : memset(transdata, 0,
push esi
push 0
push eax
call _memset
mov ecx, DWORD PTR _trans$1$[ebp]
add esp, 12 ; 0000000cH
mov eax, DWORD PTR _atomno$1$[ebp]
mov ecx, DWORD PTR [ecx+4]
$LN51@xmlRegEpxF:
; 585 : break;
; 586 : }
; 587 : }
; 588 : targetno = stateRemap[trans->to];
; 589 : /*
; 590 : * if the same atom can generate transitions to 2 different
; 591 : * states then it means the automata is not determinist and
; 592 : * the compact form can't be used !
; 593 : */
; 594 : prev = transitions[stateno * (nbatoms + 1) + atomno + 1];
add eax, DWORD PTR tv1268[ebp]
mov edx, DWORD PTR _transitions$1$[ebp]
lea esi, DWORD PTR [edx+eax*4]
mov eax, DWORD PTR _stateRemap$1$[ebp]
mov edx, DWORD PTR [esi+4]
mov eax, DWORD PTR [eax+ecx*4]
inc eax
; 595 : if (prev != 0) {
test edx, edx
je SHORT $LN52@xmlRegEpxF
; 596 : if (prev != targetno + 1) {
cmp edx, eax
jne SHORT $LN75@xmlRegEpxF
; 612 : }
; 613 : } else {
mov esi, DWORD PTR _transdata$1$[ebp]
jmp SHORT $LN20@xmlRegEpxF
$LN52@xmlRegEpxF:
; 614 : #if 0
; 615 : printf("State %d trans %d: atom %d to %d : %d to %d\n",
; 616 : i, j, trans->atom->no, trans->to, atomno, targetno);
; 617 : #endif
; 618 : transitions[stateno * (nbatoms + 1) + atomno + 1] =
mov DWORD PTR [esi+4], eax
; 619 : targetno + 1; /* to avoid 0 */
; 620 : if (transdata != NULL)
mov esi, DWORD PTR _transdata$1$[ebp]
test esi, esi
je SHORT $LN20@xmlRegEpxF
; 621 : transdata[stateno * nbatoms + atomno] =
mov eax, DWORD PTR _trans$1$[ebp]
mov ecx, DWORD PTR _atomno$1$[ebp]
add ecx, DWORD PTR _stateno$1$[ebp]
mov eax, DWORD PTR [eax]
mov eax, DWORD PTR [eax+60]
mov DWORD PTR [esi+ecx*4], eax
$LN20@xmlRegEpxF:
; 571 :
; 572 : for (j = 0;j < state->nbTrans;j++) {
mov eax, DWORD PTR _j$2$[ebp]
mov edx, DWORD PTR _state$1$[ebp]
inc eax
mov ecx, DWORD PTR tv1256[ebp]
add ecx, 20 ; 00000014H
mov DWORD PTR _j$2$[ebp], eax
mov DWORD PTR tv1256[ebp], ecx
cmp eax, DWORD PTR [edx+24]
jge SHORT $LN111@xmlRegEpxF
mov eax, edx
jmp $LL22@xmlRegEpxF
$LN50@xmlRegEpxF:
; 582 : nbstates * nbatoms * sizeof(void *));
; 583 : else {
; 584 : xmlRegexpErrMemory(ctxt, "compiling regexp");
push OFFSET ??_C@_0BB@FJPDMDM@compiling?5regexp@
push DWORD PTR _ctxt$[ebp]
call _xmlRegexpErrMemory
add esp, 8
$LN111@xmlRegEpxF:
; 553 :
; 554 : /*
; 555 : * Allocate the transition table. The first entry for each
; 556 : * state corresponds to the state type.
; 557 : */
; 558 : transdata = NULL;
; 559 :
; 560 : for (i = 0;i < ret->nbStates;i++) {
mov eax, DWORD PTR _stateRemap$1$[ebp]
$LN17@xmlRegEpxF:
mov ecx, DWORD PTR _i$5$[ebp]
inc ecx
mov DWORD PTR _i$5$[ebp], ecx
cmp ecx, DWORD PTR [edi+4]
jge SHORT $LN108@xmlRegEpxF
mov esi, DWORD PTR _transdata$1$[ebp]
jmp $LL19@xmlRegEpxF
$LN75@xmlRegEpxF:
; 597 : ret->determinist = 0;
; 598 : #ifdef DEBUG_COMPACTION
; 599 : printf("Indet: state %d trans %d, atom %d to %d : %d to %d\n",
; 600 : i, j, trans->atom->no, trans->to, atomno, targetno);
; 601 : printf(" previous to is %d\n", prev);
; 602 : #endif
; 603 : if (transdata != NULL)
mov eax, DWORD PTR _transdata$1$[ebp]
mov DWORD PTR [edi+28], 0
test eax, eax
je SHORT $LN55@xmlRegEpxF
; 604 : xmlFree(transdata);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN55@xmlRegEpxF:
; 605 : xmlFree(transitions);
push DWORD PTR _transitions$1$[ebp]
call DWORD PTR _xmlFree
; 606 : xmlFree(stateRemap);
push DWORD PTR _stateRemap$1$[ebp]
call DWORD PTR _xmlFree
; 607 : xmlFree(stringRemap);
push DWORD PTR _stringRemap$1$[ebp]
call DWORD PTR _xmlFree
add esp, 12 ; 0000000cH
xor esi, esi
; 608 : for (i = 0;i < nbatoms;i++)
test ebx, ebx
jle SHORT $LN24@xmlRegEpxF
mov edi, DWORD PTR _stringMap$1$[ebp]
$LL25@xmlRegEpxF:
; 609 : xmlFree(stringMap[i]);
push DWORD PTR [edi+esi*4]
call DWORD PTR _xmlFree
inc esi
add esp, 4
cmp esi, ebx
jl SHORT $LL25@xmlRegEpxF
mov edi, DWORD PTR _ret$1$[ebp]
$LN24@xmlRegEpxF:
; 610 : xmlFree(stringMap);
push DWORD PTR _stringMap$1$[ebp]
call DWORD PTR _xmlFree
add esp, 4
; 611 : goto not_determ;
jmp $LN114@xmlRegEpxF
$LN108@xmlRegEpxF:
; 622 : trans->atom->data;
; 623 : }
; 624 : }
; 625 : }
; 626 : ret->determinist = 1;
; 627 : #ifdef DEBUG_COMPACTION
; 628 : /*
; 629 : * Debug
; 630 : */
; 631 : for (i = 0;i < nbstates;i++) {
; 632 : for (j = 0;j < nbatoms + 1;j++) {
; 633 : printf("%02d ", transitions[i * (nbatoms + 1) + j]);
; 634 : }
; 635 : printf("\n");
; 636 : }
; 637 : printf("\n");
; 638 : #endif
; 639 : /*
; 640 : * Cleanup of the old data
; 641 : */
; 642 : if (ret->states != NULL) {
mov eax, DWORD PTR [edi+8]
mov DWORD PTR [edi+28], 1
test eax, eax
je SHORT $LN57@xmlRegEpxF
; 643 : for (i = 0;i < ret->nbStates;i++)
xor esi, esi
cmp DWORD PTR [edi+4], esi
jle SHORT $LN27@xmlRegEpxF
npad 1
$LL28@xmlRegEpxF:
; 644 : xmlRegFreeState(ret->states[i]);
mov eax, DWORD PTR [edi+8]
push DWORD PTR [eax+esi*4]
call _xmlRegFreeState
inc esi
add esp, 4
cmp esi, DWORD PTR [edi+4]
jl SHORT $LL28@xmlRegEpxF
; 518 : stringMap[nbatoms] = xmlStrdup(value);
mov eax, DWORD PTR [edi+8]
$LN27@xmlRegEpxF:
; 645 : xmlFree(ret->states);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN57@xmlRegEpxF:
; 646 : }
; 647 : ret->states = NULL;
; 648 : ret->nbStates = 0;
; 649 : if (ret->atoms != NULL) {
mov eax, DWORD PTR [edi+16]
mov DWORD PTR [edi+8], 0
mov DWORD PTR [edi+4], 0
test eax, eax
je SHORT $LN58@xmlRegEpxF
; 650 : for (i = 0;i < ret->nbAtoms;i++)
xor esi, esi
cmp DWORD PTR [edi+12], esi
jle SHORT $LN30@xmlRegEpxF
npad 3
$LL31@xmlRegEpxF:
; 651 : xmlRegFreeAtom(ret->atoms[i]);
mov eax, DWORD PTR [edi+16]
push DWORD PTR [eax+esi*4]
call _xmlRegFreeAtom
inc esi
add esp, 4
cmp esi, DWORD PTR [edi+12]
jl SHORT $LL31@xmlRegEpxF
; 518 : stringMap[nbatoms] = xmlStrdup(value);
mov eax, DWORD PTR [edi+16]
$LN30@xmlRegEpxF:
; 652 : xmlFree(ret->atoms);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN58@xmlRegEpxF:
; 653 : }
; 654 : ret->atoms = NULL;
; 655 : ret->nbAtoms = 0;
; 656 :
; 657 : ret->compact = transitions;
mov eax, DWORD PTR _transitions$1$[ebp]
; 658 : ret->transdata = transdata;
; 659 : ret->stringMap = stringMap;
; 660 : ret->nbstrings = nbatoms;
; 661 : ret->nbstates = nbstates;
; 662 : xmlFree(stateRemap);
push DWORD PTR _stateRemap$1$[ebp]
mov DWORD PTR [edi+40], eax
mov eax, DWORD PTR _transdata$1$[ebp]
mov DWORD PTR [edi+44], eax
mov eax, DWORD PTR _stringMap$1$[ebp]
mov DWORD PTR [edi+52], eax
mov eax, DWORD PTR _nbstates$1$[ebp]
mov DWORD PTR [edi+16], 0
mov DWORD PTR [edi+12], 0
mov DWORD PTR [edi+48], ebx
mov DWORD PTR [edi+36], eax
call DWORD PTR _xmlFree
; 663 : xmlFree(stringRemap);
push DWORD PTR _stringRemap$1$[ebp]
call DWORD PTR _xmlFree
add esp, 8
$LN114@xmlRegEpxF:
; 664 : }
; 665 : not_determ:
; 666 : ctxt->string = NULL;
mov esi, DWORD PTR _ctxt$[ebp]
$not_determ$118:
pop ebx
mov DWORD PTR [esi], 0
; 667 : ctxt->nbStates = 0;
; 668 : ctxt->states = NULL;
; 669 : ctxt->nbAtoms = 0;
; 670 : ctxt->atoms = NULL;
; 671 : ctxt->nbCounters = 0;
; 672 : ctxt->counters = NULL;
; 673 : return(ret);
mov eax, edi
mov DWORD PTR [esi+48], 0
mov DWORD PTR [esi+52], 0
mov DWORD PTR [esi+36], 0
mov DWORD PTR [esi+40], 0
mov DWORD PTR [esi+60], 0
mov DWORD PTR [esi+64], 0
pop esi
pop edi
; 674 : }
mov esp, ebp
pop ebp
ret 0
_xmlRegEpxFromParse ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAComputesDeterminism
_TEXT SEGMENT
tv695 = -28 ; size = 4
_statenr$2$ = -28 ; size = 4
tv697 = -24 ; size = 4
_statenr$1$ = -24 ; size = 4
tv668 = -20 ; size = 4
_state$2$ = -20 ; size = 4
_transnr$2$ = -16 ; size = 4
_transnr$1$ = -16 ; size = 4
_ret$1$ = -12 ; size = 4
tv696 = -8 ; size = 4
_last$1$ = -8 ; size = 4
tv666 = -4 ; size = 4
_state$1$ = -4 ; size = 4
_ctxt$ = 8 ; size = 4
_xmlFAComputesDeterminism PROC ; COMDAT
; 2647 : xmlFAComputesDeterminism(xmlRegParserCtxtPtr ctxt) {
push ebp
mov ebp, esp
sub esp, 28 ; 0000001cH
push ebx
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov ebx, DWORD PTR _ctxt$[ebp]
mov DWORD PTR _ret$1$[ebp], 1
mov eax, DWORD PTR [ebx+68]
cmp eax, -1
jne $LN1@xmlFACompu
; 2648 : int statenr, transnr;
; 2649 : xmlRegStatePtr state;
; 2650 : xmlRegTransPtr t1, t2, last;
; 2651 : int i;
; 2652 : int ret = 1;
; 2653 : int deep = 1;
; 2654 :
; 2655 : #ifdef DEBUG_REGEXP_GRAPH
; 2656 : printf("xmlFAComputesDeterminism\n");
; 2657 : xmlRegPrintCtxt(stdout, ctxt);
; 2658 : #endif
; 2659 : if (ctxt->determinist != -1)
; 2660 : return(ctxt->determinist);
; 2661 :
; 2662 : if (ctxt->flags & AM_AUTOMATA_RNG)
; 2663 : deep = 0;
; 2664 :
; 2665 : /*
; 2666 : * First cleanup the automata removing cancelled transitions
; 2667 : */
; 2668 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
mov eax, DWORD PTR [ebx+76]
xor ecx, ecx
and eax, 1
mov DWORD PTR _statenr$1$[ebp], ecx
mov DWORD PTR tv695[ebp], eax
mov eax, DWORD PTR [ebx+48]
push esi
push edi
test eax, eax
jle $LN3@xmlFACompu
$LL4@xmlFACompu:
; 2669 : state = ctxt->states[statenr];
mov eax, DWORD PTR [ebx+52]
mov ecx, DWORD PTR [eax+ecx*4]
mov DWORD PTR _state$1$[ebp], ecx
; 2670 : if (state == NULL)
test ecx, ecx
je $LN2@xmlFACompu
; 2671 : continue;
; 2672 : if (state->nbTrans < 2)
mov eax, DWORD PTR [ecx+24]
cmp eax, 2
jl $LN2@xmlFACompu
; 2673 : continue;
; 2674 : for (transnr = 0;transnr < state->nbTrans;transnr++) {
xor edx, edx
mov DWORD PTR _transnr$1$[ebp], edx
test eax, eax
jle $LN2@xmlFACompu
xor eax, eax
mov DWORD PTR tv668[ebp], eax
$LL7@xmlFACompu:
; 2675 : t1 = &(state->trans[transnr]);
mov edi, DWORD PTR [ecx+28]
add edi, eax
; 2676 : /*
; 2677 : * Determinism checks in case of counted or all transitions
; 2678 : * will have to be handled separately
; 2679 : */
; 2680 : if (t1->atom == NULL) {
cmp DWORD PTR [edi], 0
je $LN5@xmlFACompu
; 2681 : /* t1->nd = 1; */
; 2682 : continue;
; 2683 : }
; 2684 : if (t1->to == -1) /* eliminated */
cmp DWORD PTR [edi+4], -1
je $LN5@xmlFACompu
; 2685 : continue;
; 2686 : for (i = 0;i < transnr;i++) {
test edx, edx
jle $LN5@xmlFACompu
xor ebx, ebx
mov DWORD PTR tv696[ebp], edx
$LL10@xmlFACompu:
; 2687 : t2 = &(state->trans[i]);
mov esi, DWORD PTR [ecx+28]
add esi, ebx
; 2688 : if (t2->to == -1) /* eliminated */
mov eax, DWORD PTR [esi+4]
cmp eax, -1
je $LN8@xmlFACompu
; 2689 : continue;
; 2690 : if (t2->atom != NULL) {
mov ecx, DWORD PTR [esi]
test ecx, ecx
je $LN93@xmlFACompu
; 2691 : if (t1->to == t2->to) {
cmp DWORD PTR [edi+4], eax
jne SHORT $LN93@xmlFACompu
; 2692 : /*
; 2693 : * Here we use deep because we want to keep the
; 2694 : * transitions which indicate a conflict
; 2695 : */
; 2696 : if (xmlFAEqualAtoms(t1->atom, t2->atom, deep) &&
; 2697 : (t1->counter == t2->counter) &&
mov eax, DWORD PTR [edi]
; 2459 : if (atom1 == atom2)
cmp eax, ecx
je SHORT $LN81@xmlFACompu
; 2460 : return(1);
; 2461 : if ((atom1 == NULL) || (atom2 == NULL))
test eax, eax
je SHORT $LN93@xmlFACompu
; 2462 : return(0);
; 2463 :
; 2464 : if (atom1->type != atom2->type)
mov edx, DWORD PTR [eax+4]
cmp edx, DWORD PTR [ecx+4]
jne SHORT $LN87@xmlFACompu
; 2465 : return(0);
; 2466 : switch (atom1->type) {
dec edx
cmp edx, 4
ja SHORT $LN87@xmlFACompu
jmp DWORD PTR $LN98@xmlFACompu[edx*4]
$LN50@xmlFACompu:
; 2467 : case XML_REGEXP_EPSILON:
; 2468 : ret = 0;
; 2469 : break;
; 2470 : case XML_REGEXP_STRING:
; 2471 : if (!deep)
cmp DWORD PTR tv695[ebp], 0
je SHORT $LN51@xmlFACompu
; 2472 : ret = (atom1->valuep == atom2->valuep);
mov eax, DWORD PTR [eax+20]
xor edx, edx
cmp eax, DWORD PTR [ecx+20]
jmp SHORT $LN95@xmlFACompu
$LN51@xmlFACompu:
; 2473 : else
; 2474 : ret = xmlStrEqual((xmlChar *)atom1->valuep,
push DWORD PTR [ecx+20]
push DWORD PTR [eax+20]
call _xmlStrEqual
add esp, 8
mov edx, eax
; 2475 : (xmlChar *)atom2->valuep);
; 2476 : break;
jmp SHORT $LN55@xmlFACompu
$LN53@xmlFACompu:
; 2477 : case XML_REGEXP_CHARVAL:
; 2478 : ret = (atom1->codepoint == atom2->codepoint);
mov eax, DWORD PTR [eax+32]
xor edx, edx
cmp eax, DWORD PTR [ecx+32]
$LN95@xmlFACompu:
; 2692 : /*
; 2693 : * Here we use deep because we want to keep the
; 2694 : * transitions which indicate a conflict
; 2695 : */
; 2696 : if (xmlFAEqualAtoms(t1->atom, t2->atom, deep) &&
; 2697 : (t1->counter == t2->counter) &&
sete dl
$LN55@xmlFACompu:
test edx, edx
mov edx, DWORD PTR tv696[ebp]
je SHORT $LN93@xmlFACompu
$LN81@xmlFACompu:
mov eax, DWORD PTR [edi+8]
cmp eax, DWORD PTR [esi+8]
jne SHORT $LN93@xmlFACompu
mov eax, DWORD PTR [edi+12]
mov ecx, DWORD PTR _state$1$[ebp]
cmp eax, DWORD PTR [esi+12]
jne SHORT $LN8@xmlFACompu
; 2698 : (t1->count == t2->count))
; 2699 : t2->to = -1; /* eliminated */
mov DWORD PTR [esi+4], -1
; 2464 : if (atom1->type != atom2->type)
jmp SHORT $LN8@xmlFACompu
$LN87@xmlFACompu:
; 2685 : continue;
; 2686 : for (i = 0;i < transnr;i++) {
mov edx, DWORD PTR tv696[ebp]
$LN93@xmlFACompu:
mov ecx, DWORD PTR _state$1$[ebp]
$LN8@xmlFACompu:
add ebx, 20 ; 00000014H
sub edx, 1
mov DWORD PTR tv696[ebp], edx
jne $LL10@xmlFACompu
mov edx, DWORD PTR _transnr$1$[ebp]
mov eax, DWORD PTR tv668[ebp]
$LN5@xmlFACompu:
; 2673 : continue;
; 2674 : for (transnr = 0;transnr < state->nbTrans;transnr++) {
inc edx
add eax, 20 ; 00000014H
mov DWORD PTR _transnr$1$[ebp], edx
mov DWORD PTR tv668[ebp], eax
cmp edx, DWORD PTR [ecx+24]
jl $LL7@xmlFACompu
mov ebx, DWORD PTR _ctxt$[ebp]
$LN2@xmlFACompu:
; 2648 : int statenr, transnr;
; 2649 : xmlRegStatePtr state;
; 2650 : xmlRegTransPtr t1, t2, last;
; 2651 : int i;
; 2652 : int ret = 1;
; 2653 : int deep = 1;
; 2654 :
; 2655 : #ifdef DEBUG_REGEXP_GRAPH
; 2656 : printf("xmlFAComputesDeterminism\n");
; 2657 : xmlRegPrintCtxt(stdout, ctxt);
; 2658 : #endif
; 2659 : if (ctxt->determinist != -1)
; 2660 : return(ctxt->determinist);
; 2661 :
; 2662 : if (ctxt->flags & AM_AUTOMATA_RNG)
; 2663 : deep = 0;
; 2664 :
; 2665 : /*
; 2666 : * First cleanup the automata removing cancelled transitions
; 2667 : */
; 2668 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
mov ecx, DWORD PTR _statenr$1$[ebp]
mov eax, DWORD PTR [ebx+48]
inc ecx
mov DWORD PTR _statenr$1$[ebp], ecx
cmp ecx, eax
jl $LL4@xmlFACompu
$LN3@xmlFACompu:
; 2700 : }
; 2701 : }
; 2702 : }
; 2703 : }
; 2704 : }
; 2705 :
; 2706 : /*
; 2707 : * Check for all states that there aren't 2 transitions
; 2708 : * with the same atom and a different target.
; 2709 : */
; 2710 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
xor edx, edx
mov DWORD PTR _statenr$2$[ebp], edx
test eax, eax
jle $LN12@xmlFACompu
$LL13@xmlFACompu:
; 2711 : state = ctxt->states[statenr];
mov eax, DWORD PTR [ebx+52]
mov edx, DWORD PTR [eax+edx*4]
mov DWORD PTR _state$2$[ebp], edx
; 2712 : if (state == NULL)
test edx, edx
je $LN11@xmlFACompu
; 2713 : continue;
; 2714 : if (state->nbTrans < 2)
mov ecx, DWORD PTR [edx+24]
cmp ecx, 2
jl $LN11@xmlFACompu
; 2715 : continue;
; 2716 : last = NULL;
xor eax, eax
; 2717 : for (transnr = 0;transnr < state->nbTrans;transnr++) {
xor edi, edi
mov DWORD PTR _last$1$[ebp], eax
mov DWORD PTR _transnr$2$[ebp], edi
test ecx, ecx
jle $LN11@xmlFACompu
xor ecx, ecx
mov DWORD PTR tv666[ebp], ecx
npad 7
$LL16@xmlFACompu:
; 2718 : t1 = &(state->trans[transnr]);
mov esi, DWORD PTR [edx+28]
add esi, ecx
; 2719 : /*
; 2720 : * Determinism checks in case of counted or all transitions
; 2721 : * will have to be handled separately
; 2722 : */
; 2723 : if (t1->atom == NULL) {
cmp DWORD PTR [esi], 0
je $LN14@xmlFACompu
; 2724 : continue;
; 2725 : }
; 2726 : if (t1->to == -1) /* eliminated */
cmp DWORD PTR [esi+4], -1
je $LN14@xmlFACompu
; 2727 : continue;
; 2728 : for (i = 0;i < transnr;i++) {
test edi, edi
jle $LN14@xmlFACompu
xor ebx, ebx
mov DWORD PTR tv697[ebp], edi
$LL19@xmlFACompu:
; 2729 : t2 = &(state->trans[i]);
mov edi, DWORD PTR [edx+28]
; 2730 : if (t2->to == -1) /* eliminated */
mov edx, DWORD PTR [edi+ebx+4]
cmp edx, -1
je SHORT $LN17@xmlFACompu
; 2731 : continue;
; 2732 : if (t2->atom != NULL) {
mov eax, DWORD PTR [edi+ebx]
test eax, eax
je SHORT $LN35@xmlFACompu
; 2733 : /*
; 2734 : * But here we don't use deep because we want to
; 2735 : * find transitions which indicate a conflict
; 2736 : */
; 2737 : if (xmlFACompareAtoms(t1->atom, t2->atom, 1)) {
push 1
push eax
push DWORD PTR [esi]
call _xmlFACompareAtoms
add esp, 12 ; 0000000cH
test eax, eax
je SHORT $LN84@xmlFACompu
; 2738 : ret = 0;
; 2739 : /* mark the transitions as non-deterministic ones */
; 2740 : t1->nd = 1;
; 2741 : t2->nd = 1;
; 2742 : last = t1;
mov eax, esi
mov DWORD PTR [esi+16], 1
mov DWORD PTR _ret$1$[ebp], 0
mov DWORD PTR [edi+ebx+16], 1
mov DWORD PTR _last$1$[ebp], eax
; 2743 : }
jmp SHORT $LN17@xmlFACompu
$LN35@xmlFACompu:
; 2744 : } else if (t1->to != -1) {
mov ecx, DWORD PTR [esi+4]
cmp ecx, -1
je SHORT $LN84@xmlFACompu
; 2745 : /*
; 2746 : * do the closure in case of remaining specific
; 2747 : * epsilon transitions like choices or all
; 2748 : */
; 2749 : ret = xmlFARecurseDeterminism(ctxt, ctxt->states[t1->to],
push 0
push edx
mov edx, DWORD PTR _ctxt$[ebp]
mov eax, DWORD PTR [edx+52]
push DWORD PTR [eax+ecx*4]
push edx
call _xmlFARecurseDeterminism
mov ecx, eax
add esp, 16 ; 00000010H
mov DWORD PTR _ret$1$[ebp], ecx
; 2750 : t2->to, t2->atom);
; 2751 : /* don't shortcut the computation so all non deterministic
; 2752 : transition get marked down
; 2753 : if (ret == 0)
; 2754 : return(0);
; 2755 : */
; 2756 : if (ret == 0) {
test ecx, ecx
jne SHORT $LN84@xmlFACompu
; 2757 : t1->nd = 1;
; 2758 : /* t2->nd = 1; */
; 2759 : last = t1;
mov eax, esi
mov DWORD PTR [esi+16], 1
mov DWORD PTR _last$1$[ebp], eax
jmp SHORT $LN17@xmlFACompu
$LN84@xmlFACompu:
; 2727 : continue;
; 2728 : for (i = 0;i < transnr;i++) {
mov eax, DWORD PTR _last$1$[ebp]
$LN17@xmlFACompu:
mov edx, DWORD PTR _state$2$[ebp]
add ebx, 20 ; 00000014H
sub DWORD PTR tv697[ebp], 1
jne $LL19@xmlFACompu
mov edi, DWORD PTR _transnr$2$[ebp]
mov ecx, DWORD PTR tv666[ebp]
$LN14@xmlFACompu:
; 2717 : for (transnr = 0;transnr < state->nbTrans;transnr++) {
inc edi
add ecx, 20 ; 00000014H
mov DWORD PTR _transnr$2$[ebp], edi
mov DWORD PTR tv666[ebp], ecx
cmp edi, DWORD PTR [edx+24]
jl $LL16@xmlFACompu
; 2760 : }
; 2761 : }
; 2762 : }
; 2763 : /* don't shortcut the computation so all non deterministic
; 2764 : transition get marked down
; 2765 : if (ret == 0)
; 2766 : break; */
; 2767 : }
; 2768 :
; 2769 : /*
; 2770 : * mark specifically the last non-deterministic transition
; 2771 : * from a state since there is no need to set-up rollback
; 2772 : * from it
; 2773 : */
; 2774 : if (last != NULL) {
mov ebx, DWORD PTR _ctxt$[ebp]
test eax, eax
je SHORT $LN11@xmlFACompu
; 2775 : last->nd = 2;
mov DWORD PTR [eax+16], 2
$LN11@xmlFACompu:
; 2700 : }
; 2701 : }
; 2702 : }
; 2703 : }
; 2704 : }
; 2705 :
; 2706 : /*
; 2707 : * Check for all states that there aren't 2 transitions
; 2708 : * with the same atom and a different target.
; 2709 : */
; 2710 : for (statenr = 0;statenr < ctxt->nbStates;statenr++) {
mov edx, DWORD PTR _statenr$2$[ebp]
inc edx
mov DWORD PTR _statenr$2$[ebp], edx
cmp edx, DWORD PTR [ebx+48]
jl $LL13@xmlFACompu
$LN12@xmlFACompu:
; 2776 : }
; 2777 :
; 2778 : /* don't shortcut the computation so all non deterministic
; 2779 : transition get marked down
; 2780 : if (ret == 0)
; 2781 : break; */
; 2782 : }
; 2783 :
; 2784 : ctxt->determinist = ret;
mov eax, DWORD PTR _ret$1$[ebp]
; 2785 : return(ret);
pop edi
mov DWORD PTR [ebx+68], eax
pop esi
$LN1@xmlFACompu:
pop ebx
; 2786 : }
mov esp, ebp
pop ebp
ret 0
npad 3
$LN98@xmlFACompu:
DD $LN87@xmlFACompu
DD $LN53@xmlFACompu
DD $LN87@xmlFACompu
DD $LN87@xmlFACompu
DD $LN50@xmlFACompu
_xmlFAComputesDeterminism ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegexpErrCompile
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_extra$ = 12 ; size = 4
_xmlRegexpErrCompile PROC ; COMDAT
; 399 : {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _ctxt$[ebp]
xor edx, edx
xor ecx, ecx
test eax, eax
je SHORT $LN2@xmlRegexpE
; 400 : const char *regexp = NULL;
; 401 : int idx = 0;
; 402 :
; 403 : if (ctxt != NULL) {
; 404 : regexp = (const char *) ctxt->string;
mov ecx, DWORD PTR [eax+4]
mov edx, DWORD PTR [eax]
; 405 : idx = ctxt->cur - ctxt->string;
sub ecx, edx
; 406 : ctxt->error = XML_REGEXP_COMPILE_ERROR;
mov DWORD PTR [eax+8], 1450 ; 000005aaH
$LN2@xmlRegexpE:
; 407 : }
; 408 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
mov eax, DWORD PTR _extra$[ebp]
push eax
push OFFSET ??_C@_0BH@CFFLONMP@failed?5to?5compile?3?5?$CFs?6@
push 0
push ecx
push 0
push edx
push eax
push 0
push 0
push 3
push 1450 ; 000005aaH
push 14 ; 0000000eH
push 0
push 0
push 0
push 0
push 0
call ___xmlRaiseError
add esp, 68 ; 00000044H
; 409 : XML_REGEXP_COMPILE_ERROR, XML_ERR_FATAL, NULL, 0, extra,
; 410 : regexp, NULL, idx, 0,
; 411 : "failed to compile: %s\n", extra);
; 412 : }
pop ebp
ret 0
_xmlRegexpErrCompile ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegexpErrMemory
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_extra$ = 12 ; size = 4
_xmlRegexpErrMemory PROC ; COMDAT
; 379 : {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _ctxt$[ebp]
xor ecx, ecx
test eax, eax
je SHORT $LN2@xmlRegexpE
; 380 : const char *regexp = NULL;
; 381 : if (ctxt != NULL) {
; 382 : regexp = (const char *) ctxt->string;
; 383 : ctxt->error = XML_ERR_NO_MEMORY;
mov ecx, DWORD PTR [eax]
mov DWORD PTR [eax+8], 2
$LN2@xmlRegexpE:
; 384 : }
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
mov eax, DWORD PTR _extra$[ebp]
push eax
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push 0
push 0
push 0
push ecx
push eax
push 0
push 0
push 3
push 2
push 14 ; 0000000eH
push 0
push 0
push 0
push 0
push 0
call ___xmlRaiseError
add esp, 68 ; 00000044H
; 386 : XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra,
; 387 : regexp, NULL, 0, 0,
; 388 : "Memory allocation failed : %s\n", extra);
; 389 : }
pop ebp
ret 0
_xmlRegexpErrMemory ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataSetFlags
_TEXT SEGMENT
_am$ = 8 ; size = 4
_flags$ = 12 ; size = 4
_xmlAutomataSetFlags PROC ; COMDAT
; 5661 : xmlAutomataSetFlags(xmlAutomataPtr am, int flags) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov ecx, DWORD PTR _am$[ebp]
test ecx, ecx
je SHORT $LN1@xmlAutomat
; 5662 : if (am == NULL)
; 5663 : return;
; 5664 : am->flags |= flags;
mov eax, DWORD PTR _flags$[ebp]
or DWORD PTR [ecx+76], eax
$LN1@xmlAutomat:
; 5665 : }
pop ebp
ret 0
_xmlAutomataSetFlags ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegCheckCharacterRange
_TEXT SEGMENT
_type$ = 8 ; size = 4
_codepoint$ = 12 ; size = 4
_neg$ = 16 ; size = 4
_start$ = 20 ; size = 4
_end$ = 24 ; size = 4
_blockName$ = 28 ; size = 4
_xmlRegCheckCharacterRange PROC ; COMDAT
; 2796 : int start, int end, const xmlChar *blockName) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _type$[ebp]
xor ecx, ecx
dec eax
cmp eax, 135 ; 00000087H
ja $LN117@xmlRegChec
; 2797 : int ret = 0;
; 2798 :
; 2799 : switch (type) {
movzx eax, BYTE PTR $LN111@xmlRegChec[eax]
jmp DWORD PTR $LN122@xmlRegChec[eax*4]
$LN4@xmlRegChec:
; 2800 : case XML_REGEXP_STRING:
; 2801 : case XML_REGEXP_SUBREG:
; 2802 : case XML_REGEXP_RANGES:
; 2803 : case XML_REGEXP_EPSILON:
; 2804 : return(-1);
or eax, -1
pop esi
; 2967 : }
pop ebp
ret 0
$LN5@xmlRegChec:
; 2805 : case XML_REGEXP_ANYCHAR:
; 2806 : ret = ((codepoint != '\n') && (codepoint != '\r'));
mov eax, DWORD PTR _codepoint$[ebp]
cmp eax, 10 ; 0000000aH
je SHORT $LN58@xmlRegChec
cmp eax, 13 ; 0000000dH
je SHORT $LN58@xmlRegChec
$LN62@xmlRegChec:
; 2962 : break;
; 2963 : }
; 2964 : if (neg)
mov ecx, 1
jmp $LN117@xmlRegChec
$LN6@xmlRegChec:
; 2807 : break;
; 2808 : case XML_REGEXP_CHARVAL:
; 2809 : ret = ((codepoint >= start) && (codepoint <= end));
mov eax, DWORD PTR _codepoint$[ebp]
cmp eax, DWORD PTR _start$[ebp]
jl SHORT $LN58@xmlRegChec
cmp eax, DWORD PTR _end$[ebp]
jg SHORT $LN58@xmlRegChec
mov ecx, 1
jmp $LN117@xmlRegChec
$LN7@xmlRegChec:
; 2810 : break;
; 2811 : case XML_REGEXP_NOTSPACE:
; 2812 : neg = !neg;
xor eax, eax
cmp DWORD PTR _neg$[ebp], eax
sete al
mov DWORD PTR _neg$[ebp], eax
$LN112@xmlRegChec:
; 2813 : /* Falls through. */
; 2814 : case XML_REGEXP_ANYSPACE:
; 2815 : ret = ((codepoint == '\n') || (codepoint == '\r') ||
mov eax, DWORD PTR _codepoint$[ebp]
cmp eax, 10 ; 0000000aH
je SHORT $LN62@xmlRegChec
cmp eax, 13 ; 0000000dH
je SHORT $LN62@xmlRegChec
cmp eax, 9
je SHORT $LN62@xmlRegChec
cmp eax, 32 ; 00000020H
je SHORT $LN62@xmlRegChec
$LN58@xmlRegChec:
; 2962 : break;
; 2963 : }
; 2964 : if (neg)
xor ecx, ecx
jmp $LN117@xmlRegChec
$LN9@xmlRegChec:
; 2816 : (codepoint == '\t') || (codepoint == ' '));
; 2817 : break;
; 2818 : case XML_REGEXP_NOTINITNAME:
; 2819 : neg = !neg;
xor eax, eax
cmp DWORD PTR _neg$[ebp], eax
sete al
mov DWORD PTR _neg$[ebp], eax
$LN113@xmlRegChec:
; 2820 : /* Falls through. */
; 2821 : case XML_REGEXP_INITNAME:
; 2822 : ret = (IS_LETTER(codepoint) ||
mov esi, DWORD PTR _codepoint$[ebp]
cmp esi, 256 ; 00000100H
jge SHORT $LN70@xmlRegChec
cmp esi, 65 ; 00000041H
jl SHORT $LN64@xmlRegChec
cmp esi, 90 ; 0000005aH
jle SHORT $LN62@xmlRegChec
$LN64@xmlRegChec:
cmp esi, 97 ; 00000061H
jl SHORT $LN65@xmlRegChec
cmp esi, 122 ; 0000007aH
jle SHORT $LN62@xmlRegChec
$LN65@xmlRegChec:
cmp esi, 192 ; 000000c0H
jl SHORT $LN67@xmlRegChec
cmp esi, 214 ; 000000d6H
jle $LN62@xmlRegChec
$LN67@xmlRegChec:
cmp esi, 216 ; 000000d8H
jl SHORT $LN68@xmlRegChec
cmp esi, 246 ; 000000f6H
jle $LN62@xmlRegChec
$LN68@xmlRegChec:
cmp esi, 248 ; 000000f8H
jge $LN62@xmlRegChec
jmp SHORT $LN104@xmlRegChec
$LN70@xmlRegChec:
push OFFSET _xmlIsBaseCharGroup
push esi
call _xmlCharInRange
add esp, 8
test eax, eax
jne $LN62@xmlRegChec
$LN104@xmlRegChec:
cmp esi, 256 ; 00000100H
jl SHORT $LN108@xmlRegChec
cmp esi, 19968 ; 00004e00H
jl SHORT $LN72@xmlRegChec
cmp esi, 40869 ; 00009fa5H
jle $LN62@xmlRegChec
$LN72@xmlRegChec:
cmp esi, 12295 ; 00003007H
je $LN62@xmlRegChec
cmp esi, 12321 ; 00003021H
jl SHORT $LN108@xmlRegChec
cmp esi, 12329 ; 00003029H
jle $LN62@xmlRegChec
$LN108@xmlRegChec:
cmp esi, 95 ; 0000005fH
je $LN62@xmlRegChec
cmp esi, 58 ; 0000003aH
je $LN62@xmlRegChec
xor ecx, ecx
jmp $LN117@xmlRegChec
$LN11@xmlRegChec:
; 2823 : (codepoint == '_') || (codepoint == ':'));
; 2824 : break;
; 2825 : case XML_REGEXP_NOTNAMECHAR:
; 2826 : neg = !neg;
xor eax, eax
cmp DWORD PTR _neg$[ebp], eax
sete al
mov DWORD PTR _neg$[ebp], eax
$LN114@xmlRegChec:
; 2827 : /* Falls through. */
; 2828 : case XML_REGEXP_NAMECHAR:
; 2829 : ret = (IS_LETTER(codepoint) || IS_DIGIT(codepoint) ||
mov esi, DWORD PTR _codepoint$[ebp]
cmp esi, 256 ; 00000100H
jge SHORT $LN86@xmlRegChec
cmp esi, 65 ; 00000041H
jl SHORT $LN80@xmlRegChec
cmp esi, 90 ; 0000005aH
jle $LN62@xmlRegChec
$LN80@xmlRegChec:
cmp esi, 97 ; 00000061H
jl SHORT $LN81@xmlRegChec
cmp esi, 122 ; 0000007aH
jle $LN62@xmlRegChec
$LN81@xmlRegChec:
cmp esi, 192 ; 000000c0H
jl SHORT $LN83@xmlRegChec
cmp esi, 214 ; 000000d6H
jle $LN62@xmlRegChec
$LN83@xmlRegChec:
cmp esi, 216 ; 000000d8H
jl SHORT $LN84@xmlRegChec
cmp esi, 246 ; 000000f6H
jle $LN62@xmlRegChec
$LN84@xmlRegChec:
cmp esi, 248 ; 000000f8H
jge $LN62@xmlRegChec
jmp SHORT $LN105@xmlRegChec
$LN86@xmlRegChec:
push OFFSET _xmlIsBaseCharGroup
push esi
call _xmlCharInRange
add esp, 8
test eax, eax
jne $LN62@xmlRegChec
$LN105@xmlRegChec:
cmp esi, 256 ; 00000100H
jl SHORT $LN119@xmlRegChec
cmp esi, 19968 ; 00004e00H
jl SHORT $LN88@xmlRegChec
cmp esi, 40869 ; 00009fa5H
jle $LN62@xmlRegChec
$LN88@xmlRegChec:
cmp esi, 12295 ; 00003007H
je $LN62@xmlRegChec
cmp esi, 12321 ; 00003021H
jl SHORT $LN109@xmlRegChec
cmp esi, 12329 ; 00003029H
jle $LN62@xmlRegChec
$LN109@xmlRegChec:
cmp esi, 256 ; 00000100H
jge SHORT $LN97@xmlRegChec
$LN119@xmlRegChec:
lea eax, DWORD PTR [esi-48]
cmp eax, 9
ja SHORT $LN106@xmlRegChec
; 2962 : break;
; 2963 : }
; 2964 : if (neg)
mov ecx, 1
jmp $LN117@xmlRegChec
$LN97@xmlRegChec:
; 2827 : /* Falls through. */
; 2828 : case XML_REGEXP_NAMECHAR:
; 2829 : ret = (IS_LETTER(codepoint) || IS_DIGIT(codepoint) ||
push OFFSET _xmlIsDigitGroup
push esi
call _xmlCharInRange
add esp, 8
test eax, eax
jne $LN62@xmlRegChec
$LN106@xmlRegChec:
cmp esi, 46 ; 0000002eH
je $LN62@xmlRegChec
cmp esi, 45 ; 0000002dH
je $LN62@xmlRegChec
cmp esi, 95 ; 0000005fH
je $LN62@xmlRegChec
cmp esi, 58 ; 0000003aH
je $LN62@xmlRegChec
cmp esi, 256 ; 00000100H
jl SHORT $LN110@xmlRegChec
push OFFSET _xmlIsCombiningGroup
push esi
call _xmlCharInRange
add esp, 8
test eax, eax
jne $LN62@xmlRegChec
push OFFSET _xmlIsExtenderGroup
push esi
call _xmlCharInRange
add esp, 8
jmp SHORT $LN102@xmlRegChec
$LN110@xmlRegChec:
xor eax, eax
cmp esi, 183 ; 000000b7H
sete al
$LN102@xmlRegChec:
test eax, eax
jne $LN62@xmlRegChec
xor ecx, ecx
jmp $LN117@xmlRegChec
$LN13@xmlRegChec:
; 2830 : (codepoint == '.') || (codepoint == '-') ||
; 2831 : (codepoint == '_') || (codepoint == ':') ||
; 2832 : IS_COMBINING(codepoint) || IS_EXTENDER(codepoint));
; 2833 : break;
; 2834 : case XML_REGEXP_NOTDECIMAL:
; 2835 : neg = !neg;
xor eax, eax
cmp DWORD PTR _neg$[ebp], eax
sete al
mov DWORD PTR _neg$[ebp], eax
$LN115@xmlRegChec:
; 2962 : break;
; 2963 : }
; 2964 : if (neg)
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatNd
add esp, 4
jmp $LN120@xmlRegChec
$LN15@xmlRegChec:
; 2836 : /* Falls through. */
; 2837 : case XML_REGEXP_DECIMAL:
; 2838 : ret = xmlUCSIsCatNd(codepoint);
; 2839 : break;
; 2840 : case XML_REGEXP_REALCHAR:
; 2841 : neg = !neg;
xor eax, eax
cmp DWORD PTR _neg$[ebp], eax
sete al
mov DWORD PTR _neg$[ebp], eax
$LN116@xmlRegChec:
; 2842 : /* Falls through. */
; 2843 : case XML_REGEXP_NOTREALCHAR:
; 2844 : ret = xmlUCSIsCatP(codepoint);
mov esi, DWORD PTR _codepoint$[ebp]
push esi
call _xmlUCSIsCatP
mov ecx, eax
add esp, 4
; 2845 : if (ret == 0)
test ecx, ecx
jne $LN117@xmlRegChec
; 2846 : ret = xmlUCSIsCatZ(codepoint);
push esi
call _xmlUCSIsCatZ
mov ecx, eax
add esp, 4
; 2847 : if (ret == 0)
test ecx, ecx
jne $LN117@xmlRegChec
; 2848 : ret = xmlUCSIsCatC(codepoint);
push esi
call _xmlUCSIsCatC
add esp, 4
; 2849 : break;
jmp $LN120@xmlRegChec
$LN19@xmlRegChec:
; 2850 : case XML_REGEXP_LETTER:
; 2851 : ret = xmlUCSIsCatL(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatL
add esp, 4
; 2852 : break;
jmp $LN120@xmlRegChec
$LN20@xmlRegChec:
; 2853 : case XML_REGEXP_LETTER_UPPERCASE:
; 2854 : ret = xmlUCSIsCatLu(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatLu
add esp, 4
; 2855 : break;
jmp $LN120@xmlRegChec
$LN21@xmlRegChec:
; 2856 : case XML_REGEXP_LETTER_LOWERCASE:
; 2857 : ret = xmlUCSIsCatLl(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatLl
add esp, 4
; 2858 : break;
jmp $LN120@xmlRegChec
$LN22@xmlRegChec:
; 2859 : case XML_REGEXP_LETTER_TITLECASE:
; 2860 : ret = xmlUCSIsCatLt(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatLt
add esp, 4
; 2861 : break;
jmp $LN120@xmlRegChec
$LN23@xmlRegChec:
; 2862 : case XML_REGEXP_LETTER_MODIFIER:
; 2863 : ret = xmlUCSIsCatLm(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatLm
add esp, 4
; 2864 : break;
jmp $LN120@xmlRegChec
$LN24@xmlRegChec:
; 2865 : case XML_REGEXP_LETTER_OTHERS:
; 2866 : ret = xmlUCSIsCatLo(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatLo
add esp, 4
; 2867 : break;
jmp $LN120@xmlRegChec
$LN25@xmlRegChec:
; 2868 : case XML_REGEXP_MARK:
; 2869 : ret = xmlUCSIsCatM(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatM
add esp, 4
; 2870 : break;
jmp $LN120@xmlRegChec
$LN26@xmlRegChec:
; 2871 : case XML_REGEXP_MARK_NONSPACING:
; 2872 : ret = xmlUCSIsCatMn(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatMn
add esp, 4
; 2873 : break;
jmp $LN120@xmlRegChec
$LN27@xmlRegChec:
; 2874 : case XML_REGEXP_MARK_SPACECOMBINING:
; 2875 : ret = xmlUCSIsCatMc(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatMc
add esp, 4
; 2876 : break;
jmp $LN120@xmlRegChec
$LN28@xmlRegChec:
; 2877 : case XML_REGEXP_MARK_ENCLOSING:
; 2878 : ret = xmlUCSIsCatMe(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatMe
add esp, 4
; 2879 : break;
jmp $LN120@xmlRegChec
$LN29@xmlRegChec:
; 2880 : case XML_REGEXP_NUMBER:
; 2881 : ret = xmlUCSIsCatN(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatN
add esp, 4
; 2882 : break;
jmp $LN120@xmlRegChec
$LN31@xmlRegChec:
; 2883 : case XML_REGEXP_NUMBER_DECIMAL:
; 2884 : ret = xmlUCSIsCatNd(codepoint);
; 2885 : break;
; 2886 : case XML_REGEXP_NUMBER_LETTER:
; 2887 : ret = xmlUCSIsCatNl(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatNl
add esp, 4
; 2888 : break;
jmp $LN120@xmlRegChec
$LN32@xmlRegChec:
; 2889 : case XML_REGEXP_NUMBER_OTHERS:
; 2890 : ret = xmlUCSIsCatNo(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatNo
add esp, 4
; 2891 : break;
jmp $LN120@xmlRegChec
$LN33@xmlRegChec:
; 2892 : case XML_REGEXP_PUNCT:
; 2893 : ret = xmlUCSIsCatP(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatP
add esp, 4
; 2894 : break;
jmp $LN120@xmlRegChec
$LN34@xmlRegChec:
; 2895 : case XML_REGEXP_PUNCT_CONNECTOR:
; 2896 : ret = xmlUCSIsCatPc(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatPc
add esp, 4
; 2897 : break;
jmp $LN120@xmlRegChec
$LN35@xmlRegChec:
; 2898 : case XML_REGEXP_PUNCT_DASH:
; 2899 : ret = xmlUCSIsCatPd(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatPd
add esp, 4
; 2900 : break;
jmp $LN120@xmlRegChec
$LN36@xmlRegChec:
; 2901 : case XML_REGEXP_PUNCT_OPEN:
; 2902 : ret = xmlUCSIsCatPs(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatPs
add esp, 4
; 2903 : break;
jmp $LN120@xmlRegChec
$LN37@xmlRegChec:
; 2904 : case XML_REGEXP_PUNCT_CLOSE:
; 2905 : ret = xmlUCSIsCatPe(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatPe
add esp, 4
; 2906 : break;
jmp $LN120@xmlRegChec
$LN38@xmlRegChec:
; 2907 : case XML_REGEXP_PUNCT_INITQUOTE:
; 2908 : ret = xmlUCSIsCatPi(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatPi
add esp, 4
; 2909 : break;
jmp $LN120@xmlRegChec
$LN39@xmlRegChec:
; 2910 : case XML_REGEXP_PUNCT_FINQUOTE:
; 2911 : ret = xmlUCSIsCatPf(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatPf
add esp, 4
; 2912 : break;
jmp $LN120@xmlRegChec
$LN40@xmlRegChec:
; 2913 : case XML_REGEXP_PUNCT_OTHERS:
; 2914 : ret = xmlUCSIsCatPo(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatPo
add esp, 4
; 2915 : break;
jmp $LN120@xmlRegChec
$LN41@xmlRegChec:
; 2916 : case XML_REGEXP_SEPAR:
; 2917 : ret = xmlUCSIsCatZ(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatZ
add esp, 4
; 2918 : break;
jmp $LN120@xmlRegChec
$LN42@xmlRegChec:
; 2919 : case XML_REGEXP_SEPAR_SPACE:
; 2920 : ret = xmlUCSIsCatZs(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatZs
add esp, 4
; 2921 : break;
jmp $LN120@xmlRegChec
$LN43@xmlRegChec:
; 2922 : case XML_REGEXP_SEPAR_LINE:
; 2923 : ret = xmlUCSIsCatZl(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatZl
add esp, 4
; 2924 : break;
jmp $LN120@xmlRegChec
$LN44@xmlRegChec:
; 2925 : case XML_REGEXP_SEPAR_PARA:
; 2926 : ret = xmlUCSIsCatZp(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatZp
add esp, 4
; 2927 : break;
jmp $LN120@xmlRegChec
$LN45@xmlRegChec:
; 2928 : case XML_REGEXP_SYMBOL:
; 2929 : ret = xmlUCSIsCatS(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatS
add esp, 4
; 2930 : break;
jmp SHORT $LN120@xmlRegChec
$LN46@xmlRegChec:
; 2931 : case XML_REGEXP_SYMBOL_MATH:
; 2932 : ret = xmlUCSIsCatSm(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatSm
add esp, 4
; 2933 : break;
jmp SHORT $LN120@xmlRegChec
$LN47@xmlRegChec:
; 2934 : case XML_REGEXP_SYMBOL_CURRENCY:
; 2935 : ret = xmlUCSIsCatSc(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatSc
add esp, 4
; 2936 : break;
jmp SHORT $LN120@xmlRegChec
$LN48@xmlRegChec:
; 2937 : case XML_REGEXP_SYMBOL_MODIFIER:
; 2938 : ret = xmlUCSIsCatSk(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatSk
add esp, 4
; 2939 : break;
jmp SHORT $LN120@xmlRegChec
$LN49@xmlRegChec:
; 2940 : case XML_REGEXP_SYMBOL_OTHERS:
; 2941 : ret = xmlUCSIsCatSo(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatSo
add esp, 4
; 2942 : break;
jmp SHORT $LN120@xmlRegChec
$LN50@xmlRegChec:
; 2943 : case XML_REGEXP_OTHER:
; 2944 : ret = xmlUCSIsCatC(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatC
add esp, 4
; 2945 : break;
jmp SHORT $LN120@xmlRegChec
$LN51@xmlRegChec:
; 2946 : case XML_REGEXP_OTHER_CONTROL:
; 2947 : ret = xmlUCSIsCatCc(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatCc
add esp, 4
; 2948 : break;
jmp SHORT $LN120@xmlRegChec
$LN52@xmlRegChec:
; 2949 : case XML_REGEXP_OTHER_FORMAT:
; 2950 : ret = xmlUCSIsCatCf(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatCf
add esp, 4
; 2951 : break;
jmp SHORT $LN120@xmlRegChec
$LN53@xmlRegChec:
; 2952 : case XML_REGEXP_OTHER_PRIVATE:
; 2953 : ret = xmlUCSIsCatCo(codepoint);
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsCatCo
add esp, 4
; 2954 : break;
jmp SHORT $LN120@xmlRegChec
$LN55@xmlRegChec:
; 2955 : case XML_REGEXP_OTHER_NA:
; 2956 : /* ret = xmlUCSIsCatCn(codepoint); */
; 2957 : /* Seems it doesn't exist anymore in recent Unicode releases */
; 2958 : ret = 0;
; 2959 : break;
; 2960 : case XML_REGEXP_BLOCK_NAME:
; 2961 : ret = xmlUCSIsBlock(codepoint, (const char *) blockName);
push DWORD PTR _blockName$[ebp]
push DWORD PTR _codepoint$[ebp]
call _xmlUCSIsBlock
add esp, 8
$LN120@xmlRegChec:
; 2962 : break;
; 2963 : }
; 2964 : if (neg)
mov ecx, eax
$LN117@xmlRegChec:
cmp DWORD PTR _neg$[ebp], 0
je SHORT $LN56@xmlRegChec
; 2965 : return(!ret);
xor eax, eax
test ecx, ecx
pop esi
sete al
; 2967 : }
pop ebp
ret 0
$LN56@xmlRegChec:
; 2966 : return(ret);
mov eax, ecx
pop esi
; 2967 : }
pop ebp
ret 0
npad 2
$LN122@xmlRegChec:
DD $LN4@xmlRegChec
DD $LN6@xmlRegChec
DD $LN5@xmlRegChec
DD $LN112@xmlRegChec
DD $LN7@xmlRegChec
DD $LN113@xmlRegChec
DD $LN9@xmlRegChec
DD $LN114@xmlRegChec
DD $LN11@xmlRegChec
DD $LN115@xmlRegChec
DD $LN13@xmlRegChec
DD $LN15@xmlRegChec
DD $LN116@xmlRegChec
DD $LN19@xmlRegChec
DD $LN20@xmlRegChec
DD $LN21@xmlRegChec
DD $LN22@xmlRegChec
DD $LN23@xmlRegChec
DD $LN24@xmlRegChec
DD $LN25@xmlRegChec
DD $LN26@xmlRegChec
DD $LN27@xmlRegChec
DD $LN28@xmlRegChec
DD $LN29@xmlRegChec
DD $LN31@xmlRegChec
DD $LN32@xmlRegChec
DD $LN33@xmlRegChec
DD $LN34@xmlRegChec
DD $LN35@xmlRegChec
DD $LN36@xmlRegChec
DD $LN37@xmlRegChec
DD $LN38@xmlRegChec
DD $LN39@xmlRegChec
DD $LN40@xmlRegChec
DD $LN41@xmlRegChec
DD $LN42@xmlRegChec
DD $LN43@xmlRegChec
DD $LN44@xmlRegChec
DD $LN45@xmlRegChec
DD $LN46@xmlRegChec
DD $LN47@xmlRegChec
DD $LN48@xmlRegChec
DD $LN49@xmlRegChec
DD $LN50@xmlRegChec
DD $LN51@xmlRegChec
DD $LN52@xmlRegChec
DD $LN53@xmlRegChec
DD $LN58@xmlRegChec
DD $LN55@xmlRegChec
DD $LN117@xmlRegChec
$LN111@xmlRegChec:
DB 0
DB 1
DB 0
DB 0
DB 0
DB 2
DB 3
DB 4
DB 5
DB 6
DB 7
DB 8
DB 9
DB 10 ; 0000000aH
DB 11 ; 0000000bH
DB 12 ; 0000000cH
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 49 ; 00000031H
DB 13 ; 0000000dH
DB 14 ; 0000000eH
DB 15 ; 0000000fH
DB 16 ; 00000010H
DB 17 ; 00000011H
DB 18 ; 00000012H
DB 19 ; 00000013H
DB 20 ; 00000014H
DB 21 ; 00000015H
DB 22 ; 00000016H
DB 23 ; 00000017H
DB 9
DB 24 ; 00000018H
DB 25 ; 00000019H
DB 26 ; 0000001aH
DB 27 ; 0000001bH
DB 28 ; 0000001cH
DB 29 ; 0000001dH
DB 30 ; 0000001eH
DB 31 ; 0000001fH
DB 32 ; 00000020H
DB 33 ; 00000021H
DB 34 ; 00000022H
DB 35 ; 00000023H
DB 36 ; 00000024H
DB 37 ; 00000025H
DB 38 ; 00000026H
DB 39 ; 00000027H
DB 40 ; 00000028H
DB 41 ; 00000029H
DB 42 ; 0000002aH
DB 43 ; 0000002bH
DB 44 ; 0000002cH
DB 45 ; 0000002dH
DB 46 ; 0000002eH
DB 47 ; 0000002fH
DB 48 ; 00000030H
_xmlRegCheckCharacterRange ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegCheckCharacter
_TEXT SEGMENT
tv485 = -4 ; size = 4
_atom$ = 8 ; size = 4
_codepoint$ = 12 ; size = 4
_xmlRegCheckCharacter PROC ; COMDAT
; 2970 : xmlRegCheckCharacter(xmlRegAtomPtr atom, int codepoint) {
push ebp
mov ebp, esp
push ecx
push ebx
mov ebx, DWORD PTR _codepoint$[ebp]
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push esi
call @__CheckForDebuggerJustMyCode@4
mov ecx, DWORD PTR _atom$[ebp]
xor edx, edx
test ecx, ecx
je $LN8@xmlRegChec
; 2971 : int i, ret = 0;
; 2972 : xmlRegRangePtr range;
; 2973 :
; 2974 : if ((atom == NULL) || (!IS_CHAR(codepoint)))
cmp ebx, 256 ; 00000100H
jge SHORT $LN32@xmlRegChec
cmp ebx, 9
jl SHORT $LN24@xmlRegChec
cmp ebx, 10 ; 0000000aH
jle SHORT $LN39@xmlRegChec
$LN24@xmlRegChec:
cmp ebx, 13 ; 0000000dH
je SHORT $LN39@xmlRegChec
cmp ebx, 32 ; 00000020H
jge SHORT $LN39@xmlRegChec
; 3070 : }
pop esi
or eax, -1
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN32@xmlRegChec:
; 2971 : int i, ret = 0;
; 2972 : xmlRegRangePtr range;
; 2973 :
; 2974 : if ((atom == NULL) || (!IS_CHAR(codepoint)))
cmp ebx, 55295 ; 0000d7ffH
jle SHORT $LN39@xmlRegChec
cmp ebx, 57344 ; 0000e000H
jl SHORT $LN27@xmlRegChec
cmp ebx, 65533 ; 0000fffdH
jle SHORT $LN39@xmlRegChec
$LN27@xmlRegChec:
lea eax, DWORD PTR [ebx-65536]
cmp eax, 1048575 ; 000fffffH
ja $LN8@xmlRegChec
$LN39@xmlRegChec:
; 2975 : return(-1);
; 2976 :
; 2977 : switch (atom->type) {
mov esi, DWORD PTR [ecx+4]
lea eax, DWORD PTR [esi-1]
cmp eax, 135 ; 00000087H
ja $LN22@xmlRegChec
movzx eax, BYTE PTR $LN41@xmlRegChec[eax]
jmp DWORD PTR $LN44@xmlRegChec[eax*4]
$LN10@xmlRegChec:
; 2978 : case XML_REGEXP_SUBREG:
; 2979 : case XML_REGEXP_EPSILON:
; 2980 : return(-1);
; 2981 : case XML_REGEXP_CHARVAL:
; 2982 : return(codepoint == atom->codepoint);
xor eax, eax
cmp ebx, DWORD PTR [ecx+32]
pop esi
sete al
; 3070 : }
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN11@xmlRegChec:
push edi
; 2983 : case XML_REGEXP_RANGES: {
; 2984 : int accept = 0;
xor esi, esi
; 2985 :
; 2986 : for (i = 0;i < atom->nbRanges;i++) {
xor edi, edi
cmp DWORD PTR [ecx+52], edx
jle SHORT $LN40@xmlRegChec
$LL6@xmlRegChec:
; 2987 : range = atom->ranges[i];
mov eax, DWORD PTR [ecx+56]
mov eax, DWORD PTR [eax+edi*4]
; 2988 : if (range->neg == 2) {
push DWORD PTR [eax+16]
mov ecx, DWORD PTR [eax]
push DWORD PTR [eax+12]
mov DWORD PTR tv485[ebp], ecx
push DWORD PTR [eax+8]
push 0
push ebx
push DWORD PTR [eax+4]
call _xmlRegCheckCharacterRange
mov ecx, DWORD PTR tv485[ebp]
add esp, 24 ; 00000018H
cmp ecx, 2
jne SHORT $LN12@xmlRegChec
; 2989 : ret = xmlRegCheckCharacterRange(range->type, codepoint,
; 2990 : 0, range->start, range->end,
; 2991 : range->blockName);
; 2992 : if (ret != 0)
test eax, eax
je SHORT $LN4@xmlRegChec
$LN17@xmlRegChec:
pop edi
pop esi
; 3000 : else
; 3001 : return(0);
xor eax, eax
; 3070 : }
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN12@xmlRegChec:
; 2993 : return(0); /* excluded char */
; 2994 : } else if (range->neg) {
test ecx, ecx
je SHORT $LN15@xmlRegChec
; 2995 : ret = xmlRegCheckCharacterRange(range->type, codepoint,
; 2996 : 0, range->start, range->end,
; 2997 : range->blockName);
; 2998 : if (ret == 0)
test eax, eax
jne SHORT $LN17@xmlRegChec
; 2999 : accept = 1;
lea esi, DWORD PTR [eax+1]
; 3002 : } else {
jmp SHORT $LN4@xmlRegChec
$LN15@xmlRegChec:
; 3003 : ret = xmlRegCheckCharacterRange(range->type, codepoint,
; 3004 : 0, range->start, range->end,
; 3005 : range->blockName);
; 3006 : if (ret != 0)
test eax, eax
mov eax, 1
cmovne esi, eax
$LN4@xmlRegChec:
; 2985 :
; 2986 : for (i = 0;i < atom->nbRanges;i++) {
mov ecx, DWORD PTR _atom$[ebp]
inc edi
cmp edi, DWORD PTR [ecx+52]
jl SHORT $LL6@xmlRegChec
$LN40@xmlRegChec:
pop edi
; 3007 : accept = 1; /* might still be excluded */
; 3008 : }
; 3009 : }
; 3010 : return(accept);
mov eax, esi
pop esi
; 3070 : }
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN20@xmlRegChec:
; 3011 : }
; 3012 : case XML_REGEXP_STRING:
; 3013 : printf("TODO: XML_REGEXP_STRING\n");
push OFFSET ??_C@_0BJ@POCEJEIB@TODO?3?5XML_REGEXP_STRING?6@
call _printf
add esp, 4
$LN8@xmlRegChec:
; 3070 : }
pop esi
or eax, -1
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN21@xmlRegChec:
; 3014 : return(-1);
; 3015 : case XML_REGEXP_ANYCHAR:
; 3016 : case XML_REGEXP_ANYSPACE:
; 3017 : case XML_REGEXP_NOTSPACE:
; 3018 : case XML_REGEXP_INITNAME:
; 3019 : case XML_REGEXP_NOTINITNAME:
; 3020 : case XML_REGEXP_NAMECHAR:
; 3021 : case XML_REGEXP_NOTNAMECHAR:
; 3022 : case XML_REGEXP_DECIMAL:
; 3023 : case XML_REGEXP_NOTDECIMAL:
; 3024 : case XML_REGEXP_REALCHAR:
; 3025 : case XML_REGEXP_NOTREALCHAR:
; 3026 : case XML_REGEXP_LETTER:
; 3027 : case XML_REGEXP_LETTER_UPPERCASE:
; 3028 : case XML_REGEXP_LETTER_LOWERCASE:
; 3029 : case XML_REGEXP_LETTER_TITLECASE:
; 3030 : case XML_REGEXP_LETTER_MODIFIER:
; 3031 : case XML_REGEXP_LETTER_OTHERS:
; 3032 : case XML_REGEXP_MARK:
; 3033 : case XML_REGEXP_MARK_NONSPACING:
; 3034 : case XML_REGEXP_MARK_SPACECOMBINING:
; 3035 : case XML_REGEXP_MARK_ENCLOSING:
; 3036 : case XML_REGEXP_NUMBER:
; 3037 : case XML_REGEXP_NUMBER_DECIMAL:
; 3038 : case XML_REGEXP_NUMBER_LETTER:
; 3039 : case XML_REGEXP_NUMBER_OTHERS:
; 3040 : case XML_REGEXP_PUNCT:
; 3041 : case XML_REGEXP_PUNCT_CONNECTOR:
; 3042 : case XML_REGEXP_PUNCT_DASH:
; 3043 : case XML_REGEXP_PUNCT_OPEN:
; 3044 : case XML_REGEXP_PUNCT_CLOSE:
; 3045 : case XML_REGEXP_PUNCT_INITQUOTE:
; 3046 : case XML_REGEXP_PUNCT_FINQUOTE:
; 3047 : case XML_REGEXP_PUNCT_OTHERS:
; 3048 : case XML_REGEXP_SEPAR:
; 3049 : case XML_REGEXP_SEPAR_SPACE:
; 3050 : case XML_REGEXP_SEPAR_LINE:
; 3051 : case XML_REGEXP_SEPAR_PARA:
; 3052 : case XML_REGEXP_SYMBOL:
; 3053 : case XML_REGEXP_SYMBOL_MATH:
; 3054 : case XML_REGEXP_SYMBOL_CURRENCY:
; 3055 : case XML_REGEXP_SYMBOL_MODIFIER:
; 3056 : case XML_REGEXP_SYMBOL_OTHERS:
; 3057 : case XML_REGEXP_OTHER:
; 3058 : case XML_REGEXP_OTHER_CONTROL:
; 3059 : case XML_REGEXP_OTHER_FORMAT:
; 3060 : case XML_REGEXP_OTHER_PRIVATE:
; 3061 : case XML_REGEXP_OTHER_NA:
; 3062 : case XML_REGEXP_BLOCK_NAME:
; 3063 : ret = xmlRegCheckCharacterRange(atom->type, codepoint, 0, 0, 0,
push DWORD PTR [ecx+20]
push 0
push 0
push 0
push ebx
push esi
call _xmlRegCheckCharacterRange
; 3064 : (const xmlChar *)atom->valuep);
; 3065 : if (atom->neg)
mov ecx, DWORD PTR _atom$[ebp]
add esp, 24 ; 00000018H
mov edx, eax
cmp DWORD PTR [ecx+28], 0
je SHORT $LN22@xmlRegChec
; 3066 : ret = !ret;
xor ecx, ecx
test edx, edx
sete cl
mov edx, ecx
$LN22@xmlRegChec:
; 3067 : break;
; 3068 : }
; 3069 : return(ret);
pop esi
mov eax, edx
; 3070 : }
pop ebx
mov esp, ebp
pop ebp
ret 0
npad 2
$LN44@xmlRegChec:
DD $LN8@xmlRegChec
DD $LN10@xmlRegChec
DD $LN11@xmlRegChec
DD $LN20@xmlRegChec
DD $LN21@xmlRegChec
DD $LN22@xmlRegChec
$LN41@xmlRegChec:
DB 0
DB 1
DB 2
DB 0
DB 3
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 5
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
DB 4
_xmlRegCheckCharacter ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegStrEqualWildcard
_TEXT SEGMENT
_expStr$ = 8 ; size = 4
_valStr$ = 12 ; size = 4
_xmlRegStrEqualWildcard PROC ; COMDAT
; 3651 : xmlRegStrEqualWildcard(const xmlChar *expStr, const xmlChar *valStr) {
push ebp
mov ebp, esp
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _expStr$[ebp]
mov eax, DWORD PTR _valStr$[ebp]
cmp esi, eax
je SHORT $LN16@xmlRegStrE
; 3652 : if (expStr == valStr) return(1);
; 3653 : if (expStr == NULL) return(0);
test esi, esi
je SHORT $LN31@xmlRegStrE
; 3654 : if (valStr == NULL) return(0);
test eax, eax
je SHORT $LN31@xmlRegStrE
mov bl, BYTE PTR [eax]
$LL4@xmlRegStrE:
; 3655 : do {
; 3656 : /*
; 3657 : * Eval if we have a wildcard for the current item.
; 3658 : */
; 3659 : if (*expStr != *valStr) {
mov cl, BYTE PTR [esi]
cmp cl, bl
je SHORT $LN14@xmlRegStrE
; 3660 : /* if one of them starts with a wildcard make valStr be it */
; 3661 : if (*valStr == '*') {
; 3662 : const xmlChar *tmp;
; 3663 :
; 3664 : tmp = valStr;
; 3665 : valStr = expStr;
; 3666 : expStr = tmp;
; 3667 : }
; 3668 : if ((*valStr != 0) && (*expStr != 0) && (*expStr++ == '*')) {
cmp bl, 42 ; 0000002aH
movzx edx, cl
movzx ecx, bl
mov edi, eax
cmovne edx, ecx
cmovne edi, esi
test dl, dl
je SHORT $LN31@xmlRegStrE
mov cl, BYTE PTR [edi]
test cl, cl
je SHORT $LN31@xmlRegStrE
cmp cl, 42 ; 0000002aH
jne SHORT $LN31@xmlRegStrE
cmp bl, cl
cmovne esi, eax
mov eax, esi
$LL7@xmlRegStrE:
; 3669 : do {
; 3670 : if (*valStr == XML_REG_STRING_SEPARATOR)
cmp dl, 124 ; 0000007cH
je SHORT $LN2@xmlRegStrE
; 3671 : break;
; 3672 : valStr++;
; 3673 : } while (*valStr != 0);
mov cl, BYTE PTR [eax+1]
inc eax
mov dl, cl
test cl, cl
jne SHORT $LL7@xmlRegStrE
; 3674 : continue;
jmp SHORT $LN2@xmlRegStrE
$LN14@xmlRegStrE:
; 3675 : } else
; 3676 : return(0);
; 3677 : }
; 3678 : expStr++;
; 3679 : valStr++;
inc eax
mov edi, esi
$LN2@xmlRegStrE:
; 3680 : } while (*valStr != 0);
mov bl, BYTE PTR [eax]
lea esi, DWORD PTR [edi+1]
test bl, bl
jne SHORT $LL4@xmlRegStrE
; 3681 : if (*expStr != 0)
cmp BYTE PTR [esi], bl
je SHORT $LN16@xmlRegStrE
$LN31@xmlRegStrE:
pop edi
; 3682 : return (0);
; 3683 : else
; 3684 : return (1);
; 3685 : }
pop esi
xor eax, eax
pop ebx
pop ebp
ret 0
$LN16@xmlRegStrE:
pop edi
pop esi
mov eax, 1
pop ebx
pop ebp
ret 0
_xmlRegStrEqualWildcard ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegFreeAtom
_TEXT SEGMENT
_atom$ = 8 ; size = 4
_xmlRegFreeAtom PROC ; COMDAT
; 810 : xmlRegFreeAtom(xmlRegAtomPtr atom) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _atom$[ebp]
test esi, esi
je $LN1@xmlRegFree
; 811 : int i;
; 812 :
; 813 : if (atom == NULL)
; 814 : return;
; 815 :
; 816 : for (i = 0;i < atom->nbRanges;i++)
push edi
xor edi, edi
cmp DWORD PTR [esi+52], edi
jle SHORT $LN3@xmlRegFree
push ebx
$LL4@xmlRegFree:
; 817 : xmlRegFreeRange(atom->ranges[i]);
mov eax, DWORD PTR [esi+56]
mov ebx, DWORD PTR [eax+edi*4]
; 739 : if (range == NULL)
test ebx, ebx
je SHORT $LN2@xmlRegFree
; 740 : return;
; 741 :
; 742 : if (range->blockName != NULL)
mov eax, DWORD PTR [ebx+16]
test eax, eax
je SHORT $LN13@xmlRegFree
; 743 : xmlFree(range->blockName);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN13@xmlRegFree:
; 744 : xmlFree(range);
push ebx
call DWORD PTR _xmlFree
add esp, 4
$LN2@xmlRegFree:
; 811 : int i;
; 812 :
; 813 : if (atom == NULL)
; 814 : return;
; 815 :
; 816 : for (i = 0;i < atom->nbRanges;i++)
inc edi
cmp edi, DWORD PTR [esi+52]
jl SHORT $LL4@xmlRegFree
pop ebx
$LN3@xmlRegFree:
; 818 : if (atom->ranges != NULL)
mov eax, DWORD PTR [esi+56]
pop edi
test eax, eax
je SHORT $LN6@xmlRegFree
; 819 : xmlFree(atom->ranges);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN6@xmlRegFree:
; 820 : if ((atom->type == XML_REGEXP_STRING) && (atom->valuep != NULL))
mov eax, DWORD PTR [esi+4]
cmp eax, 5
jne SHORT $LN8@xmlRegFree
mov ecx, DWORD PTR [esi+20]
test ecx, ecx
je SHORT $LN7@xmlRegFree
; 821 : xmlFree(atom->valuep);
push ecx
call DWORD PTR _xmlFree
mov eax, DWORD PTR [esi+4]
add esp, 4
$LN7@xmlRegFree:
; 822 : if ((atom->type == XML_REGEXP_STRING) && (atom->valuep2 != NULL))
cmp eax, 5
jne SHORT $LN8@xmlRegFree
mov eax, DWORD PTR [esi+24]
test eax, eax
je SHORT $LN9@xmlRegFree
; 823 : xmlFree(atom->valuep2);
push eax
call DWORD PTR _xmlFree
mov eax, DWORD PTR [esi+4]
add esp, 4
$LN8@xmlRegFree:
; 824 : if ((atom->type == XML_REGEXP_BLOCK_NAME) && (atom->valuep != NULL))
cmp eax, 136 ; 00000088H
jne SHORT $LN9@xmlRegFree
mov eax, DWORD PTR [esi+20]
test eax, eax
je SHORT $LN9@xmlRegFree
; 825 : xmlFree(atom->valuep);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN9@xmlRegFree:
; 826 : xmlFree(atom);
push esi
call DWORD PTR _xmlFree
add esp, 4
$LN1@xmlRegFree:
pop esi
; 827 : }
pop ebp
ret 0
_xmlRegFreeAtom ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegFreeState
_TEXT SEGMENT
_state$ = 8 ; size = 4
_xmlRegFreeState PROC ; COMDAT
; 897 : xmlRegFreeState(xmlRegStatePtr state) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _state$[ebp]
test esi, esi
je SHORT $LN1@xmlRegFree
; 898 : if (state == NULL)
; 899 : return;
; 900 :
; 901 : if (state->trans != NULL)
mov eax, DWORD PTR [esi+28]
test eax, eax
je SHORT $LN3@xmlRegFree
; 902 : xmlFree(state->trans);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN3@xmlRegFree:
; 903 : if (state->transTo != NULL)
mov eax, DWORD PTR [esi+40]
test eax, eax
je SHORT $LN4@xmlRegFree
; 904 : xmlFree(state->transTo);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN4@xmlRegFree:
; 905 : xmlFree(state);
push esi
call DWORD PTR _xmlFree
add esp, 4
$LN1@xmlRegFree:
pop esi
; 906 : }
pop ebp
ret 0
_xmlRegFreeState ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFAParseRegExp
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_top$ = 12 ; size = 4
_xmlFAParseRegExp PROC ; COMDAT
; 5378 : xmlFAParseRegExp(xmlRegParserCtxtPtr ctxt, int top) {
push ebp
mov ebp, esp
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
push 0
push esi
mov ebx, DWORD PTR [esi+24]
mov DWORD PTR [esi+20], 0
call _xmlFAParseBranch
add esp, 8
cmp DWORD PTR _top$[ebp], 0
je SHORT $LN4@xmlFAParse
; 5379 : xmlRegStatePtr start, end;
; 5380 :
; 5381 : /* if not top start should have been generated by an epsilon trans */
; 5382 : start = ctxt->state;
; 5383 : ctxt->end = NULL;
; 5384 : xmlFAParseBranch(ctxt, NULL);
; 5385 : if (top) {
; 5386 : #ifdef DEBUG_REGEXP_GRAPH
; 5387 : printf("State %d is final\n", ctxt->state->no);
; 5388 : #endif
; 5389 : ctxt->state->type = XML_REGEXP_FINAL_STATE;
mov eax, DWORD PTR [esi+24]
mov DWORD PTR [eax], 2
$LN4@xmlFAParse:
; 5390 : }
; 5391 : if (CUR != '|') {
mov eax, DWORD PTR [esi+4]
mov edi, DWORD PTR [esi+24]
cmp BYTE PTR [eax], 124 ; 0000007cH
jne SHORT $LN15@xmlFAParse
$LL2@xmlFAParse:
; 5392 : ctxt->end = ctxt->state;
; 5393 : return;
; 5394 : }
; 5395 : end = ctxt->state;
; 5396 : while ((CUR == '|') && (ctxt->error == 0)) {
cmp DWORD PTR [esi+8], 0
jne SHORT $LN3@xmlFAParse
; 5397 : NEXT;
inc eax
mov DWORD PTR [esi+4], eax
; 5398 : if (CUR == 0) {
cmp BYTE PTR [eax], 0
je SHORT $LN10@xmlFAParse
; 5400 : return;
; 5401 : }
; 5402 : ctxt->state = start;
; 5403 : ctxt->end = NULL;
; 5404 : xmlFAParseBranch(ctxt, end);
push edi
push esi
mov DWORD PTR [esi+24], ebx
mov DWORD PTR [esi+20], 0
call _xmlFAParseBranch
mov eax, DWORD PTR [esi+4]
add esp, 8
cmp BYTE PTR [eax], 124 ; 0000007cH
je SHORT $LL2@xmlFAParse
$LN3@xmlFAParse:
; 5405 : }
; 5406 : if (!top) {
cmp DWORD PTR _top$[ebp], 0
jne SHORT $LN7@xmlFAParse
; 5407 : ctxt->state = end;
mov DWORD PTR [esi+24], edi
$LN15@xmlFAParse:
; 5408 : ctxt->end = end;
; 5409 : }
; 5410 : }
mov DWORD PTR [esi+20], edi
$LN7@xmlFAParse:
pop edi
pop esi
pop ebx
pop ebp
ret 0
$LN10@xmlFAParse:
; 5399 : ERROR("expecting a branch after |")
push OFFSET ??_C@_0BL@KAIMKABF@expecting?5a?5branch?5after?5?$HM@
push esi
mov DWORD PTR [esi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
pop edi
; 5408 : ctxt->end = end;
; 5409 : }
; 5410 : }
pop esi
pop ebx
pop ebp
ret 0
_xmlFAParseRegExp ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataIsDeterminist
_TEXT SEGMENT
_am$ = 8 ; size = 4
_xmlAutomataIsDeterminist PROC ; COMDAT
; 6322 : xmlAutomataIsDeterminist(xmlAutomataPtr am) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _am$[ebp]
test eax, eax
jne SHORT $LN2@xmlAutomat
; 6323 : int ret;
; 6324 :
; 6325 : if (am == NULL)
; 6326 : return(-1);
or eax, -1
; 6329 : return(ret);
; 6330 : }
pop ebp
ret 0
$LN2@xmlAutomat:
; 6327 :
; 6328 : ret = xmlFAComputesDeterminism(am);
mov DWORD PTR _am$[ebp], eax
; 6329 : return(ret);
; 6330 : }
pop ebp
; 6327 :
; 6328 : ret = xmlFAComputesDeterminism(am);
jmp _xmlFAComputesDeterminism
_xmlAutomataIsDeterminist ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataCompile
_TEXT SEGMENT
_am$ = 8 ; size = 4
_xmlAutomataCompile PROC ; COMDAT
; 6302 : xmlAutomataCompile(xmlAutomataPtr am) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _am$[ebp]
test esi, esi
je SHORT $LN3@xmlAutomat
; 6303 : xmlRegexpPtr ret;
; 6304 :
; 6305 : if ((am == NULL) || (am->error != 0)) return(NULL);
cmp DWORD PTR [esi+8], 0
jne SHORT $LN3@xmlAutomat
; 6306 : xmlFAEliminateEpsilonTransitions(am);
push esi
call _xmlFAEliminateEpsilonTransitions
; 6307 : /* xmlFAComputesDeterminism(am); */
; 6308 : ret = xmlRegEpxFromParse(am);
push esi
call _xmlRegEpxFromParse
add esp, 8
pop esi
; 6309 :
; 6310 : return(ret);
; 6311 : }
pop ebp
ret 0
$LN3@xmlAutomat:
; 6303 : xmlRegexpPtr ret;
; 6304 :
; 6305 : if ((am == NULL) || (am->error != 0)) return(NULL);
xor eax, eax
pop esi
; 6309 :
; 6310 : return(ret);
; 6311 : }
pop ebp
ret 0
_xmlAutomataCompile ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewCounter
_TEXT SEGMENT
_am$ = 8 ; size = 4
_min$ = 12 ; size = 4
_max$ = 16 ; size = 4
_xmlAutomataNewCounter PROC ; COMDAT
; 6230 : xmlAutomataNewCounter(xmlAutomataPtr am, int min, int max) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _am$[ebp]
test esi, esi
je SHORT $LN5@xmlAutomat
; 6231 : int ret;
; 6232 :
; 6233 : if (am == NULL)
; 6234 : return(-1);
; 6235 :
; 6236 : ret = xmlRegGetCounter(am);
push esi
call _xmlRegGetCounter
mov edi, eax
add esp, 4
; 6237 : if (ret < 0)
test edi, edi
js SHORT $LN5@xmlAutomat
; 6239 : am->counters[ret].min = min;
mov edx, DWORD PTR [esi+64]
mov ecx, DWORD PTR _min$[ebp]
; 6240 : am->counters[ret].max = max;
mov eax, DWORD PTR _max$[ebp]
mov DWORD PTR [edx+edi*8], ecx
mov ecx, DWORD PTR [esi+64]
mov DWORD PTR [ecx+edi*8+4], eax
; 6241 : return(ret);
mov eax, edi
pop edi
; 6242 : }
pop esi
pop ebp
ret 0
$LN5@xmlAutomat:
pop edi
; 6238 : return(-1);
or eax, -1
; 6242 : }
pop esi
pop ebp
ret 0
_xmlAutomataNewCounter ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewCounterTrans
_TEXT SEGMENT
_am$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_counter$ = 20 ; size = 4
_xmlAutomataNewCounterTrans PROC ; COMDAT
; 6283 : xmlAutomataStatePtr to, int counter) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _am$[ebp]
test esi, esi
je SHORT $LN3@xmlAutomat
; 6284 : if ((am == NULL) || (from == NULL) || (counter < 0))
mov eax, DWORD PTR _from$[ebp]
test eax, eax
je SHORT $LN3@xmlAutomat
mov ecx, DWORD PTR _counter$[ebp]
test ecx, ecx
js SHORT $LN3@xmlAutomat
; 6286 : xmlFAGenerateCountedTransition(am, from, to, counter);
push edi
mov edi, DWORD PTR _to$[ebp]
push ecx
push edi
push eax
push esi
call _xmlFAGenerateCountedTransition
add esp, 16 ; 00000010H
; 6287 : if (to == NULL)
test edi, edi
jne SHORT $LN4@xmlAutomat
; 6288 : return(am->state);
mov eax, DWORD PTR [esi+24]
pop edi
pop esi
; 6290 : }
pop ebp
ret 0
$LN4@xmlAutomat:
; 6289 : return(to);
mov eax, edi
pop edi
pop esi
; 6290 : }
pop ebp
ret 0
$LN3@xmlAutomat:
; 6285 : return(NULL);
xor eax, eax
pop esi
; 6290 : }
pop ebp
ret 0
_xmlAutomataNewCounterTrans ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewCountedTrans
_TEXT SEGMENT
_am$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_counter$ = 20 ; size = 4
_xmlAutomataNewCountedTrans PROC ; COMDAT
; 6259 : xmlAutomataStatePtr to, int counter) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _am$[ebp]
test esi, esi
je SHORT $LN3@xmlAutomat
; 6260 : if ((am == NULL) || (from == NULL) || (counter < 0))
mov eax, DWORD PTR _from$[ebp]
test eax, eax
je SHORT $LN3@xmlAutomat
mov ecx, DWORD PTR _counter$[ebp]
test ecx, ecx
js SHORT $LN3@xmlAutomat
; 6262 : xmlFAGenerateCountedEpsilonTransition(am, from, to, counter);
push edi
mov edi, DWORD PTR _to$[ebp]
push ecx
push edi
push eax
push esi
call _xmlFAGenerateCountedEpsilonTransition
add esp, 16 ; 00000010H
; 6263 : if (to == NULL)
test edi, edi
jne SHORT $LN4@xmlAutomat
; 6264 : return(am->state);
mov eax, DWORD PTR [esi+24]
pop edi
pop esi
; 6266 : }
pop ebp
ret 0
$LN4@xmlAutomat:
; 6265 : return(to);
mov eax, edi
pop edi
pop esi
; 6266 : }
pop ebp
ret 0
$LN3@xmlAutomat:
; 6261 : return(NULL);
xor eax, eax
pop esi
; 6266 : }
pop ebp
ret 0
_xmlAutomataNewCountedTrans ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewEpsilon
_TEXT SEGMENT
_am$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_xmlAutomataNewEpsilon PROC ; COMDAT
; 6185 : xmlAutomataStatePtr to) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _am$[ebp]
test esi, esi
je SHORT $LN3@xmlAutomat
; 6186 : if ((am == NULL) || (from == NULL))
mov eax, DWORD PTR _from$[ebp]
test eax, eax
je SHORT $LN3@xmlAutomat
; 6188 : xmlFAGenerateEpsilonTransition(am, from, to);
push edi
mov edi, DWORD PTR _to$[ebp]
push edi
push eax
push esi
call _xmlFAGenerateEpsilonTransition
add esp, 12 ; 0000000cH
; 6189 : if (to == NULL)
test edi, edi
jne SHORT $LN4@xmlAutomat
; 6190 : return(am->state);
mov eax, DWORD PTR [esi+24]
pop edi
pop esi
; 6192 : }
pop ebp
ret 0
$LN4@xmlAutomat:
; 6191 : return(to);
mov eax, edi
pop edi
pop esi
; 6192 : }
pop ebp
ret 0
$LN3@xmlAutomat:
; 6187 : return(NULL);
xor eax, eax
pop esi
; 6192 : }
pop ebp
ret 0
_xmlAutomataNewEpsilon ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewAllTrans
_TEXT SEGMENT
_am$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_lax$ = 20 ; size = 4
_xmlAutomataNewAllTrans PROC ; COMDAT
; 6210 : xmlAutomataStatePtr to, int lax) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _am$[ebp]
test esi, esi
je SHORT $LN3@xmlAutomat
; 6211 : if ((am == NULL) || (from == NULL))
cmp DWORD PTR _from$[ebp], 0
je SHORT $LN3@xmlAutomat
; 6213 : xmlFAGenerateAllTransition(am, from, to, lax);
push ebx
push edi
mov edi, DWORD PTR _to$[ebp]
mov ebx, edi
; 1467 : if (to == NULL) {
test edi, edi
jne SHORT $LN12@xmlAutomat
; 1468 : to = xmlRegNewState(ctxt);
push esi
call _xmlRegNewState
mov ebx, eax
; 1469 : xmlRegStatePush(ctxt, to);
push ebx
push esi
call _xmlRegStatePush
add esp, 12 ; 0000000cH
; 1470 : ctxt->state = to;
mov DWORD PTR [esi+24], ebx
$LN12@xmlAutomat:
; 6214 : if (to == NULL)
xor eax, eax
cmp DWORD PTR _lax$[ebp], eax
setne al
add eax, 1193046 ; 00123456H
push eax
push -1
push ebx
push 0
push DWORD PTR _from$[ebp]
push esi
call _xmlRegStateAddTrans
add esp, 24 ; 00000018H
test edi, edi
jne SHORT $LN4@xmlAutomat
; 6215 : return(am->state);
mov eax, DWORD PTR [esi+24]
pop edi
pop ebx
pop esi
; 6217 : }
pop ebp
ret 0
$LN4@xmlAutomat:
; 6216 : return(to);
mov eax, edi
pop edi
pop ebx
pop esi
; 6217 : }
pop ebp
ret 0
$LN3@xmlAutomat:
; 6212 : return(NULL);
xor eax, eax
pop esi
; 6217 : }
pop ebp
ret 0
_xmlAutomataNewAllTrans ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewOnceTrans2
_TEXT SEGMENT
$T1 = -4 ; size = 4
_counter$1$ = 8 ; size = 4
_atom$1$ = 8 ; size = 4
_am$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_token$ = 20 ; size = 4
_token2$ = 24 ; size = 4
_min$ = 28 ; size = 4
_max$ = 32 ; size = 4
_data$ = 36 ; size = 4
_xmlAutomataNewOnceTrans2 PROC ; COMDAT
; 6037 : int min, int max, void *data) {
push ebp
mov ebp, esp
push ecx
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov ebx, DWORD PTR _am$[ebp]
test ebx, ebx
je $LN3@xmlAutomat
; 6038 : xmlRegAtomPtr atom;
; 6039 : int counter;
; 6040 :
; 6041 : if ((am == NULL) || (from == NULL) || (token == NULL))
cmp DWORD PTR _from$[ebp], 0
je SHORT $LN3@xmlAutomat
mov esi, DWORD PTR _token$[ebp]
test esi, esi
je SHORT $LN3@xmlAutomat
; 6042 : return(NULL);
; 6043 : if (min < 1)
mov eax, DWORD PTR _min$[ebp]
cmp eax, 1
jl SHORT $LN3@xmlAutomat
; 6044 : return(NULL);
; 6045 : if ((max < min) || (max < 1))
mov ecx, DWORD PTR _max$[ebp]
cmp ecx, eax
jl SHORT $LN3@xmlAutomat
cmp ecx, 1
jl SHORT $LN3@xmlAutomat
; 6046 : return(NULL);
; 6047 : atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
push 5
push ebx
call _xmlRegNewAtom
mov edi, eax
add esp, 8
mov DWORD PTR _atom$1$[ebp], edi
; 6048 : if (atom == NULL)
test edi, edi
je SHORT $LN3@xmlAutomat
; 6049 : return(NULL);
; 6050 : if ((token2 == NULL) || (*token2 == 0)) {
mov eax, DWORD PTR _token2$[ebp]
test eax, eax
je SHORT $LN10@xmlAutomat
cmp BYTE PTR [eax], 0
je SHORT $LN10@xmlAutomat
; 6052 : } else {
; 6053 : int lenn, lenp;
; 6054 : xmlChar *str;
; 6055 :
; 6056 : lenn = strlen((char *) token2);
mov edi, eax
lea ecx, DWORD PTR [edi+1]
$LL14@xmlAutomat:
mov al, BYTE PTR [edi]
inc edi
test al, al
jne SHORT $LL14@xmlAutomat
sub edi, ecx
; 6057 : lenp = strlen((char *) token);
lea ecx, DWORD PTR [esi+1]
npad 2
$LL15@xmlAutomat:
mov al, BYTE PTR [esi]
inc esi
test al, al
jne SHORT $LL15@xmlAutomat
sub esi, ecx
; 6058 :
; 6059 : str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
lea eax, DWORD PTR [edi+2]
add eax, esi
push eax
call DWORD PTR _xmlMallocAtomic
add esp, 4
mov DWORD PTR $T1[ebp], eax
; 6060 : if (str == NULL) {
test eax, eax
jne SHORT $LN11@xmlAutomat
; 6061 : xmlRegFreeAtom(atom);
push DWORD PTR _atom$1$[ebp]
call _xmlRegFreeAtom
add esp, 4
$LN3@xmlAutomat:
; 6091 : }
pop edi
pop esi
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN11@xmlAutomat:
; 6062 : return(NULL);
; 6063 : }
; 6064 : memcpy(&str[0], token, lenp);
push esi
push DWORD PTR _token$[ebp]
push eax
call _memcpy
; 6065 : str[lenp] = '|';
add esi, DWORD PTR $T1[ebp]
; 6066 : memcpy(&str[lenp + 1], token2, lenn);
push edi
push DWORD PTR _token2$[ebp]
lea eax, DWORD PTR [esi+1]
mov BYTE PTR [esi], 124 ; 0000007cH
push eax
call _memcpy
; 6067 : str[lenn + lenp + 1] = 0;
; 6068 :
; 6069 : atom->valuep = str;
mov eax, DWORD PTR $T1[ebp]
add esp, 24 ; 00000018H
mov BYTE PTR [esi+edi+1], 0
mov edi, DWORD PTR _atom$1$[ebp]
jmp SHORT $LN9@xmlAutomat
$LN10@xmlAutomat:
; 6051 : atom->valuep = xmlStrdup(token);
push esi
call _xmlStrdup
add esp, 4
$LN9@xmlAutomat:
; 6070 : }
; 6071 : atom->data = data;
mov DWORD PTR [edi+20], eax
mov eax, DWORD PTR _data$[ebp]
mov DWORD PTR [edi+60], eax
; 6072 : atom->quant = XML_REGEXP_QUANT_ONCEONLY;
; 6073 : atom->min = min;
mov eax, DWORD PTR _min$[ebp]
mov DWORD PTR [edi+12], eax
; 6074 : atom->max = max;
mov eax, DWORD PTR _max$[ebp]
; 6075 : /*
; 6076 : * associate a counter to the transition.
; 6077 : */
; 6078 : counter = xmlRegGetCounter(am);
push ebx
mov DWORD PTR [edi+8], 6
mov DWORD PTR [edi+16], eax
call _xmlRegGetCounter
; 6079 : am->counters[counter].min = 1;
mov ecx, DWORD PTR [ebx+64]
add esp, 4
; 6080 : am->counters[counter].max = 1;
; 6081 :
; 6082 : /* xmlFAGenerateTransitions(am, from, to, atom); */
; 6083 : if (to == NULL) {
mov esi, DWORD PTR _to$[ebp]
mov DWORD PTR _counter$1$[ebp], eax
mov DWORD PTR [ecx+eax*8], 1
mov ecx, DWORD PTR [ebx+64]
mov DWORD PTR [ecx+eax*8+4], 1
test esi, esi
jne SHORT $LN12@xmlAutomat
; 6084 : to = xmlRegNewState(am);
push ebx
call _xmlRegNewState
mov esi, eax
; 6085 : xmlRegStatePush(am, to);
push esi
push ebx
call _xmlRegStatePush
mov eax, DWORD PTR _counter$1$[ebp]
add esp, 12 ; 0000000cH
$LN12@xmlAutomat:
; 6086 : }
; 6087 : xmlRegStateAddTrans(am, from, atom, to, counter, -1);
push -1
push eax
push esi
push edi
push DWORD PTR _from$[ebp]
push ebx
call _xmlRegStateAddTrans
; 6088 : xmlRegAtomPush(am, atom);
push edi
push ebx
call _xmlRegAtomPush
add esp, 32 ; 00000020H
; 6089 : am->state = to;
mov DWORD PTR [ebx+24], esi
; 6090 : return(to);
mov eax, esi
pop edi
; 6091 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
_xmlAutomataNewOnceTrans2 ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewOnceTrans
_TEXT SEGMENT
_counter$1$ = 8 ; size = 4
_am$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_token$ = 20 ; size = 4
_min$ = 24 ; size = 4
_max$ = 28 ; size = 4
_data$ = 32 ; size = 4
_xmlAutomataNewOnceTrans PROC ; COMDAT
; 6116 : int min, int max, void *data) {
push ebp
mov ebp, esp
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _am$[ebp]
test esi, esi
je $LN3@xmlAutomat
; 6117 : xmlRegAtomPtr atom;
; 6118 : int counter;
; 6119 :
; 6120 : if ((am == NULL) || (from == NULL) || (token == NULL))
cmp DWORD PTR _from$[ebp], 0
je $LN3@xmlAutomat
cmp DWORD PTR _token$[ebp], 0
je $LN3@xmlAutomat
; 6121 : return(NULL);
; 6122 : if (min < 1)
mov edi, DWORD PTR _min$[ebp]
cmp edi, 1
jl $LN3@xmlAutomat
; 6123 : return(NULL);
; 6124 : if ((max < min) || (max < 1))
mov eax, DWORD PTR _max$[ebp]
cmp eax, edi
jl $LN3@xmlAutomat
cmp eax, 1
jl $LN3@xmlAutomat
; 6125 : return(NULL);
; 6126 : atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
push 5
push esi
call _xmlRegNewAtom
mov ebx, eax
add esp, 8
; 6127 : if (atom == NULL)
test ebx, ebx
je $LN3@xmlAutomat
; 6128 : return(NULL);
; 6129 : atom->valuep = xmlStrdup(token);
push DWORD PTR _token$[ebp]
call _xmlStrdup
; 6130 : atom->data = data;
mov ecx, DWORD PTR _data$[ebp]
mov DWORD PTR [ebx+20], eax
; 6131 : atom->quant = XML_REGEXP_QUANT_ONCEONLY;
; 6132 : atom->min = min;
; 6133 : atom->max = max;
mov eax, DWORD PTR _max$[ebp]
; 6134 : /*
; 6135 : * associate a counter to the transition.
; 6136 : */
; 6137 : counter = xmlRegGetCounter(am);
push esi
mov DWORD PTR [ebx+60], ecx
mov DWORD PTR [ebx+8], 6
mov DWORD PTR [ebx+12], edi
mov DWORD PTR [ebx+16], eax
call _xmlRegGetCounter
; 6138 : am->counters[counter].min = 1;
mov ecx, DWORD PTR [esi+64]
add esp, 8
; 6139 : am->counters[counter].max = 1;
; 6140 :
; 6141 : /* xmlFAGenerateTransitions(am, from, to, atom); */
; 6142 : if (to == NULL) {
mov edi, DWORD PTR _to$[ebp]
mov DWORD PTR _counter$1$[ebp], eax
mov DWORD PTR [ecx+eax*8], 1
mov ecx, DWORD PTR [esi+64]
mov DWORD PTR [ecx+eax*8+4], 1
test edi, edi
jne SHORT $LN8@xmlAutomat
; 6143 : to = xmlRegNewState(am);
push esi
call _xmlRegNewState
mov edi, eax
; 6144 : xmlRegStatePush(am, to);
push edi
push esi
call _xmlRegStatePush
mov eax, DWORD PTR _counter$1$[ebp]
add esp, 12 ; 0000000cH
$LN8@xmlAutomat:
; 6145 : }
; 6146 : xmlRegStateAddTrans(am, from, atom, to, counter, -1);
push -1
push eax
push edi
push ebx
push DWORD PTR _from$[ebp]
push esi
call _xmlRegStateAddTrans
; 6147 : xmlRegAtomPush(am, atom);
push ebx
push esi
call _xmlRegAtomPush
add esp, 32 ; 00000020H
; 6148 : am->state = to;
mov DWORD PTR [esi+24], edi
; 6149 : return(to);
mov eax, edi
pop edi
; 6150 : }
pop esi
pop ebx
pop ebp
ret 0
$LN3@xmlAutomat:
pop edi
pop esi
xor eax, eax
pop ebx
pop ebp
ret 0
_xmlAutomataNewOnceTrans ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewCountTrans2
_TEXT SEGMENT
$T1 = -4 ; size = 4
_counter$1$ = 8 ; size = 4
_atom$1$ = 8 ; size = 4
_am$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_token$ = 20 ; size = 4
_token2$ = 24 ; size = 4
_min$ = 28 ; size = 4
_max$ = 32 ; size = 4
_data$ = 36 ; size = 4
_xmlAutomataNewCountTrans2 PROC ; COMDAT
; 5882 : int min, int max, void *data) {
push ebp
mov ebp, esp
push ecx
push ebx
push esi
mov esi, DWORD PTR _min$[ebp]
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push edi
call @__CheckForDebuggerJustMyCode@4
mov ebx, DWORD PTR _am$[ebp]
test ebx, ebx
je SHORT $LN3@xmlAutomat
; 5883 : xmlRegAtomPtr atom;
; 5884 : int counter;
; 5885 :
; 5886 : if ((am == NULL) || (from == NULL) || (token == NULL))
cmp DWORD PTR _from$[ebp], 0
je SHORT $LN3@xmlAutomat
cmp DWORD PTR _token$[ebp], 0
je SHORT $LN3@xmlAutomat
; 5887 : return(NULL);
; 5888 : if (min < 0)
test esi, esi
js SHORT $LN3@xmlAutomat
; 5889 : return(NULL);
; 5890 : if ((max < min) || (max < 1))
mov eax, DWORD PTR _max$[ebp]
cmp eax, esi
jl SHORT $LN3@xmlAutomat
cmp eax, 1
jl SHORT $LN3@xmlAutomat
; 5891 : return(NULL);
; 5892 : atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
push 5
push ebx
call _xmlRegNewAtom
mov edi, eax
add esp, 8
mov DWORD PTR _atom$1$[ebp], edi
; 5893 : if (atom == NULL)
test edi, edi
je SHORT $LN3@xmlAutomat
; 5894 : return(NULL);
; 5895 : if ((token2 == NULL) || (*token2 == 0)) {
mov eax, DWORD PTR _token2$[ebp]
test eax, eax
je $LN10@xmlAutomat
cmp BYTE PTR [eax], 0
je SHORT $LN10@xmlAutomat
; 5897 : } else {
; 5898 : int lenn, lenp;
; 5899 : xmlChar *str;
; 5900 :
; 5901 : lenn = strlen((char *) token2);
mov edi, eax
lea ecx, DWORD PTR [edi+1]
$LL19@xmlAutomat:
mov al, BYTE PTR [edi]
inc edi
test al, al
jne SHORT $LL19@xmlAutomat
; 5902 : lenp = strlen((char *) token);
mov esi, DWORD PTR _token$[ebp]
sub edi, ecx
lea ecx, DWORD PTR [esi+1]
npad 1
$LL20@xmlAutomat:
mov al, BYTE PTR [esi]
inc esi
test al, al
jne SHORT $LL20@xmlAutomat
sub esi, ecx
; 5903 :
; 5904 : str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
lea eax, DWORD PTR [edi+2]
add eax, esi
push eax
call DWORD PTR _xmlMallocAtomic
add esp, 4
mov DWORD PTR $T1[ebp], eax
; 5905 : if (str == NULL) {
test eax, eax
jne SHORT $LN11@xmlAutomat
; 5906 : xmlRegFreeAtom(atom);
push DWORD PTR _atom$1$[ebp]
call _xmlRegFreeAtom
add esp, 4
$LN3@xmlAutomat:
; 5946 : }
pop edi
pop esi
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN11@xmlAutomat:
; 5907 : return(NULL);
; 5908 : }
; 5909 : memcpy(&str[0], token, lenp);
push esi
push DWORD PTR _token$[ebp]
push eax
call _memcpy
; 5910 : str[lenp] = '|';
add esi, DWORD PTR $T1[ebp]
; 5911 : memcpy(&str[lenp + 1], token2, lenn);
push edi
push DWORD PTR _token2$[ebp]
lea eax, DWORD PTR [esi+1]
mov BYTE PTR [esi], 124 ; 0000007cH
push eax
call _memcpy
; 5912 : str[lenn + lenp + 1] = 0;
; 5913 :
; 5914 : atom->valuep = str;
mov eax, DWORD PTR $T1[ebp]
add esp, 24 ; 00000018H
mov BYTE PTR [esi+edi+1], 0
mov edi, DWORD PTR _atom$1$[ebp]
mov esi, DWORD PTR _min$[ebp]
jmp SHORT $LN9@xmlAutomat
$LN10@xmlAutomat:
; 5896 : atom->valuep = xmlStrdup(token);
push DWORD PTR _token$[ebp]
call _xmlStrdup
add esp, 4
$LN9@xmlAutomat:
; 5915 : }
; 5916 : atom->data = data;
mov DWORD PTR [edi+20], eax
; 5917 : if (min == 0)
; 5918 : atom->min = 1;
; 5919 : else
; 5920 : atom->min = min;
; 5921 : atom->max = max;
test esi, esi
mov eax, DWORD PTR _data$[ebp]
mov DWORD PTR [edi+60], eax
mov eax, 1
cmovne eax, esi
mov DWORD PTR [edi+12], eax
mov eax, DWORD PTR _max$[ebp]
; 5922 :
; 5923 : /*
; 5924 : * associate a counter to the transition.
; 5925 : */
; 5926 : counter = xmlRegGetCounter(am);
push ebx
mov DWORD PTR [edi+16], eax
call _xmlRegGetCounter
; 5927 : am->counters[counter].min = min;
mov ecx, DWORD PTR [ebx+64]
mov edx, eax
; 5928 : am->counters[counter].max = max;
mov eax, DWORD PTR _max$[ebp]
add esp, 4
mov DWORD PTR _counter$1$[ebp], edx
mov DWORD PTR [ecx+edx*8], esi
mov ecx, DWORD PTR [ebx+64]
; 5929 :
; 5930 : /* xmlFAGenerateTransitions(am, from, to, atom); */
; 5931 : if (to == NULL) {
mov esi, DWORD PTR _to$[ebp]
mov DWORD PTR [ecx+edx*8+4], eax
test esi, esi
jne SHORT $LN14@xmlAutomat
; 5932 : to = xmlRegNewState(am);
push ebx
call _xmlRegNewState
mov esi, eax
; 5933 : xmlRegStatePush(am, to);
push esi
push ebx
call _xmlRegStatePush
mov edx, DWORD PTR _counter$1$[ebp]
add esp, 12 ; 0000000cH
$LN14@xmlAutomat:
; 5934 : }
; 5935 : xmlRegStateAddTrans(am, from, atom, to, counter, -1);
push -1
push edx
push esi
push edi
push DWORD PTR _from$[ebp]
push ebx
call _xmlRegStateAddTrans
; 5936 : xmlRegAtomPush(am, atom);
push edi
push ebx
call _xmlRegAtomPush
add esp, 32 ; 00000020H
; 5937 : am->state = to;
mov DWORD PTR [ebx+24], esi
; 5938 :
; 5939 : if (to == NULL)
; 5940 : to = am->state;
; 5941 : if (to == NULL)
test esi, esi
je $LN3@xmlAutomat
; 5942 : return(NULL);
; 5943 : if (min == 0)
cmp DWORD PTR _min$[ebp], 0
jne SHORT $LN17@xmlAutomat
; 5944 : xmlFAGenerateEpsilonTransition(am, from, to);
push esi
push DWORD PTR _from$[ebp]
push ebx
call _xmlFAGenerateEpsilonTransition
add esp, 12 ; 0000000cH
$LN17@xmlAutomat:
; 5945 : return(to);
pop edi
mov eax, esi
; 5946 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
_xmlAutomataNewCountTrans2 ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewCountTrans
_TEXT SEGMENT
_counter$1$ = -4 ; size = 4
_atom$1$ = 8 ; size = 4
_am$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_token$ = 20 ; size = 4
_min$ = 24 ; size = 4
_max$ = 28 ; size = 4
_data$ = 32 ; size = 4
_xmlAutomataNewCountTrans PROC ; COMDAT
; 5968 : int min, int max, void *data) {
push ebp
mov ebp, esp
push ecx
push ebx
mov ebx, DWORD PTR _min$[ebp]
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push esi
push edi
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _am$[ebp]
test esi, esi
je $LN3@xmlAutomat
; 5969 : xmlRegAtomPtr atom;
; 5970 : int counter;
; 5971 :
; 5972 : if ((am == NULL) || (from == NULL) || (token == NULL))
cmp DWORD PTR _from$[ebp], 0
je $LN3@xmlAutomat
cmp DWORD PTR _token$[ebp], 0
je $LN3@xmlAutomat
; 5973 : return(NULL);
; 5974 : if (min < 0)
test ebx, ebx
js $LN3@xmlAutomat
; 5975 : return(NULL);
; 5976 : if ((max < min) || (max < 1))
mov eax, DWORD PTR _max$[ebp]
cmp eax, ebx
jl $LN3@xmlAutomat
cmp eax, 1
jl $LN3@xmlAutomat
; 5977 : return(NULL);
; 5978 : atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
push 5
push esi
call _xmlRegNewAtom
mov edi, eax
add esp, 8
mov DWORD PTR _atom$1$[ebp], edi
; 5979 : if (atom == NULL)
test edi, edi
je $LN3@xmlAutomat
; 5980 : return(NULL);
; 5981 : atom->valuep = xmlStrdup(token);
push DWORD PTR _token$[ebp]
call _xmlStrdup
; 5982 : atom->data = data;
mov ecx, DWORD PTR _data$[ebp]
; 5983 : if (min == 0)
; 5984 : atom->min = 1;
; 5985 : else
; 5986 : atom->min = min;
; 5987 : atom->max = max;
test ebx, ebx
mov DWORD PTR [edi+20], eax
mov eax, 1
cmovne eax, ebx
mov DWORD PTR [edi+60], ecx
mov DWORD PTR [edi+12], eax
mov eax, DWORD PTR _max$[ebp]
; 5988 :
; 5989 : /*
; 5990 : * associate a counter to the transition.
; 5991 : */
; 5992 : counter = xmlRegGetCounter(am);
push esi
mov DWORD PTR [edi+16], eax
call _xmlRegGetCounter
; 5993 : am->counters[counter].min = min;
mov ecx, DWORD PTR [esi+64]
mov edx, eax
; 5994 : am->counters[counter].max = max;
; 5995 :
; 5996 : /* xmlFAGenerateTransitions(am, from, to, atom); */
; 5997 : if (to == NULL) {
mov edi, DWORD PTR _to$[ebp]
add esp, 8
mov eax, DWORD PTR _max$[ebp]
mov DWORD PTR _counter$1$[ebp], edx
mov DWORD PTR [ecx+edx*8], ebx
mov ecx, DWORD PTR [esi+64]
mov DWORD PTR [ecx+edx*8+4], eax
test edi, edi
jne SHORT $LN10@xmlAutomat
; 5998 : to = xmlRegNewState(am);
push esi
call _xmlRegNewState
mov edi, eax
; 5999 : xmlRegStatePush(am, to);
push edi
push esi
call _xmlRegStatePush
mov edx, DWORD PTR _counter$1$[ebp]
add esp, 12 ; 0000000cH
$LN10@xmlAutomat:
; 6000 : }
; 6001 : xmlRegStateAddTrans(am, from, atom, to, counter, -1);
push -1
push edx
push edi
push DWORD PTR _atom$1$[ebp]
push DWORD PTR _from$[ebp]
push esi
call _xmlRegStateAddTrans
; 6002 : xmlRegAtomPush(am, atom);
push DWORD PTR _atom$1$[ebp]
push esi
call _xmlRegAtomPush
add esp, 32 ; 00000020H
; 6003 : am->state = to;
mov DWORD PTR [esi+24], edi
; 6004 :
; 6005 : if (to == NULL)
; 6006 : to = am->state;
; 6007 : if (to == NULL)
test edi, edi
je SHORT $LN3@xmlAutomat
; 6008 : return(NULL);
; 6009 : if (min == 0)
test ebx, ebx
jne SHORT $LN13@xmlAutomat
; 6010 : xmlFAGenerateEpsilonTransition(am, from, to);
push edi
push DWORD PTR _from$[ebp]
push esi
call _xmlFAGenerateEpsilonTransition
add esp, 12 ; 0000000cH
$LN13@xmlAutomat:
; 6011 : return(to);
mov eax, edi
pop edi
; 6012 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN3@xmlAutomat:
pop edi
pop esi
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
ret 0
_xmlAutomataNewCountTrans ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewNegTrans
_TEXT SEGMENT
_err_msg$ = -204 ; size = 200
_atom$1$ = -4 ; size = 4
$T1 = 8 ; size = 4
_am$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_token$ = 20 ; size = 4
_token2$ = 24 ; size = 4
_data$ = 28 ; size = 4
_xmlAutomataNewNegTrans PROC ; COMDAT
; 5814 : const xmlChar *token2, void *data) {
push ebp
mov ebp, esp
sub esp, 204 ; 000000ccH
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push ebx
push esi
push edi
call @__CheckForDebuggerJustMyCode@4
mov ebx, DWORD PTR _am$[ebp]
test ebx, ebx
je $LN3@xmlAutomat
; 5815 : xmlRegAtomPtr atom;
; 5816 : xmlChar err_msg[200];
; 5817 :
; 5818 : if ((am == NULL) || (from == NULL) || (token == NULL))
cmp DWORD PTR _from$[ebp], 0
je $LN3@xmlAutomat
mov edi, DWORD PTR _token$[ebp]
test edi, edi
je $LN3@xmlAutomat
; 5819 : return(NULL);
; 5820 : atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
push 5
push ebx
call _xmlRegNewAtom
mov esi, eax
add esp, 8
mov DWORD PTR _atom$1$[ebp], esi
; 5821 : if (atom == NULL)
test esi, esi
je $LN3@xmlAutomat
; 5822 : return(NULL);
; 5823 : atom->data = data;
mov eax, DWORD PTR _data$[ebp]
mov DWORD PTR [esi+60], eax
; 5824 : atom->neg = 1;
; 5825 : if ((token2 == NULL) || (*token2 == 0)) {
mov eax, DWORD PTR _token2$[ebp]
mov DWORD PTR [esi+28], 1
test eax, eax
je SHORT $LN7@xmlAutomat
cmp BYTE PTR [eax], 0
je SHORT $LN7@xmlAutomat
; 5827 : } else {
; 5828 : int lenn, lenp;
; 5829 : xmlChar *str;
; 5830 :
; 5831 : lenn = strlen((char *) token2);
mov edi, eax
lea ecx, DWORD PTR [edi+1]
npad 4
$LL13@xmlAutomat:
mov al, BYTE PTR [edi]
inc edi
test al, al
jne SHORT $LL13@xmlAutomat
; 5832 : lenp = strlen((char *) token);
mov esi, DWORD PTR _token$[ebp]
sub edi, ecx
lea ecx, DWORD PTR [esi+1]
npad 1
$LL14@xmlAutomat:
mov al, BYTE PTR [esi]
inc esi
test al, al
jne SHORT $LL14@xmlAutomat
sub esi, ecx
; 5833 :
; 5834 : str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
lea eax, DWORD PTR [edi+2]
add eax, esi
push eax
call DWORD PTR _xmlMallocAtomic
add esp, 4
mov DWORD PTR $T1[ebp], eax
; 5835 : if (str == NULL) {
test eax, eax
je $LN15@xmlAutomat
; 5836 : xmlRegFreeAtom(atom);
; 5837 : return(NULL);
; 5838 : }
; 5839 : memcpy(&str[0], token, lenp);
push esi
push DWORD PTR _token$[ebp]
push eax
call _memcpy
; 5840 : str[lenp] = '|';
add esi, DWORD PTR $T1[ebp]
; 5841 : memcpy(&str[lenp + 1], token2, lenn);
push edi
push DWORD PTR _token2$[ebp]
lea eax, DWORD PTR [esi+1]
mov BYTE PTR [esi], 124 ; 0000007cH
push eax
call _memcpy
; 5842 : str[lenn + lenp + 1] = 0;
; 5843 :
; 5844 : atom->valuep = str;
mov eax, DWORD PTR $T1[ebp]
add esp, 24 ; 00000018H
mov BYTE PTR [esi+edi+1], 0
mov esi, DWORD PTR _atom$1$[ebp]
jmp SHORT $LN6@xmlAutomat
$LN7@xmlAutomat:
; 5826 : atom->valuep = xmlStrdup(token);
push edi
call _xmlStrdup
add esp, 4
$LN6@xmlAutomat:
; 5845 : }
; 5846 : snprintf((char *) err_msg, 199, "not %s", (const char *) atom->valuep);
push eax
push OFFSET ??_C@_06NGEMONLJ@not?5?$CFs@
mov DWORD PTR [esi+20], eax
lea eax, DWORD PTR _err_msg$[ebp]
push 199 ; 000000c7H
push eax
call _snprintf
; 5847 : err_msg[199] = 0;
; 5848 : atom->valuep2 = xmlStrdup(err_msg);
lea eax, DWORD PTR _err_msg$[ebp]
mov BYTE PTR _err_msg$[ebp+199], 0
push eax
call _xmlStrdup
; 5849 :
; 5850 : if (xmlFAGenerateTransitions(am, from, to, atom) < 0) {
mov edi, DWORD PTR _to$[ebp]
push esi
push edi
push DWORD PTR _from$[ebp]
mov DWORD PTR [esi+24], eax
push ebx
call _xmlFAGenerateTransitions
add esp, 36 ; 00000024H
test eax, eax
js SHORT $LN12@xmlAutomat
; 5852 : return(NULL);
; 5853 : }
; 5854 : am->negs++;
inc DWORD PTR [ebx+72]
; 5855 : if (to == NULL)
test edi, edi
jne SHORT $LN10@xmlAutomat
; 5856 : return(am->state);
mov eax, DWORD PTR [ebx+24]
pop edi
; 5858 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN15@xmlAutomat:
; 5835 : if (str == NULL) {
mov esi, DWORD PTR _atom$1$[ebp]
$LN12@xmlAutomat:
; 5851 : xmlRegFreeAtom(atom);
push esi
call _xmlRegFreeAtom
add esp, 4
$LN3@xmlAutomat:
; 5858 : }
pop edi
pop esi
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN10@xmlAutomat:
; 5857 : return(to);
mov eax, edi
pop edi
; 5858 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
_xmlAutomataNewNegTrans ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewTransition2
_TEXT SEGMENT
$T1 = -4 ; size = 4
_am$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_token$ = 20 ; size = 4
_token2$ = 24 ; size = 4
_data$ = 28 ; size = 4
_xmlAutomataNewTransition2 PROC ; COMDAT
; 5754 : const xmlChar *token2, void *data) {
push ebp
mov ebp, esp
push ecx
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR _am$[ebp]
test edi, edi
je $LN3@xmlAutomat
; 5755 : xmlRegAtomPtr atom;
; 5756 :
; 5757 : if ((am == NULL) || (from == NULL) || (token == NULL))
cmp DWORD PTR _from$[ebp], 0
je $LN3@xmlAutomat
mov esi, DWORD PTR _token$[ebp]
test esi, esi
je $LN3@xmlAutomat
; 5758 : return(NULL);
; 5759 : atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
push 5
push edi
call _xmlRegNewAtom
mov ebx, eax
add esp, 8
; 5760 : if (atom == NULL)
test ebx, ebx
je $LN3@xmlAutomat
; 5761 : return(NULL);
; 5762 : atom->data = data;
mov eax, DWORD PTR _data$[ebp]
mov DWORD PTR [ebx+60], eax
; 5763 : if ((token2 == NULL) || (*token2 == 0)) {
mov eax, DWORD PTR _token2$[ebp]
test eax, eax
je SHORT $LN7@xmlAutomat
cmp BYTE PTR [eax], 0
je SHORT $LN7@xmlAutomat
; 5765 : } else {
; 5766 : int lenn, lenp;
; 5767 : xmlChar *str;
; 5768 :
; 5769 : lenn = strlen((char *) token2);
mov edi, eax
lea ecx, DWORD PTR [edi+1]
npad 3
$LL13@xmlAutomat:
mov al, BYTE PTR [edi]
inc edi
test al, al
jne SHORT $LL13@xmlAutomat
sub edi, ecx
; 5770 : lenp = strlen((char *) token);
lea ecx, DWORD PTR [esi+1]
npad 4
$LL14@xmlAutomat:
mov al, BYTE PTR [esi]
inc esi
test al, al
jne SHORT $LL14@xmlAutomat
sub esi, ecx
; 5771 :
; 5772 : str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
lea eax, DWORD PTR [edi+2]
add eax, esi
push eax
call DWORD PTR _xmlMallocAtomic
add esp, 4
mov DWORD PTR $T1[ebp], eax
; 5773 : if (str == NULL) {
test eax, eax
je SHORT $LN12@xmlAutomat
; 5774 : xmlRegFreeAtom(atom);
; 5775 : return(NULL);
; 5776 : }
; 5777 : memcpy(&str[0], token, lenp);
push esi
push DWORD PTR _token$[ebp]
push eax
call _memcpy
; 5778 : str[lenp] = '|';
add esi, DWORD PTR $T1[ebp]
; 5779 : memcpy(&str[lenp + 1], token2, lenn);
push edi
push DWORD PTR _token2$[ebp]
lea eax, DWORD PTR [esi+1]
mov BYTE PTR [esi], 124 ; 0000007cH
push eax
call _memcpy
; 5780 : str[lenn + lenp + 1] = 0;
; 5781 :
; 5782 : atom->valuep = str;
mov eax, DWORD PTR $T1[ebp]
add esp, 24 ; 00000018H
mov BYTE PTR [esi+edi+1], 0
mov edi, DWORD PTR _am$[ebp]
jmp SHORT $LN6@xmlAutomat
$LN7@xmlAutomat:
; 5764 : atom->valuep = xmlStrdup(token);
push esi
call _xmlStrdup
add esp, 4
$LN6@xmlAutomat:
; 5783 : }
; 5784 :
; 5785 : if (xmlFAGenerateTransitions(am, from, to, atom) < 0) {
mov esi, DWORD PTR _to$[ebp]
push ebx
push esi
push DWORD PTR _from$[ebp]
mov DWORD PTR [ebx+20], eax
push edi
call _xmlFAGenerateTransitions
add esp, 16 ; 00000010H
test eax, eax
jns SHORT $LN9@xmlAutomat
$LN12@xmlAutomat:
; 5786 : xmlRegFreeAtom(atom);
push ebx
call _xmlRegFreeAtom
add esp, 4
$LN3@xmlAutomat:
; 5792 : }
pop edi
pop esi
xor eax, eax
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN9@xmlAutomat:
; 5787 : return(NULL);
; 5788 : }
; 5789 : if (to == NULL)
test esi, esi
jne SHORT $LN10@xmlAutomat
; 5790 : return(am->state);
mov eax, DWORD PTR [edi+24]
pop edi
; 5792 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
$LN10@xmlAutomat:
pop edi
; 5791 : return(to);
mov eax, esi
; 5792 : }
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 0
_xmlAutomataNewTransition2 ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewTransition
_TEXT SEGMENT
_am$ = 8 ; size = 4
_from$ = 12 ; size = 4
_to$ = 16 ; size = 4
_token$ = 20 ; size = 4
_data$ = 24 ; size = 4
_xmlAutomataNewTransition PROC ; COMDAT
; 5716 : void *data) {
push ebp
mov ebp, esp
push ebx
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _am$[ebp]
test esi, esi
je SHORT $LN3@xmlAutomat
; 5717 : xmlRegAtomPtr atom;
; 5718 :
; 5719 : if ((am == NULL) || (from == NULL) || (token == NULL))
cmp DWORD PTR _from$[ebp], 0
je SHORT $LN3@xmlAutomat
mov ebx, DWORD PTR _token$[ebp]
test ebx, ebx
je SHORT $LN3@xmlAutomat
; 5720 : return(NULL);
; 5721 : atom = xmlRegNewAtom(am, XML_REGEXP_STRING);
push 5
push esi
call _xmlRegNewAtom
mov edi, eax
add esp, 8
; 5722 : if (atom == NULL)
test edi, edi
je SHORT $LN3@xmlAutomat
; 5723 : return(NULL);
; 5724 : atom->data = data;
mov eax, DWORD PTR _data$[ebp]
; 5725 : atom->valuep = xmlStrdup(token);
push ebx
mov DWORD PTR [edi+60], eax
call _xmlStrdup
; 5726 :
; 5727 : if (xmlFAGenerateTransitions(am, from, to, atom) < 0) {
mov ebx, DWORD PTR _to$[ebp]
push edi
push ebx
push DWORD PTR _from$[ebp]
mov DWORD PTR [edi+20], eax
push esi
call _xmlFAGenerateTransitions
add esp, 20 ; 00000014H
test eax, eax
jns SHORT $LN5@xmlAutomat
; 5728 : xmlRegFreeAtom(atom);
push edi
call _xmlRegFreeAtom
add esp, 4
$LN3@xmlAutomat:
; 5733 : return(to);
; 5734 : }
pop edi
pop esi
xor eax, eax
pop ebx
pop ebp
ret 0
$LN5@xmlAutomat:
; 5729 : return(NULL);
; 5730 : }
; 5731 : if (to == NULL)
test ebx, ebx
jne SHORT $LN6@xmlAutomat
; 5732 : return(am->state);
mov eax, DWORD PTR [esi+24]
pop edi
; 5733 : return(to);
; 5734 : }
pop esi
pop ebx
pop ebp
ret 0
$LN6@xmlAutomat:
pop edi
pop esi
mov eax, ebx
pop ebx
pop ebp
ret 0
_xmlAutomataNewTransition ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataNewState
_TEXT SEGMENT
_am$ = 8 ; size = 4
_xmlAutomataNewState PROC ; COMDAT
; 6161 : xmlAutomataNewState(xmlAutomataPtr am) {
push ebp
mov ebp, esp
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR _am$[ebp]
test edi, edi
jne SHORT $LN2@xmlAutomat
; 6162 : xmlAutomataStatePtr to;
; 6163 :
; 6164 : if (am == NULL)
; 6165 : return(NULL);
xor eax, eax
pop edi
; 6169 : }
pop ebp
ret 0
$LN2@xmlAutomat:
push esi
; 6166 : to = xmlRegNewState(am);
push edi
call _xmlRegNewState
mov esi, eax
; 6167 : xmlRegStatePush(am, to);
push esi
push edi
call _xmlRegStatePush
add esp, 12 ; 0000000cH
; 6168 : return(to);
mov eax, esi
pop esi
pop edi
; 6169 : }
pop ebp
ret 0
_xmlAutomataNewState ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataSetFinalState
_TEXT SEGMENT
_am$ = 8 ; size = 4
_state$ = 12 ; size = 4
_xmlAutomataSetFinalState PROC ; COMDAT
; 5692 : xmlAutomataSetFinalState(xmlAutomataPtr am, xmlAutomataStatePtr state) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
cmp DWORD PTR _am$[ebp], 0
je SHORT $LN3@xmlAutomat
; 5693 : if ((am == NULL) || (state == NULL))
mov eax, DWORD PTR _state$[ebp]
test eax, eax
je SHORT $LN3@xmlAutomat
; 5695 : state->type = XML_REGEXP_FINAL_STATE;
mov DWORD PTR [eax], 2
; 5696 : return(0);
xor eax, eax
; 5697 : }
pop ebp
ret 0
$LN3@xmlAutomat:
; 5694 : return(-1);
or eax, -1
; 5697 : }
pop ebp
ret 0
_xmlAutomataSetFinalState ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlAutomataGetInitState
_TEXT SEGMENT
_am$ = 8 ; size = 4
_xmlAutomataGetInitState PROC ; COMDAT
; 5676 : xmlAutomataGetInitState(xmlAutomataPtr am) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _am$[ebp]
test eax, eax
jne SHORT $LN2@xmlAutomat
; 5680 : }
pop ebp
ret 0
$LN2@xmlAutomat:
; 5677 : if (am == NULL)
; 5678 : return(NULL);
; 5679 : return(am->start);
mov eax, DWORD PTR [eax+16]
; 5680 : }
pop ebp
ret 0
_xmlAutomataGetInitState ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlFreeAutomata
_TEXT SEGMENT
_am$ = 8 ; size = 4
_xmlFreeAutomata PROC ; COMDAT
; 5647 : xmlFreeAutomata(xmlAutomataPtr am) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _am$[ebp]
test eax, eax
je SHORT $LN1@xmlFreeAut
; 5648 : if (am == NULL)
; 5649 : return;
; 5650 : xmlRegFreeParserCtxt(am);
mov DWORD PTR _am$[ebp], eax
; 5651 : }
pop ebp
; 5648 : if (am == NULL)
; 5649 : return;
; 5650 : xmlRegFreeParserCtxt(am);
jmp _xmlRegFreeParserCtxt
$LN1@xmlFreeAut:
; 5651 : }
pop ebp
ret 0
_xmlFreeAutomata ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlNewAutomata
_TEXT SEGMENT
_xmlNewAutomata PROC ; COMDAT
; 5615 : xmlNewAutomata(void) {
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
; 688 : ret = (xmlRegParserCtxtPtr) xmlMalloc(sizeof(xmlRegParserCtxt));
push 80 ; 00000050H
call DWORD PTR _xmlMalloc
mov esi, eax
add esp, 4
; 689 : if (ret == NULL)
test esi, esi
je $LN16@xmlNewAuto
; 690 : return(NULL);
; 691 : memset(ret, 0, sizeof(xmlRegParserCtxt));
mov DWORD PTR [esi], 0
mov DWORD PTR [esi+16], 0
mov DWORD PTR [esi+24], 0
mov DWORD PTR [esi+28], 0
mov DWORD PTR [esi+32], 0
mov DWORD PTR [esi+36], 0
mov DWORD PTR [esi+40], 0
mov DWORD PTR [esi+44], 0
mov DWORD PTR [esi+48], 0
mov DWORD PTR [esi+52], 0
mov DWORD PTR [esi+56], 0
mov DWORD PTR [esi+60], 0
mov DWORD PTR [esi+64], 0
mov DWORD PTR [esi+76], 0
; 692 : if (string != NULL)
; 693 : ret->string = xmlStrdup(string);
; 694 : ret->cur = ret->string;
mov DWORD PTR [esi+4], 0
; 695 : ret->neg = 0;
mov DWORD PTR [esi+12], 0
; 696 : ret->negs = 0;
mov DWORD PTR [esi+72], 0
; 697 : ret->error = 0;
mov DWORD PTR [esi+8], 0
; 698 : ret->determinist = -1;
mov DWORD PTR [esi+68], -1
; 5616 : xmlAutomataPtr ctxt;
; 5617 :
; 5618 : ctxt = xmlRegNewParserCtxt(NULL);
; 5619 : if (ctxt == NULL)
; 5620 : return(NULL);
; 5621 :
; 5622 : /* initialize the parser */
; 5623 : ctxt->end = NULL;
; 5624 : ctxt->start = ctxt->state = xmlRegNewState(ctxt);
push esi
mov DWORD PTR [esi+20], 0
call _xmlRegNewState
add esp, 4
mov DWORD PTR [esi+24], eax
mov DWORD PTR [esi+16], eax
; 5625 : if (ctxt->start == NULL) {
test eax, eax
jne SHORT $LN3@xmlNewAuto
; 5650 : xmlRegFreeParserCtxt(am);
push esi
call _xmlRegFreeParserCtxt
add esp, 4
$LN16@xmlNewAuto:
; 5638 : }
xor eax, eax
pop esi
ret 0
$LN3@xmlNewAuto:
; 5626 : xmlFreeAutomata(ctxt);
; 5627 : return(NULL);
; 5628 : }
; 5629 : ctxt->start->type = XML_REGEXP_START_STATE;
mov DWORD PTR [eax], 1
; 5630 : if (xmlRegStatePush(ctxt, ctxt->start) < 0) {
push DWORD PTR [esi+16]
push esi
call _xmlRegStatePush
add esp, 8
test eax, eax
jns SHORT $LN4@xmlNewAuto
; 5631 : xmlRegFreeState(ctxt->start);
push DWORD PTR [esi+16]
call _xmlRegFreeState
; 5650 : xmlRegFreeParserCtxt(am);
push esi
call _xmlRegFreeParserCtxt
add esp, 8
; 5638 : }
xor eax, eax
pop esi
ret 0
$LN4@xmlNewAuto:
; 5632 : xmlFreeAutomata(ctxt);
; 5633 : return(NULL);
; 5634 : }
; 5635 : ctxt->flags = 0;
mov DWORD PTR [esi+76], 0
; 5636 :
; 5637 : return(ctxt);
mov eax, esi
pop esi
; 5638 : }
ret 0
_xmlNewAutomata ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpDump
_TEXT SEGMENT
_buf$ = 8 ; size = 4
_expr$ = 12 ; size = 4
_xmlExpDump PROC ; COMDAT
; 8126 : xmlExpDump(xmlBufferPtr buf, xmlExpNodePtr expr) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov ecx, DWORD PTR _buf$[ebp]
test ecx, ecx
je SHORT $LN3@xmlExpDump
; 8127 : if ((buf == NULL) || (expr == NULL))
mov eax, DWORD PTR _expr$[ebp]
test eax, eax
je SHORT $LN3@xmlExpDump
; 8128 : return;
; 8129 : xmlExpDumpInt(buf, expr, 0);
push 0
push eax
push ecx
call _xmlExpDumpInt
add esp, 12 ; 0000000cH
$LN3@xmlExpDump:
; 8130 : }
pop ebp
ret 0
_xmlExpDump ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpSubsume
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_exp$ = 12 ; size = 4
_sub$ = 16 ; size = 4
_xmlExpSubsume PROC ; COMDAT
; 7814 : xmlExpSubsume(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
push ebp
mov ebp, esp
push ebx
mov ebx, DWORD PTR _ctxt$[ebp]
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push esi
push edi
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR _exp$[ebp]
test edi, edi
je SHORT $LN3@xmlExpSubs
; 7815 : xmlExpNodePtr tmp;
; 7816 :
; 7817 : if ((exp == NULL) || (ctxt == NULL) || (sub == NULL))
test ebx, ebx
je SHORT $LN3@xmlExpSubs
mov esi, DWORD PTR _sub$[ebp]
test esi, esi
je SHORT $LN3@xmlExpSubs
; 7818 : return(-1);
; 7819 :
; 7820 : /*
; 7821 : * TODO: speedup by checking the language of sub is a subset of the
; 7822 : * language of exp
; 7823 : */
; 7824 : /*
; 7825 : * O(1) speedups
; 7826 : */
; 7827 : if (IS_NILLABLE(sub) && (!IS_NILLABLE(exp))) {
test BYTE PTR [esi+1], 1
je SHORT $LN4@xmlExpSubs
test BYTE PTR [edi+1], 1
je SHORT $LN12@xmlExpSubs
$LN4@xmlExpSubs:
; 7828 : #ifdef DEBUG_DERIV
; 7829 : printf("Sub nillable and not exp : can't subsume\n");
; 7830 : #endif
; 7831 : return(0);
; 7832 : }
; 7833 : if (xmlExpCheckCard(exp, sub) == 0) {
push esi
push edi
call _xmlExpCheckCard
add esp, 8
test eax, eax
je SHORT $LN12@xmlExpSubs
; 7834 : #ifdef DEBUG_DERIV
; 7835 : printf("sub generate longuer sequances than exp : can't subsume\n");
; 7836 : #endif
; 7837 : return(0);
; 7838 : }
; 7839 : tmp = xmlExpExpDeriveInt(ctxt, exp, sub);
push esi
push edi
push ebx
call _xmlExpExpDeriveInt
add esp, 12 ; 0000000cH
; 7840 : #ifdef DEBUG_DERIV
; 7841 : printf("Result derivation :\n");
; 7842 : PRINT_EXP(tmp);
; 7843 : #endif
; 7844 : if (tmp == NULL)
test eax, eax
je SHORT $LN3@xmlExpSubs
; 7845 : return(-1);
; 7846 : if (tmp == forbiddenExp)
cmp eax, DWORD PTR _forbiddenExp
je SHORT $LN12@xmlExpSubs
; 7847 : return(0);
; 7848 : if (tmp == emptyExp)
cmp eax, DWORD PTR _emptyExp
je SHORT $LN11@xmlExpSubs
; 7849 : return(1);
; 7850 : if ((tmp != NULL) && (IS_NILLABLE(tmp))) {
mov bl, BYTE PTR [eax+1]
push eax
push DWORD PTR _ctxt$[ebp]
call _xmlExpFree
add esp, 8
test bl, 1
je SHORT $LN12@xmlExpSubs
$LN11@xmlExpSubs:
pop edi
; 7851 : xmlExpFree(ctxt, tmp);
; 7852 : return(1);
; 7853 : }
; 7854 : xmlExpFree(ctxt, tmp);
; 7855 : return(0);
; 7856 : }
pop esi
mov eax, 1
pop ebx
pop ebp
ret 0
$LN12@xmlExpSubs:
pop edi
pop esi
xor eax, eax
pop ebx
pop ebp
ret 0
$LN3@xmlExpSubs:
pop edi
pop esi
or eax, -1
pop ebx
pop ebp
ret 0
_xmlExpSubsume ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpExpDerive
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_exp$ = 12 ; size = 4
_sub$ = 16 ; size = 4
_xmlExpExpDerive PROC ; COMDAT
; 7780 : xmlExpExpDerive(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp, xmlExpNodePtr sub) {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _exp$[ebp]
test esi, esi
je SHORT $LN3@xmlExpExpD
; 7781 : if ((exp == NULL) || (ctxt == NULL) || (sub == NULL))
cmp DWORD PTR _ctxt$[ebp], 0
je SHORT $LN3@xmlExpExpD
mov edi, DWORD PTR _sub$[ebp]
test edi, edi
je SHORT $LN3@xmlExpExpD
; 7783 :
; 7784 : /*
; 7785 : * O(1) speedups
; 7786 : */
; 7787 : if (IS_NILLABLE(sub) && (!IS_NILLABLE(exp))) {
test BYTE PTR [edi+1], 1
je SHORT $LN4@xmlExpExpD
test BYTE PTR [esi+1], 1
je SHORT $LN7@xmlExpExpD
$LN4@xmlExpExpD:
; 7788 : #ifdef DEBUG_DERIV
; 7789 : printf("Sub nillable and not exp : can't subsume\n");
; 7790 : #endif
; 7791 : return(forbiddenExp);
; 7792 : }
; 7793 : if (xmlExpCheckCard(exp, sub) == 0) {
push edi
push esi
call _xmlExpCheckCard
add esp, 8
test eax, eax
jne SHORT $LN5@xmlExpExpD
$LN7@xmlExpExpD:
; 7794 : #ifdef DEBUG_DERIV
; 7795 : printf("sub generate longuer sequances than exp : can't subsume\n");
; 7796 : #endif
; 7797 : return(forbiddenExp);
mov eax, DWORD PTR _forbiddenExp
pop edi
; 7800 : }
pop esi
pop ebp
ret 0
$LN5@xmlExpExpD:
; 7798 : }
; 7799 : return(xmlExpExpDeriveInt(ctxt, exp, sub));
push edi
push esi
push DWORD PTR _ctxt$[ebp]
call _xmlExpExpDeriveInt
add esp, 12 ; 0000000cH
pop edi
; 7800 : }
pop esi
pop ebp
ret 0
$LN3@xmlExpExpD:
pop edi
; 7782 : return(NULL);
xor eax, eax
; 7800 : }
pop esi
pop ebp
ret 0
_xmlExpExpDerive ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpStringDerive
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_exp$ = 12 ; size = 4
_str$ = 16 ; size = 4
_len$ = 20 ; size = 4
_xmlExpStringDerive PROC ; COMDAT
; 7213 : const xmlChar *str, int len) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
cmp DWORD PTR _exp$[ebp], 0
je SHORT $LN3@xmlExpStri
; 7214 : const xmlChar *input;
; 7215 :
; 7216 : if ((exp == NULL) || (ctxt == NULL) || (str == NULL)) {
mov esi, DWORD PTR _ctxt$[ebp]
test esi, esi
je SHORT $LN3@xmlExpStri
mov eax, DWORD PTR _str$[ebp]
test eax, eax
je SHORT $LN3@xmlExpStri
; 7218 : }
; 7219 : /*
; 7220 : * check the string is in the dictionary, if yes use an interned
; 7221 : * copy, otherwise we know it's not an acceptable input
; 7222 : */
; 7223 : input = xmlDictExists(ctxt->dict, str, len);
push DWORD PTR _len$[ebp]
push eax
push DWORD PTR [esi]
call _xmlDictExists
add esp, 12 ; 0000000cH
; 7224 : if (input == NULL) {
test eax, eax
jne SHORT $LN4@xmlExpStri
; 7225 : return(forbiddenExp);
mov eax, DWORD PTR _forbiddenExp
pop esi
; 7228 : }
pop ebp
ret 0
$LN4@xmlExpStri:
; 7226 : }
; 7227 : return(xmlExpStringDeriveInt(ctxt, exp, input));
push eax
push DWORD PTR _exp$[ebp]
push esi
call _xmlExpStringDeriveInt
add esp, 12 ; 0000000cH
pop esi
; 7228 : }
pop ebp
ret 0
$LN3@xmlExpStri:
; 7217 : return(NULL);
xor eax, eax
pop esi
; 7228 : }
pop ebp
ret 0
_xmlExpStringDerive ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpGetStart
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_exp$ = 12 ; size = 4
_tokList$ = 16 ; size = 4
_len$ = 20 ; size = 4
_xmlExpGetStart PROC ; COMDAT
; 7068 : const xmlChar**tokList, int len) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov ecx, DWORD PTR _ctxt$[ebp]
test ecx, ecx
je SHORT $LN3@xmlExpGetS
; 7069 : if ((ctxt == NULL) || (exp == NULL) || (tokList == NULL) || (len <= 0))
mov eax, DWORD PTR _exp$[ebp]
test eax, eax
je SHORT $LN3@xmlExpGetS
mov edx, DWORD PTR _tokList$[ebp]
test edx, edx
je SHORT $LN3@xmlExpGetS
cmp DWORD PTR _len$[ebp], 0
jle SHORT $LN3@xmlExpGetS
; 7071 : return(xmlExpGetStartInt(ctxt, exp, tokList, len, 0));
push 0
push DWORD PTR _len$[ebp]
push edx
push eax
push ecx
call _xmlExpGetStartInt
add esp, 20 ; 00000014H
; 7072 : }
pop ebp
ret 0
$LN3@xmlExpGetS:
; 7070 : return(-1);
or eax, -1
; 7072 : }
pop ebp
ret 0
_xmlExpGetStart ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpGetLanguage
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_exp$ = 12 ; size = 4
_langList$ = 16 ; size = 4
_len$ = 20 ; size = 4
_xmlExpGetLanguage PROC ; COMDAT
; 7000 : const xmlChar**langList, int len) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov ecx, DWORD PTR _ctxt$[ebp]
test ecx, ecx
je SHORT $LN3@xmlExpGetL
; 7001 : if ((ctxt == NULL) || (exp == NULL) || (langList == NULL) || (len <= 0))
mov eax, DWORD PTR _exp$[ebp]
test eax, eax
je SHORT $LN3@xmlExpGetL
mov edx, DWORD PTR _langList$[ebp]
test edx, edx
je SHORT $LN3@xmlExpGetL
cmp DWORD PTR _len$[ebp], 0
jle SHORT $LN3@xmlExpGetL
; 7003 : return(xmlExpGetLanguageInt(ctxt, exp, langList, len, 0));
push 0
push DWORD PTR _len$[ebp]
push edx
push eax
push ecx
call _xmlExpGetLanguageInt
add esp, 20 ; 00000014H
; 7004 : }
pop ebp
ret 0
$LN3@xmlExpGetL:
; 7002 : return(-1);
or eax, -1
; 7004 : }
pop ebp
ret 0
_xmlExpGetLanguage ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpMaxToken
_TEXT SEGMENT
_expr$ = 8 ; size = 4
_xmlExpMaxToken PROC ; COMDAT
; 8141 : xmlExpMaxToken(xmlExpNodePtr expr) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _expr$[ebp]
test eax, eax
jne SHORT $LN2@xmlExpMaxT
; 8142 : if (expr == NULL)
; 8143 : return(-1);
or eax, -1
; 8145 : }
pop ebp
ret 0
$LN2@xmlExpMaxT:
; 8144 : return(expr->c_max);
mov eax, DWORD PTR [eax+8]
; 8145 : }
pop ebp
ret 0
_xmlExpMaxToken ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpIsNillable
_TEXT SEGMENT
_exp$ = 8 ; size = 4
_xmlExpIsNillable PROC ; COMDAT
; 7083 : xmlExpIsNillable(xmlExpNodePtr exp) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _exp$[ebp]
test eax, eax
jne SHORT $LN2@xmlExpIsNi
; 7084 : if (exp == NULL)
; 7085 : return(-1);
or eax, -1
; 7087 : }
pop ebp
ret 0
$LN2@xmlExpIsNi:
; 7086 : return(IS_NILLABLE(exp) != 0);
movzx eax, BYTE PTR [eax+1]
and eax, 1
; 7087 : }
pop ebp
ret 0
_xmlExpIsNillable ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpNewRange
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_subset$ = 12 ; size = 4
_min$ = 16 ; size = 4
_max$ = 20 ; size = 4
_xmlExpNewRange PROC ; COMDAT
; 6935 : xmlExpNewRange(xmlExpCtxtPtr ctxt, xmlExpNodePtr subset, int min, int max) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov edx, DWORD PTR _ctxt$[ebp]
test edx, edx
jne SHORT $LN2@xmlExpNewR
; 6936 : if (ctxt == NULL)
; 6937 : return(NULL);
xor eax, eax
; 6944 : NULL, NULL, min, max));
; 6945 : }
pop ebp
ret 0
$LN2@xmlExpNewR:
; 6938 : if ((subset == NULL) || (min < 0) || (max < -1) ||
mov ecx, DWORD PTR _subset$[ebp]
push esi
test ecx, ecx
je SHORT $LN4@xmlExpNewR
mov esi, DWORD PTR _min$[ebp]
test esi, esi
js SHORT $LN4@xmlExpNewR
mov eax, DWORD PTR _max$[ebp]
cmp eax, -1
jl SHORT $LN4@xmlExpNewR
test eax, eax
js SHORT $LN3@xmlExpNewR
cmp esi, eax
jg SHORT $LN4@xmlExpNewR
$LN3@xmlExpNewR:
; 6942 : }
; 6943 : return(xmlExpHashGetEntry(ctxt, XML_EXP_COUNT, subset,
push eax
push esi
push 0
push 0
push ecx
push 5
push edx
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
pop esi
; 6944 : NULL, NULL, min, max));
; 6945 : }
pop ebp
ret 0
$LN4@xmlExpNewR:
; 6939 : ((max >= 0) && (min > max))) {
; 6940 : xmlExpFree(ctxt, subset);
push ecx
push edx
call _xmlExpFree
add esp, 8
; 6941 : return(NULL);
xor eax, eax
pop esi
; 6944 : NULL, NULL, min, max));
; 6945 : }
pop ebp
ret 0
_xmlExpNewRange ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpNewSeq
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_left$ = 12 ; size = 4
_right$ = 16 ; size = 4
_xmlExpNewSeq PROC ; COMDAT
; 6909 : xmlExpNewSeq(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
test esi, esi
jne SHORT $LN2@xmlExpNewS
; 6910 : if (ctxt == NULL)
; 6911 : return(NULL);
xor eax, eax
pop esi
; 6918 : }
pop ebp
ret 0
$LN2@xmlExpNewS:
; 6912 : if ((left == NULL) || (right == NULL)) {
mov eax, DWORD PTR _left$[ebp]
push edi
mov edi, DWORD PTR _right$[ebp]
test eax, eax
je SHORT $LN4@xmlExpNewS
test edi, edi
je SHORT $LN4@xmlExpNewS
; 6916 : }
; 6917 : return(xmlExpHashGetEntry(ctxt, XML_EXP_SEQ, left, right, NULL, 0, 0));
push 0
push 0
push 0
push edi
push eax
push 3
push esi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
pop edi
pop esi
; 6918 : }
pop ebp
ret 0
$LN4@xmlExpNewS:
; 6913 : xmlExpFree(ctxt, left);
push eax
push esi
call _xmlExpFree
; 6914 : xmlExpFree(ctxt, right);
push edi
push esi
call _xmlExpFree
add esp, 16 ; 00000010H
; 6915 : return(NULL);
xor eax, eax
pop edi
pop esi
; 6918 : }
pop ebp
ret 0
_xmlExpNewSeq ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpNewOr
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_left$ = 12 ; size = 4
_right$ = 16 ; size = 4
_xmlExpNewOr PROC ; COMDAT
; 6884 : xmlExpNewOr(xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
test esi, esi
jne SHORT $LN2@xmlExpNewO
; 6885 : if (ctxt == NULL)
; 6886 : return(NULL);
xor eax, eax
pop esi
; 6893 : }
pop ebp
ret 0
$LN2@xmlExpNewO:
; 6887 : if ((left == NULL) || (right == NULL)) {
mov eax, DWORD PTR _left$[ebp]
push edi
mov edi, DWORD PTR _right$[ebp]
test eax, eax
je SHORT $LN4@xmlExpNewO
test edi, edi
je SHORT $LN4@xmlExpNewO
; 6891 : }
; 6892 : return(xmlExpHashGetEntry(ctxt, XML_EXP_OR, left, right, NULL, 0, 0));
push 0
push 0
push 0
push edi
push eax
push 4
push esi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
pop edi
pop esi
; 6893 : }
pop ebp
ret 0
$LN4@xmlExpNewO:
; 6888 : xmlExpFree(ctxt, left);
push eax
push esi
call _xmlExpFree
; 6889 : xmlExpFree(ctxt, right);
push edi
push esi
call _xmlExpFree
add esp, 16 ; 00000010H
; 6890 : return(NULL);
xor eax, eax
pop edi
pop esi
; 6893 : }
pop ebp
ret 0
_xmlExpNewOr ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpNewAtom
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_name$ = 12 ; size = 4
_len$ = 16 ; size = 4
_xmlExpNewAtom PROC ; COMDAT
; 6861 : xmlExpNewAtom(xmlExpCtxtPtr ctxt, const xmlChar *name, int len) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
test esi, esi
je SHORT $LN3@xmlExpNewA
; 6862 : if ((ctxt == NULL) || (name == NULL))
mov eax, DWORD PTR _name$[ebp]
test eax, eax
je SHORT $LN3@xmlExpNewA
; 6864 : name = xmlDictLookup(ctxt->dict, name, len);
push DWORD PTR _len$[ebp]
push eax
push DWORD PTR [esi]
call _xmlDictLookup
add esp, 12 ; 0000000cH
; 6865 : if (name == NULL)
test eax, eax
je SHORT $LN3@xmlExpNewA
; 6866 : return(NULL);
; 6867 : return(xmlExpHashGetEntry(ctxt, XML_EXP_ATOM, NULL, NULL, name, 0, 0));
push 0
push 0
push eax
push 0
push 0
push 2
push esi
call _xmlExpHashGetEntry
add esp, 28 ; 0000001cH
pop esi
; 6868 : }
pop ebp
ret 0
$LN3@xmlExpNewA:
; 6863 : return(NULL);
xor eax, eax
pop esi
; 6868 : }
pop ebp
ret 0
_xmlExpNewAtom ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpParse
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_expr$ = 12 ; size = 4
_xmlExpParse PROC ; COMDAT
; 8027 : xmlExpParse(xmlExpCtxtPtr ctxt, const char *expr) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
mov eax, DWORD PTR _expr$[ebp]
push esi
mov DWORD PTR [esi+24], eax
mov DWORD PTR [esi+28], eax
call _xmlExpParseExpr
mov edx, DWORD PTR [esi+28]
add esp, 4
$LL2@xmlExpPars:
; 8028 : xmlExpNodePtr ret;
; 8029 :
; 8030 : ctxt->expr = expr;
; 8031 : ctxt->cur = expr;
; 8032 :
; 8033 : ret = xmlExpParseExpr(ctxt);
; 8034 : SKIP_BLANKS
mov cl, BYTE PTR [edx]
cmp cl, 32 ; 00000020H
je SHORT $LN4@xmlExpPars
cmp cl, 10 ; 0000000aH
je SHORT $LN4@xmlExpPars
cmp cl, 13 ; 0000000dH
je SHORT $LN4@xmlExpPars
cmp cl, 9
jne SHORT $LN3@xmlExpPars
$LN4@xmlExpPars:
inc edx
mov DWORD PTR [esi+28], edx
jmp SHORT $LL2@xmlExpPars
$LN3@xmlExpPars:
; 8035 : if (*ctxt->cur != 0) {
test cl, cl
je SHORT $LN1@xmlExpPars
; 8036 : xmlExpFree(ctxt, ret);
push eax
push esi
call _xmlExpFree
add esp, 8
; 8037 : return(NULL);
xor eax, eax
$LN1@xmlExpPars:
pop esi
; 8038 : }
; 8039 : return(ret);
; 8040 : }
pop ebp
ret 0
_xmlExpParse ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpRef
_TEXT SEGMENT
_exp$ = 8 ; size = 4
_xmlExpRef PROC ; COMDAT
; 6845 : xmlExpRef(xmlExpNodePtr exp) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _exp$[ebp]
test eax, eax
je SHORT $LN2@xmlExpRef
; 6846 : if (exp != NULL)
; 6847 : exp->ref++;
inc DWORD PTR [eax+4]
$LN2@xmlExpRef:
; 6848 : }
pop ebp
ret 0
_xmlExpRef ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpFree
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_exp$ = 12 ; size = 4
_xmlExpFree PROC ; COMDAT
; 6803 : xmlExpFree(xmlExpCtxtPtr ctxt, xmlExpNodePtr exp) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _exp$[ebp]
test esi, esi
je $LN5@xmlExpFree
; 6804 : if ((exp == NULL) || (exp == forbiddenExp) || (exp == emptyExp))
cmp esi, DWORD PTR _forbiddenExp
je $LN5@xmlExpFree
cmp esi, DWORD PTR _emptyExp
je $LN5@xmlExpFree
; 6805 : return;
; 6806 : exp->ref--;
add DWORD PTR [esi+4], -1
; 6807 : if (exp->ref == 0) {
jne $LN5@xmlExpFree
; 6808 : unsigned short key;
; 6809 :
; 6810 : /* Unlink it first from the hash table */
; 6811 : key = exp->key % ctxt->size;
movzx eax, WORD PTR [esi+2]
push edi
mov edi, DWORD PTR _ctxt$[ebp]
cdq
idiv DWORD PTR [edi+8]
; 6812 : if (ctxt->table[key] == exp) {
mov eax, DWORD PTR [edi+4]
movzx ecx, dx
lea ecx, DWORD PTR [eax+ecx*4]
mov eax, DWORD PTR [ecx]
cmp eax, esi
je SHORT $LN16@xmlExpFree
; 6813 : ctxt->table[key] = exp->next;
; 6814 : } else {
; 6815 : xmlExpNodePtr tmp;
; 6816 :
; 6817 : tmp = ctxt->table[key];
; 6818 : while (tmp != NULL) {
test eax, eax
je SHORT $LN3@xmlExpFree
npad 6
$LL2@xmlExpFree:
; 6819 : if (tmp->next == exp) {
lea ecx, DWORD PTR [eax+16]
mov eax, DWORD PTR [ecx]
cmp eax, esi
je SHORT $LN16@xmlExpFree
; 6813 : ctxt->table[key] = exp->next;
; 6814 : } else {
; 6815 : xmlExpNodePtr tmp;
; 6816 :
; 6817 : tmp = ctxt->table[key];
; 6818 : while (tmp != NULL) {
test eax, eax
jne SHORT $LL2@xmlExpFree
; 6819 : if (tmp->next == exp) {
jmp SHORT $LN3@xmlExpFree
$LN16@xmlExpFree:
; 6820 : tmp->next = exp->next;
; 6821 : break;
; 6822 : }
; 6823 : tmp = tmp->next;
; 6824 : }
; 6825 : }
; 6826 :
; 6827 : if ((exp->type == XML_EXP_SEQ) || (exp->type == XML_EXP_OR)) {
mov eax, DWORD PTR [esi+16]
mov DWORD PTR [ecx], eax
$LN3@xmlExpFree:
mov al, BYTE PTR [esi]
cmp al, 3
je SHORT $LN12@xmlExpFree
cmp al, 4
je SHORT $LN12@xmlExpFree
; 6830 : } else if (exp->type == XML_EXP_COUNT) {
cmp al, 5
jne SHORT $LN13@xmlExpFree
; 6831 : xmlExpFree(ctxt, exp->exp_left);
push DWORD PTR [esi+12]
push edi
call _xmlExpFree
add esp, 8
; 6832 : }
; 6833 : xmlFree(exp);
push esi
call DWORD PTR _xmlFree
add esp, 4
; 6834 : ctxt->nb_nodes--;
dec DWORD PTR [edi+16]
pop edi
pop esi
; 6835 : }
; 6836 : }
pop ebp
ret 0
$LN12@xmlExpFree:
; 6828 : xmlExpFree(ctxt, exp->exp_left);
push DWORD PTR [esi+12]
push edi
call _xmlExpFree
; 6829 : xmlExpFree(ctxt, exp->exp_right);
push DWORD PTR [esi+20]
push edi
call _xmlExpFree
add esp, 16 ; 00000010H
$LN13@xmlExpFree:
; 6832 : }
; 6833 : xmlFree(exp);
push esi
call DWORD PTR _xmlFree
add esp, 4
; 6834 : ctxt->nb_nodes--;
dec DWORD PTR [edi+16]
pop edi
$LN5@xmlExpFree:
pop esi
; 6835 : }
; 6836 : }
pop ebp
ret 0
_xmlExpFree ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpCtxtNbCons
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlExpCtxtNbCons PROC ; COMDAT
; 8171 : xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _ctxt$[ebp]
test eax, eax
jne SHORT $LN2@xmlExpCtxt
; 8172 : if (ctxt == NULL)
; 8173 : return(-1);
or eax, -1
; 8175 : }
pop ebp
ret 0
$LN2@xmlExpCtxt:
; 8174 : return(ctxt->nb_cons);
mov eax, DWORD PTR [eax+32]
; 8175 : }
pop ebp
ret 0
_xmlExpCtxtNbCons ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpCtxtNbNodes
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlExpCtxtNbNodes PROC ; COMDAT
; 8156 : xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov eax, DWORD PTR _ctxt$[ebp]
test eax, eax
jne SHORT $LN2@xmlExpCtxt
; 8157 : if (ctxt == NULL)
; 8158 : return(-1);
or eax, -1
; 8160 : }
pop ebp
ret 0
$LN2@xmlExpCtxt:
; 8159 : return(ctxt->nb_nodes);
mov eax, DWORD PTR [eax+16]
; 8160 : }
pop ebp
ret 0
_xmlExpCtxtNbNodes ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpNewCtxt
_TEXT SEGMENT
_maxNodes$ = 8 ; size = 4
_dict$ = 12 ; size = 4
_xmlExpNewCtxt PROC ; COMDAT
; 6368 : xmlExpNewCtxt(int maxNodes, xmlDictPtr dict) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
push 40 ; 00000028H
call DWORD PTR _xmlMalloc
mov esi, eax
add esp, 4
test esi, esi
je SHORT $LN9@xmlExpNewC
; 6369 : xmlExpCtxtPtr ret;
; 6370 : int size = 256;
; 6371 :
; 6372 : if (maxNodes <= 4096)
; 6373 : maxNodes = 4096;
; 6374 :
; 6375 : ret = (xmlExpCtxtPtr) xmlMalloc(sizeof(xmlExpCtxt));
mov DWORD PTR [esi], 0
mov ecx, 4096 ; 00001000H
cmp DWORD PTR _maxNodes$[ebp], ecx
; 6376 : if (ret == NULL)
; 6377 : return(NULL);
; 6378 : memset(ret, 0, sizeof(xmlExpCtxt));
mov DWORD PTR [esi+4], 0
cmovg ecx, DWORD PTR _maxNodes$[ebp]
mov DWORD PTR [esi+16], 0
mov DWORD PTR [esi+24], 0
mov DWORD PTR [esi+28], 0
mov DWORD PTR [esi+32], 0
mov DWORD PTR [esi+36], 0
; 6379 : ret->size = size;
; 6380 : ret->nbElems = 0;
; 6381 : ret->maxNodes = maxNodes;
; 6382 : ret->table = xmlMalloc(size * sizeof(xmlExpNodePtr));
push 1024 ; 00000400H
mov DWORD PTR [esi+8], 256 ; 00000100H
mov DWORD PTR [esi+12], 0
mov DWORD PTR [esi+20], ecx
call DWORD PTR _xmlMalloc
add esp, 4
mov DWORD PTR [esi+4], eax
; 6383 : if (ret->table == NULL) {
test eax, eax
jne SHORT $LN4@xmlExpNewC
; 6384 : xmlFree(ret);
push esi
call DWORD PTR _xmlFree
add esp, 4
$LN9@xmlExpNewC:
; 6400 : }
xor eax, eax
pop esi
pop ebp
ret 0
$LN4@xmlExpNewC:
; 6385 : return(NULL);
; 6386 : }
; 6387 : memset(ret->table, 0, size * sizeof(xmlExpNodePtr));
push 1024 ; 00000400H
push 0
push eax
call _memset
; 6388 : if (dict == NULL) {
mov eax, DWORD PTR _dict$[ebp]
add esp, 12 ; 0000000cH
test eax, eax
jne SHORT $LN5@xmlExpNewC
; 6389 : ret->dict = xmlDictCreate();
call _xmlDictCreate
mov DWORD PTR [esi], eax
; 6390 : if (ret->dict == NULL) {
test eax, eax
jne SHORT $LN6@xmlExpNewC
; 6391 : xmlFree(ret->table);
push DWORD PTR [esi+4]
call DWORD PTR _xmlFree
; 6392 : xmlFree(ret);
push esi
call DWORD PTR _xmlFree
add esp, 8
; 6393 : return(NULL);
xor eax, eax
pop esi
; 6400 : }
pop ebp
ret 0
$LN5@xmlExpNewC:
; 6394 : }
; 6395 : } else {
; 6396 : ret->dict = dict;
; 6397 : xmlDictReference(ret->dict);
push eax
mov DWORD PTR [esi], eax
call _xmlDictReference
add esp, 4
$LN6@xmlExpNewC:
; 6398 : }
; 6399 : return(ret);
mov eax, esi
pop esi
; 6400 : }
pop ebp
ret 0
_xmlExpNewCtxt ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlExpFreeCtxt
_TEXT SEGMENT
_ctxt$ = 8 ; size = 4
_xmlExpFreeCtxt PROC ; COMDAT
; 6409 : xmlExpFreeCtxt(xmlExpCtxtPtr ctxt) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _ctxt$[ebp]
test esi, esi
je SHORT $LN1@xmlExpFree
; 6410 : if (ctxt == NULL)
; 6411 : return;
; 6412 : xmlDictFree(ctxt->dict);
push DWORD PTR [esi]
call _xmlDictFree
; 6413 : if (ctxt->table != NULL)
mov eax, DWORD PTR [esi+4]
add esp, 4
test eax, eax
je SHORT $LN3@xmlExpFree
; 6414 : xmlFree(ctxt->table);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN3@xmlExpFree:
; 6415 : xmlFree(ctxt);
push esi
call DWORD PTR _xmlFree
add esp, 4
$LN1@xmlExpFree:
pop esi
; 6416 : }
pop ebp
ret 0
_xmlExpFreeCtxt ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegExecErrInfo
_TEXT SEGMENT
_exec$ = 8 ; size = 4
_string$ = 12 ; size = 4
_nbval$ = 16 ; size = 4
_nbneg$ = 20 ; size = 4
_values$ = 24 ; size = 4
_terminal$ = 28 ; size = 4
_xmlRegExecErrInfo PROC ; COMDAT
; 4408 : int *nbval, int *nbneg, xmlChar **values, int *terminal) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov ecx, DWORD PTR _exec$[ebp]
test ecx, ecx
jne SHORT $LN2@xmlRegExec
; 4409 : if (exec == NULL)
; 4410 : return(-1);
or eax, -1
; 4418 : }
pop ebp
ret 0
$LN2@xmlRegExec:
; 4411 : if (string != NULL) {
mov edx, DWORD PTR _string$[ebp]
test edx, edx
je SHORT $LN5@xmlRegExec
; 4412 : if (exec->status != 0)
cmp DWORD PTR [ecx], 0
je SHORT $LN4@xmlRegExec
; 4413 : *string = exec->errString;
mov eax, DWORD PTR [ecx+80]
mov DWORD PTR [edx], eax
; 4416 : }
; 4417 : return(xmlRegExecGetValues(exec, 1, nbval, nbneg, values, terminal));
mov DWORD PTR _string$[ebp], 1
mov DWORD PTR _exec$[ebp], ecx
; 4418 : }
pop ebp
; 4416 : }
; 4417 : return(xmlRegExecGetValues(exec, 1, nbval, nbneg, values, terminal));
jmp _xmlRegExecGetValues
$LN4@xmlRegExec:
; 4414 : else
; 4415 : *string = NULL;
mov DWORD PTR [edx], 0
$LN5@xmlRegExec:
; 4416 : }
; 4417 : return(xmlRegExecGetValues(exec, 1, nbval, nbneg, values, terminal));
mov DWORD PTR _string$[ebp], 1
mov DWORD PTR _exec$[ebp], ecx
; 4418 : }
pop ebp
; 4416 : }
; 4417 : return(xmlRegExecGetValues(exec, 1, nbval, nbneg, values, terminal));
jmp _xmlRegExecGetValues
_xmlRegExecErrInfo ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegExecNextValues
_TEXT SEGMENT
_exec$ = 8 ; size = 4
_nbval$ = 12 ; size = 4
_nbneg$ = 16 ; size = 4
_values$ = 20 ; size = 4
_terminal$ = 24 ; size = 4
_xmlRegExecNextValues PROC ; COMDAT
; 4383 : xmlChar **values, int *terminal) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
push DWORD PTR _terminal$[ebp]
push DWORD PTR _values$[ebp]
push DWORD PTR _nbneg$[ebp]
push DWORD PTR _nbval$[ebp]
push 0
push DWORD PTR _exec$[ebp]
call _xmlRegExecGetValues
add esp, 24 ; 00000018H
; 4384 : return(xmlRegExecGetValues(exec, 0, nbval, nbneg, values, terminal));
; 4385 : }
pop ebp
ret 0
_xmlRegExecNextValues ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegExecPushString2
_TEXT SEGMENT
_buf$ = -152 ; size = 150
_str$1$ = 8 ; size = 4
_exec$ = 8 ; size = 4
_value$ = 12 ; size = 4
_value2$ = 16 ; size = 4
_data$ = 20 ; size = 4
_xmlRegExecPushString2 PROC ; COMDAT
; 4162 : const xmlChar *value2, void *data) {
push ebp
mov ebp, esp
sub esp, 152 ; 00000098H
mov ecx, OFFSET __F6DD4902_xmlregexp@c
push ebx
call @__CheckForDebuggerJustMyCode@4
mov ebx, DWORD PTR _exec$[ebp]
test ebx, ebx
je $LN15@xmlRegExec
; 4163 : xmlChar buf[150];
; 4164 : int lenn, lenp, ret;
; 4165 : xmlChar *str;
; 4166 :
; 4167 : if (exec == NULL)
; 4168 : return(-1);
; 4169 : if (exec->comp == NULL)
cmp DWORD PTR [ebx+8], 0
je $LN15@xmlRegExec
; 4171 : if (exec->status != 0)
mov eax, DWORD PTR [ebx]
test eax, eax
jne SHORT $LN1@xmlRegExec
; 4172 : return(exec->status);
; 4173 :
; 4174 : if (value2 == NULL)
mov eax, DWORD PTR _value2$[ebp]
test eax, eax
jne SHORT $LN5@xmlRegExec
; 4145 : return(xmlRegExecPushStringInternal(exec, value, data, 0));
push eax
push DWORD PTR _data$[ebp]
push DWORD PTR _value$[ebp]
push ebx
call _xmlRegExecPushStringInternal
add esp, 16 ; 00000010H
pop ebx
; 4202 : }
mov esp, ebp
pop ebp
ret 0
$LN5@xmlRegExec:
push edi
; 4175 : return(xmlRegExecPushString(exec, value, data));
; 4176 :
; 4177 : lenn = strlen((char *) value2);
mov edi, eax
lea ecx, DWORD PTR [edi+1]
$LL16@xmlRegExec:
mov al, BYTE PTR [edi]
inc edi
test al, al
jne SHORT $LL16@xmlRegExec
push esi
; 4178 : lenp = strlen((char *) value);
mov esi, DWORD PTR _value$[ebp]
sub edi, ecx
lea ecx, DWORD PTR [esi+1]
$LL17@xmlRegExec:
mov al, BYTE PTR [esi]
inc esi
test al, al
jne SHORT $LL17@xmlRegExec
sub esi, ecx
; 4179 :
; 4180 : if (150 < lenn + lenp + 2) {
lea eax, DWORD PTR [edi+2]
add eax, esi
cmp eax, 150 ; 00000096H
jle SHORT $LN6@xmlRegExec
; 4181 : str = (xmlChar *) xmlMallocAtomic(lenn + lenp + 2);
push eax
call DWORD PTR _xmlMallocAtomic
add esp, 4
mov DWORD PTR _str$1$[ebp], eax
; 4182 : if (str == NULL) {
test eax, eax
jne SHORT $LN7@xmlRegExec
; 4183 : exec->status = -1;
pop esi
mov DWORD PTR [ebx], -1
; 4184 : return(-1);
or eax, -1
pop edi
$LN1@xmlRegExec:
pop ebx
; 4202 : }
mov esp, ebp
pop ebp
ret 0
$LN6@xmlRegExec:
; 4185 : }
; 4186 : } else {
; 4187 : str = buf;
lea eax, DWORD PTR _buf$[ebp]
mov DWORD PTR _str$1$[ebp], eax
$LN7@xmlRegExec:
; 4188 : }
; 4189 : memcpy(&str[0], value, lenp);
push esi
push DWORD PTR _value$[ebp]
push eax
call _memcpy
; 4190 : str[lenp] = XML_REG_STRING_SEPARATOR;
add esi, DWORD PTR _str$1$[ebp]
; 4191 : memcpy(&str[lenp + 1], value2, lenn);
push edi
push DWORD PTR _value2$[ebp]
lea eax, DWORD PTR [esi+1]
mov BYTE PTR [esi], 124 ; 0000007cH
push eax
call _memcpy
; 4192 : str[lenn + lenp + 1] = 0;
mov BYTE PTR [esi+edi+1], 0
add esp, 24 ; 00000018H
; 4193 :
; 4194 : if (exec->comp->compact != NULL)
mov eax, DWORD PTR [ebx+8]
cmp DWORD PTR [eax+40], 0
je SHORT $LN9@xmlRegExec
; 4195 : ret = xmlRegCompactPushString(exec, exec->comp, str, data);
push DWORD PTR _data$[ebp]
push DWORD PTR _str$1$[ebp]
push eax
push ebx
call _xmlRegCompactPushString
jmp SHORT $LN20@xmlRegExec
$LN9@xmlRegExec:
; 4196 : else
; 4197 : ret = xmlRegExecPushStringInternal(exec, str, data, 1);
push 1
push DWORD PTR _data$[ebp]
push DWORD PTR _str$1$[ebp]
push ebx
call _xmlRegExecPushStringInternal
$LN20@xmlRegExec:
; 4198 :
; 4199 : if (str != buf)
mov esi, eax
lea ecx, DWORD PTR _buf$[ebp]
mov eax, DWORD PTR _str$1$[ebp]
add esp, 16 ; 00000010H
cmp eax, ecx
je SHORT $LN11@xmlRegExec
; 4200 : xmlFree(str);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN11@xmlRegExec:
; 4201 : return(ret);
mov eax, esi
pop esi
pop edi
pop ebx
; 4202 : }
mov esp, ebp
pop ebp
ret 0
$LN15@xmlRegExec:
; 4170 : return(-1);
or eax, -1
pop ebx
; 4202 : }
mov esp, ebp
pop ebp
ret 0
_xmlRegExecPushString2 ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegExecPushString
_TEXT SEGMENT
_exec$ = 8 ; size = 4
_value$ = 12 ; size = 4
_data$ = 16 ; size = 4
_xmlRegExecPushString PROC ; COMDAT
; 4144 : void *data) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
push 0
push DWORD PTR _data$[ebp]
push DWORD PTR _value$[ebp]
push DWORD PTR _exec$[ebp]
call _xmlRegExecPushStringInternal
add esp, 16 ; 00000010H
; 4145 : return(xmlRegExecPushStringInternal(exec, value, data, 0));
; 4146 : }
pop ebp
ret 0
_xmlRegExecPushString ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegFreeExecCtxt
_TEXT SEGMENT
_exec$ = 8 ; size = 4
_xmlRegFreeExecCtxt PROC ; COMDAT
; 3572 : xmlRegFreeExecCtxt(xmlRegExecCtxtPtr exec) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _exec$[ebp]
test esi, esi
je $LN1@xmlRegFree
; 3573 : if (exec == NULL)
; 3574 : return;
; 3575 :
; 3576 : if (exec->rollbacks != NULL) {
mov eax, DWORD PTR [esi+40]
push edi
test eax, eax
je SHORT $LN9@xmlRegFree
; 3577 : if (exec->counts != NULL) {
cmp DWORD PTR [esi+44], 0
mov edx, eax
je SHORT $LN3@xmlRegFree
; 3578 : int i;
; 3579 :
; 3580 : for (i = 0;i < exec->maxRollbacks;i++)
xor edi, edi
cmp DWORD PTR [esi+32], edi
jle SHORT $LN3@xmlRegFree
; 3581 : if (exec->rollbacks[i].counts != NULL)
push ebx
xor ebx, ebx
$LL4@xmlRegFree:
mov ecx, DWORD PTR [ebx+eax+12]
test ecx, ecx
je SHORT $LN2@xmlRegFree
; 3582 : xmlFree(exec->rollbacks[i].counts);
push ecx
call DWORD PTR _xmlFree
mov eax, DWORD PTR [esi+40]
add esp, 4
mov edx, eax
$LN2@xmlRegFree:
; 3578 : int i;
; 3579 :
; 3580 : for (i = 0;i < exec->maxRollbacks;i++)
inc edi
add ebx, 16 ; 00000010H
cmp edi, DWORD PTR [esi+32]
jl SHORT $LL4@xmlRegFree
pop ebx
$LN3@xmlRegFree:
; 3583 : }
; 3584 : xmlFree(exec->rollbacks);
push edx
call DWORD PTR _xmlFree
add esp, 4
$LN9@xmlRegFree:
; 3585 : }
; 3586 : if (exec->counts != NULL)
mov eax, DWORD PTR [esi+44]
test eax, eax
je SHORT $LN12@xmlRegFree
; 3587 : xmlFree(exec->counts);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN12@xmlRegFree:
; 3588 : if (exec->inputStack != NULL) {
mov eax, DWORD PTR [esi+68]
test eax, eax
je SHORT $LN13@xmlRegFree
; 3589 : int i;
; 3590 :
; 3591 : for (i = 0;i < exec->inputStackNr;i++) {
xor edi, edi
cmp DWORD PTR [esi+52], edi
jle SHORT $LN6@xmlRegFree
; 3592 : if (exec->inputStack[i].value != NULL)
mov edx, eax
npad 1
$LL7@xmlRegFree:
mov ecx, DWORD PTR [eax+edi*8]
test ecx, ecx
je SHORT $LN5@xmlRegFree
; 3593 : xmlFree(exec->inputStack[i].value);
push ecx
call DWORD PTR _xmlFree
mov eax, DWORD PTR [esi+68]
add esp, 4
mov edx, eax
$LN5@xmlRegFree:
; 3589 : int i;
; 3590 :
; 3591 : for (i = 0;i < exec->inputStackNr;i++) {
inc edi
cmp edi, DWORD PTR [esi+52]
jl SHORT $LL7@xmlRegFree
mov eax, edx
$LN6@xmlRegFree:
; 3594 : }
; 3595 : xmlFree(exec->inputStack);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN13@xmlRegFree:
; 3596 : }
; 3597 : if (exec->errString != NULL)
mov eax, DWORD PTR [esi+80]
pop edi
test eax, eax
je SHORT $LN15@xmlRegFree
; 3598 : xmlFree(exec->errString);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN15@xmlRegFree:
; 3599 : xmlFree(exec);
push esi
call DWORD PTR _xmlFree
add esp, 4
$LN1@xmlRegFree:
pop esi
; 3600 : }
pop ebp
ret 0
_xmlRegFreeExecCtxt ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegNewExecCtxt
_TEXT SEGMENT
_comp$ = 8 ; size = 4
_callback$ = 12 ; size = 4
_data$ = 16 ; size = 4
_xmlRegNewExecCtxt PROC ; COMDAT
; 3511 : xmlRegNewExecCtxt(xmlRegexpPtr comp, xmlRegExecCallbacks callback, void *data) {
push ebp
mov ebp, esp
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR _comp$[ebp]
test edi, edi
je $LN15@xmlRegNewE
; 3512 : xmlRegExecCtxtPtr exec;
; 3513 :
; 3514 : if (comp == NULL)
; 3515 : return(NULL);
; 3516 : if ((comp->compact == NULL) && (comp->states == NULL))
cmp DWORD PTR [edi+40], 0
jne SHORT $LN14@xmlRegNewE
cmp DWORD PTR [edi+8], 0
je $LN15@xmlRegNewE
$LN14@xmlRegNewE:
push esi
; 3518 : exec = (xmlRegExecCtxtPtr) xmlMalloc(sizeof(xmlRegExecCtxt));
push 92 ; 0000005cH
call DWORD PTR _xmlMalloc
mov esi, eax
add esp, 4
; 3519 : if (exec == NULL) {
test esi, esi
jne SHORT $LN4@xmlRegNewE
; 385 : __xmlRaiseError(NULL, NULL, NULL, NULL, NULL, XML_FROM_REGEXP,
push OFFSET ??_C@_0BL@LMPHHOAL@creating?5execution?5context@
push OFFSET ??_C@_0BP@DJFHNAOK@Memory?5allocation?5failed?5?3?5?$CFs?6@
push eax
push eax
push eax
push eax
push OFFSET ??_C@_0BL@LMPHHOAL@creating?5execution?5context@
push eax
push eax
push 3
push 2
push 14 ; 0000000eH
push eax
push eax
push eax
push eax
push eax
call ___xmlRaiseError
add esp, 68 ; 00000044H
; 3520 : xmlRegexpErrMemory(NULL, "creating execution context");
; 3521 : return(NULL);
xor eax, eax
pop esi
pop edi
; 3563 : }
pop ebp
ret 0
$LN4@xmlRegNewE:
; 3522 : }
; 3523 : memset(exec, 0, sizeof(xmlRegExecCtxt));
push 92 ; 0000005cH
push 0
push esi
call _memset
add esp, 12 ; 0000000cH
; 3524 : exec->inputString = NULL;
; 3525 : exec->index = 0;
; 3526 : exec->determinist = 1;
mov DWORD PTR [esi+4], 1
; 3527 : exec->maxRollbacks = 0;
; 3528 : exec->nbRollbacks = 0;
; 3529 : exec->rollbacks = NULL;
; 3530 : exec->status = 0;
; 3531 : exec->comp = comp;
mov DWORD PTR [esi+8], edi
; 3532 : if (comp->compact == NULL)
cmp DWORD PTR [edi+40], 0
jne SHORT $LN5@xmlRegNewE
; 3533 : exec->state = comp->states[0];
mov eax, DWORD PTR [edi+8]
mov eax, DWORD PTR [eax]
mov DWORD PTR [esi+20], eax
$LN5@xmlRegNewE:
; 3534 : exec->transno = 0;
; 3535 : exec->transcount = 0;
; 3536 : exec->callback = callback;
mov eax, DWORD PTR _callback$[ebp]
mov DWORD PTR [esi+12], eax
; 3537 : exec->data = data;
mov eax, DWORD PTR _data$[ebp]
mov DWORD PTR [esi+24], 0
mov DWORD PTR [esi+28], 0
mov DWORD PTR [esi+16], eax
; 3538 : if (comp->nbCounters > 0) {
mov eax, DWORD PTR [edi+20]
test eax, eax
jle SHORT $LN6@xmlRegNewE
; 3539 : /*
; 3540 : * For error handling, exec->counts is allocated twice the size
; 3541 : * the second half is used to store the data in case of rollback
; 3542 : */
; 3543 : exec->counts = (int *) xmlMalloc(comp->nbCounters * sizeof(int)
shl eax, 3
push eax
call DWORD PTR _xmlMalloc
mov ecx, eax
add esp, 4
mov DWORD PTR [esi+44], ecx
; 3544 : * 2);
; 3545 : if (exec->counts == NULL) {
test ecx, ecx
jne SHORT $LN8@xmlRegNewE
; 3546 : xmlRegexpErrMemory(NULL, "creating execution context");
push OFFSET ??_C@_0BL@LMPHHOAL@creating?5execution?5context@
push eax
call _xmlRegexpErrMemory
; 3547 : xmlFree(exec);
push esi
call DWORD PTR _xmlFree
add esp, 12 ; 0000000cH
xor eax, eax
pop esi
pop edi
; 3563 : }
pop ebp
ret 0
$LN8@xmlRegNewE:
; 3548 : return(NULL);
; 3549 : }
; 3550 : memset(exec->counts, 0, comp->nbCounters * sizeof(int) * 2);
mov eax, DWORD PTR [edi+20]
shl eax, 3
push eax
push 0
push ecx
call _memset
; 3551 : exec->errCounts = &exec->counts[comp->nbCounters];
mov ecx, DWORD PTR [edi+20]
add esp, 12 ; 0000000cH
mov eax, DWORD PTR [esi+44]
lea eax, DWORD PTR [eax+ecx*4]
; 3552 : } else {
jmp SHORT $LN7@xmlRegNewE
$LN6@xmlRegNewE:
; 3553 : exec->counts = NULL;
mov DWORD PTR [esi+44], 0
; 3554 : exec->errCounts = NULL;
xor eax, eax
$LN7@xmlRegNewE:
; 3555 : }
; 3556 : exec->inputStackMax = 0;
mov DWORD PTR [esi+84], eax
; 3557 : exec->inputStackNr = 0;
; 3558 : exec->inputStack = NULL;
; 3559 : exec->errStateNo = -1;
; 3560 : exec->errString = NULL;
; 3561 : exec->nbPush = 0;
; 3562 : return(exec);
mov eax, esi
mov DWORD PTR [esi+48], 0
mov DWORD PTR [esi+52], 0
mov DWORD PTR [esi+68], 0
mov DWORD PTR [esi+72], -1
mov DWORD PTR [esi+80], 0
mov DWORD PTR [esi+88], 0
pop esi
pop edi
; 3563 : }
pop ebp
ret 0
$LN15@xmlRegNewE:
; 3517 : return(NULL);
xor eax, eax
pop edi
; 3563 : }
pop ebp
ret 0
_xmlRegNewExecCtxt ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegexpIsDeterminist
_TEXT SEGMENT
_comp$ = 8 ; size = 4
_xmlRegexpIsDeterminist PROC ; COMDAT
; 5530 : xmlRegexpIsDeterminist(xmlRegexpPtr comp) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _comp$[ebp]
test esi, esi
jne SHORT $LN5@xmlRegexpI
; 5531 : xmlAutomataPtr am;
; 5532 : int ret;
; 5533 :
; 5534 : if (comp == NULL)
; 5535 : return(-1);
or eax, -1
pop esi
; 5559 : }
pop ebp
ret 0
$LN5@xmlRegexpI:
; 5536 : if (comp->determinist != -1)
mov eax, DWORD PTR [esi+28]
cmp eax, -1
jne $LN1@xmlRegexpI
; 5537 : return(comp->determinist);
; 5538 :
; 5539 : am = xmlNewAutomata();
push ebx
call _xmlNewAutomata
mov ebx, eax
; 5540 : if (am->states != NULL) {
cmp DWORD PTR [ebx+52], 0
je SHORT $LN7@xmlRegexpI
; 5541 : int i;
; 5542 :
; 5543 : for (i = 0;i < am->nbStates;i++)
push edi
xor edi, edi
cmp DWORD PTR [ebx+48], edi
jle SHORT $LN3@xmlRegexpI
npad 3
$LL4@xmlRegexpI:
; 5544 : xmlRegFreeState(am->states[i]);
mov eax, DWORD PTR [ebx+52]
mov esi, DWORD PTR [eax+edi*4]
; 898 : if (state == NULL)
test esi, esi
je SHORT $LN2@xmlRegexpI
; 899 : return;
; 900 :
; 901 : if (state->trans != NULL)
mov eax, DWORD PTR [esi+28]
test eax, eax
je SHORT $LN11@xmlRegexpI
; 902 : xmlFree(state->trans);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN11@xmlRegexpI:
; 903 : if (state->transTo != NULL)
mov eax, DWORD PTR [esi+40]
test eax, eax
je SHORT $LN12@xmlRegexpI
; 904 : xmlFree(state->transTo);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN12@xmlRegexpI:
; 905 : xmlFree(state);
push esi
call DWORD PTR _xmlFree
add esp, 4
$LN2@xmlRegexpI:
; 5541 : int i;
; 5542 :
; 5543 : for (i = 0;i < am->nbStates;i++)
inc edi
cmp edi, DWORD PTR [ebx+48]
jl SHORT $LL4@xmlRegexpI
mov esi, DWORD PTR _comp$[ebp]
$LN3@xmlRegexpI:
; 5545 : xmlFree(am->states);
push DWORD PTR [ebx+52]
call DWORD PTR _xmlFree
add esp, 4
pop edi
$LN7@xmlRegexpI:
; 5546 : }
; 5547 : am->nbAtoms = comp->nbAtoms;
mov eax, DWORD PTR [esi+12]
mov DWORD PTR [ebx+36], eax
; 5548 : am->atoms = comp->atoms;
mov eax, DWORD PTR [esi+16]
mov DWORD PTR [ebx+40], eax
; 5549 : am->nbStates = comp->nbStates;
mov eax, DWORD PTR [esi+4]
mov DWORD PTR [ebx+48], eax
; 5550 : am->states = comp->states;
mov eax, DWORD PTR [esi+8]
mov DWORD PTR [ebx+52], eax
; 5551 : am->determinist = -1;
mov DWORD PTR [ebx+68], -1
; 5552 : am->flags = comp->flags;
mov eax, DWORD PTR [esi+32]
; 5553 : ret = xmlFAComputesDeterminism(am);
push ebx
mov DWORD PTR [ebx+76], eax
call _xmlFAComputesDeterminism
; 5650 : xmlRegFreeParserCtxt(am);
push ebx
; 5553 : ret = xmlFAComputesDeterminism(am);
mov esi, eax
; 5554 : am->atoms = NULL;
mov DWORD PTR [ebx+40], 0
; 5555 : am->states = NULL;
mov DWORD PTR [ebx+52], 0
; 5650 : xmlRegFreeParserCtxt(am);
call _xmlRegFreeParserCtxt
; 5556 : xmlFreeAutomata(am);
; 5557 : comp->determinist = ret;
mov eax, DWORD PTR _comp$[ebp]
; 5650 : xmlRegFreeParserCtxt(am);
add esp, 8
; 5556 : xmlFreeAutomata(am);
; 5557 : comp->determinist = ret;
mov DWORD PTR [eax+28], esi
; 5558 : return(ret);
mov eax, esi
pop ebx
$LN1@xmlRegexpI:
pop esi
; 5559 : }
pop ebp
ret 0
_xmlRegexpIsDeterminist ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegexpPrint
_TEXT SEGMENT
_output$ = 8 ; size = 4
_regexp$ = 12 ; size = 4
_xmlRegexpPrint PROC ; COMDAT
; 5426 : xmlRegexpPrint(FILE *output, xmlRegexpPtr regexp) {
push ebp
mov ebp, esp
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR _output$[ebp]
test edi, edi
je $LN9@xmlRegexpP
; 5427 : int i;
; 5428 :
; 5429 : if (output == NULL)
; 5430 : return;
; 5431 : fprintf(output, " regexp: ");
push esi
push OFFSET ??_C@_09BNLLHCCB@?5regexp?3?5@
push edi
call _fprintf
; 5432 : if (regexp == NULL) {
mov esi, DWORD PTR _regexp$[ebp]
add esp, 8
test esi, esi
jne SHORT $LN12@xmlRegexpP
; 5433 : fprintf(output, "NULL\n");
push OFFSET ??_C@_05NJDBAOFA@NULL?6@
push edi
call _fprintf
add esp, 8
pop esi
pop edi
; 5451 : regexp->counters[i].max);
; 5452 : }
; 5453 : }
pop ebp
ret 0
$LN12@xmlRegexpP:
push ebx
; 5434 : return;
; 5435 : }
; 5436 : fprintf(output, "'%s' ", regexp->string);
push DWORD PTR [esi]
push OFFSET ??_C@_05IMLJLABD@?8?$CFs?8?5@
push edi
call _fprintf
; 5437 : fprintf(output, "\n");
push OFFSET ??_C@_01EEMJAFIK@?6@
push edi
call _fprintf
; 5438 : fprintf(output, "%d atoms:\n", regexp->nbAtoms);
push DWORD PTR [esi+12]
push OFFSET ??_C@_0L@PLBJGPP@?$CFd?5atoms?3?6@
push edi
call _fprintf
; 5439 : for (i = 0;i < regexp->nbAtoms; i++) {
xor ebx, ebx
add esp, 32 ; 00000020H
cmp DWORD PTR [esi+12], ebx
jle SHORT $LN3@xmlRegexpP
$LL4@xmlRegexpP:
; 5440 : fprintf(output, " %02d ", i);
push ebx
push OFFSET ??_C@_06NLBGECGK@?5?$CF02d?5@
push edi
call _fprintf
; 5441 : xmlRegPrintAtom(output, regexp->atoms[i]);
mov eax, DWORD PTR [esi+16]
push DWORD PTR [eax+ebx*4]
push edi
call _xmlRegPrintAtom
inc ebx
add esp, 20 ; 00000014H
cmp ebx, DWORD PTR [esi+12]
jl SHORT $LL4@xmlRegexpP
$LN3@xmlRegexpP:
; 5442 : }
; 5443 : fprintf(output, "%d states:", regexp->nbStates);
push DWORD PTR [esi+4]
push OFFSET ??_C@_0L@LDKKLMNF@?$CFd?5states?3@
push edi
call _fprintf
; 5444 : fprintf(output, "\n");
push OFFSET ??_C@_01EEMJAFIK@?6@
push edi
call _fprintf
; 5445 : for (i = 0;i < regexp->nbStates; i++) {
xor ebx, ebx
add esp, 20 ; 00000014H
cmp DWORD PTR [esi+4], ebx
jle SHORT $LN6@xmlRegexpP
$LL7@xmlRegexpP:
; 5446 : xmlRegPrintState(output, regexp->states[i]);
mov eax, DWORD PTR [esi+8]
push DWORD PTR [eax+ebx*4]
push edi
call _xmlRegPrintState
inc ebx
add esp, 8
cmp ebx, DWORD PTR [esi+4]
jl SHORT $LL7@xmlRegexpP
$LN6@xmlRegexpP:
; 5447 : }
; 5448 : fprintf(output, "%d counters:\n", regexp->nbCounters);
push DWORD PTR [esi+20]
push OFFSET ??_C@_0O@EOOCDOKK@?$CFd?5counters?3?6@
push edi
call _fprintf
; 5449 : for (i = 0;i < regexp->nbCounters; i++) {
xor ebx, ebx
add esp, 12 ; 0000000cH
cmp DWORD PTR [esi+20], ebx
jle SHORT $LN27@xmlRegexpP
$LL10@xmlRegexpP:
; 5450 : fprintf(output, " %d: min %d max %d\n", i, regexp->counters[i].min,
mov eax, DWORD PTR [esi+24]
push DWORD PTR [eax+ebx*8+4]
push DWORD PTR [eax+ebx*8]
push ebx
push OFFSET ??_C@_0BE@LNLBBGGH@?5?$CFd?3?5min?5?$CFd?5max?5?$CFd?6@
push edi
call _fprintf
inc ebx
add esp, 20 ; 00000014H
cmp ebx, DWORD PTR [esi+20]
jl SHORT $LL10@xmlRegexpP
$LN27@xmlRegexpP:
pop ebx
pop esi
$LN9@xmlRegexpP:
pop edi
; 5451 : regexp->counters[i].max);
; 5452 : }
; 5453 : }
pop ebp
ret 0
_xmlRegexpPrint ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegexpExec
_TEXT SEGMENT
_comp$ = 8 ; size = 4
_content$ = 12 ; size = 4
_xmlRegexpExec PROC ; COMDAT
; 5515 : xmlRegexpExec(xmlRegexpPtr comp, const xmlChar *content) {
push ebp
mov ebp, esp
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov ecx, DWORD PTR _comp$[ebp]
test ecx, ecx
je SHORT $LN3@xmlRegexpE
; 5516 : if ((comp == NULL) || (content == NULL))
mov eax, DWORD PTR _content$[ebp]
test eax, eax
je SHORT $LN3@xmlRegexpE
; 5518 : return(xmlFARegExec(comp, content));
mov DWORD PTR _content$[ebp], eax
mov DWORD PTR _comp$[ebp], ecx
; 5519 : }
pop ebp
; 5518 : return(xmlFARegExec(comp, content));
jmp _xmlFARegExec
$LN3@xmlRegexpE:
; 5517 : return(-1);
or eax, -1
; 5519 : }
pop ebp
ret 0
_xmlRegexpExec ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegFreeRegexp
_TEXT SEGMENT
_regexp$ = 8 ; size = 4
_xmlRegFreeRegexp PROC ; COMDAT
; 5568 : xmlRegFreeRegexp(xmlRegexpPtr regexp) {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR _regexp$[ebp]
test esi, esi
je $LN1@xmlRegFree
; 5569 : int i;
; 5570 : if (regexp == NULL)
; 5571 : return;
; 5572 :
; 5573 : if (regexp->string != NULL)
mov eax, DWORD PTR [esi]
test eax, eax
je SHORT $LN12@xmlRegFree
; 5574 : xmlFree(regexp->string);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN12@xmlRegFree:
; 5575 : if (regexp->states != NULL) {
cmp DWORD PTR [esi+8], 0
push edi
je SHORT $LN13@xmlRegFree
; 5576 : for (i = 0;i < regexp->nbStates;i++)
xor edi, edi
cmp DWORD PTR [esi+4], edi
jle SHORT $LN3@xmlRegFree
push ebx
$LL4@xmlRegFree:
; 5577 : xmlRegFreeState(regexp->states[i]);
mov eax, DWORD PTR [esi+8]
mov ebx, DWORD PTR [eax+edi*4]
; 898 : if (state == NULL)
test ebx, ebx
je SHORT $LN2@xmlRegFree
; 899 : return;
; 900 :
; 901 : if (state->trans != NULL)
mov eax, DWORD PTR [ebx+28]
test eax, eax
je SHORT $LN22@xmlRegFree
; 902 : xmlFree(state->trans);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN22@xmlRegFree:
; 903 : if (state->transTo != NULL)
mov eax, DWORD PTR [ebx+40]
test eax, eax
je SHORT $LN23@xmlRegFree
; 904 : xmlFree(state->transTo);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN23@xmlRegFree:
; 905 : xmlFree(state);
push ebx
call DWORD PTR _xmlFree
add esp, 4
$LN2@xmlRegFree:
; 5576 : for (i = 0;i < regexp->nbStates;i++)
inc edi
cmp edi, DWORD PTR [esi+4]
jl SHORT $LL4@xmlRegFree
pop ebx
$LN3@xmlRegFree:
; 5578 : xmlFree(regexp->states);
push DWORD PTR [esi+8]
call DWORD PTR _xmlFree
add esp, 4
$LN13@xmlRegFree:
; 5579 : }
; 5580 : if (regexp->atoms != NULL) {
mov eax, DWORD PTR [esi+16]
test eax, eax
je SHORT $LN14@xmlRegFree
; 5581 : for (i = 0;i < regexp->nbAtoms;i++)
xor edi, edi
cmp DWORD PTR [esi+12], edi
jle SHORT $LN6@xmlRegFree
npad 1
$LL7@xmlRegFree:
; 5582 : xmlRegFreeAtom(regexp->atoms[i]);
mov eax, DWORD PTR [esi+16]
push DWORD PTR [eax+edi*4]
call _xmlRegFreeAtom
inc edi
add esp, 4
cmp edi, DWORD PTR [esi+12]
jl SHORT $LL7@xmlRegFree
mov eax, DWORD PTR [esi+16]
$LN6@xmlRegFree:
; 5583 : xmlFree(regexp->atoms);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN14@xmlRegFree:
; 5584 : }
; 5585 : if (regexp->counters != NULL)
mov eax, DWORD PTR [esi+24]
test eax, eax
je SHORT $LN15@xmlRegFree
; 5586 : xmlFree(regexp->counters);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN15@xmlRegFree:
; 5587 : if (regexp->compact != NULL)
mov eax, DWORD PTR [esi+40]
test eax, eax
je SHORT $LN16@xmlRegFree
; 5588 : xmlFree(regexp->compact);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN16@xmlRegFree:
; 5589 : if (regexp->transdata != NULL)
mov eax, DWORD PTR [esi+44]
test eax, eax
je SHORT $LN17@xmlRegFree
; 5590 : xmlFree(regexp->transdata);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN17@xmlRegFree:
; 5591 : if (regexp->stringMap != NULL) {
mov eax, DWORD PTR [esi+52]
test eax, eax
je SHORT $LN18@xmlRegFree
; 5592 : for (i = 0; i < regexp->nbstrings;i++)
xor edi, edi
cmp DWORD PTR [esi+48], edi
jle SHORT $LN9@xmlRegFree
$LL10@xmlRegFree:
; 5593 : xmlFree(regexp->stringMap[i]);
mov eax, DWORD PTR [esi+52]
push DWORD PTR [eax+edi*4]
call DWORD PTR _xmlFree
inc edi
add esp, 4
cmp edi, DWORD PTR [esi+48]
jl SHORT $LL10@xmlRegFree
mov eax, DWORD PTR [esi+52]
$LN9@xmlRegFree:
; 5594 : xmlFree(regexp->stringMap);
push eax
call DWORD PTR _xmlFree
add esp, 4
$LN18@xmlRegFree:
; 5595 : }
; 5596 :
; 5597 : xmlFree(regexp);
push esi
call DWORD PTR _xmlFree
add esp, 4
pop edi
$LN1@xmlRegFree:
pop esi
; 5598 : }
pop ebp
ret 0
_xmlRegFreeRegexp ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\users\dag\documents\_clients\codeproject authors group\windows on arm\libxml2\libxml2-2.9.9\xmlregexp.c
; COMDAT _xmlRegexpCompile
_TEXT SEGMENT
_regexp$ = 8 ; size = 4
_xmlRegexpCompile PROC ; COMDAT
; 5466 : xmlRegexpCompile(const xmlChar *regexp) {
push ebp
mov ebp, esp
push edi
mov ecx, OFFSET __F6DD4902_xmlregexp@c
call @__CheckForDebuggerJustMyCode@4
push DWORD PTR _regexp$[ebp]
call _xmlRegNewParserCtxt
mov edi, eax
add esp, 4
test edi, edi
je $LN8@xmlRegexpC
; 5467 : xmlRegexpPtr ret;
; 5468 : xmlRegParserCtxtPtr ctxt;
; 5469 :
; 5470 : ctxt = xmlRegNewParserCtxt(regexp);
; 5471 : if (ctxt == NULL)
; 5472 : return(NULL);
; 5473 :
; 5474 : /* initialize the parser */
; 5475 : ctxt->end = NULL;
push edi
mov DWORD PTR [edi+20], 0
; 5476 : ctxt->start = ctxt->state = xmlRegNewState(ctxt);
call _xmlRegNewState
; 5477 : xmlRegStatePush(ctxt, ctxt->start);
push eax
push edi
mov DWORD PTR [edi+24], eax
mov DWORD PTR [edi+16], eax
call _xmlRegStatePush
; 5478 :
; 5479 : /* parse the expression building an automata */
; 5480 : xmlFAParseRegExp(ctxt, 1);
push 1
push edi
call _xmlFAParseRegExp
; 5481 : if (CUR != 0) {
mov eax, DWORD PTR [edi+4]
add esp, 20 ; 00000014H
cmp BYTE PTR [eax], 0
je SHORT $LN3@xmlRegexpC
; 5482 : ERROR("xmlFAParseRegExp: extra characters");
push OFFSET ??_C@_0CD@GPPIOFAL@xmlFAParseRegExp?3?5extra?5charact@
push edi
mov DWORD PTR [edi+8], 1450 ; 000005aaH
call _xmlRegexpErrCompile
add esp, 8
$LN3@xmlRegexpC:
; 5483 : }
; 5484 : if (ctxt->error != 0) {
cmp DWORD PTR [edi+8], 0
jne SHORT $LN7@xmlRegexpC
; 5485 : xmlRegFreeParserCtxt(ctxt);
; 5486 : return(NULL);
; 5487 : }
; 5488 : ctxt->end = ctxt->state;
mov eax, DWORD PTR [edi+24]
mov DWORD PTR [edi+20], eax
; 5489 : ctxt->start->type = XML_REGEXP_START_STATE;
mov eax, DWORD PTR [edi+16]
; 5490 : ctxt->end->type = XML_REGEXP_FINAL_STATE;
; 5491 :
; 5492 : /* remove the Epsilon except for counted transitions */
; 5493 : xmlFAEliminateEpsilonTransitions(ctxt);
push edi
mov DWORD PTR [eax], 1
mov eax, DWORD PTR [edi+20]
mov DWORD PTR [eax], 2
call _xmlFAEliminateEpsilonTransitions
add esp, 4
; 5494 :
; 5495 :
; 5496 : if (ctxt->error != 0) {
cmp DWORD PTR [edi+8], 0
jne SHORT $LN7@xmlRegexpC
; 5498 : return(NULL);
; 5499 : }
; 5500 : ret = xmlRegEpxFromParse(ctxt);
push esi
push edi
call _xmlRegEpxFromParse
; 5501 : xmlRegFreeParserCtxt(ctxt);
push edi
mov esi, eax
call _xmlRegFreeParserCtxt
add esp, 8
; 5502 : return(ret);
mov eax, esi
pop esi
pop edi
; 5503 : }
pop ebp
ret 0
$LN7@xmlRegexpC:
; 5497 : xmlRegFreeParserCtxt(ctxt);
push edi
call _xmlRegFreeParserCtxt
add esp, 4
$LN8@xmlRegexpC:
; 5503 : }
xor eax, eax
pop edi
pop ebp
ret 0
_xmlRegexpCompile ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\program files (x86)\windows kits\10\include\10.0.17763.0\ucrt\stdio.h
; COMDAT _snprintf
_TEXT SEGMENT
__Buffer$ = 8 ; size = 4
__BufferCount$ = 12 ; size = 4
__Format$ = 16 ; size = 4
_snprintf PROC ; COMDAT
; 1948 : {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __A452D4A0_stdio@h
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR __Format$[ebp]
; 1440 : int const _Result = __stdio_common_vsprintf(
call ___local_stdio_printf_options
lea ecx, DWORD PTR __Format$[ebp+4]
push ecx
push 0
mov ecx, DWORD PTR [eax]
push esi
push DWORD PTR __BufferCount$[ebp]
or ecx, 2
push DWORD PTR __Buffer$[ebp]
push DWORD PTR [eax+4]
push ecx
call DWORD PTR __imp____stdio_common_vsprintf
add esp, 28 ; 0000001cH
; 1441 : _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR,
; 1442 : _Buffer, _BufferCount, _Format, NULL, _ArgList);
; 1443 :
; 1444 : return _Result < 0 ? -1 : _Result;
or ecx, -1
test eax, eax
cmovs eax, ecx
; 1949 : int _Result;
; 1950 : va_list _ArgList;
; 1951 : __crt_va_start(_ArgList, _Format);
; 1952 : #pragma warning(suppress:28719) // 28719
; 1953 : _Result = vsnprintf(_Buffer, _BufferCount, _Format, _ArgList);
; 1954 : __crt_va_end(_ArgList);
; 1955 : return _Result;
pop esi
; 1956 : }
pop ebp
ret 0
_snprintf ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\program files (x86)\windows kits\10\include\10.0.17763.0\ucrt\stdio.h
; COMDAT _vsnprintf
_TEXT SEGMENT
__Buffer$ = 8 ; size = 4
__BufferCount$ = 12 ; size = 4
__Format$ = 16 ; size = 4
__ArgList$ = 20 ; size = 4
_vsnprintf PROC ; COMDAT
; 1439 : {
push ebp
mov ebp, esp
mov ecx, OFFSET __A452D4A0_stdio@h
call @__CheckForDebuggerJustMyCode@4
call ___local_stdio_printf_options
push DWORD PTR __ArgList$[ebp]
mov ecx, eax
push 0
push DWORD PTR __Format$[ebp]
push DWORD PTR __BufferCount$[ebp]
mov eax, DWORD PTR [ecx]
push DWORD PTR __Buffer$[ebp]
or eax, 2
push DWORD PTR [ecx+4]
push eax
call DWORD PTR __imp____stdio_common_vsprintf
or ecx, -1
add esp, 28 ; 0000001cH
test eax, eax
cmovs eax, ecx
; 1440 : int const _Result = __stdio_common_vsprintf(
; 1441 : _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR,
; 1442 : _Buffer, _BufferCount, _Format, NULL, _ArgList);
; 1443 :
; 1444 : return _Result < 0 ? -1 : _Result;
; 1445 : }
pop ebp
ret 0
_vsnprintf ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\program files (x86)\windows kits\10\include\10.0.17763.0\ucrt\stdio.h
; COMDAT _printf
_TEXT SEGMENT
__Format$ = 8 ; size = 4
_printf PROC ; COMDAT
; 954 : {
push ebp
mov ebp, esp
push esi
push edi
mov ecx, OFFSET __A452D4A0_stdio@h
call @__CheckForDebuggerJustMyCode@4
mov edi, DWORD PTR __Format$[ebp]
push 1
call DWORD PTR __imp____acrt_iob_func
mov esi, eax
; 643 : return __stdio_common_vfprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, _Stream, _Format, _Locale, _ArgList);
call ___local_stdio_printf_options
lea ecx, DWORD PTR __Format$[ebp+4]
push ecx
push 0
push edi
push esi
push DWORD PTR [eax+4]
push DWORD PTR [eax]
call DWORD PTR __imp____stdio_common_vfprintf
add esp, 28 ; 0000001cH
; 955 : int _Result;
; 956 : va_list _ArgList;
; 957 : __crt_va_start(_ArgList, _Format);
; 958 : _Result = _vfprintf_l(stdout, _Format, NULL, _ArgList);
; 959 : __crt_va_end(_ArgList);
; 960 : return _Result;
pop edi
pop esi
; 961 : }
pop ebp
ret 0
_printf ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\program files (x86)\windows kits\10\include\10.0.17763.0\ucrt\stdio.h
; COMDAT _fprintf
_TEXT SEGMENT
__Stream$ = 8 ; size = 4
__Format$ = 12 ; size = 4
_fprintf PROC ; COMDAT
; 835 : {
push ebp
mov ebp, esp
push esi
mov ecx, OFFSET __A452D4A0_stdio@h
call @__CheckForDebuggerJustMyCode@4
mov esi, DWORD PTR __Format$[ebp]
; 643 : return __stdio_common_vfprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, _Stream, _Format, _Locale, _ArgList);
call ___local_stdio_printf_options
lea ecx, DWORD PTR __Format$[ebp+4]
push ecx
push 0
push esi
push DWORD PTR __Stream$[ebp]
push DWORD PTR [eax+4]
push DWORD PTR [eax]
call DWORD PTR __imp____stdio_common_vfprintf
add esp, 24 ; 00000018H
; 836 : int _Result;
; 837 : va_list _ArgList;
; 838 : __crt_va_start(_ArgList, _Format);
; 839 : _Result = _vfprintf_l(_Stream, _Format, NULL, _ArgList);
; 840 : __crt_va_end(_ArgList);
; 841 : return _Result;
pop esi
; 842 : }
pop ebp
ret 0
_fprintf ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\program files (x86)\windows kits\10\include\10.0.17763.0\ucrt\stdio.h
; COMDAT __vfprintf_l
_TEXT SEGMENT
__Stream$ = 8 ; size = 4
__Format$ = 12 ; size = 4
__Locale$ = 16 ; size = 4
__ArgList$ = 20 ; size = 4
__vfprintf_l PROC ; COMDAT
; 642 : {
push ebp
mov ebp, esp
mov ecx, OFFSET __A452D4A0_stdio@h
call @__CheckForDebuggerJustMyCode@4
call ___local_stdio_printf_options
push DWORD PTR __ArgList$[ebp]
push DWORD PTR __Locale$[ebp]
push DWORD PTR __Format$[ebp]
push DWORD PTR __Stream$[ebp]
push DWORD PTR [eax+4]
push DWORD PTR [eax]
call DWORD PTR __imp____stdio_common_vfprintf
add esp, 24 ; 00000018H
; 643 : return __stdio_common_vfprintf(_CRT_INTERNAL_LOCAL_PRINTF_OPTIONS, _Stream, _Format, _Locale, _ArgList);
; 644 : }
pop ebp
ret 0
__vfprintf_l ENDP
_TEXT ENDS
; Function compile flags: /Ogtp
; File c:\program files (x86)\windows kits\10\include\10.0.17763.0\ucrt\corecrt_stdio_config.h
; COMDAT ___local_stdio_printf_options
_TEXT SEGMENT
___local_stdio_printf_options PROC ; COMDAT
mov ecx, OFFSET __2CC6E67D_corecrt_stdio_config@h
call @__CheckForDebuggerJustMyCode@4
mov eax, OFFSET ?_OptionsStorage@?1??__local_stdio_printf_options@@9@9 ; `__local_stdio_printf_options'::`2'::_OptionsStorage
ret 0
___local_stdio_printf_options ENDP
_TEXT ENDS
END
| 21.560797
| 126
| 0.623909
|
5911c3e932bd275e97ef8bf3c0c23bfaa251d1c6
| 439
|
asm
|
Assembly
|
oeis/016/A016273.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/016/A016273.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/016/A016273.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A016273: Expansion of 1/((1-2x)(1-3x)(1-5x)).
; Submitted by Jon Maiga
; 1,10,69,410,2261,11970,61909,315850,1598421,8050130,40425749,202656090,1014866581,5079099490,25409813589,127092049130,635589254741,3178333432050,15892828897429,79467630222970,397348609370901,1986774423719810,9933966253389269
mov $1,1
mov $2,1
mov $3,2
lpb $0
sub $0,1
mul $1,5
mul $3,3
add $3,2
add $1,$3
mul $2,2
add $2,1
sub $1,$2
lpe
mov $0,$1
| 23.105263
| 226
| 0.719818
|
57ffcfaa103dc54ceb841f0318696be8b10e79ce
| 345
|
asm
|
Assembly
|
src/cmath.asm
|
AmFobes/MineAssemble
|
3272c597a7b3935d3fa4cf37b77faef82d68e1cd
|
[
"MIT"
] | 479
|
2015-01-13T14:19:51.000Z
|
2022-03-30T05:19:05.000Z
|
src/cmath.asm
|
AmFobes/MineAssemble
|
3272c597a7b3935d3fa4cf37b77faef82d68e1cd
|
[
"MIT"
] | 8
|
2016-03-14T18:45:04.000Z
|
2021-03-29T19:59:35.000Z
|
src/cmath.asm
|
AmFobes/MineAssemble
|
3272c597a7b3935d3fa4cf37b77faef82d68e1cd
|
[
"MIT"
] | 34
|
2015-02-24T13:25:49.000Z
|
2022-01-21T17:34:59.000Z
|
;
; This file contains an implementation of part of the C math library
;
[bits 32]
global sinf, cosf, absf
section .text
sinf:
fld dword [esp + 4]
fsin
ret
cosf:
fld dword [esp + 4]
fcos
ret
absf:
fld dword [esp + 4]
fabs
ret
section .data
temp dd 0.0
| 13.269231
| 68
| 0.515942
|
bbee50b67e440dba48ae4b2f21bfafc79fd7c1aa
| 929
|
asm
|
Assembly
|
programs/oeis/286/A286577.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/286/A286577.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/286/A286577.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
; A286577: If n = 3k-1 then a(n) = a(k), otherwise a(n) = n.
; 0,1,1,3,4,1,6,7,3,9,10,4,12,13,1,15,16,6,18,19,7,21,22,3,24,25,9,27,28,10,30,31,4,33,34,12,36,37,13,39,40,1,42,43,15,45,46,16,48,49,6,51,52,18,54,55,19,57,58,7,60,61,21,63,64,22,66,67,3,69,70,24,72,73,25,75,76,9,78,79,27,81,82,28,84,85,10,87,88,30,90,91,31,93,94,4,96,97,33,99,100,34,102,103,12,105,106,36,108,109,37,111,112,13,114,115,39,117,118,40,120,121,1,123,124,42,126,127,43,129,130,15,132,133,45,135,136,46,138,139,16,141,142,48,144,145,49,147,148,6,150,151,51,153,154,52,156,157,18,159,160,54,162,163,55,165,166,19,168,169,57,171,172,58,174,175,7,177,178,60,180,181,61,183,184,21,186,187,63,189,190,64,192,193,22,195,196,66,198,199,67,201,202,3,204,205,69,207,208,70,210,211,24,213,214,72,216,217,73,219,220,25,222,223,75,225,226,76,228,229,9,231,232,78,234,235,79,237,238,27,240,241,81,243,244,82,246,247,28,249
lpb $0
add $0,1
dif $0,3
lpe
mov $1,$0
| 103.222222
| 823
| 0.674919
|
7bcb27a236b4cad85370549be0a2298b6f0c7689
| 222
|
asm
|
Assembly
|
programs/oeis/043/A043554.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/043/A043554.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/043/A043554.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
; A043554: Essentially same as A005811.
; 1,1,2,1,2,3,2,1,2,3,4,3,2,3,2,1,2,3,4,3,4,5,4,3,2,3,4,3
cal $0,5811 ; Number of runs in binary expansion of n (n>0); number of 1's in Gray code for n.
trn $0,1
add $1,$0
add $1,1
| 27.75
| 94
| 0.630631
|
499a60dffd04c777684a07ea38f19f07720e491a
| 505
|
asm
|
Assembly
|
oeis/105/A105531.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/105/A105531.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/105/A105531.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A105531: Decimal expansion of arctan 1/3.
; Submitted by Jon Maiga
; 3,2,1,7,5,0,5,5,4,3,9,6,6,4,2,1,9,3,4,0,1,4,0,4,6,1,4,3,5,8,6,6,1,3,1,9,0,2,0,7,5,5,2,9,5,5,5,7,6,5,6,1,9,1,4,3,2,8,0,3,0,5,9,3,5,6,7,5,6,2,3,7,4,0,5,8,1,0,5,4,4,3,5,6,4,0,8,4,2,2,3,5,0,6,4,1,3,7,4,4
mov $1,1
mov $2,1
mov $3,$0
mul $3,4
lpb $3
mul $1,$3
mov $5,$3
mul $5,2
add $5,1
mul $2,$5
mul $2,5
add $1,$2
div $1,$5
div $2,$5
sub $3,1
lpe
mul $1,3
mov $4,10
pow $4,$0
div $2,$4
div $1,$2
mov $0,$1
mod $0,10
| 18.035714
| 201
| 0.526733
|
38c810c52e5ade94e5b1da79dbe79cca8caa9c60
| 287
|
asm
|
Assembly
|
oeis/021/A021360.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/021/A021360.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/021/A021360.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A021360: Decimal expansion of 1/356.
; 0,0,2,8,0,8,9,8,8,7,6,4,0,4,4,9,4,3,8,2,0,2,2,4,7,1,9,1,0,1,1,2,3,5,9,5,5,0,5,6,1,7,9,7,7,5,2,8,0,8,9,8,8,7,6,4,0,4,4,9,4,3,8,2,0,2,2,4,7,1,9,1,0,1,1,2,3,5,9,5,5,0,5,6,1,7,9,7,7,5,2,8,0,8,9,8,8,7,6
seq $0,173833 ; 10^n - 3.
div $0,356
mod $0,10
| 41
| 199
| 0.54007
|
33c3578d038f5b7a1e19a86ce7f1aa4171af5aee
| 170
|
asm
|
Assembly
|
libsrc/_DEVELOPMENT/adt/ba_stack/c/sccz80/ba_stack_pop.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
libsrc/_DEVELOPMENT/adt/ba_stack/c/sccz80/ba_stack_pop.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
libsrc/_DEVELOPMENT/adt/ba_stack/c/sccz80/ba_stack_pop.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
; int ba_stack_pop(ba_stack_t *s)
SECTION code_adt_ba_stack
PUBLIC ba_stack_pop
defc ba_stack_pop = asm_ba_stack_pop
INCLUDE "adt/ba_stack/z80/asm_ba_stack_pop.asm"
| 15.454545
| 47
| 0.823529
|
64db7c1b3a56195e73385e4be00348391e004d18
| 333
|
asm
|
Assembly
|
src/data/lumine-text.asm
|
Iemnur/Mother2GbaTranslation
|
b8ca6df07ef69762fc5cc7453657b8e71178c78d
|
[
"MIT"
] | 149
|
2015-03-19T11:22:47.000Z
|
2022-03-23T17:57:39.000Z
|
src/data/lumine-text.asm
|
Iemnur/Mother2GbaTranslation
|
b8ca6df07ef69762fc5cc7453657b8e71178c78d
|
[
"MIT"
] | 77
|
2015-06-16T17:38:47.000Z
|
2022-01-24T14:21:28.000Z
|
src/data/lumine-text.asm
|
Iemnur/Mother2GbaTranslation
|
b8ca6df07ef69762fc5cc7453657b8e71178c78d
|
[
"MIT"
] | 29
|
2015-06-16T00:58:04.000Z
|
2021-12-23T22:38:30.000Z
|
.loadtable "data/lumine-table.tbl"
.strn "\blank"
.strn "I'm \cness.... It's been a long road getting here... "
.strn "Soon, I'll be... Soon, I'll be... Soon, I'll be... "
.strn "What will happen to us? W...what's happening? "
.strn "My thoughts are being written out on the wall... or are they?"
.str "\blank"
| 37
| 72
| 0.600601
|
8a4557ec980884a50933773776653e6ea41bc2c8
| 6,376
|
asm
|
Assembly
|
Transynther/x86/_processed/NONE/_zr_/i9-9900K_12_0xa0.log_21829_879.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 9
|
2020-08-13T19:41:58.000Z
|
2022-03-30T12:22:51.000Z
|
Transynther/x86/_processed/NONE/_zr_/i9-9900K_12_0xa0.log_21829_879.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 1
|
2021-04-29T06:29:35.000Z
|
2021-05-13T21:02:30.000Z
|
Transynther/x86/_processed/NONE/_zr_/i9-9900K_12_0xa0.log_21829_879.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 3
|
2020-07-14T17:07:07.000Z
|
2022-03-21T01:12:22.000Z
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r15
push %r8
push %rax
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0xdba8, %rax
nop
nop
nop
nop
and %r15, %r15
movw $0x6162, (%rax)
nop
nop
nop
mfence
lea addresses_normal_ht+0x53d1, %rsi
lea addresses_A_ht+0x10358, %rdi
dec %r10
mov $83, %rcx
rep movsw
inc %r10
lea addresses_WT_ht+0x10848, %r10
nop
nop
nop
nop
nop
inc %r15
mov (%r10), %esi
xor %r10, %r10
lea addresses_UC_ht+0x2ba8, %rcx
xor $57120, %r8
mov $0x6162636465666768, %rax
movq %rax, %xmm2
vmovups %ymm2, (%rcx)
cmp %rax, %rax
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r8
pop %r15
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r15
push %r8
push %r9
push %rax
push %rsi
// Load
lea addresses_UC+0x7070, %r8
nop
nop
nop
dec %rsi
mov (%r8), %ax
nop
nop
nop
nop
nop
and $10054, %r11
// Store
mov $0xfa8, %r11
nop
nop
nop
nop
nop
cmp %r15, %r15
movb $0x51, (%r11)
nop
nop
nop
nop
nop
and $61533, %r11
// Store
lea addresses_US+0x1360c, %r8
add $56901, %r15
mov $0x5152535455565758, %r11
movq %r11, %xmm0
vmovups %ymm0, (%r8)
nop
nop
cmp $19260, %r9
// Store
lea addresses_RW+0xe3a8, %r15
nop
nop
sub %r8, %r8
mov $0x5152535455565758, %rsi
movq %rsi, %xmm5
movups %xmm5, (%r15)
nop
nop
nop
and $23297, %rsi
// Store
lea addresses_D+0x178fc, %rax
nop
nop
nop
nop
cmp $47638, %r15
movl $0x51525354, (%rax)
nop
nop
nop
xor $63816, %r11
// Store
lea addresses_WT+0x1b5ba, %rsi
nop
nop
add %r12, %r12
mov $0x5152535455565758, %r9
movq %r9, %xmm0
movups %xmm0, (%rsi)
nop
nop
nop
xor $5117, %r9
// Faulty Load
lea addresses_RW+0xe3a8, %r12
sub $2109, %r9
movups (%r12), %xmm6
vpextrq $1, %xmm6, %r8
lea oracles, %r9
and $0xff, %r8
shlq $12, %r8
mov (%r9,%r8,1), %r8
pop %rsi
pop %rax
pop %r9
pop %r8
pop %r15
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_RW', 'AVXalign': False, 'size': 16}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': False, 'congruent': 3, 'type': 'addresses_UC', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 7, 'type': 'addresses_P', 'AVXalign': False, 'size': 1}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_US', 'AVXalign': False, 'size': 32}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_RW', 'AVXalign': False, 'size': 16}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 1, 'type': 'addresses_D', 'AVXalign': False, 'size': 4}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 1, 'type': 'addresses_WT', 'AVXalign': False, 'size': 16}}
[Faulty Load]
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_RW', 'AVXalign': False, 'size': 16}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'NT': False, 'same': True, 'congruent': 11, 'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 2}}
{'src': {'same': False, 'congruent': 0, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 3, 'type': 'addresses_A_ht'}}
{'src': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 4}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 8, 'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 32}}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
| 35.820225
| 2,999
| 0.653231
|
14688d030bf5e8bf47c8fa0029f8e611cea9e8b6
| 4,738
|
asm
|
Assembly
|
Transynther/x86/_processed/NONE/_zr_/i7-7700_9_0xca.log_21829_756.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 9
|
2020-08-13T19:41:58.000Z
|
2022-03-30T12:22:51.000Z
|
Transynther/x86/_processed/NONE/_zr_/i7-7700_9_0xca.log_21829_756.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 1
|
2021-04-29T06:29:35.000Z
|
2021-05-13T21:02:30.000Z
|
Transynther/x86/_processed/NONE/_zr_/i7-7700_9_0xca.log_21829_756.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 3
|
2020-07-14T17:07:07.000Z
|
2022-03-21T01:12:22.000Z
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r13
push %r14
push %r9
push %rax
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0xfcdd, %r13
nop
nop
nop
nop
nop
and %r14, %r14
mov (%r13), %r11w
nop
nop
nop
add %r9, %r9
lea addresses_A_ht+0x11bdd, %rsi
lea addresses_UC_ht+0xcdc1, %rdi
nop
nop
nop
nop
nop
and $41786, %rax
mov $65, %rcx
rep movsl
nop
nop
nop
nop
add %rax, %rax
lea addresses_A_ht+0xdbdd, %r13
nop
nop
nop
sub $40691, %r11
and $0xffffffffffffffc0, %r13
vmovntdqa (%r13), %ymm2
vextracti128 $1, %ymm2, %xmm2
vpextrq $0, %xmm2, %rax
nop
nop
nop
sub %r14, %r14
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r9
pop %r14
pop %r13
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %rbp
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
// Faulty Load
lea addresses_A+0x97dd, %rbx
nop
nop
nop
nop
nop
xor %rcx, %rcx
movb (%rbx), %dl
lea oracles, %rbp
and $0xff, %rdx
shlq $12, %rdx
mov (%rbp,%rdx,1), %rdx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'congruent': 0, 'AVXalign': False, 'same': True, 'size': 32, 'NT': False, 'type': 'addresses_A'}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'congruent': 0, 'AVXalign': False, 'same': True, 'size': 1, 'NT': False, 'type': 'addresses_A'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'congruent': 5, 'AVXalign': False, 'same': False, 'size': 2, 'NT': False, 'type': 'addresses_normal_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 8, 'same': False, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'congruent': 2, 'same': True, 'type': 'addresses_UC_ht'}}
{'src': {'congruent': 9, 'AVXalign': False, 'same': False, 'size': 32, 'NT': True, 'type': 'addresses_A_ht'}, 'OP': 'LOAD'}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
| 44.698113
| 2,999
| 0.662938
|
f4329cc8c3ea3f4c4c3fd329287b9fd54aa27b5d
| 9,024
|
asm
|
Assembly
|
scripts/viridianpokecenter.asm
|
longlostsoul/EvoYellow
|
fe5d0d372c4e90d384c4005a93f19d7968f2ff13
|
[
"Unlicense"
] | 16
|
2018-08-28T21:47:01.000Z
|
2022-02-20T20:29:59.000Z
|
scripts/viridianpokecenter.asm
|
longlostsoul/EvoYellow
|
fe5d0d372c4e90d384c4005a93f19d7968f2ff13
|
[
"Unlicense"
] | 5
|
2019-04-03T19:53:11.000Z
|
2022-03-11T22:49:34.000Z
|
scripts/viridianpokecenter.asm
|
longlostsoul/EvoYellow
|
fe5d0d372c4e90d384c4005a93f19d7968f2ff13
|
[
"Unlicense"
] | 2
|
2019-12-09T19:46:02.000Z
|
2020-12-05T21:36:30.000Z
|
ViridianPokeCenterScript:
call Serial_TryEstablishingExternallyClockedConnection
jp EnableAutoTextBoxDrawing
ViridianPokecenterTextPointers:
dw ViridianHealNurseText
dw ViridianPokeCenterText2
dw ViridianPokeCenterText3
dw ViridianTradeNurseText
dw ViridianPokeCenterText5
ViridianHealNurseText:
TX_POKECENTER_NURSE
ViridianPokeCenterText2:
TX_FAR _ViridianPokeCenterText2
db "@"
ViridianPokeCenterText3:
TX_FAR _ViridianPokeCenterText3
db "@"
ViridianTradeNurseText:
;TX_CABLE_CLUB_RECEPTIONIST
TX_ASM
call SaveScreenTilesToBuffer2
;Shamelessly nicking Wonder Trade from Matteo's Red++
; Display the "Welcome to the Global Terminal" text
ld hl, WelcomeToGlobalText
call PrintText
call ManualTextScroll
; Check if the player has a Pokedex yet
CheckEvent EVENT_GOT_POKEDEX
jr nz, .hasPokedex ; If you do, jump to the rest of the routine
; If the player DOES NOT have a Pokedex, say they can't trade yet
ld hl, BeingAdjustedText
jp PrintText
jp TextScriptEnd
; If the player has a Pokedex, go on to ask if they want to make a Wonder Trade
.hasPokedex
ld hl, WouldYouLikeToWonderTradeText
call PrintText
call YesNoChoice
ld a,[wCurrentMenuItem]
and a
jr nz,.comeAgain
call WonderTrade_DoTrade
jr c, .comeAgain ; If the trade failed, go to the "please come again" text
ld hl, CompletedWonderTradeText ; Otherwise do the "completed a trade" text
jp PrintText
jp TextScriptEnd
.comeAgain
ld hl, ComeAgainText
jp PrintText
jp TextScriptEnd
ViridianPokeCenterText5:
TX_ASM
callab PokecenterChanseyText
jp TextScriptEnd
; Main routine for making Wonder Trade happen
; Most of this copied directly from the in-game trade function and modified to work the way we want
WonderTrade_DoTrade:
; Open a normal party menu and let the player choose a Pokemon
xor a
ld [wNamingScreenType],a
dec a
ld [wUpdateSpritesEnabled],a
call DisplayPartyMenu
push af
call WonderTrade_RestoreScreen
pop af
ld a,$1
jp c,.tradeFailed ; jump if the player didn't select a pokemon
; Make sure they didn't try to offer something the game can't give in return
ld a, [wcf91] ; Pokemon you selected
call CheckForBanned ; Check to make sure this isn't a banned Pokemon
and a
jr nz, .keepGoing ; if it wasn't banned, keep going with the trade
ld hl, BannedMonText
call PrintText
call ManualTextScroll
jr WonderTrade_DoTrade ; If it was banned, let them try again
; If it wasn't banned, set what they offered as the GiveMon
.keepGoing
ld a, [wcf91] ; Grab the Pokemon we chose from the menu again
ld [wInGameTradeGiveMonSpecies], a ; store as the GiveMon
ld de,wInGameTradeGiveMonName ; Location to copy its name to
call WonderTrade_GetMonName ; Copy the name of the Pokemon the player chose into this address
; Ask if the player is sure they want to trade this Pokemon
ld hl, AreYouSureText
call PrintText
call YesNoChoice
ld a,[wCurrentMenuItem]
and a
jr nz,.tradeFailed ; If not, cancel the trade
; Setup the variables for the Received Pokemon name and ID before the trade
call GetWonderTradeReceiveMon ; Come up with a Random Pokemon for them to receive
ld [wInGameTradeReceiveMonSpecies],a ; Store this as the ReceiveMon
ld de,wInGameTradeReceiveMonName ; Location to copy its name to
call WonderTrade_GetMonName ; Copy the name of the Pokemon to this address
ld a, [wInGameTradeReceiveMonSpecies] ; Load the receivemon back into a
ld de, wInGameTradeMonNick ; Location to copy its name to again
call WonderTrade_GetMonName ; Copy its name to be the Nickname
; Take whatever level the Pokemon you offered was, and set it to be the level the received 'mon will be
ld a,[wWhichPokemon]
ld hl,wPartyMon1Level
ld bc,$002c
call AddNTimes
ld a,[hl]
ld [wCurEnemyLVL],a
; Connet the link cable like so
ld hl, WonderConnectCableText
call PrintText
; Do the actual trade stuff
ld a,[wWhichPokemon]
push af
ld a,[wCurEnemyLVL]
push af
call LoadHpBarAndStatusTilePatterns
call WonderTrade_PrepareTradeData
predef InternalClockTradeAnim
pop af
ld [wCurEnemyLVL],a
pop af
ld [wWhichPokemon],a
ld a,[wInGameTradeReceiveMonSpecies] ;load the mon to get
ld [wcf91],a
xor a
ld [wMonDataLocation],a
ld [wRemoveMonFromBox],a
call RemovePokemon
ld a,$80
ld [wMonDataLocation],a
call AddPartyMon
call WonderTrade_CopyDataToReceivedMon
callba InGameTrade_CheckForTradeEvo
call ClearScreen
call WonderTrade_RestoreScreen
callba RedrawMapView
and a
ld a,$3
jr .tradeSucceeded
.tradeFailed
scf
.tradeSucceeded
ret
WonderTrade_RestoreScreen: ; Restore the screen stuff when we're done
call GBPalWhiteOutWithDelay3
call RestoreScreenTilesAndReloadTilePatterns
call ReloadTilesetTilePatterns
call LoadScreenTilesFromBuffer2
call Delay3
call LoadGBPal
ld c, 10
call DelayFrames
ld b, BANK(LoadWildData)
ld hl, LoadWildData
jp Bankswitch
WonderTrade_PrepareTradeData: ; Get the data setup for the trade
ld hl, wTradedPlayerMonSpecies
ld a, [wInGameTradeGiveMonSpecies]
ld [hli], a ; wTradedPlayerMonSpecies
ld a, [wInGameTradeReceiveMonSpecies]
ld [hl], a ; wTradedEnemyMonSpecies
ld hl, wPartyMonOT
ld bc, NAME_LENGTH
ld a, [wWhichPokemon]
call AddNTimes
ld de, wTradedPlayerMonOT
ld bc, NAME_LENGTH
call WonderTrade_CopyData
ld hl, WonderTrade_TrainerString
ld de, wTradingWhichEnemyMon ;MonOT
call WonderTrade_CopyData
ld de, wGrassRate ;TrainerName
call WonderTrade_CopyData
ld hl, wPartyMon1OTID
ld bc, wPartyMon2 - wPartyMon1
ld a, [wWhichPokemon]
call AddNTimes
ld de, wTradedPlayerMonOTID
ld bc, $2
call WonderTrade_CopyData
call Random
ld hl, hRandomAdd
ld de, wTradedEnemyMonOTID
jp CopyData
; copies name of species a to hl
WonderTrade_GetMonName:
push de
ld [wd11e],a
call GetMonName
ld hl,wcd6d
pop de
ld bc,$b
jp CopyData
; Copy data without losing your place
WonderTrade_CopyData:
push hl
push bc
call CopyData
pop bc
pop hl
ret
WonderTrade_CopyDataToReceivedMon: ; Copy the Nickname and OT from RAM to the Pokemon
ld hl, wPartyMonNicks
ld bc, $b
call WonderTrade_GetReceivedMonPointer
ld hl, wInGameTradeMonNick
ld bc, $b
call CopyData
ld hl, wPartyMonOT
ld bc, $b
call WonderTrade_GetReceivedMonPointer
ld hl, WonderTrade_TrainerString
ld bc, $b
call CopyData
ld hl, wPartyMon1OTID
ld bc, wPartyMon2 - wPartyMon1
call WonderTrade_GetReceivedMonPointer
ld hl, wTradedEnemyMonOTID
ld bc, $2
jp CopyData
; the received mon's index is (partyCount - 1),
; so this adds bc to hl (partyCount - 1) times and moves the result to de
WonderTrade_GetReceivedMonPointer:
ld a, [wPartyCount]
dec a
call AddNTimes
ld e, l
ld d, h
ret
WonderTrade_TrainerString:
db "MYSTERY@@@@"
; Stores a random Pokemon ID into register a
; Makes sure it is a valid Pokemon ID
; Makes sure it is NOT in the list of banned pokemon
GetWonderTradeReceiveMon:
call Random ; Get a random number
and a ; Check if it was 0
jr z, GetWonderTradeReceiveMon ; If it was zero, try again
cp NUM_POKEMON + 1 ; Make sure it is a valid Pokemon ID
jr nc, GetWonderTradeReceiveMon ; If it wasn't, try again
ld b, a ; Store this in Register b so we don't lose it
ld hl, BannedMons ; Load the table of Pokemon that we don't need showing up in Wonder Trade
.loop
ld a, [hli] ; Read entry from list
cp b ; See if it matches the ID we generated
jr z, GetWonderTradeReceiveMon ; If it does, try again
inc a ; Increase it, to see if we hit the end of the list ($FF)
jr nz, .loop ; If we haven't hit the end of the list, keep checking
ld a,b ; If we made it through the list ok, put the ID we generated back into a where it needs to be
ret ; We're done here
CheckForBanned: ; Check if the player tried to trade a banned Pokemon
ld b,a ; store in b so we don't lose it
ld hl,BannedMons ; load table of banned mons
.loop
ld a, [hli] ; read the entry from the list
cp b ; see if it matches the one the player chose
jr z, .banned ; if it did, mark that as a banned Pokemon
inc a ; otherwise, check to see if we are at the end of the list
jr nz, .loop ; if we aren't, loop again to keep reading the list
ld a,b ; if we're done, put the Pokemon ID back in a
ret
.banned ; if the Pokemon was banned, set a to zero
xor a
ret
BannedMons: ; List of Pokemon not allowed to show up in Wonder Trade
db ARTICUNO
db ZAPDOS
db MOLTRES
db MEWTWO
db MEW
db RAIKOU
db SUICUNE
db ENTEI
db $FF
WonderConnectCableText:
TX_FAR _ConnectCableText
db "@"
WelcomeToGlobalText:
text "Connecting! Note,"
line "slightly buggy.@@"
BeingAdjustedText:
text "The system is"
line "unusable without"
cont "a pokedex."
para "Please try back"
line "later.@@"
WouldYouLikeToWonderTradeText:
text "Would you like to"
line "use WONDER TRADE?@@"
ComeAgainText:
text "Come again!@@"
line "@@"
CompletedWonderTradeText:
text "Trade complete!"
line "@@"
BannedMonText:
text "Please "
line "choose again!@@"
AreYouSureText:
text "You will not be"
line "able to get your"
cont "#MON back if"
cont "you continue."
para "Are you sure you"
line "want to trade?@@"
| 26.541176
| 104
| 0.769171
|
af81fff7f91dfb460e8c9d1a652a8d42d4875774
| 581
|
asm
|
Assembly
|
oeis/024/A024015.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/024/A024015.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/024/A024015.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A024015: 2^n-n^5.
; 1,1,-28,-235,-1008,-3093,-7712,-16679,-32512,-58537,-98976,-159003,-244736,-363101,-521440,-726607,-983040,-1288785,-1627424,-1951811,-2151424,-1986949,-959328,1952265,8814592,23788807,55227488,119868821,251225088,516359763,1049441824,2118854497,4261412864,8550799199,17134433760,34307216493,68659010560,137369609515,274798671776,549665589689,1099409227776,2198907399351,4397915819872,8795946013765,17592021128192,35184187560707,70368538214688,140737259010321,281474721906688,562949670946063
mov $1,2
pow $1,$0
pow $0,5
add $0,1
sub $1,$0
add $1,1
mov $0,$1
| 52.818182
| 493
| 0.803787
|
9cbe1d0eb94574fc8b2b0d9cc60336cf06cedca2
| 4,093
|
asm
|
Assembly
|
audio/sfx_pointers.asm
|
MathyFurret/CryEd
|
395f04b261ba7970226b47e7c50406a58eb2fda0
|
[
"MIT"
] | 1
|
2019-02-12T03:36:48.000Z
|
2019-02-12T03:36:48.000Z
|
audio/sfx_pointers.asm
|
MathyFurret/CryEd
|
395f04b261ba7970226b47e7c50406a58eb2fda0
|
[
"MIT"
] | null | null | null |
audio/sfx_pointers.asm
|
MathyFurret/CryEd
|
395f04b261ba7970226b47e7c50406a58eb2fda0
|
[
"MIT"
] | 1
|
2021-03-27T00:03:08.000Z
|
2021-03-27T00:03:08.000Z
|
SFX: ; e927c
; entries correspond to SFX_* constants
dba Sfx_DexFanfare5079
dba Sfx_Item
dba Sfx_CaughtMon
dba Sfx_PokeballsPlacedOnTable
dba Sfx_Potion
dba Sfx_FullHeal
dba Sfx_Menu
dba Sfx_ReadText
dba Sfx_ReadText2
dba Sfx_DexFanfare2049
dba Sfx_DexFanfare80109
dba Sfx_Poison
dba Sfx_GotSafariBalls
dba Sfx_BootPc
dba Sfx_ShutDownPc
dba Sfx_ChoosePcOption
dba Sfx_EscapeRope
dba Sfx_PushButton
dba Sfx_SecondPartOfItemfinder
dba Sfx_WarpTo
dba Sfx_WarpFrom
dba Sfx_ChangeDexMode
dba Sfx_JumpOverLedge
dba Sfx_GrassRustle
dba Sfx_Fly
dba Sfx_Wrong
dba Sfx_Squeak
dba Sfx_Strength
dba Sfx_Boat
dba Sfx_WallOpen
dba Sfx_PlacePuzzlePieceDown
dba Sfx_EnterDoor
dba Sfx_SwitchPokemon
dba Sfx_Tally
dba Sfx_Transaction
dba Sfx_ExitBuilding
dba Sfx_Bump
dba Sfx_Save
dba Sfx_Pokeflute
dba Sfx_ElevatorEnd
dba Sfx_ThrowBall
dba Sfx_BallPoof
dba Sfx_Unknown3A
dba Sfx_Run
dba Sfx_SlotMachineStart
dba Sfx_Fanfare
dba Sfx_Peck
dba Sfx_Kinesis
dba Sfx_Lick
dba Sfx_Pound
dba Sfx_MovePuzzlePiece
dba Sfx_CometPunch
dba Sfx_MegaPunch
dba Sfx_Scratch
dba Sfx_Vicegrip
dba Sfx_RazorWind
dba Sfx_Cut
dba Sfx_WingAttack
dba Sfx_Whirlwind
dba Sfx_Bind
dba Sfx_VineWhip
dba Sfx_DoubleKick
dba Sfx_MegaKick
dba Sfx_Headbutt
dba Sfx_HornAttack
dba Sfx_Tackle
dba Sfx_PoisonSting
dba Sfx_Powder
dba Sfx_Doubleslap
dba Sfx_Bite
dba Sfx_JumpKick
dba Sfx_Stomp
dba Sfx_TailWhip
dba Sfx_KarateChop
dba Sfx_Submission
dba Sfx_WaterGun
dba Sfx_SwordsDance
dba Sfx_Thunder
dba Sfx_Supersonic
dba Sfx_Leer
dba Sfx_Ember
dba Sfx_Bubblebeam
dba Sfx_HydroPump
dba Sfx_Surf
dba Sfx_Psybeam
dba Sfx_Charge
dba Sfx_Thundershock
dba Sfx_Psychic
dba Sfx_Screech
dba Sfx_BoneClub
dba Sfx_Sharpen
dba Sfx_EggBomb
dba Sfx_Sing
dba Sfx_HyperBeam
dba Sfx_Shine
dba Sfx_Unknown5F
dba Sfx_Unknown60
dba Sfx_Unknown61
dba Sfx_SwitchPockets
dba Sfx_Unknown63
dba Sfx_Burn
dba Sfx_TitleScreenEntrance
dba Sfx_Unknown66
dba Sfx_GetCoinFromSlots
dba Sfx_PayDay
dba Sfx_Metronome
dba Sfx_Call
dba Sfx_HangUp
dba Sfx_NoSignal
dba Sfx_Sandstorm
dba Sfx_Elevator
dba Sfx_Protect
dba Sfx_Sketch
dba Sfx_RainDance
dba Sfx_Aeroblast
dba Sfx_Spark
dba Sfx_Curse
dba Sfx_Rage
dba Sfx_Thief
dba Sfx_Thief2
dba Sfx_SpiderWeb
dba Sfx_MindReader
dba Sfx_Nightmare
dba Sfx_Snore
dba Sfx_SweetKiss
dba Sfx_SweetKiss2
dba Sfx_BellyDrum
dba Sfx_Unknown7F
dba Sfx_SludgeBomb
dba Sfx_Foresight
dba Sfx_Spite
dba Sfx_Outrage
dba Sfx_PerishSong
dba Sfx_GigaDrain
dba Sfx_Attract
dba Sfx_Kinesis2
dba Sfx_ZapCannon
dba Sfx_MeanLook
dba Sfx_HealBell
dba Sfx_Return
dba Sfx_ExpBar
dba Sfx_MilkDrink
dba Sfx_Present
dba Sfx_MorningSun
dba Sfx_LevelUp
dba Sfx_KeyItem
dba Sfx_Fanfare2
dba Sfx_RegisterPhoneNumber
dba Sfx_3RdPlace
dba Sfx_GetEggFromDayCareMan
dba Sfx_GetEggFromDayCareLady
dba Sfx_MoveDeleted
dba Sfx_2ndPlace
dba Sfx_1stPlace
dba Sfx_ChooseACard
dba Sfx_GetTm
dba Sfx_GetBadge
dba Sfx_QuitSlots
dba Sfx_EggCrack
dba Sfx_DexFanfareLessThan20
dba Sfx_DexFanfare140169
dba Sfx_DexFanfare170199
dba Sfx_DexFanfare200229
dba Sfx_DexFanfare230Plus
dba Sfx_Evolved
dba Sfx_MasterBall
dba Sfx_EggHatch
dba Sfx_GsIntroCharizardFireball
dba Sfx_GsIntroPokemonAppears
dba Sfx_Flash
dba Sfx_GameFreakLogoGs
dba Sfx_NotVeryEffective
dba Sfx_Damage
dba Sfx_SuperEffective
dba Sfx_BallBounce
dba Sfx_Moonlight
dba Sfx_Encore
dba Sfx_BeatUp
dba Sfx_BatonPass
dba Sfx_BallWobble
dba Sfx_SweetScent
dba Sfx_SweetScent2
dba Sfx_HitEndOfExpBar
dba Sfx_GiveTrademon
dba Sfx_GetTrademon
dba Sfx_TrainArrived
dba Sfx_StopSlot
dba Sfx_2Boops
dba Sfx_GlassTing
dba Sfx_GlassTing2
; Crystal adds the following SFX:
dba Sfx_IntroUnown1
dba Sfx_IntroUnown2
dba Sfx_IntroUnown3
dba Sfx_DittoPopUp
dba Sfx_DittoTransform
dba Sfx_IntroSuicune1
dba Sfx_IntroPichu
dba Sfx_IntroSuicune2
dba Sfx_IntroSuicune3
dba Sfx_DittoBounce
dba Sfx_IntroSuicune4
dba Sfx_GameFreakPresents
dba Sfx_Tingle
dba Sfx_UnknownCB
dba Sfx_TwoPcBeeps
dba Sfx_4NoteDitty
dba Sfx_Twinkle
; e94e9
| 19.037209
| 39
| 0.841681
|
e591d8d539c9e23bfb67a29ff31f4aaa16d97240
| 686
|
asm
|
Assembly
|
oeis/041/A041085.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/041/A041085.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/041/A041085.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A041085: Denominators of continued fraction convergents to sqrt(50).
; Submitted by Jon Maiga
; 1,14,197,2772,39005,548842,7722793,108667944,1529074009,21515704070,302748930989,4260000737916,59942759261813,843458630403298,11868363584907985,167000548819115088,2349876047052519217,33065265207554384126,465263588952813896981,6546755510546948941860,92119840736610099083021,1296224525823088336104154,18239263202259846804541177,256645909357460943599680632,3611281994206713057200070025,50814593828251443744400660982,715015595589726925478809323773,10061032932084428400447731193804
mov $3,1
lpb $0
sub $0,1
add $2,$3
mov $3,$1
mov $1,$2
mul $2,7
add $3,$2
lpe
add $2,$3
mov $0,$2
| 42.875
| 478
| 0.841108
|
485467710f7ef6b2bfcc3c42e359d9e72290ee3c
| 6,020
|
asm
|
Assembly
|
Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_1228.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 9
|
2020-08-13T19:41:58.000Z
|
2022-03-30T12:22:51.000Z
|
Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_1228.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 1
|
2021-04-29T06:29:35.000Z
|
2021-05-13T21:02:30.000Z
|
Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_1228.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 3
|
2020-07-14T17:07:07.000Z
|
2022-03-21T01:12:22.000Z
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r14
push %r9
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_D_ht+0x186d, %rsi
lea addresses_WC_ht+0x1b26d, %rdi
clflush (%rsi)
nop
and $4614, %rdx
mov $81, %rcx
rep movsb
nop
nop
nop
nop
nop
xor $505, %r14
lea addresses_WT_ht+0x19ed, %rbx
clflush (%rbx)
nop
nop
nop
add $63118, %r9
movups (%rbx), %xmm3
vpextrq $1, %xmm3, %rsi
add $59387, %rsi
lea addresses_A_ht+0x4a0d, %rsi
lea addresses_normal_ht+0x14a6d, %rdi
cmp $65307, %r10
mov $110, %rcx
rep movsb
nop
sub %rdx, %rdx
lea addresses_WT_ht+0x9d6d, %rsi
lea addresses_D_ht+0x746d, %rdi
nop
xor $29211, %rbx
mov $85, %rcx
rep movsq
nop
nop
inc %rsi
lea addresses_WC_ht+0x132d, %rdx
nop
sub %rcx, %rcx
movw $0x6162, (%rdx)
nop
nop
nop
nop
xor %rcx, %rcx
lea addresses_D_ht+0x1d548, %rsi
lea addresses_UC_ht+0x188dd, %rdi
nop
nop
nop
nop
nop
xor %rdx, %rdx
mov $38, %rcx
rep movsb
nop
nop
nop
nop
nop
add $51324, %rdx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r9
pop %r14
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r14
push %rax
push %rbp
push %rbx
push %rdx
// Store
lea addresses_normal+0x5c7d, %rbx
nop
inc %r13
movb $0x51, (%rbx)
nop
dec %rbx
// Store
lea addresses_RW+0x39a8, %r13
cmp $29099, %r10
mov $0x5152535455565758, %rbx
movq %rbx, %xmm4
vmovups %ymm4, (%r13)
inc %rdx
// Faulty Load
lea addresses_normal+0x1aa6d, %r10
nop
nop
nop
and %r13, %r13
mov (%r10), %r14w
lea oracles, %rdx
and $0xff, %r14
shlq $12, %r14
mov (%rdx,%r14,1), %r14
pop %rdx
pop %rbx
pop %rbp
pop %rax
pop %r14
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'NT': True, 'AVXalign': True, 'size': 2, 'type': 'addresses_normal', 'congruent': 0}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_normal', 'congruent': 1}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_RW', 'congruent': 0}, 'OP': 'STOR'}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_normal', 'congruent': 0}}
<gen_prepare_buffer>
{'dst': {'same': False, 'congruent': 11, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 8, 'type': 'addresses_D_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_WT_ht', 'congruent': 6}}
{'dst': {'same': False, 'congruent': 10, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 5, 'type': 'addresses_A_ht'}}
{'dst': {'same': False, 'congruent': 7, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 6, 'type': 'addresses_WT_ht'}}
{'dst': {'same': True, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_WC_ht', 'congruent': 6}, 'OP': 'STOR'}
{'dst': {'same': False, 'congruent': 0, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 0, 'type': 'addresses_D_ht'}}
{'34': 21829}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
| 40.675676
| 2,999
| 0.660465
|
752343dbad6d0bca77855d129f438a471643edfa
| 986
|
asm
|
Assembly
|
codegen-tests/bitfield-class/icc13.0.1/10-shr-eq.asm
|
Deaod/bitfields
|
e84c18f18621637174edaffbefec486a45fbd9cf
|
[
"MIT"
] | null | null | null |
codegen-tests/bitfield-class/icc13.0.1/10-shr-eq.asm
|
Deaod/bitfields
|
e84c18f18621637174edaffbefec486a45fbd9cf
|
[
"MIT"
] | null | null | null |
codegen-tests/bitfield-class/icc13.0.1/10-shr-eq.asm
|
Deaod/bitfields
|
e84c18f18621637174edaffbefec486a45fbd9cf
|
[
"MIT"
] | null | null | null |
L__routine_start__Z11test_devicev_0:
test_device():
push rsi #270.20
call rand #272.14
mov edx, DWORD PTR [rsp] #173.21
mov esi, edx #249.23
and edx, 258048 #249.56
mov ecx, eax #249.80
shr edx, cl #249.80
and esi, -258049 #249.23
and edx, 258048 #249.87
or esi, edx #249.87
mov DWORD PTR [rsp], esi #173.9
pop rcx #291.1
ret #291.1
| 58
| 71
| 0.239351
|
d678f8b0ec9b9bbb0422a1117a5855303a890737
| 867
|
asm
|
Assembly
|
T2.asm
|
abphilip-vit/CollegeP2
|
3a68b9003e11c74af4185b2aa001c798dc05400a
|
[
"Apache-2.0"
] | 1
|
2021-04-22T08:08:42.000Z
|
2021-04-22T08:08:42.000Z
|
T2.asm
|
allenalvin333/CollegeP2
|
71a93954871876f148bc76d3740eb880dcd4099e
|
[
"Apache-2.0"
] | null | null | null |
T2.asm
|
allenalvin333/CollegeP2
|
71a93954871876f148bc76d3740eb880dcd4099e
|
[
"Apache-2.0"
] | null | null | null |
ORG 000H
CLR P2.0 // Motor 1
CLR P2.1 // Motor 2
CLR P2.2 // Motor 3
CLR P2.3 // Motor 4
CLR P0.0 // Left - p2.6
CLR P0.1 // Right - p2.7
FORWARD:
SETB P2.1
SETB P2.2
SJMP CHECK
LEFT:
RIGHT:
STOP:
void forward (void)
{
mot1=0;
mot2=1;
mot3=1;
mot4=0;
}
void backward (void)
{
mot1=0;
mot2=1;
mot3=0;
mot4=1;
}
void left (void)
{
mot1=0;
mot2=1;
mot3=0;
mot4=0;
}
void right (void)
{
mot1=0;
mot2=0;
mot3=1;
mot4=0;
}
void stop (void)
{
mot1=0;
mot2=0;
mot3=0;
mot4=0;
}
void main()
{
s_left=1;
s_right=1;
while(1)
{
if(s_left==0 && s_right==0)
{
forward();
}
else if(s_left==1 && s_right==1)
{
stop();
}
else if(s_left==0 && s_right==1)
{
left();
}
else if(s_left==1 && s_right==0)
{
right();
}
}
}
| 10.321429
| 35
| 0.486736
|
85cb37e677ce70783b3ec1072970239dc9f4c11f
| 3,463
|
nasm
|
Assembly
|
shellcode/shellcode.nasm
|
JS-Burns/CVE-2016-6366
|
0ba7426a9bf2a01c807608b7e1b63f87fe2699a5
|
[
"MIT"
] | 171
|
2016-09-22T23:35:35.000Z
|
2021-12-21T21:56:17.000Z
|
shellcode/shellcode.nasm
|
FDlucifer/CVE-2016-6366
|
0ba7426a9bf2a01c807608b7e1b63f87fe2699a5
|
[
"MIT"
] | 3
|
2016-09-27T01:05:07.000Z
|
2016-11-02T03:12:21.000Z
|
shellcode/shellcode.nasm
|
FDlucifer/CVE-2016-6366
|
0ba7426a9bf2a01c807608b7e1b63f87fe2699a5
|
[
"MIT"
] | 79
|
2016-09-22T23:16:29.000Z
|
2021-05-07T16:17:13.000Z
|
;
; Cisco ASA - Authentication Bypass 'EXTRABACON' (Improved Shellcode) (75 bytes)
;
; Copyright: (c) 2016 RiskSense, Inc. (https://risksense.com)
; License: http://opensource.org/licenses/MIT
; Release Date: September 15, 2016
;
; Author: Sean Dillon (PGP: 2E3C8D72353C9B8C9FF797E753EC4C9876D5727B)
;
; Description:
; This is not the same shellcode as the Equation Group version,
; but accomplishes the same task of disabling the auth functions
; in less stages/bytes. Particularly, it is 75 bytes in one stage
; instead of 200+ bytes spread across 2 stages.
;
; Build/Run:
; 1) $ nasm shelldisable.nasm
;
; Note: The offsets given are for 9.2(3), not part of the original release
;
BITS 32
; comment this out to generate the pass-enable shellcode
%define MODE_PASS_DISABLE
SAFERET_OFFSET equ 0x9277386 ; where to continue execution
PMCHECK_BOUNDS equ 0x9b78000 ; mprotect for pmcheck()
PMCHECK_OFFSET equ 0x9b78010 ; location of pmcheck()
ADMAUTH_BOUNDS equ 0x8085000 ; page align for admauth()
ADMAUTH_OFFSET equ 0x8085a40 ; location of admauth()
; we must patch pmcheck() and admauth() to always return true
; xor eax, eax = 31 c0
; inc eax = 40
; ret = c3
PATCHED_CODE equ 0xc340c031 ; gotta love endianess
PMCHECK_CODE equ 0x89c03155 ; the original bytes at pmcheck()
ADMAUTH_CODE equ 0x57e58955 ; the original bytes at admauth()
%ifdef MODE_PASS_DISABLE
%define PMCHECK_BYTES PATCHED_CODE
%define ADMAUTH_BYTES PATCHED_CODE
%else
%define PMCHECK_BYTES PMCHECK_CODE
%define ADMAUTH_BYTES ADMAUTH_CODE
%endif
; we need to fix the function frame to continue normal operation
; eax = 0x0
; esi = 0x0
; edi = 0x0b
; ebx = 0x10
; ebp = [esp - 0x4 (ret)] + 0x??
FIX_EBP equ 0x48 ; this is 0x58 in versions before 8.4(1)
FIX_EDI equ 0x0f0f0f0b ; seems static?
FIX_EBX equ 0x10 ; seems static?
_start:
; these are registers we have to clean up, so we can null them before save
xor ebx, ebx
xor esi, esi
xor ecx, ecx ; ecx is volatile register
xor eax, eax
pusha ; save all registers
xor edx, edx
add ch, 0x10 ; ecx = 0x1000
add dl, 0x7 ; edx = 0x7
add al, 0x7d ; eax = 0x7d
push eax ; save eax for second call
mov ebx, PMCHECK_BOUNDS ; ebx = byte boundary for mprotect
int 0x80 ; sys_mprotect(PMCHECK_BOUNDS, 0x1000, 0x7)
pop eax ; eax = 0x7d
mov ebx, ADMAUTH_BOUNDS ; second function page align
int 0x80 ; sys_mprotect(ADMAUTH_BOUNDS, 0x1000, 0x7)
mov dword [PMCHECK_OFFSET], PMCHECK_BYTES ; write patch code to both functions
mov dword [ADMAUTH_OFFSET], ADMAUTH_BYTES
popa ; restore all registers
push SAFERET_OFFSET ; push the safe return address
; these registers are pre-xored
add bl, FIX_EBX
mov edi, FIX_EDI
mov ebp, esp
add ebp, FIX_EBP
ret ; return to safe address
| 34.287129
| 87
| 0.588796
|
e53e00cc8e5266dc3aded432a265b81c6919b17c
| 3,718
|
asm
|
Assembly
|
risc-v/lab/intern-string.asm
|
tangfeixiong/learningclang
|
9dec3993173d29d32a8eca1726f5f740be06d798
|
[
"Apache-2.0"
] | 1
|
2018-04-13T03:09:08.000Z
|
2018-04-13T03:09:08.000Z
|
risc-v/lab/intern-string.asm
|
tangfeixiong/learningclang
|
9dec3993173d29d32a8eca1726f5f740be06d798
|
[
"Apache-2.0"
] | null | null | null |
risc-v/lab/intern-string.asm
|
tangfeixiong/learningclang
|
9dec3993173d29d32a8eca1726f5f740be06d798
|
[
"Apache-2.0"
] | 1
|
2018-06-30T09:14:09.000Z
|
2018-06-30T09:14:09.000Z
|
.data
.align 4
errEnvc: asciz "error: Environment call failed"
errDivz: asciz "error: Divided by zero failed"
asciiSpace: .byte '\t', '\n', '\v', '\f', '\r', ' '
asciiLineFeed: .byte 0x0a
asciiLineSpace: .byte 0x20
asciiEOT: .byte 4
arrIdentifiers: .space 512 # Hold identifiers, capacity=128
sizeIdentifiers: .4byte 0 # Size of identifiers
pHashTable: .space 128 # Hold hash, capacity=32
sizeHashTable: .4byte 0 # Size of hashtable
.text
internFileImpl:
addi s11, a0 # save original buffer pointer
addi a7, a7, 0 # offset of first interned-string
addi a6, a6, 0 # index of interned-string
addi t0, t0, 0 # length of interned-string
loop_space_front:
lb t1, 0(a0)
li t6, asciiEOT
beq t1, t6, done_space_front
li t6, asciiLineFeed
beq t1, t6, pass_space_front
li t6, asciiLineSpace
beq t1, t6, pass_space_front
lw a7, a0
j done_space_front
pass_space_front:
addi a0, a0, 1
j loop_space_front
done_space_front:
addi a0, a0, 1
addi t0, t0, 0
jal ra, 0
# Add hashtable
#
# Param:
# a7: string address
# a6: registerd hash, also is index of hashtable to add
# Return:
# a5:
add_hashtable:
la t0, arrIdentifiers
mul t6, a6, 4
addi t0, t0, t6
lw t1, 0(t0)
bne t1, add_bucket
sw a7, 0(t0)
jal add_identifiers
ret
add_bucket:
ret
# Add id into array
add_identifiers:
# Hash string
# Calculate hash with checksum
# Param:
# a7: registerd address of string (ended with '\0')
# a6: registerd modulo
# Return:
# a5: hash
calculate_string_hash:
beqz a6, failed # divide by 0 err
li a5, 0
loop_string:
lb t0, 0(a7)
beqz t0, pass
addi t1, a5, t0
; div t1, a6
rem a5, t1, a6
addi a7, a7, 1
j pass
failed:
la a0, errDivz # to stdErr
li a7, 4
ecall
li a7, 10 # terminate
ecall
pass:
ret
# Allocate in heap to perform immutable copy
# The source are char buffer not include white space
# The destination are copy of source plus '\0'
# Param:
# a7: registerd address of source
# a6: source length
# Retrun:
# a5: destination address
copy_string_buffer:
lw t0, a7 # save source
addi a7, 9 # using RARS to allocate heap
addi a0, a6, 1
ecall
li t1, 0x80000000
bge a0, t1, failed # not heap (kernel mem)
li t6, 0 # index of source
li a7, t0 # restore source
lw a5, a0 # save destination
loop_src:
beq t6, a6, done_loop
lb t0, 0(a7)
sw t0, 0(a0)
addi t6, t6, 1
addi a7, a7, 1
addi a0, a0, 1
j loop_src
done_loop:
li t0, 0
sw t0, 0(a0)
j pass
failed:
la a0, errEnvc # to stdErr
li a7, 4
ecall
li a7, 10 # terminate
ecall
pass:
jalr zero, 0(ra)
| 26
| 73
| 0.470145
|
756aebb1d735a9003a0c1e48b1782e8921ebea65
| 1,032
|
asm
|
Assembly
|
libsrc/_DEVELOPMENT/arch/zxn/esxdos/z80/asm_esx_m_tapeout_trunc.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 640
|
2017-01-14T23:33:45.000Z
|
2022-03-30T11:28:42.000Z
|
libsrc/_DEVELOPMENT/arch/zxn/esxdos/z80/asm_esx_m_tapeout_trunc.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 1,600
|
2017-01-15T16:12:02.000Z
|
2022-03-31T12:11:12.000Z
|
libsrc/_DEVELOPMENT/arch/zxn/esxdos/z80/asm_esx_m_tapeout_trunc.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 215
|
2017-01-17T10:43:03.000Z
|
2022-03-23T17:25:02.000Z
|
; unsigned char esx_m_tapeout_trunc(unsigned char *filename)
SECTION code_esxdos
PUBLIC asm_esx_m_tapeout_trunc
EXTERN __esx_m_tapeout_call_default_drive
asm_esx_m_tapeout_trunc:
; enter : hl = char *filename
;
; exit : success
;
; hl = 0
; carry reset
;
; fail
;
; hl = -1
; carry set, errno set
;
; uses : af, bc, de, hl, ix
ld b,3
IF __SDCC_IY
push hl
pop iy
ELSE
push hl
pop ix
ENDIF
jp __esx_m_tapeout_call_default_drive
; ***************************************************************************
; * M_TAPEOUT ($8c) *
; ***************************************************************************
; Tape output redirection control.
; Entry:
; B=0, out_open:
; Create/attach tap file with name at IX for appending, drive A
; B=1, out_close:
; Detach tap file
; B=2, out_info:
; Return attached filename to buffer at IX and drive in A
; B=3, out_trunc:
; Create/overwrite tap file with name at IX, drive A
| 20.235294
| 77
| 0.53876
|
48ba63910bceb54db9c0721de31c9e56ddff3aad
| 2,067
|
asm
|
Assembly
|
Transynther/x86/_processed/US/_zr_/i3-7100_9_0xca_notsx.log_1_757.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 9
|
2020-08-13T19:41:58.000Z
|
2022-03-30T12:22:51.000Z
|
Transynther/x86/_processed/US/_zr_/i3-7100_9_0xca_notsx.log_1_757.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 1
|
2021-04-29T06:29:35.000Z
|
2021-05-13T21:02:30.000Z
|
Transynther/x86/_processed/US/_zr_/i3-7100_9_0xca_notsx.log_1_757.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 3
|
2020-07-14T17:07:07.000Z
|
2022-03-21T01:12:22.000Z
|
.global s_prepare_buffers
s_prepare_buffers:
push %r12
push %r14
push %r15
push %r8
push %rbp
push %rbx
lea addresses_WT_ht+0x1600b, %rbx
nop
nop
nop
nop
nop
sub $55407, %r15
movb $0x61, (%rbx)
nop
nop
xor $9058, %rbx
lea addresses_D_ht+0x198ed, %r15
clflush (%r15)
nop
nop
nop
dec %r14
mov (%r15), %ebp
nop
and $16500, %r12
lea addresses_WC_ht+0x98ed, %r8
nop
add $65387, %rbp
movups (%r8), %xmm2
vpextrq $0, %xmm2, %r12
nop
mfence
pop %rbx
pop %rbp
pop %r8
pop %r15
pop %r14
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r15
push %r8
push %r9
push %rcx
push %rdi
push %rdx
push %rsi
// Store
lea addresses_PSE+0x1ada9, %r9
nop
add %rdx, %rdx
mov $0x5152535455565758, %r11
movq %r11, %xmm4
vmovups %ymm4, (%r9)
inc %r15
// REPMOV
lea addresses_UC+0x1f22d, %rsi
mov $0xeef, %rdi
nop
nop
nop
nop
mfence
mov $54, %rcx
rep movsb
nop
nop
nop
xor %rdi, %rdi
// Faulty Load
lea addresses_US+0xf4ed, %rdx
nop
nop
dec %r8
mov (%rdx), %r15
lea oracles, %r9
and $0xff, %r15
shlq $12, %r15
mov (%r9,%r15,1), %r15
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r15
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': True, 'type': 'addresses_US', 'size': 32, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 1, 'NT': False, 'type': 'addresses_PSE', 'size': 32, 'AVXalign': False}}
{'src': {'type': 'addresses_UC', 'congruent': 6, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_P', 'congruent': 0, 'same': False}}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_US', 'size': 8, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 1, 'NT': False, 'type': 'addresses_WT_ht', 'size': 1, 'AVXalign': False}}
{'src': {'same': False, 'congruent': 10, 'NT': True, 'type': 'addresses_D_ht', 'size': 4, 'AVXalign': True}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 10, 'NT': False, 'type': 'addresses_WC_ht', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
{'00': 1}
00
*/
| 18.131579
| 141
| 0.642961
|
6fbba6a53c630da2bf3908a6a916495b02769291
| 546
|
asm
|
Assembly
|
oeis/121/A121224.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/121/A121224.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/121/A121224.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A121224: Decimal expansion of 1/(2*tan(1/2)).
; Submitted by Christian Krause
; 9,1,5,2,4,3,8,6,0,8,5,6,2,2,5,9,5,9,6,3,4,0,0,9,7,1,9,4,8,4,4,0,8,3,1,1,8,7,9,0,5,3,9,7,4,0,0,8,0,6,7,0,0,2,1,8,3,2,0,7,9,7,3,3,9,2,7,3,0,6,1,2,0,9,8,1,7,7,5,8,0,0,5,6,0,7,3,2,4,3,8,9,5,5,2,4,9,1,3,9
add $0,1
mov $3,$0
mul $3,3
lpb $3
mov $4,$3
cmp $4,0
add $3,$4
div $1,$3
add $1,$2
add $2,$1
sub $1,$2
mul $2,$3
mul $2,4
add $1,$2
div $1,$0
div $2,$0
add $2,1
sub $3,1
lpe
mov $5,10
pow $5,$0
div $2,$5
div $1,$2
mov $0,$1
mod $0,10
| 18.2
| 201
| 0.516484
|
872302ab03ce89c0d7882676bf2c20957c534dbd
| 1,069
|
asm
|
Assembly
|
reuse/TestArraySum.asm
|
William0Friend/my_masm
|
e8073266c03c01424ad84b9ed9cf13e9da1eabb1
|
[
"Apache-2.0"
] | null | null | null |
reuse/TestArraySum.asm
|
William0Friend/my_masm
|
e8073266c03c01424ad84b9ed9cf13e9da1eabb1
|
[
"Apache-2.0"
] | null | null | null |
reuse/TestArraySum.asm
|
William0Friend/my_masm
|
e8073266c03c01424ad84b9ed9cf13e9da1eabb1
|
[
"Apache-2.0"
] | null | null | null |
; Testing the ArraySum procedure (TestArraySum.asm)
.386
.model flat,stdcall
.stack 4096
ExitProcess PROTO, dwExitCode:dword
.data
array dword 10000h,20000h,30000h,40000h,50000h
theSum dword ?
.code
main proc
mov esi,OFFSET array ; ESI points to array
mov ecx,LENGTHOF array ; ECX = array count
call ArraySum ; calculate the sum
mov theSum,eax ; returned in EAX
invoke ExitProcess,0
main endp
;-----------------------------------------------------
ArraySum proc
;
; Calculates the sum of an array of 32-bit integers.
; Receives: ESI = the array offset
; ECX = number of elements in the array
; Returns: EAX = sum of the array elements
;-----------------------------------------------------
push esi ; save ESI, ECX
push ecx
mov eax,0 ; set the sum to zero
L1:
add eax,[esi] ; add each integer to sum
add esi,TYPE DWORD ; point to next integer
loop L1 ; repeat for array size
pop ecx ; restore ECX, ESI
pop esi
ret ; sum is in EAX
ArraySum endp
end main
| 24.860465
| 55
| 0.596819
|
feda729a1df6b0967a2df18ec4d8c5a21cda55c6
| 4,605
|
asm
|
Assembly
|
Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_21829_1209.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 9
|
2020-08-13T19:41:58.000Z
|
2022-03-30T12:22:51.000Z
|
Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_21829_1209.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 1
|
2021-04-29T06:29:35.000Z
|
2021-05-13T21:02:30.000Z
|
Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_21829_1209.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 3
|
2020-07-14T17:07:07.000Z
|
2022-03-21T01:12:22.000Z
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r8
push %r9
push %rax
push %rbp
push %rsi
lea addresses_WC_ht+0x97c, %r11
nop
nop
cmp %rbp, %rbp
movups (%r11), %xmm4
vpextrq $0, %xmm4, %r8
nop
nop
nop
add %r8, %r8
lea addresses_WC_ht+0x2b7c, %r9
nop
nop
add $45098, %rax
mov $0x6162636465666768, %rsi
movq %rsi, %xmm2
vmovups %ymm2, (%r9)
nop
nop
nop
sub %rax, %rax
lea addresses_UC_ht+0x6f7c, %r9
nop
nop
add %rax, %rax
mov $0x6162636465666768, %rbp
movq %rbp, (%r9)
nop
nop
nop
nop
nop
inc %r8
pop %rsi
pop %rbp
pop %rax
pop %r9
pop %r8
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r13
push %r15
push %rax
push %rsi
// Faulty Load
lea addresses_PSE+0x1977c, %r15
nop
nop
nop
nop
nop
add $63122, %r13
movb (%r15), %r11b
lea oracles, %r10
and $0xff, %r11
shlq $12, %r11
mov (%r10,%r11,1), %r11
pop %rsi
pop %rax
pop %r15
pop %r13
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_PSE', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_PSE', 'size': 1, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'same': True, 'congruent': 9, 'NT': False, 'type': 'addresses_WC_ht', 'size': 16, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 9, 'NT': False, 'type': 'addresses_WC_ht', 'size': 32, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 10, 'NT': False, 'type': 'addresses_UC_ht', 'size': 8, 'AVXalign': False}}
{'33': 21829}
33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33
*/
| 49.516129
| 2,999
| 0.661455
|
c667a86fa84f607811532c9e727dcc4361630de8
| 618
|
asm
|
Assembly
|
oeis/173/A173267.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/173/A173267.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/173/A173267.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A173267: a(n) = 121*n^2 + n.
; 122,486,1092,1940,3030,4362,5936,7752,9810,12110,14652,17436,20462,23730,27240,30992,34986,39222,43700,48420,53382,58586,64032,69720,75650,81822,88236,94892,101790,108930,116312,123936,131802,139910,148260,156852,165686,174762,184080,193640,203442,213486,223772,234300,245070,256082,267336,278832,290570,302550,314772,327236,339942,352890,366080,379512,393186,407102,421260,435660,450302,465186,480312,495680,511290,527142,543236,559572,576150,592970,610032,627336,644882,662670,680700,698972,717486
mov $1,$0
add $0,1
mul $0,11
pow $0,2
add $0,$1
sub $0,3
div $0,2
add $0,2
mul $0,2
| 47.538462
| 501
| 0.783172
|
06184306a1622a9ca4c09d3a6d8b1e65641a22c4
| 325
|
asm
|
Assembly
|
oeis/021/A021617.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/021/A021617.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/021/A021617.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A021617: Decimal expansion of 1/613.
; Submitted by Jon Maiga
; 0,0,1,6,3,1,3,2,1,3,7,0,3,0,9,9,5,1,0,6,0,3,5,8,8,9,0,7,0,1,4,6,8,1,8,9,2,3,3,2,7,8,9,5,5,9,5,4,3,2,3,0,0,1,6,3,1,3,2,1,3,7,0,3,0,9,9,5,1,0,6,0,3,5,8,8,9,0,7,0,1,4,6,8,1,8,9,2,3,3,2,7,8,9,5,5,9,5,4
add $0,1
mov $1,10
pow $1,$0
div $1,613
mov $0,$1
mod $0,10
| 29.545455
| 199
| 0.556923
|
73c242f96947fef386b706eb5a49aa6b834147e7
| 4,759
|
asm
|
Assembly
|
examples/Fibonacci/output.asm
|
mkiesinger/HackVM-to-MiMa
|
7acba633ca5458e665329ab2d2c8afb19b4edf31
|
[
"MIT"
] | 1
|
2019-11-06T20:54:32.000Z
|
2019-11-06T20:54:32.000Z
|
examples/Fibonacci/output.asm
|
mkiesinger/HackVM-to-MiMa
|
7acba633ca5458e665329ab2d2c8afb19b4edf31
|
[
"MIT"
] | null | null | null |
examples/Fibonacci/output.asm
|
mkiesinger/HackVM-to-MiMa
|
7acba633ca5458e665329ab2d2c8afb19b4edf31
|
[
"MIT"
] | null | null | null |
* = 0
JMP START
* = 1
LCL: DS 0
ARG: DS 0
THIS: DS 0
THAT: DS 0
TEMP0: DS 0
TEMP1: DS 0
TEMP2: DS 0
TEMP3: DS 0
TEMP4: DS 0
TEMP5: DS 0
TEMP6: DS 0
TEMP7: DS 0
SP: DS 0
T0: DS 0
T1: DS 0
* = 16
* = 32768
START: JMP Setup
MONE: DS 65535
MONECF: DS -1
MFIVECF: DS -5
NFLAG: DS 32768
Setup: LDC 256
STV SP
JMP Sys.init
Sys.halt: AND MONECF
Sys.halt.WHILE_EXP0: LDC 0
ADD MONECF
NOT
JMN Sys.halt.WHILE_END0
JMP Sys.halt.WHILE_EXP0
Sys.halt.WHILE_END0: LDC 0
STIV SP
LDC 1
ADD SP
STV SP
JMP RETURN
Sys.init: LDC Sys.Sys.init.ret.0
STIV SP
LDC Main.main
STV T0
LDC 4
STV T1
JMP CALL
Sys.Sys.init.ret.0: LDV MONECF
ADD SP
STV SP
LDIV SP
STV TEMP0
LDC Sys.Sys.init.ret.2
STIV SP
LDC Sys.halt
STV T0
LDC 4
STV T1
JMP CALL
Sys.Sys.init.ret.2: LDV MONECF
ADD SP
STV SP
LDIV SP
STV TEMP0
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
JMP RETURN
Main.fibonacci: LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 1
ADD MONE
NOT
STV T1
LDC 0
ADD ARG
STV T0
LDIV T0
ADD T1
AND NFLAG
EQL NFLAG
AND MONE
ADD MONECF
NOT
JMN Main.fibonacci.IF_TRUE0
JMP Main.fibonacci.IF_FALSE0
Main.fibonacci.IF_TRUE0: LDC 0
STIV SP
LDC 1
ADD SP
STV SP
JMP RETURN
Main.fibonacci.IF_FALSE0: LDC 0
ADD ARG
STV T0
LDIV T0
STV T0
LDC 1
EQL T0
AND MONE
ADD MONECF
NOT
JMN Main.fibonacci.IF_TRUE1
JMP Main.fibonacci.IF_FALSE1
Main.fibonacci.IF_TRUE1: LDC 1
STIV SP
LDC 1
ADD SP
STV SP
JMP RETURN
Main.fibonacci.IF_FALSE1: LDC 1
ADD MONE
NOT
STV T1
LDC 0
ADD ARG
STV T0
LDIV T0
ADD T1
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC Main.Main.fibonacci.IF_FALSE1.ret.1
STIV SP
LDC Main.fibonacci
STV T0
LDC 5
STV T1
JMP CALL
Main.Main.fibonacci.IF_FALSE1.ret.1: LDV MONECF
ADD SP
STV SP
LDC 0
ADD LCL
STV T0
LDIV SP
STIV T0
LDC 2
ADD MONE
NOT
STV T1
LDC 0
ADD ARG
STV T0
LDIV T0
ADD T1
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC Main.Main.fibonacci.IF_FALSE1.ret.4
STIV SP
LDC Main.fibonacci
STV T0
LDC 5
STV T1
JMP CALL
Main.Main.fibonacci.IF_FALSE1.ret.4: LDV MONECF
ADD SP
STV SP
LDC 1
ADD LCL
STV T0
LDIV SP
STIV T0
LDC 0
ADD LCL
STV T0
LDIV T0
STV T0
LDC 1
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
JMP RETURN
Main.main: LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 0
STIV SP
LDC 0
ADD LCL
STV T0
LDIV SP
STIV T0
LDC 7
STIV SP
LDC 1
ADD SP
STV SP
LDC Main.Main.main.ret.3
STIV SP
LDC Main.fibonacci
STV T0
LDC 5
STV T1
JMP CALL
Main.Main.main.ret.3: LDV MONECF
ADD SP
STV SP
LDC 1
ADD LCL
STV T0
LDIV SP
STIV T0
LDC 16384
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 1
ADD LCL
STV T0
LDIV T0
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
JMP RETURN
CALL: LDC 1
ADD SP
STV SP
LDV LCL
STIV SP
LDC 1
ADD SP
STV SP
LDV ARG
STIV SP
LDC 1
ADD SP
STV SP
LDV THIS
STIV SP
LDC 1
ADD SP
STV SP
LDV THAT
STIV SP
LDC 1
ADD SP
STV SP
LDV T1
NOT
ADD SP
STV ARG
LDV SP
STV LCL
JIND T0
RETURN: LDV LCL
STV T0
ADD MFIVECF
STV T1
LDIV T1
STV T1
LDV MONECF
ADD SP
STV SP
LDIV SP
STIV ARG
LDC 1
ADD ARG
STV SP
LDV MONECF
ADD T0
STV T0
LDIV T0
STV THAT
LDV MONECF
ADD T0
STV T0
LDIV T0
STV THIS
LDV MONECF
ADD T0
STV T0
LDIV T0
STV ARG
LDV MONECF
ADD T0
STV T0
LDIV T0
STV LCL
JIND T1
* = 16384 // added this part for easier lookup after simulation
SCREEN: DS 0
| 14.20597
| 69
| 0.514394
|
32aa6af47255a03a000d21fe35848891df5511be
| 719
|
asm
|
Assembly
|
oeis/038/A038731.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/038/A038731.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/038/A038731.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A038731: Number of columns in all directed column-convex polyominoes of area n+1.
; 1,3,10,32,99,299,887,2595,7508,21526,61251,173173,486925,1362627,3797374,10543724,29180067,80521055,221610563,608468451,1667040776,4558234018,12441155715,33900136297,92230468249,250570010499,679844574322,1842280003640,4986579299043,13482893189651,36418822295951,98278304480163,264973561464380,713810060090542,1921402189020099,5168065537430749,13890855944442277,37311017828945475,100153682620372198,268677969733055876,720352560603471651,1930268774450502983,5169648615842792795,13838372569988997987
mov $2,$0
mul $0,2
mov $1,$0
add $1,3
lpb $2
sub $0,$2
add $0,2
add $0,$1
add $1,$0
sub $2,1
lpe
mov $0,$1
div $0,5
add $0,1
| 39.944444
| 498
| 0.815021
|
4314a5b870a49665f76b567ac30e31733fbc0b4c
| 310
|
asm
|
Assembly
|
boot-info-table.asm
|
miles-canfield/Lassen-Peak
|
c0d9d6232c9fcaeb5ba4d9872e8e7966cc08652e
|
[
"MIT"
] | null | null | null |
boot-info-table.asm
|
miles-canfield/Lassen-Peak
|
c0d9d6232c9fcaeb5ba4d9872e8e7966cc08652e
|
[
"MIT"
] | null | null | null |
boot-info-table.asm
|
miles-canfield/Lassen-Peak
|
c0d9d6232c9fcaeb5ba4d9872e8e7966cc08652e
|
[
"MIT"
] | null | null | null |
boot_info_table_addr equ 0x00000000
struc boot_info_table_struc
pit_irq: resb 1
keyboard_irq: resb 1
ioapic_count: resb 1
processor_count: resb 1
tsc_frequency: resd 1 ;khz
lapic_address: resq 1
ioapic_address: resq 1
ioapic_id: resd 1
processor_list: resw 256 ;msb=processor-id lsb=apic-id
endstruc
| 22.142857
| 55
| 0.803226
|
b8c32cf5df63b6205c2cc98dde336004e3a1e838
| 735
|
asm
|
Assembly
|
libsrc/_DEVELOPMENT/arch/zx/bifrost_l/c/sdcc/BIFROSTL_drawTileL_callee.asm
|
teknoplop/z88dk
|
bb03fbfd6b2ab0f397a1358559089f9cd3706485
|
[
"ClArtistic"
] | null | null | null |
libsrc/_DEVELOPMENT/arch/zx/bifrost_l/c/sdcc/BIFROSTL_drawTileL_callee.asm
|
teknoplop/z88dk
|
bb03fbfd6b2ab0f397a1358559089f9cd3706485
|
[
"ClArtistic"
] | null | null | null |
libsrc/_DEVELOPMENT/arch/zx/bifrost_l/c/sdcc/BIFROSTL_drawTileL_callee.asm
|
teknoplop/z88dk
|
bb03fbfd6b2ab0f397a1358559089f9cd3706485
|
[
"ClArtistic"
] | 1
|
2019-12-03T23:57:48.000Z
|
2019-12-03T23:57:48.000Z
|
; ----------------------------------------------------------------
; Z88DK INTERFACE LIBRARY FOR THE BIFROST* ENGINE - RELEASE 1.2/L
;
; See "bifrost_l.h" for further details
; ----------------------------------------------------------------
; void BIFROSTL_drawTileL(unsigned int row, unsigned int col, unsigned int tile)
; callee
SECTION code_clib
SECTION code_bifrost_l
PUBLIC _BIFROSTL_drawTileL_callee
EXTERN asm_BIFROSTL_drawTileL
_BIFROSTL_drawTileL_callee:
pop hl ; RET address
pop bc ; C=row
pop de ; E=col
ld d,c ; D=row
ex (sp),hl ; L=tile
ld a,l ; A=tile
jp asm_BIFROSTL_drawTileL ; execute 'draw_tile'
| 27.222222
| 80
| 0.510204
|
18c3016953f527b124dda1355e1a40da29cb5f76
| 46,947
|
asm
|
Assembly
|
src/Fiery_Hell.asm
|
Garuflax/FieryHell
|
085df1e8dc0df290cc7397370b832fb7ad386734
|
[
"MIT"
] | 1
|
2020-04-11T21:13:18.000Z
|
2020-04-11T21:13:18.000Z
|
src/Fiery_Hell.asm
|
Garuflax/FieryHell
|
085df1e8dc0df290cc7397370b832fb7ad386734
|
[
"MIT"
] | null | null | null |
src/Fiery_Hell.asm
|
Garuflax/FieryHell
|
085df1e8dc0df290cc7397370b832fb7ad386734
|
[
"MIT"
] | null | null | null |
; Integrating the memory architecture of the NES system. This defines the later structure of the NES-ROM
.INCLUDE "nes_memory.inc"
.INCLUDE "nes.inc"
* Fill all unused data with $ 00.
.EMPTYFILL $00
; We now switch to address $ 00 (absolute: $ 00) from BANK 0 to SLOT 0. HEADER
.BANK 0 SLOT 0
.ORG $0000
* Byte 0-Byte 2: string ‘NES’ to identify the file as an iNES file
.DB "NES"
* Byte 3: value $1A = 26 , also used to identify file format
.DB $1A
* Byte 4: Number of 16 KB PRG-ROM banks. The PRG-ROM (Program ROM) is the area of ROM used to store the program code.
.DB 2
* Byte 5: Number of 8 KB CHR-ROM / VROM banks. The names CHR-ROM (Character ROM) and VROM are used synonymously to refer to the area of ROM used to store graphics information, the pattern tables.
.DB 1
* Byte 6: ROM Control Byte 1:
/* Bit 0 - Indicates the type of mirroring used by the game where 0 indicates horizontal mirroring, 1 indicates vertical mirroring.
Bit 1 - Indicates the presence of battery-backed RAM at memory locations $6000-$7FFF.
Bit 2 - Indicates the presence of a 512-byte trainer at memory locations $7000-$71FF.
Bit 3 - If this bit is set it overrides bit 0 to indicate four-screen mirroring should be used.
Bits 4-7 - Four lower bits of the mapper number. */
.DB 0
* Byte 7: ROM Control Byte 2:
/* Bits 0-3 - Reserved for future usage and should all be 0.
Bits 4-7 - Four upper bits of the mapper number. */
.DB 0
* Byte 8: Number of 8 KB PRG-RAM banks. For compatibility with previous versions of the iNES format, assume 1 page of PRG-RAM when this is 0.
.DB 0
* Byte 9-Byte15: Reserved for future usage and should all be 0.
* Defines:
.EQU player_min_x $8
.EQU player_min_y $8
.EQU player_max_x $F0
.EQU player_max_y $E0
.EQU player_start_x $70
.EQU player_start_y $70
.EQU fireball_min_x $00
.EQU fireball_min_y $00
.EQU fireball_max_x $F8
.EQU fireball_max_y $E8
.EQU size_of_fireball $2
.EQU fireball_amount $20
.EQU fireball_speed $02
.EQU song_size $100
.EQU game_length $C0
.EQU buttons $0
.EQU current_note $1
.EQU current_song1 $2
.EQU current_song2 $4
.EQU note_pulse $6
.EQU pulse_limit $7
.EQU frame_done $8
.EQU x_player $9
.EQU y_player $A
.EQU song_limit $B
.EQU up_index $C
.EQU down_index $D
.EQU right_index $E
.EQU left_index $F
.EQU up_fireballs $10 ; Array of 8 (x,y) coordinates of fireballs (16 Bytes)
.EQU down_fireballs $20
.EQU right_fireballs $30
.EQU left_fireballs $40
.EQU temp0 $50
.EQU temp1 $51
.EQU temp2 $52
.EQU temp3 $53
.BANK 1 SLOT 3
.ORG $0000
* Palette colours can be found: http://wiki.nesdev.com/w/index.php/PPU_palettes
* BACKGROUND | SPRITES
* Colour: RED GREEN BLUE WHITE RED GREEN BLUE WHITE
palette: .DB $0F, $06, $16, $26, $0F, $09, $19, $29, $0F, $02, $12, $22, $0F, $00, $10, $30, $0F, $06, $16, $26, $0F, $09, $19, $29, $0F, $02, $12, $22, $0F, $00, $10, $30
* Menu background: Separated in four parts so it is simpler to pass it to the PPU
nameTable00: .DSB 17, 1 .DSB 7, 0 .DSB 1, 1 .DSB 7, 0 .DB 1, 0, 0, 'F' , 'E' , 'Y' , 0, 0
.DSB 1, 1 .DSB 7, 0 .DB 1, 0, 0, 0, 'L' , 0, 0, 0
.REPEAT 9
.DSB 1, 1 .DSB 7, 0
.ENDR
.DB 1, 0, 0, 'R' , 0, 'R' , 0, 0
.REPEAT 9
.DSB 1, 1 .DSB 7, 0
.ENDR
.DB 1, 'F' , 'N' , 'L' , 'R' , 0, '2' , 0, 1
.DSB 7, 0 .DSB 16, 1
nameTable01: .DSB 17, 1 .DSB 7 0 .DSB 1, 1 .DSB 7, 0 .DB 1, 0, 0, 0, 0, 0 , 0, 0
.DSB 1, 1 .DSB 7, 0 .DB 1, 0, 0, 0, 'L' , 0, 0, 0
.REPEAT 9
.DSB 1, 1 .DSB 7, 0
.ENDR
.DB 1, 0, 0, 'E' , 'S' , 'T' , 0, 0
.REPEAT 9
.DSB 1, 1 .DSB 7, 0
.ENDR
.DB 1, 'A' , 'D' , 'I' , 'I' , 0, '0' , 0, 1
.DSB 7, 0 .DSB 16, 1
nameTable02: .DSB 16, 1 .DSB 7 0 .DSB 1, 1 .DSB 7, 0 .DB 1, 0, 0, 0 , 'I' , 'R' , 0, 0
.DSB 1, 1 .DSB 7, 0 .DB 1, 0, 0, 0, 'H' , 0, 0, 0
.REPEAT 9
.DSB 1, 1 .DSB 7, 0
.ENDR
.DB 1, 0, 0, 0 , 'S' , 'T' , 0, 0
.REPEAT 9
.DSB 1, 1 .DSB 7, 0
.ENDR
.DB 1, 0, 'C' , 'O' , 'N' , 0 , 0, '2' , 1
.DSB 7, 0 .DSB 17, 1
nameTable03: .DSB 16, 1 .DSB 7 0 .DSB 1, 1 .DSB 7, 0 .DB 1, 0, 0, 0 , 0, 0, 0, 0
.DSB 1, 1 .DSB 7, 0 .DB 1, 0, 0, 0, 'E' , 0, 0, 0
.REPEAT 9
.DSB 1, 1 .DSB 7, 0
.ENDR
.DB 1, 0, 0, 'P' , 'S' , 'A' , 0, 0
.REPEAT 9
.DSB 1, 1 .DSB 7, 0
.ENDR
.DB 1, 0, 'U' , 0, 'A' , 0 , 0, '0' , 1
.DSB 7, 0 .DSB 17, 1
attributeTable0: .DSB 9, $00 .DSB 6, $A5 .DSB 33, $00 .DSB 1, $C0 .DSB 6, $F0 .DSB 1, $30 .DSB 8, 0
*01230123012301230123012301230123
*################################ RED
*################################ RED
*## ## RED
*## ## RED
*## F I E R Y ## GREEN
*## ## GREEN
*## HELL ## BLUE
*## ## BLUE
*## ## RED
*## ## RED
*## ## RED
*## ## RED
*## ## RED
*## ## RED
*## ## RED
*## ## RED
*## PRESS START ## RED
*## ## RED
*## ## RED
*## ## RED
*## ## RED
*## ## RED
*## ## RED
*## ## RED
*## ## RED
*## ## RED
*## FACUNDO LINARI 2020 ## WHITE
*## ## WHITE
*################################ RED
*################################ RED
nameTable20: .DB $05, $04, $04, $04, $04, $04, $04, $04, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $05, $04, $04, $04, $04, $04, $04, $04
nameTable21: .DB $04, $04, $04, $04, $04, $04, $04, $04, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $06, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $07, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $07, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $04, $04, $04, $04, $04, $04, $04, $04
nameTable22: .DB $04, $04, $04, $04, $04, $04, $04, $04, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $06, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $07, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $06, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $04, $04, $04, $04, $04, $04, $04, $04
nameTable23: .DB $04, $04, $04, $04, $04, $04, $04, $05, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $00, $00, $00, $00, $00, $00, $00, $04, $04, $04, $04, $04, $04, $04, $04, $05
attributeTable2: .DSB 64, $FF
up_pattern:
.DB $10, $00, $00, $00, $30, $00, $00, $00, $50, $00, $00, $00, $70, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $18, $08, $38, $00, $28, $60, $00, $00, $48, $00, $00, $40, $00, $00, $00, $00
.DB $58, $00, $58, $68, $78, $00, $70, $60, $68, $00, $80, $00, $78, $88, $98, $00
.DB $90, $80, $B0, $00, $A0, $C0, $00, $00, $B8, $00, $00, $00, $A8, $00, $00, $00
.DB $88, $00, $88, $78, $80, $00, $90, $98, $A0, $00, $88, $00, $98, $00, $70, $00
.DB $68, $00, $58, $80, $00, $00, $70, $00, $60, $00, $50, $78, $00, $00, $80, $88
.DB $90, $00, $00, $80, $A0, $00, $00, $98, $90, $A8, $E0, $00, $00, $00, $00, $00
.DB $D8, $C0, $B0, $B8, $A8, $98, $A0, $90, $68, $88, $60, $40, $50, $30, $20, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
down_pattern:
.DB $E8, $00, $00, $00, $C8, $00, $00, $00, $A8, $00, $00, $00, $88, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $E0, $F0, $C0, $00, $D0, $98, $00, $00, $B0, $00, $00, $B8, $00, $00, $00, $00
.DB $A0, $00, $A0, $90, $80, $00, $88, $98, $90, $00, $78, $00, $80, $70, $60, $00
.DB $68, $78, $48, $00, $58, $38, $00, $00, $40, $00, $00, $00, $50, $00, $00, $00
.DB $70, $00, $70, $80, $78, $00, $68, $60, $58, $00, $70, $00, $60, $00, $88, $00
.DB $90, $00, $A0, $78, $00, $00, $88, $00, $98, $00, $A8, $80, $00, $00, $78, $70
.DB $68, $00, $00, $78, $58, $00, $00, $60, $68, $50, $18, $00, $00, $00, $00, $00
.DB $20, $38, $48, $40, $50, $60, $58, $68, $90, $70, $98, $B8, $A8, $C8, $D8, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
right_pattern:
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $18, $A0, $20, $A8, $28, $B0, $30, $B8, $58, $C8, $60, $D0, $68, $D8, $70, $E0
.DB $90, $C0, $88, $B8, $80, $A8, $78, $A0, $38, $78, $48, $88, $78, $C8, $98, $E0
.DB $10, $40, $20, $50, $28, $58, $18, $48, $20, $68, $30, $88, $40, $A8, $50, $C8
.DB $60, $D0, $48, $C0, $40, $B8, $28, $A8, $18, $88, $20, $90, $60, $B0, $70, $D0
.DB $20, $60, $18, $58, $30, $70, $28, $68, $10, $70, $18, $78, $08, $80, $10, $78
.DB $08, $80, $28, $70, $38, $60, $48, $50, $08, $58, $10, $68, $18, $78, $20, $88
.DB $10, $00, $00, $00, $C0, $00, $00, $00, $40, $00, $00, $00, $90, $00, $70, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
left_pattern:
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $D0, $48, $C8, $40, $C0, $38, $B8, $30, $90, $20, $88, $18, $80, $10, $78, $08
.DB $58, $28, $60, $30, $68, $40, $70, $48, $B0, $70, $A0, $60, $70, $20, $50, $08
.DB $D8, $A8, $C8, $98, $C0, $90, $D0, $A0, $C8, $80, $B8, $60, $A8, $40, $98, $20
.DB $88, $18, $A0, $28, $A8, $30, $C0, $40, $D0, $60, $C8, $58, $88, $38, $78, $18
.DB $C8, $88, $D0, $90, $B8, $78, $C0, $80, $D8, $78, $D0, $70, $E0, $68, $D8, $70
.DB $E0, $68, $C0, $78, $B0, $88, $A0, $98, $E0, $90, $D8, $80, $D0, $70, $C8, $60
.DB $D8, $00, $00, $00, $28, $00, $00, $00, $A8, $00, $00, $00, $58, $00, $78, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
win_message: .DSB 33, 1 .DSB 10, 0 .DB "GAME OVER"
.DSB 11, 0 .DSB 2, 1 .DSB 30, 0 .DSB 33, 1
irq: ; So many interrupts are generated so it is impossible to return to the main code. I won't be using APU's IRQs because of this
jmp irq ; Halt
rti
nmi:
pha
;lda #$00
;sta frame_done
jsr draw_player
jsr draw_fireballs
lda #$02
sta OAMDMA.W
lda #$01
sta frame_done
pla
rti
*At power-up:
;
; P = $34 (IRQ disabled)
; A, X, Y = 0
; S = $FD
; $4017 = $00 (frame irq enabled)
; $4015 = $00 (all channels disabled)
; $4000-$400F = $00
; $4010-$4013 = $00
; All 15 bits of noise channel LFSR = $0000. The first time the LFSR is clocked from the all-0s state, it will shift in a 1.
; 2A03G: APU Frame Counter reset. (but 2A03letterless: APU frame counter powers up at a value equivalent to 15)
;
; Internal memory ($0000-$07FF) has unreliable startup state.
*After reset
;
; A, X, Y were not affected
; S was decremented by 3 (but nothing was written to the stack)
; The I (IRQ disable) flag was set to true (status ORed with $04)
; The internal memory was unchanged
; APU mode in $4017 was unchanged
; APU was silenced ($4015 = 0)
; APU triangle phase is reset to 0 (i.e. outputs a value of 15, the first step of its waveform)
; APU DPCM output ANDed with 1 (upper 6 bits cleared)
; 2A03G: APU Frame Counter reset. (but 2A03letterless: APU frame counter retains old value)
reset:
sei
cld
ldx #0
stx PPUCTRL.W ; disable NMI
stx PPUMASK.W ; disable rendering
dex ; X = 0xFF
txs ; Set up stack
ldx #$40
stx JOYPAD2.W ; disable APU frame
ldx #$FF
bit PPUSTATUS.W
@vblankwait1:
bit PPUSTATUS.W
bpl @vblankwait1
inx ; X = 0
txa ; A = X
@clearmem:
sta $000,x
sta $100,x
sta $300,x
sta $400,x
sta $500,x
sta $600,x
sta $700,x
inx
bne @clearmem
lda #$FF ; A = 0xFF
@clearspritemem:
sta $200,x
inx
bne @clearspritemem
; Configure Sound
lda #%00000011
sta APUSTATUS.W ;enable square 1 and square 2
lda #%10111111 ;Duty 10, Volume F
sta APUPULSE1ENV.W
lda #%01111111 ;Duty 01, Volume F
sta APUPULSE2ENV.W
@vblankwait2:
bit PPUSTATUS.W
bpl @vblankwait2
start:
lda #$20
sta PPUADDR.W
stx PPUADDR.W ; PPUADDR = 0x2000
ldy #240
@loadNameTable0:
lda nameTable00.W, x
sta PPUDATA.W
lda nameTable01.W, x
sta PPUDATA.W
lda nameTable02.W, x
sta PPUDATA.W
lda nameTable03.W, x
sta PPUDATA.W
inx
dey
bne @loadNameTable0
ldx #64
@loadAttributeTable0:
lda attributeTable0.W, y
sta PPUDATA.W
iny
dex
bne @loadAttributeTable0
lda #$28
sta PPUADDR.W
stx PPUADDR.W ; PPUADDR = 0x2800
ldy #240
@loadNameTable2:
lda nameTable20.W, x
sta PPUDATA.W
lda nameTable21.W, x
sta PPUDATA.W
lda nameTable22.W, x
sta PPUDATA.W
lda nameTable23.W, x
sta PPUDATA.W
inx
dey
bne @loadNameTable2
ldx #64
@loadAttributeTable2:
lda attributeTable2.W, y
sta PPUDATA.W
iny
dex
bne @loadAttributeTable2
lda #$3F
sta PPUADDR.W
stx PPUADDR.W ; PPUADDR = 0x3F00
ldy #32
@init_palette:
lda palette.W, x
sta PPUDATA.W
inx
dey
bne @init_palette
@init_video:
bit PPUSTATUS.W
@vblankwait:
bit PPUSTATUS.W
bpl @vblankwait
lda #0
sta PPUSCROLL.W
sta PPUSCROLL.W
lda #$88
sta PPUCTRL.W ; Set the address of the 'pattern tables' and generate NMI
;cli ; Clear the interrupt disable flag allowing normal interrupt requests to be serviced. I won't be using APUs IRQ
go_menu:
jsr play_menu_song
lda #0
sta frame_done
@wait:
lda frame_done
beq @wait
lda #0
sta PPUSCROLL.W
sta PPUSCROLL.W
lda #$88
sta PPUCTRL.W
lda #$0E
sta PPUMASK.W ; turn on the sign of background
menu_loop:
lda frame_done
beq menu_loop
jsr do_note
jsr read_joy
lda #0
sta frame_done
lda buttons
and #$10
beq menu_loop
go_game:
jsr play_game_song
lda #0
sta frame_done
@wait:
lda frame_done
beq @wait
lda #0
sta PPUSCROLL.W
sta PPUSCROLL.W
lda #$8A
sta PPUCTRL.W ; Change name table
lda #$1E
sta PPUMASK.W ; turn on the sign of background and sprites
jsr init_player
jsr init_fireballs
game_loop:
lda frame_done
beq game_loop
jsr do_note
jsr read_joy
lda buttons
and #$20
bne go_menu
lda current_note
cmp #game_length
beq go_end
jsr create_fireball
jsr update_player
jsr update_fireballs
jsr check_collision
bcs go_lose
lda #0
sta frame_done
jmp game_loop
go_lose:
jsr play_lose_song
lda #$08
sta $201 ; Replace player sprite
lose_loop:
lda frame_done
beq lose_loop
jsr do_note
jsr read_joy
lda #0
sta frame_done
lda buttons
and #$C0
beq lose_loop
jmp go_menu
go_end:
jsr play_end_song
lda #$0A
sta PPUCTRL.W ; Turn off nmis at start of vertical blanking interval
bit PPUSTATUS.W
@vblankwait:
bit PPUSTATUS.W
bpl @vblankwait
lda #$29
ldx #$80
sta PPUADDR.W
stx PPUADDR.W ; PPUADDR = 0x2980
ldy #$80
ldx #$00
@print_win_message:
lda win_message.W, x
sta PPUDATA.W
inx
dey
bne @print_win_message
lda #$2B
ldx #$D8
sta PPUADDR.W
stx PPUADDR.W ; PPUADDR = 0x2BD8
ldy #8
lda #$FF
@update_attribute_table:
sta PPUDATA.W
dey
bne @update_attribute_table
lda #0
sta PPUSCROLL.W
sta PPUSCROLL.W
lda #$8A
sta PPUCTRL.W
lda #$0E
sta PPUMASK.W ; turn on the sign of background
end_loop:
lda frame_done
beq end_loop
jsr do_note
jsr read_joy
lda #0
sta frame_done
jmp end_loop
.BANK 2 SLOT 4
.ORG $3FFA
.DW nmi, reset, irq
.ORG $0000
; At the same time that we strobe bit 0, we initialize the ring counter
read_joy:
lda #$01
; While the strobe bit is set, buttons will be continuously reloaded.
; This means that reading from JOYPAD1 will only return the state of the
; first button: button A.
sta JOYPAD1.W
sta buttons
lsr A ; now A is 0
; By storing 0 into JOYPAD1, the strobe bit is cleared and the reloading stops.
; This allows all 8 buttons (newly reloaded) to be read from JOYPAD1.
sta JOYPAD1.W
@loop:
lda JOYPAD1.W
lsr A ; bit 0 -> Carry
rol buttons ; Carry -> bit 0; bit 7 -> Carry
bcc @loop
rts
init_player:
pha
lda #$00
sta $201 ; Tile to use for sprite
lda #$02
sta $202 ; Palette, priority and flipping
lda #player_start_x
sta x_player ; starting X
lda #player_start_y
sta y_player ; starting Y
pla
rts
init_fireballs:
pha
txa
pha
tya
pha
clc
lda #(fireball_amount >> 1)
sta temp0
lda #$00
tax
tay
sta up_index
sta down_index
sta right_index
sta left_index
@init_vertical:
lda #$FF
sta up_fireballs, X
inx
sta up_fireballs, X
inx
lda #$07
sta $205, Y
lda #$00
sta $206, Y
tya
adc #$04
tay
dec temp0
bne @init_vertical
lda #(fireball_amount >> 1)
sta temp0
@init_horizontal:
lda #$FF
sta up_fireballs, X
inx
sta up_fireballs, X
inx
lda #$07
sta $205, Y
lda #$01
sta $206, Y
tya
adc #$04
tay
dec temp0
bne @init_horizontal
pla
tay
pla
tax
pla
rts
draw_player:
pha
tya
pha
ldy x_player
sty $203
ldy y_player
dey
sty $200
pla
tay
pla
rts
draw_fireballs:
pha
txa
pha
tya
pha
lda #fireball_amount
sta temp0
lda #$00
tax
tay
@loop:
lda up_fireballs, Y
sta $207, X
iny
lda up_fireballs, Y
sta $204, X
dec $204, X
iny
inx
inx
inx
inx
dec temp0
bne @loop
pla
tay
pla
tax
pla
rts
update_player:
pha
lda buttons
and #$08
bne @up
lda buttons
and #$04
bne @down
@horizontal:
lda buttons
and #$02
bne @left
lda buttons
and #$01
bne @right
jmp @end
@up:
lda y_player
cmp #player_min_y
beq @horizontal
dec y_player
jmp @horizontal
@down:
lda y_player
cmp #player_max_y
beq @horizontal
inc y_player
jmp @horizontal
@left:
lda x_player
cmp #player_min_x
beq @end
dec x_player
jmp @end
@right:
lda x_player
cmp #player_max_x
beq @end
inc x_player
@end:
pla
rts
update_fireballs:
pha
txa
pha
tya
pha
lda #(fireball_amount >> 2)
sta temp0
lda #$FF
ldx #$00
@update_up:
cmp up_fireballs, X
beq @@next
.REPEAT fireball_speed
dec up_fireballs + 1, X
.ENDR
ldy up_fireballs + 1, X
cpy #fireball_min_y
bne @@next
sta up_fireballs, X
sta up_fireballs + 1, X
@@next:
inx
inx
dec temp0
bne @update_up
lda #(fireball_amount >> 2)
sta temp0
lda #$FF
@update_down:
cmp up_fireballs, X
beq @@next
.REPEAT fireball_speed
inc up_fireballs + 1, X
.ENDR
ldy up_fireballs + 1, X
cpy #fireball_max_y
bne @@next
sta up_fireballs, X
sta up_fireballs + 1, X
@@next:
inx
inx
dec temp0
bne @update_down
lda #(fireball_amount >> 2)
sta temp0
lda #$FF
@update_right:
cmp up_fireballs, X
beq @@next
.REPEAT fireball_speed
inc up_fireballs, X
.ENDR
ldy up_fireballs, X
cpy #fireball_max_x
bne @@next
sta up_fireballs, X
sta up_fireballs + 1, X
@@next:
inx
inx
dec temp0
bne @update_right
lda #(fireball_amount >> 2)
sta temp0
lda #$FF
@update_left:
cmp up_fireballs, X
beq @@next
.REPEAT fireball_speed
dec up_fireballs, X
.ENDR
ldy up_fireballs, X
cpy #fireball_min_x
bne @@next
sta up_fireballs, X
sta up_fireballs + 1, X
@@next:
inx
inx
dec temp0
bne @update_left
pla
tay
pla
tax
pla
rts
create_fireball:
pha
txa
pha
tya
pha
lda note_pulse
bne @end
ldx current_note
dex
lda up_pattern.W, X
beq @down
ldy up_index
sta up_fireballs, Y
lda #fireball_max_y
sta up_fireballs + 1, Y
inc up_index
inc up_index
@down:
lda down_pattern.W, X
beq @right
ldy down_index
sta down_fireballs, Y
lda #fireball_min_y
sta down_fireballs + 1, Y
inc down_index
inc down_index
@right:
lda right_pattern.W, X
beq @left
ldy right_index
sta right_fireballs + 1, Y
lda #fireball_min_x
sta right_fireballs, Y
inc right_index
inc right_index
@left:
lda left_pattern.W, X
beq @setup_fix_indexes_loop
ldy left_index
sta left_fireballs + 1, Y
lda #fireball_max_x
sta left_fireballs, Y
inc left_index
inc left_index
@setup_fix_indexes_loop:
lda #(size_of_fireball * fireball_amount >> 2)
ldy #$00
ldx #$04
@fix_indexes:
cmp up_index - 1, X
bne @@continue
sty up_index - 1, X
@@continue:
dex
bne @fix_indexes
@end:
pla
tay
pla
tax
pla
rts
check_collision:
pha
txa
pha
tya
pha
clc
lda x_player
adc #$03
sta temp0
sta temp1
;inc temp1 ; Remove comment to make game easier
lda y_player
adc #$03
sta temp2
sta temp3
;inc temp3 ; Remove comment to make game easier
ldx #(fireball_amount * size_of_fireball)
@loop:
lda temp0
cmp up_fireballs - size_of_fireball, X
bcc @next
lda temp2
cmp up_fireballs - size_of_fireball + 1, X
bcc @next
lda up_fireballs - size_of_fireball, X
adc #06
cmp temp1
bcc @next
lda up_fireballs - size_of_fireball + 1, X
adc #06
cmp temp3
bcc @next
jmp @collides
@next:
dex
dex
bne @loop
clc
jmp @end
@collides:
sec
@end:
pla
tay
pla
tax
pla
rts
reset_song:
pha
lda #0
sta note_pulse
sta current_note
pla
rts
play_menu_song:
pha
jsr reset_song
lda #$20
sta pulse_limit
lda #(menu_song1 & $FF)
sta current_song1
lda #(menu_song1 >> 8)
sta (current_song1 + 1)
lda #(menu_song2 & $FF)
sta current_song2
lda #(menu_song2 >> 8)
sta (current_song2 + 1)
pla
rts
play_game_song:
pha
jsr reset_song
lda #$10
sta pulse_limit
lda #(game_song1 & $FF)
sta current_song1
lda #(game_song1 >> 8)
sta (current_song1 + 1)
lda #(game_song2 & $FF)
sta current_song2
lda #(game_song2 >> 8)
sta (current_song2 + 1)
pla
rts
play_lose_song:
pha
jsr reset_song
lda #$08
sta pulse_limit
lda #(lose_song1 & $FF)
sta current_song1
lda #(lose_song1 >> 8)
sta (current_song1 + 1)
lda #(lose_song2 & $FF)
sta current_song2
lda #(lose_song2 >> 8)
sta (current_song2 + 1)
pla
rts
play_end_song:
pha
jsr reset_song
lda #$10
sta pulse_limit
lda #(end_song1 & $FF)
sta current_song1
lda #(end_song1 >> 8)
sta (current_song1 + 1)
lda #(end_song2 & $FF)
sta current_song2
lda #(end_song2 >> 8)
sta (current_song2 + 1)
pla
rts
do_note:
pha
tya
pha
ldy note_pulse
cpy pulse_limit
bne @end
ldy current_note
lda (current_song1),Y
tay
lda periodTableHi.W,Y
sta APUPULSE1HIGH.W
lda periodTableLo.W,Y
sta APUPULSE1LOW.W
ldy current_note
lda (current_song2),Y
tay
lda periodTableHi.W,Y
sta APUPULSE2HIGH.W
lda periodTableLo.W,Y
sta APUPULSE2LOW.W
inc current_note
ldy #$FF
sty note_pulse
@end:
inc note_pulse
pla
tay
pla
rts
menu_song1:
.DB $2B, $2B, $2D, $2D, $29, $29, $29, $29, $27, $27, $29, $27, $26, $26, $26, $29
.DB $2B, $2B, $2D, $2D, $2E, $2E, $30, $30, $32, $30, $2E, $30, $2D, $2D, $2D, $2D
.DB $2B, $2B, $2D, $2D, $29, $29, $29, $29, $2B, $2B, $29, $2B, $2D, $2D, $2D, $2E
.DB $32, $32, $33, $33, $35, $35, $37, $37, $3A, $3A, $3C, $3C, $3E, $3E, $3E, $3E
.DB $3F, $3F, $3E, $3E, $39, $39, $3C, $3C, $3A, $3A, $39, $39, $37, $37, $37, $37
.DB $3F, $3F, $3E, $3E, $39, $39, $3C, $3C, $3A, $3A, $3C, $3C, $3E, $3E, $3E, $3E
.DB $3F, $3F, $3E, $3E, $39, $39, $3C, $3C, $3A, $3C, $3A, $39, $37, $37, $37, $37
.DB $3F, $3F, $3F, $3E, $41, $41, $41, $3C, $3A, $3A, $3A, $3A, $3A, $3A, $3C, $3E
.DB $3F, $3F, $3F, $3E, $41, $41, $3F, $45, $48, $45, $46, $42, $43, $3E, $3A, $37
.DB $33, $35, $37, $39, $3C, $3A, $39, $37, $36, $37, $39, $36, $37, $32, $2E, $2B
.DB $27, $26, $2B, $2D, $29, $30, $2E, $2D, $30, $32, $2D, $2D, $2B, $2B, $2B, $29
.DB $27, $27, $27, $27, $27, $27, $27, $27, $29, $29, $29, $29, $29, $29, $29, $29
.DB $26, $26, $26, $26, $26, $26, $26, $26, $2B, $2B, $2B, $2B, $2B, $2B, $2B, $2B
.DB $27, $27, $27, $27, $27, $27, $27, $27, $29, $29, $29, $29, $29, $29, $29, $29
.DB $2A, $2A, $2A, $2A, $2A, $2A, $2A, $2A, $2B, $29, $27, $26, $29, $27, $26, $24
.DB $27, $29, $27, $26, $24, $22, $24, $24, $26, $26, $26, $27, $2A, $2A, $2A, $2D
menu_song2:
.DB $1F, $1F, $1F, $1F, $1D, $1D, $1D, $1D, $1B, $1B, $1B, $1B, $1A, $1A, $1A, $1A
.DB $1F, $1F, $1F, $1F, $1D, $1D, $1D, $1D, $1B, $1B, $1B, $1B, $1A, $1A, $1A, $1A
.DB $1F, $1F, $1F, $1F, $1D, $1D, $1D, $1D, $1B, $1B, $1B, $1B, $1A, $1A, $1A, $1A
.DB $1F, $1F, $1F, $1F, $1D, $1D, $1D, $1D, $1B, $1B, $1B, $1B, $1A, $1A, $1A, $1A
.DB $1B, $1B, $1B, $1B, $1D, $1D, $1D, $1D, $16, $16, $16, $16, $1F, $1F, $1F, $1F
.DB $1B, $1B, $1B, $1B, $1D, $1D, $1D, $1D, $16, $16, $16, $16, $1A, $1A, $1A, $1A
.DB $1B, $16, $1B, $16, $1D, $18, $1D, $18, $16, $1D, $16, $1D, $1F, $1A, $1F, $1A
.DB $1B, $16, $1B, $16, $1D, $18, $1D, $18, $16, $1D, $16, $1D, $16, $1D, $16, $1D
.DB $1B, $00, $1B, $00, $1D, $00, $1D, $00, $1E, $00, $1E, $00, $1F, $00, $1F, $00
.DB $1B, $00, $1B, $00, $1D, $00, $1D, $00, $1E, $00, $1E, $00, $1F, $00, $1F, $00
.DB $1B, $00, $1B, $00, $1D, $00, $1D, $00, $1E, $00, $1E, $00, $1F, $00, $1F, $00
.DB $1B, $00, $1F, $00, $22, $00, $26, $00, $1D, $00, $21, $00, $24, $00, $27, $00
.DB $1A, $00, $1D, $00, $21, $00, $24, $00, $1F, $00, $22, $00, $26, $00, $29, $00
.DB $1B, $00, $1F, $00, $22, $00, $26, $00, $1D, $00, $21, $00, $24, $00, $27, $00
.DB $1A, $00, $1E, $00, $21, $00, $26, $00, $1F, $1F, $1F, $1F, $1D, $1D, $1D, $1D
.DB $1B, $1B, $1B, $1B, $1D, $1D, $1D, $1D, $1A, $1A, $1A, $1A, $1E, $1E, $1E, $1E
game_song1:
.DB $2A, $2A, $2A, $2A, $2D, $2D, $2D, $2D, $30, $30, $30, $30, $33, $33, $33, $33
.DB $33, $33, $33, $33, $33, $33, $33, $33, $33, $33, $33, $33, $33, $33, $33, $33
.DB $2B, $29, $2E, $2E, $2D, $32, $32, $32, $30, $30, $30, $2E, $2E, $2E, $2E, $2E
.DB $30, $00, $30, $32, $33, $33, $32, $30, $31, $31, $34, $34, $32, $36, $39, $39
.DB $37, $35, $3E, $3E, $3C, $41, $41, $41, $3F, $3F, $3F, $3E, $3E, $3E, $3E, $3E
.DB $3C, $00, $3C, $3A, $3C, $3C, $3E, $3F, $40, $40, $3D, $3D, $3E, $3E, $39, $39
.DB $37, $37, $35, $3A, $3A, $3A, $39, $39, $36, $36, $35, $39, $39, $39, $3A, $3C
.DB $3E, $3E, $3E, $3C, $41, $41, $41, $3F, $3E, $42, $45, $45, $45, $45, $45, $45
.DB $43, $3E, $3A, $3E, $3A, $37, $3A, $37, $32, $37, $32, $2E, $32, $2E, $2B, $2B
.DB $2B, $2B, $2B, $2B, $2B, $2B, $2B, $2B, $2B, $2B, $2B, $2B, $2B, $2B, $2B, $2B
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
game_song2:
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $1F, $26, $1F, $26, $1F, $26, $1F, $26, $22, $29, $22, $29, $22, $29, $22, $29
.DB $24, $2B, $24, $2B, $24, $2B, $24, $2B, $21, $28, $21, $28, $26, $2D, $26, $2D
.DB $1F, $26, $1F, $26, $1F, $26, $1F, $26, $22, $29, $22, $29, $22, $29, $22, $29
.DB $24, $2B, $24, $2B, $24, $2B, $24, $2B, $21, $28, $21, $28, $26, $2D, $26, $2D
.DB $1F, $26, $1F, $26, $1F, $26, $1F, $26, $1E, $26, $1E, $26, $1E, $26, $1E, $26
.DB $1D, $26, $1D, $26, $1D, $26, $1D, $26, $1A, $26, $1A, $26, $1A, $26, $1A, $26
.DB $1F, $00, $00, $00, $1F, $00, $00, $00, $1F, $00, $00, $00, $1F, $00, $1F, $1F
.DB $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
lose_song1:
.DB $37, $37, $37, $36, $35, $35, $35, $34, $33, $33, $33, $32, $31, $31, $31, $30
.DB $2F, $2F, $2F, $2F, $2F, $2F, $2E, $2E, $2E, $2E, $2E, $2E, $2E, $2E, $2E, $2E
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $2E, $2E, $2E, $00, $2E, $2E, $2E, $00, $32, $32, $32, $00, $35, $35, $37, $37
.DB $37, $37, $35, $35, $35, $35, $35, $35, $35, $35, $35, $35, $35, $35, $35, $35
.DB $3A, $3A, $3A, $00, $3A, $3A, $3A, $00, $37, $37, $37, $00, $35, $35, $37, $37
.DB $37, $37, $3A, $3A, $37, $37, $35, $35, $37, $37, $37, $00, $32, $32, $32, $00
.DB $2E, $2E, $2E, $00, $2E, $2E, $2E, $00, $32, $32, $32, $00, $35, $35, $37, $37
.DB $37, $37, $3A, $3A, $3A, $3A, $3A, $3A, $3A, $3A, $3A, $3A, $3A, $3A, $3A, $3A
.DB $3C, $3C, $3C, $00, $3C, $3C, $3C, $00, $3C, $3C, $3C, $00, $39, $39, $3A, $3A
.DB $3A, $3A, $3A, $3A, $3A, $3A, $3A, $3A, $46, $46, $46, $46, $46, $46, $46, $46
.DB $46, $46, $46, $46, $46, $46, $46, $46, $46, $46, $46, $46, $46, $46, $46, $46
.DB $47, $47, $47, $46, $45, $45, $45, $44, $43, $43, $43, $42, $41, $41, $41, $40
.DB $3F, $3F, $3F, $3E, $3D, $3D, $3D, $3C, $3B, $3B, $3B, $3A, $39, $39, $39, $38
lose_song2:
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $22, $22, $22, $29, $2B, $2B, $2B, $29, $22, $22, $22, $29, $2B, $2B, $2B, $29
.DB $22, $22, $22, $29, $2B, $2B, $2B, $29, $22, $22, $22, $29, $2B, $2B, $2B, $29
.DB $1B, $1B, $1B, $22, $24, $24, $24, $22, $1B, $1B, $1B, $22, $24, $24, $24, $22
.DB $22, $22, $22, $29, $2B, $2B, $2B, $29, $22, $22, $22, $29, $2B, $2B, $2B, $29
.DB $1B, $1B, $1B, $22, $24, $24, $24, $22, $22, $22, $22, $29, $2B, $2B, $2B, $29
.DB $22, $22, $22, $29, $2B, $2B, $2B, $29, $22, $22, $22, $29, $2B, $2B, $2B, $29
.DB $1B, $1B, $1B, $22, $24, $24, $24, $22, $1B, $1B, $1B, $22, $24, $24, $24, $22
.DB $1D, $1D, $1D, $24, $26, $26, $26, $24, $1D, $1D, $1D, $24, $26, $26, $26, $24
.DB $22, $22, $22, $22, $22, $22, $22, $22, $22, $22, $22, $22, $22, $22, $22, $22
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
end_song1:
.DB $33, $33, $00, $33, $33, $37, $3A, $3A, $3A, $37, $37, $37, $39, $39, $39, $3C
.DB $3C, $3C, $3C, $3C, $3C, $3C, $3C, $00, $3C, $3C, $3C, $3E, $3E, $3E, $3E, $3E
.DB $3E, $3E, $3E, $3E, $3B, $3B, $3B, $37, $37, $37, $37, $37, $37, $35, $35, $35
.DB $33, $33, $00, $33, $33, $35, $37, $37, $37, $35, $35, $00, $35, $35, $35, $33
.DB $33, $33, $35, $35, $35, $33, $33, $33, $32, $32, $32, $32, $32, $32, $32, $32
.DB $32, $30, $30, $30, $2F, $2F, $30, $32, $32, $32, $32, $32, $32, $32, $32, $32
.DB $3F, $3F, $3F, $3E, $3E, $3E, $3C, $3C, $3C, $3A, $3A, $3A, $41, $41, $41, $3F
.DB $3F, $3F, $3E, $3E, $3E, $3C, $3C, $3C, $3E, $3E, $3E, $3E, $3E, $3E, $3E, $3E
.DB $3E, $3C, $3C, $3C, $3B, $3B, $3C, $3E, $3E, $3E, $3E, $3E, $3E, $3F, $3F, $00
.DB $3F, $3F, $3F, $3E, $3E, $3E, $3C, $3C, $3C, $3A, $3A, $3A, $41, $41, $41, $3F
.DB $3F, $3F, $41, $41, $41, $43, $43, $00, $43, $43, $43, $43, $43, $43, $43, $43
.DB $43, $48, $48, $4A, $47, $47, $47, $47, $47, $47, $47, $47, $47, $45, $45, $47
.DB $43, $43, $43, $41, $41, $41, $3F, $3F, $3F, $3E, $3E, $3E, $3C, $3C, $3C, $3A
.DB $3A, $3A, $39, $39, $39, $37, $37, $00, $37, $37, $37, $37, $37, $37, $37, $37
.DB $37, $37, $37, $37, $37, $37, $37, $37, $37, $37, $37, $37, $00, $00, $00, $00
.DB $32, $00, $00, $00, $2F, $00, $00, $00, $2B, $00, $00, $00, $32, $00, $00, $00
end_song2:
.DB $1B, $1F, $22, $1B, $1F, $22, $1B, $1F, $22, $1B, $1F, $22, $1D, $21, $24, $1D
.DB $21, $24, $1D, $21, $24, $1D, $21, $24, $1F, $24, $26, $1F, $24, $26, $1F, $24
.DB $26, $1F, $24, $26, $1F, $23, $26, $1F, $23, $26, $1F, $23, $26, $1F, $23, $26
.DB $1B, $1F, $22, $1B, $1F, $22, $1B, $1F, $22, $1B, $1F, $22, $1D, $21, $24, $1D
.DB $21, $24, $1D, $21, $24, $1D, $21, $24, $1F, $24, $26, $1F, $24, $26, $1F, $24
.DB $26, $1F, $24, $26, $1F, $23, $26, $1F, $23, $26, $1F, $23, $26, $1F, $23, $26
.DB $1B, $1F, $22, $1B, $1F, $22, $1B, $1F, $22, $1B, $1F, $22, $1D, $21, $24, $1D
.DB $21, $24, $1D, $21, $24, $1D, $21, $24, $1F, $24, $26, $1F, $24, $26, $1F, $24
.DB $26, $1F, $24, $26, $1F, $23, $26, $1F, $23, $26, $1F, $23, $26, $1F, $23, $26
.DB $1B, $1F, $22, $1B, $1F, $22, $1B, $1F, $22, $1B, $1F, $22, $1D, $21, $24, $1D
.DB $21, $24, $1D, $21, $24, $1D, $21, $24, $1F, $24, $26, $1F, $24, $26, $1F, $24
.DB $26, $1F, $24, $26, $1F, $23, $26, $1F, $23, $26, $1F, $23, $26, $1F, $23, $26
.DB $1B, $1B, $1B, $1B, $1B, $1B, $1B, $1B, $1B, $1B, $1B, $1B, $1D, $1D, $1D, $1D
.DB $1D, $1D, $1D, $1D, $1D, $1D, $1D, $1D, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F
.DB $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $1F, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
periodTableLo:
.DB $f1, $7f, $13, $ad, $4d, $f3, $9d, $4c, $00, $b8, $74, $34
.DB $f8, $bf, $89, $56, $26, $f9, $ce, $a6, $80, $5c, $3a, $1a
.DB $fb, $df, $c4, $ab, $93, $7c, $67, $52, $3f, $2d, $1c, $0c
.DB $fd, $ef, $e1, $d5, $c9, $bd, $b3, $a9, $9f, $96, $8e, $86
.DB $7e, $77, $70, $6a, $64, $5e, $59, $54, $4f, $4b, $46, $42
.DB $3f, $3b, $38, $34, $31, $2f, $2c, $29, $27, $25, $23, $21
.DB $1f, $1d, $1b, $1a, $18, $17, $15, $14
periodTableHi:
.DB $07, $07, $07, $06, $06, $05, $05, $05, $05, $04, $04, $04
.DB $03, $03, $03, $03, $03, $02, $02, $02, $02, $02, $02, $02
.DB $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01, $01
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00, $00
.DB $00, $00, $00, $00, $00, $00, $00, $00
* CHR-ROM
.BANK 3 SLOT 5
* Pattern Table 0 (4KB)
.ORG $0000
.DSW 8, $0000 ; EMPTY
.DSB 8, $FF
.DSB 8, $00 ; STRONG SQUARE
.DSB 8, $00
.DSB 8, $FF ; LIGHT SQUARE
.DSW 8, $FFFF ; WHITE SQUARE
.DB $00, $3C, $3C, $3C, $7E, $FF, $FF, $FF, $00, $00, $18, $18, $18, $3C, $7E, $7E ; SPIKE1
.DB $00, $00, $18, $18, $18, $3C, $7E, $7E, $00, $3C, $3C, $3C, $7E, $FF, $FF, $FF ; SPIKE2
.DB $00, $08, $04, $00, $18, $60, $00, $00, $00, $0C, $0C, $00, $38, $70, $00, $00 ; CRACK1
.DB $00, $00, $C0, $20, $00, $02, $0C, $00, $00, $00, $E0, $60, $00, $06, $0E, $00 ; CRACK2
.DSW 320 , $0000
.DB $00, $3C, $24, $24, $24, $24, $24, $3C, $00, $3C, $24, $24, $24, $24, $24, $3C ; 0
.DB $00, $04, $04, $04, $04, $04, $04, $04, $00, $04, $04, $04, $04, $04, $04, $04 ; 1
.DB $00, $3C, $04, $04, $3C, $20, $20, $3C, $00, $3C, $04, $04, $3C, $20, $20, $3C ; 2
.DB $00, $3C, $04, $04, $3C, $04, $04, $3C, $00, $3C, $04, $04, $3C, $04, $04, $3C ; 3
.DB $00, $24, $24, $24, $3C, $04, $04, $04, $00, $24, $24, $24, $3C, $04, $04, $04 ; 4
.DB $00, $3C, $20, $20, $3C, $04, $04, $3C, $00, $3C, $20, $20, $3C, $04, $04, $3C ; 5
.DB $00, $3C, $20, $20, $3C, $24, $24, $3C, $00, $3C, $20, $20, $3C, $24, $24, $3C ; 6
.DB $00, $3C, $04, $04, $04, $04, $04, $04, $00, $3C, $04, $04, $04, $04, $04, $04 ; 7
.DB $00, $3C, $24, $24, $3C, $24, $24, $3C, $00, $3C, $24, $24, $3C, $24, $24, $3C ; 8
.DB $00, $3C, $24, $24, $3C, $04, $04, $3C, $00, $3C, $24, $24, $3C, $04, $04, $3C ; 9
.DSW 56 , $0000
.DB $00, $3C, $24, $24, $3C, $24, $24, $24, $00, $3C, $24, $24, $3C, $24, $24, $24 ; A
.DB $00, $38, $24, $24, $3C, $24, $24, $38, $00, $38, $24, $24, $3C, $24, $24, $38 ; B
.DB $00, $3C, $40, $40, $40, $40, $40, $3C, $00, $3C, $40, $40, $40, $40, $40, $3C ; C
.DB $00, $70, $48, $44, $44, $44, $48, $70, $00, $70, $48, $44, $44, $44, $48, $70 ; D
.DB $00, $7E, $40, $40, $7C, $40, $40, $7E, $00, $7E, $40, $40, $7C, $40, $40, $7E ; E
.DB $00, $7E, $40, $40, $7C, $40, $40, $40, $00, $7E, $40, $40, $7C, $40, $40, $40 ; F
.DB $00, $3C, $40, $40, $4C, $44, $44, $3C, $00, $3C, $40, $40, $4C, $44, $44, $3C ; G
.DB $00, $24, $24, $24, $3C, $24, $24, $24, $00, $24, $24, $24, $3C, $24, $24, $24 ; H
.DB $00, $1C, $08, $08, $08, $08, $08, $1C, $00, $1C, $08, $08, $08, $08, $08, $1C ; I
.DB $00, $38, $08, $08, $08, $08, $48, $30, $00, $38, $08, $08, $08, $08, $48, $30 ; J
.DB $00, $84, $88, $90, $C0, $90, $88, $84, $00, $84, $88, $90, $C0, $90, $88, $84 ; K
.DB $00, $20, $20, $20, $20, $20, $20, $3C, $00, $20, $20, $20, $20, $20, $20, $3C ; L
.DB $00, $22, $36, $2A, $2A, $22, $22, $22, $00, $22, $36, $2A, $2A, $22, $22, $22 ; M
.DB $00, $42, $62, $72, $5A, $4E, $46, $42, $00, $42, $62, $72, $5A, $4E, $46, $42 ; N
.DB $00, $18, $24, $42, $42, $42, $24, $18, $00, $18, $24, $42, $42, $42, $24, $18 ; O
.DB $00, $38, $24, $24, $38, $20, $20, $20, $00, $38, $24, $24, $38, $20, $20, $20 ; P
.DB $00, $18, $24, $42, $42, $4A, $24, $1A, $00, $18, $24, $42, $42, $4A, $24, $1A ; Q
.DB $00, $38, $24, $24, $38, $30, $28, $24, $00, $38, $24, $24, $38, $30, $28, $24 ; R
.DB $00, $1C, $20, $20, $1C, $02, $02, $1C, $00, $1C, $20, $20, $1C, $02, $02, $1C ; S
.DB $00, $3E, $08, $08, $08, $08, $08, $08, $00, $3E, $08, $08, $08, $08, $08, $08 ; T
.DB $00, $42, $42, $42, $42, $42, $42, $3C, $00, $42, $42, $42, $42, $42, $42, $3C ; U
.DB $00, $42, $42, $24, $24, $24, $18, $18, $00, $42, $42, $24, $24, $24, $18, $18 ; V
.DB $81, $81, $C3, $42, $59, $59, $24, $24, $81, $81, $C3, $42, $59, $59, $24, $24 ; W
.DB $00, $42, $42, $24, $18, $18, $24, $42, $00, $42, $42, $24, $18, $18, $24, $42 ; X
.DB $00, $22, $14, $14, $08, $08, $08, $08, $00, $22, $14, $14, $08, $08, $08, $08 ; Y
.DB $00, $7E, $06, $0C, $18, $30, $60, $7E, $00, $7E, $06, $0C, $18, $30, $60, $7E ; Z
.DSW 1320, $A5A5
* Pattern Table 1 (4KB)
.DB $3C, $7E, $DB, $FF, $DB, $E7, $7E, $3C, $00, $3C, $7E, $7E, $7E, $7E, $3C, $00 ; Smile
.DB $FF, $FF, $C3, $C3, $C3, $C3, $FF, $FF, $00, $00, $3C, $3C, $3C, $3C, $00, $00 ; Win Spot 1
.DB $FF, $FF, $FF, $E7, $E7, $FF, $FF, $FF, $FF, $81, $81, $99, $99, $81, $81, $FF ; Win Spot 2
.DB $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $C3, $C3, $C3, $C3, $FF, $FF ; Win Spot 3
.DB $00, $7E, $7E, $7E, $7E, $7E, $7E, $00, $FF, $FF, $FF, $E7, $E7, $FF, $FF, $FF ; Win Spot 4
.DB $00, $00, $3C, $3C, $3C, $3C, $00, $00, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF ; Win Spot 5
.DB $FF, $81, $81, $99, $99, $81, $81, $FF, $00, $7E, $7E, $7E, $7E, $7E, $7E, $00 ; Win Spot 6
.DB $00, $18, $3C, $7E, $7E, $3C, $18, $00, $00, $00, $18, $3C, $3C, $18, $00, $00 ; Ball
.DB $C3, $66, $3C, $18, $18, $3C, $66, $C3, $00, $00, $00, $00, $00, $00, $00, $00 ; Dead
.DSW 1976, $5A5A
| 36.393023
| 1,215
| 0.47675
|
22836d10dcf2acd53d249175d8a3bc0474f4a10a
| 168
|
asm
|
Assembly
|
audio/sfx/snare5_3.asm
|
AmateurPanda92/pokemon-rby-dx
|
f7ba1cc50b22d93ed176571e074a52d73360da93
|
[
"MIT"
] | 9
|
2020-07-12T19:44:21.000Z
|
2022-03-03T23:32:40.000Z
|
audio/sfx/snare5_3.asm
|
JStar-debug2020/pokemon-rby-dx
|
c2fdd8145d96683addbd8d9075f946a68d1527a1
|
[
"MIT"
] | 7
|
2020-07-16T10:48:52.000Z
|
2021-01-28T18:32:02.000Z
|
audio/sfx/snare5_3.asm
|
JStar-debug2020/pokemon-rby-dx
|
c2fdd8145d96683addbd8d9075f946a68d1527a1
|
[
"MIT"
] | 2
|
2021-03-28T18:33:43.000Z
|
2021-05-06T13:12:09.000Z
|
SFX_Snare5_3_Ch7:
noisenote 7, 8, 4, 55
noisenote 6, 8, 4, 54
noisenote 5, 8, 3, 53
noisenote 4, 8, 3, 52
noisenote 3, 8, 2, 51
noisenote 2, 8, 1, 50
endchannel
| 18.666667
| 22
| 0.654762
|
d7f8156e83f9676c40dd53a046122109fa210de8
| 331
|
asm
|
Assembly
|
blinker01/entry.asm
|
kjaleshire/raspberry-pi-rs
|
28b4cde6731b38f659d4bcb5a4f8fe6bce64afb3
|
[
"MIT"
] | null | null | null |
blinker01/entry.asm
|
kjaleshire/raspberry-pi-rs
|
28b4cde6731b38f659d4bcb5a4f8fe6bce64afb3
|
[
"MIT"
] | null | null | null |
blinker01/entry.asm
|
kjaleshire/raspberry-pi-rs
|
28b4cde6731b38f659d4bcb5a4f8fe6bce64afb3
|
[
"MIT"
] | null | null | null |
.globl _start
_start:
mov sp, #0x8000
bl rust_main
hang:
b hang
.globl dummy
dummy:
// just do some work to waste cycles
push {r4, r5, r6, r7, r8, lr}
mov r4, #0x0
mov r5, #0x1
mov r6, #0x2
mov r7, #0x3
mov r8, #0x4
mov lr, #0x5
pop {r4, r5, r6, r7, r8, pc}
| 17.421053
| 40
| 0.510574
|
b10020448e4418bba4bb992cb828708fb506cea5
| 5,400
|
asm
|
Assembly
|
Transynther/x86/_processed/NONE/_xt_/i7-8650U_0xd2_notsx.log_21829_1774.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 9
|
2020-08-13T19:41:58.000Z
|
2022-03-30T12:22:51.000Z
|
Transynther/x86/_processed/NONE/_xt_/i7-8650U_0xd2_notsx.log_21829_1774.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 1
|
2021-04-29T06:29:35.000Z
|
2021-05-13T21:02:30.000Z
|
Transynther/x86/_processed/NONE/_xt_/i7-8650U_0xd2_notsx.log_21829_1774.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 3
|
2020-07-14T17:07:07.000Z
|
2022-03-21T01:12:22.000Z
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r8
push %r9
push %rax
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0x1ce29, %rax
nop
nop
and $62005, %rcx
mov $0x6162636465666768, %r8
movq %r8, %xmm0
vmovups %ymm0, (%rax)
nop
nop
nop
nop
nop
and $8370, %r11
lea addresses_WC_ht+0x1a7b1, %rdi
nop
nop
nop
nop
nop
and %r12, %r12
movups (%rdi), %xmm7
vpextrq $0, %xmm7, %r9
xor $39999, %rdi
lea addresses_UC_ht+0x1d409, %rax
nop
and %rcx, %rcx
mov (%rax), %r9d
nop
xor $60343, %r11
lea addresses_D_ht+0x113e1, %rax
nop
nop
and $28092, %r8
movl $0x61626364, (%rax)
nop
nop
nop
xor $10194, %r9
lea addresses_normal_ht+0xc189, %rsi
lea addresses_A_ht+0xea81, %rdi
dec %r11
mov $2, %rcx
rep movsw
nop
nop
nop
nop
nop
sub $36671, %r9
lea addresses_A_ht+0x12e65, %rsi
lea addresses_WT_ht+0xca09, %rdi
nop
nop
nop
nop
xor $41450, %rax
mov $70, %rcx
rep movsb
nop
nop
cmp %r11, %r11
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r9
pop %r8
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r8
push %r9
push %rax
push %rbx
push %rdi
push %rdx
// Faulty Load
lea addresses_WC+0x14209, %rbx
add $11657, %rax
mov (%rbx), %r8
lea oracles, %r9
and $0xff, %r8
shlq $12, %r8
mov (%r9,%r8,1), %r8
pop %rdx
pop %rdi
pop %rbx
pop %rax
pop %r9
pop %r8
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_WC', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_WC', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 4, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 3, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 3, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 5, 'same': False}, 'dst': {'type': 'addresses_A_ht', 'congruent': 3, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 0, 'same': True}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 11, 'same': False}}
{'38': 21829}
38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38
*/
| 43.902439
| 2,999
| 0.65963
|
9dbf149e4c0de2fb72a39ceb8cb777fffdbb0888
| 629
|
asm
|
Assembly
|
oeis/256/A256328.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/256/A256328.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/256/A256328.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A256328: Number of partitions of 6n into exactly 4 parts.
; 0,2,15,47,108,206,351,551,816,1154,1575,2087,2700,3422,4263,5231,6336,7586,8991,10559,12300,14222,16335,18647,21168,23906,26871,30071,33516,37214,41175,45407,49920,54722,59823,65231,70956,77006,83391,90119,97200,104642,112455,120647,129228,138206,147591,157391,167616,178274,189375,200927,212940,225422,238383,251831,265776,280226,295191,310679,326700,343262,360375,378047,396288,415106,434511,454511,475116,496334,518175,540647,563760,587522,611943,637031,662796,689246,716391,744239,772800,802082
mov $1,$0
mul $0,6
add $0,3
mov $2,$1
mul $2,$1
mul $0,$2
div $0,4
| 57.181818
| 500
| 0.791733
|
94261da23fd2ce25ce808507d05b0ddfcad0dd0b
| 341
|
asm
|
Assembly
|
oeis/083/A083319.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/083/A083319.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/083/A083319.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A083319: 4^n+3^n-2^n.
; Submitted by Jamie Morken(s3.)
; 1,5,21,83,321,1235,4761,18443,71841,281315,1106601,4369403,17304561,68694995,273202041,1088057963,4337948481,17308878275,69106635081,276039644123,1102997363601,4408504767155,17623562909721,70462878967883
mov $1,3
pow $1,$0
mov $2,2
pow $2,$0
sub $1,$2
pow $2,2
add $2,$1
mov $0,$2
| 26.230769
| 205
| 0.753666
|
b7021cd9379ebdc46228cc785ee2e50fc84a77cd
| 4,924
|
asm
|
Assembly
|
Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0xca_notsx.log_21829_158.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 9
|
2020-08-13T19:41:58.000Z
|
2022-03-30T12:22:51.000Z
|
Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0xca_notsx.log_21829_158.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 1
|
2021-04-29T06:29:35.000Z
|
2021-05-13T21:02:30.000Z
|
Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0xca_notsx.log_21829_158.asm
|
ljhsiun2/medusa
|
67d769b8a2fb42c538f10287abaf0e6dbb463f0c
|
[
"MIT"
] | 3
|
2020-07-14T17:07:07.000Z
|
2022-03-21T01:12:22.000Z
|
.global s_prepare_buffers
s_prepare_buffers:
push %r12
push %r14
push %r8
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_UC_ht+0x40ce, %rdi
nop
nop
nop
xor $55719, %r14
vmovups (%rdi), %ymm7
vextracti128 $0, %ymm7, %xmm7
vpextrq $1, %xmm7, %r8
nop
nop
sub $43735, %rcx
lea addresses_UC_ht+0x1532d, %rsi
lea addresses_normal_ht+0x307d, %rdi
nop
nop
nop
mfence
mov $56, %rcx
rep movsq
cmp %r8, %r8
lea addresses_D_ht+0x16145, %r12
clflush (%r12)
cmp $28207, %rdx
movb $0x61, (%r12)
nop
nop
nop
cmp %rdi, %rdi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r8
pop %r14
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r14
push %r15
push %rax
push %rbp
push %rbx
push %rdx
// Store
lea addresses_A+0x1302e, %rbp
clflush (%rbp)
nop
nop
nop
nop
add %rdx, %rdx
mov $0x5152535455565758, %rbx
movq %rbx, %xmm0
vmovups %ymm0, (%rbp)
nop
nop
and $17386, %rdx
// Faulty Load
lea addresses_PSE+0xeafd, %rbx
nop
nop
inc %rax
mov (%rbx), %rdx
lea oracles, %rbp
and $0xff, %rdx
shlq $12, %rdx
mov (%rbp,%rdx,1), %rdx
pop %rdx
pop %rbx
pop %rbp
pop %rax
pop %r15
pop %r14
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 0, 'same': False, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 0, 'same': False, 'type': 'addresses_A'}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 0, 'same': True, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 0, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 1, 'same': False, 'type': 'addresses_UC_ht'}, 'dst': {'congruent': 7, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'REPM'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 3, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'STOR'}
{'33': 21829}
33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33
*/
| 47.805825
| 2,999
| 0.661251
|
d0435986c4d603cfe6279093e32b5f83010271ad
| 689
|
asm
|
Assembly
|
programs/oeis/263/A263537.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/263/A263537.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/263/A263537.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A263537: Integers k such that A098531(k) is divisible by A000071(k+2).
; 1,2,13,25,31,43,55,61,73,85,91,103,115,121,133,145,151,163,175,181,193,205,211,223,235,241,253,265,271,283,295,301,313,325,331,343,355,361,373,385,391,403,415,421,433,445,451,463,475,481,493,505,511,523,535,541,553,565,571,583,595,601,613,625,631,643,655,661,673,685,691,703,715,721,733,745,751,763,775,781,793,805,811,823,835,841,853,865,871,883,895,901,913,925,931,943,955,961,973,985
mul $0,2
trn $0,1
mov $2,$0
mov $3,$0
mul $0,2
add $0,2
sub $0,$3
mul $3,2
mov $4,5
lpb $0
sub $0,1
trn $0,2
mov $1,$4
add $2,$3
add $2,3
add $3,2
sub $1,$3
add $1,2
mov $3,3
lpe
add $1,$2
sub $1,7
mov $0,$1
| 25.518519
| 388
| 0.657475
|
85ae68205f4c4a1147dfe6fbb499dc01a7cc7293
| 633
|
asm
|
Assembly
|
35-speed.asm
|
yuwanzeon/human-resource-machine-solutions
|
c95641bf409ed3419f7e71eafac0fcdabecb7204
|
[
"MIT"
] | 1
|
2016-12-29T06:55:26.000Z
|
2016-12-29T06:55:26.000Z
|
35-speed.asm
|
yuwanzeon/human-resource-machine-solutions
|
c95641bf409ed3419f7e71eafac0fcdabecb7204
|
[
"MIT"
] | null | null | null |
35-speed.asm
|
yuwanzeon/human-resource-machine-solutions
|
c95641bf409ed3419f7e71eafac0fcdabecb7204
|
[
"MIT"
] | null | null | null |
-- HUMAN RESOURCE MACHINE PROGRAM --
COPYFROM 14
COPYTO 13
INBOX
COPYTO 0
OUTBOX
INBOX
COPYTO 1
SUB 0
JUMPZ c
COPYFROM 1
OUTBOX
BUMPUP 13
INBOX
COPYTO 2
SUB 0
JUMPZ b
COPYFROM 2
SUB 1
JUMPZ a
COPYFROM 2
OUTBOX
BUMPUP 13
a:
b:
c:
BUMPUP 13
d:
e:
INBOX
COPYTO 12
COPYFROM 13
COPYTO 11
f:
BUMPDN 11
JUMPN g
COPYFROM 12
SUB [11]
JUMPZ e
JUMP f
g:
COPYFROM 12
COPYTO [13]
OUTBOX
BUMPUP 13
JUMP d
| 12.66
| 36
| 0.466035
|
f59681a0143a15f9aa27ed7707c0f840d2ec1a21
| 18,312
|
asm
|
Assembly
|
Appl/Games/GWPoker/gwpoker.asm
|
steakknife/pcgeos
|
95edd7fad36df400aba9bab1d56e154fc126044a
|
[
"Apache-2.0"
] | 504
|
2018-11-18T03:35:53.000Z
|
2022-03-29T01:02:51.000Z
|
Appl/Games/GWPoker/gwpoker.asm
|
steakknife/pcgeos
|
95edd7fad36df400aba9bab1d56e154fc126044a
|
[
"Apache-2.0"
] | 96
|
2018-11-19T21:06:50.000Z
|
2022-03-06T10:26:48.000Z
|
Appl/Games/GWPoker/gwpoker.asm
|
steakknife/pcgeos
|
95edd7fad36df400aba9bab1d56e154fc126044a
|
[
"Apache-2.0"
] | 73
|
2018-11-19T20:46:53.000Z
|
2022-03-29T00:59:26.000Z
|
COMMENT @----------------------------------------------------------------------
Copyright (c) GeoWorks 1990 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: GeoWorks Poker
FILE: gwpoker.asm
REVISION HISTORY:
Name Date Description
---- ---- -----------
Jon 12/90 Initial Version
bchow 2 /93 2.0 update
DESCRIPTION:
RCS STAMP:
$Id: gwpoker.asm,v 1.1 97/04/04 15:19:57 newdeal Exp $
------------------------------------------------------------------------------@
;------------------------------------------------------------------------------
; Common GEODE stuff
;------------------------------------------------------------------------------
_Application = 1
;Standard include files
include geos.def
include geode.def
include ec.def
include myMacros.def
include library.def
include resource.def
include object.def
include graphics.def
include gstring.def
include Objects/winC.def
include heap.def
include lmem.def
include timer.def
include timedate.def
include system.def
include file.def
include fileEnum.def
include vm.def
include hugearr.def
include Objects/inputC.def
include initfile.def
include dbase.def
;------------------------------------------------------------------------------
; Libraries used
;------------------------------------------------------------------------------
UseLib ui.def
UseLib sound.def
UseLib game.def
UseLib cards.def
UseLib dbase.def
UseLib wav.def
; Don't enable both of these at once
WAV_SOUND equ 0
STANDARD_SOUND equ 1
; This enables/disables code to allow setting of card fading. The ui
; must be uncommented/commented in bjack.ui also.
FADING = 0
include pokerGame.asm
include payoffDisplay.asm
include pokerSound.asm
;------------------------------------------------------------------------------
; Macros
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; Constants
;------------------------------------------------------------------------------
SCORE_DISPLAY_BUFFER_SIZE equ 12 ;11 chars for score +
; null terminator
if STANDARD_SOUND
; Notes
; WHOLE equ 48
; HALF equ WHOLE/2
HALF_D equ HALF * 3/2
; QUARTER equ WHOLE/4
QUARTER_D equ QUARTER * 3/2
; EIGHTH equ QUARTER/2
endif
;------------------------------------------------------------------------------
; Definitions
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; Object Class include files
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; Class & Method Definitions
;------------------------------------------------------------------------------
;This is the class for this application's process.
PokerProcessClass class GenProcessClass
MSG_ADD message
MSG_POKER_SAVE_OPTIONS message
PokerProcessClass endc ;end of class definition
;------------------------------------------------------------------------------
; Resources
;------------------------------------------------------------------------------
include sizes.def
include gwpoker.rdef
;------------------------------------------------------------------------------
; Initialized variables and class structures
;------------------------------------------------------------------------------
idata segment
;Class definition is stored in the application's idata resource here.
PokerProcessClass mask CLASSF_NEVER_SAVED
idata ends
;------------------------------------------------------------------------------
; Uninitialized variables
;------------------------------------------------------------------------------
udata segment
udata ends
;------------------------------------------------------------------------------
; Code for PokerProcessClass
;------------------------------------------------------------------------------
CommonCode segment resource ;start of code resource
PokerStartUp method PokerProcessClass, MSG_GEN_PROCESS_OPEN_APPLICATION
call PokerSetViewBackgroundColor
; If the game is already open then we started to exit
; but were started backup. All the ui objects should still
; be in place. So just call the super class. Note -
; the AAF_RESTORING_FROM_STATE bit will be set in this
; case even though we aren't coming back from state, so
; checking for being open must come before checking the
; bit.
;
call PokerCheckIfGameIsOpen
jc callSuper
test cx, mask AAF_RESTORING_FROM_STATE
jz startingUp
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov ax, MSG_GAME_RESTORE_BITMAPS
mov di, mask MF_FIXUP_DS
call ObjMessage
callSuper:
mov di, offset PokerProcessClass
mov ax, MSG_GEN_PROCESS_OPEN_APPLICATION
call ObjCallSuperNoLock
setupSounds:
if STANDARD_SOUND
; Under any circumstances that we receive
; MSG_GEN_PROCESS_OPEN_APPLICATION the sound buffers will
; need to be created.
;
CallMod SoundSetupSounds
endif
; Mark the game as open so that we can detect the lazarus
; situation.
;
call PokerMarkGameOpen
ret
startingUp:
call PokerMakeSureTokenIsInstalled
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov ax, MSG_GAME_SETUP_STUFF
mov di, mask MF_FIXUP_DS
call ObjMessage
mov di, offset PokerProcessClass
mov ax, MSG_GEN_PROCESS_OPEN_APPLICATION
call ObjCallSuperNoLock
;
; We're not restoring from state, so we need to create a full
; deck and start a new game here
;
; Instantiate a full deck of cards,including 2 jokers
;
CallObject MyHand, MSG_HAND_MAKE_FULL_HAND, MF_FIXUP_DS
CallObject MyPlayingTable, MSG_ADD_JOKER, MF_FIXUP_DS
CallObject MyPlayingTable, MSG_ADD_JOKER, MF_FIXUP_DS
;
; Get which card back we're using
;
mov cx, cs
mov ds, cx ;DS:SI <- ptr to category string
mov si, offset pokerCategoryString
mov dx, offset pokerWhichBackString
call InitFileReadInteger
jc wild
mov_trash cx, ax ;cx <- which back
mov ax, MSG_GAME_SET_WHICH_BACK
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
clr di
call ObjMessage
wild:
;
; Get the wild choice
;
mov cx, cs
mov ds, cx
mov si, offset pokerCategoryString
mov dx, offset pokerWildString
call InitFileReadInteger
jc getPlayTune
mov_trash cx, ax ;cx <- wild
clr dx ;indeterminate ones
mov ax, MSG_GEN_ITEM_GROUP_SET_SINGLE_SELECTION
mov bx, handle WildList
mov si, offset WildList
clr di
call ObjMessage
getPlayTune:
;
; Set sound setting
;
mov cx, cs
mov ds, cx
mov si, offset pokerCategoryString ;category
mov dx, offset pokerPlayTuneString ;key
call InitFileReadInteger ;look into the .ini file
jc getFading
mov_trash cx, ax ;cx <- which back
mov dx, 0 ;not indeterminate
mov ax, MSG_GEN_ITEM_GROUP_SET_SINGLE_SELECTION
mov bx, handle SoundList
mov si, offset SoundList
clr di
call ObjMessage
getFading:
if FADING
;
; Set fading mode.
;
mov cx, cs
mov ds, cx
mov si, offset pokerCategoryString ;category
mov dx, offset pokerFadingString ;key
call InitFileReadBoolean ;look into the .ini file
jc initScore
mov_trash cx, ax ;dx = boolean Fade
clr dx ;indeterminate ones
mov bx, handle FadeList
mov si, offset FadeList
mov ax, MSG_GEN_BOOLEAN_GROUP_SET_GROUP_STATE
clr di
call ObjMessage
initScore:
endif
;
; Initialize the score and wager fields if not restoring from
; state.
;
mov cx, INITIAL_CASH
CallObject MyPlayingTable, MSG_GAME_UPDATE_SCORE, MF_FORCE_QUEUE
mov cx, INITIAL_WAGER
clr dx
CallObject MyPlayingTable, MSG_ADJUST_WAGER_AND_CASH, MF_FORCE_QUEUE
clr cx
clr dx
CallObject MyPlayingTable, MSG_SHOW_WINNINGS, MF_FORCE_QUEUE
;
; Read the UI to see whether or not we want wild cards to
; show up while playing
;
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
clr di
mov ax, MSG_SET_WILD
call ObjMessage
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
clr di
mov ax, MSG_SOLITAIRE_SET_FADE_STATUS
call ObjMessage
jmp setupSounds
PokerStartUp endm
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
PokerCheckIfGameIsOpen
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Will check if the varData ATTR_SOLITAIRE_GAME_OPEN
exists for MyPlayingTable
CALLED BY: SolitiareOpenApplication
PASS: nothing
RETURN: carry set if vardata found
carry clear if not found
DESTROYED: nothing
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
PW 7/ 7/93 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
PokerCheckIfGameIsOpen proc near
uses ax,bx,cx,dx,si,di,bp
.enter
sub sp, size GetVarDataParams
mov bp, sp
mov ss:[bp].GVDP_dataType, \
ATTR_POKER_GAME_OPEN
mov {word} ss:[bp].GVDP_bufferSize, 0
; clrdw ss:[bp].GVDP_buffer
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov ax, MSG_META_GET_VAR_DATA
mov dx, size GetVarDataParams
mov di, mask MF_CALL or mask MF_STACK
call ObjMessage
add sp, size GetVarDataParams
cmp ax, -1 ; check if not found
stc
jne varDataFound
;varDataNotFound:
clc
varDataFound:
.leave
ret
PokerCheckIfGameIsOpen endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
PokerMarkGameOpen
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Will add the varData ATTR_SOLITAIRE_GAME_OPEN to
MyPlayingTable
CALLED BY: PokerOpenApplication
PASS: nothing
RETURN: nothing
DESTROYED: nothing
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
PW 7/ 7/93 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
PokerMarkGameOpen proc near
uses ax,bx,cx,dx,si,di,bp
.enter
sub sp, size AddVarDataParams
mov bp, sp
mov ss:[bp].AVDP_dataType, \
ATTR_POKER_GAME_OPEN
mov {word} ss:[bp].AVDP_dataSize, size byte
clrdw ss:[bp].AVDP_data
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov ax, MSG_META_ADD_VAR_DATA
mov dx, size AddVarDataParams
mov di, mask MF_CALL or mask MF_STACK
call ObjMessage
add sp, size AddVarDataParams
.leave
ret
PokerMarkGameOpen endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
PokerMakeSureTokenIsInstalled
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: The zoomer doesn't force applications to install their tokens.
So we must do it ourselves
CALLED BY: INTERNAL
GWPokerStartUp
PASS: *ds:si - GWPokerProcessClass
RETURN:
nothing
DESTROYED:
nothing
PSEUDO CODE/STRATEGY:
none
KNOWN BUGS/SIDE EFFECTS/IDEAS:
This routine should be optimized for SMALL SIZE over SPEED
Common cases:
unknown
REVISION HISTORY:
Name Date Description
---- ---- -----------
srs 8/20/93 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
PokerMakeSureTokenIsInstalled proc near
uses ax,bx,cx,dx,bp,si,di
.enter
mov bx,handle PokerApp
mov si,offset PokerApp
mov di,mask MF_FIXUP_DS
mov ax,MSG_GEN_APPLICATION_INSTALL_TOKEN
call ObjMessage
.leave
ret
PokerMakeSureTokenIsInstalled endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
PokerSetViewBackgroundColor
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Set the background color of the view to green if on
a color display and white if on a black and white
display
CALLED BY: PokerOpenApplication
PASS:
RETURN:
nothing
DESTROYED:
nothing
PSEUDO CODE/STRATEGY:
none
KNOWN BUGS/SIDE EFFECTS/IDEAS:
This routine should be optimized for SMALL SIZE over SPEED
Common cases:
unknown
REVISION HISTORY:
Name Date Description
---- ---- -----------
srs 6/ 7/93 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
PokerSetViewBackgroundColor proc near
uses ax,bx,cx,dx,di,si,bp
.enter
; Use VUP_QUERY to field to avoid building GenApp object.
;
mov bx, segment GenFieldClass
mov si, offset GenFieldClass
mov ax, MSG_VIS_VUP_QUERY
mov cx, VUQ_DISPLAY_SCHEME ; get display scheme
mov di, mask MF_RECORD
call ObjMessage ; di = event handle
mov cx, di ; cx = event handle
mov bx, handle PokerApp
mov si, offset PokerApp
mov ax, MSG_GEN_CALL_PARENT
mov di,mask MF_CALL or mask MF_FIXUP_DS
call ObjMessage ; ah = display type, bp = ptsize
mov cl, C_GREEN ;assume color display
and ah, mask DT_DISP_CLASS
cmp ah, DC_GRAY_1 shl offset DT_DISP_CLASS
jne setColor
mov cl,C_WHITE
setColor:
mov ch, CF_INDEX or (CMT_DITHER shl offset CMM_MAP_TYPE)
mov bx,handle PokerView
mov si,offset PokerView
mov di,mask MF_FIXUP_DS
mov ax,MSG_GEN_VIEW_SET_COLOR
call ObjMessage
mov ch, CF_INDEX
mov di,mask MF_FIXUP_DS
mov bx,handle InstructionDisplay
mov si,offset InstructionDisplay
mov ax,MSG_VIS_TEXT_SET_WASH_COLOR
call ObjMessage
mov di,mask MF_FIXUP_DS
mov bx,handle Instruction2Display
mov si,offset Instruction2Display
call ObjMessage
mov di,mask MF_FIXUP_DS
mov bx,handle FiveOfAKindDisplay
mov si,offset FiveOfAKindDisplay
call ObjMessage
mov di,mask MF_FIXUP_DS
mov bx,handle StraightFlushDisplay
mov si,offset StraightFlushDisplay
call ObjMessage
mov di,mask MF_FIXUP_DS
mov bx,handle FourOfAKindDisplay
mov si,offset FourOfAKindDisplay
call ObjMessage
mov di,mask MF_FIXUP_DS
mov bx,handle FullHouseDisplay
mov si,offset FullHouseDisplay
call ObjMessage
mov di,mask MF_FIXUP_DS
mov bx,handle FlushDisplay
mov si,offset FlushDisplay
call ObjMessage
mov di,mask MF_FIXUP_DS
mov bx,handle StraightDisplay
mov si,offset StraightDisplay
call ObjMessage
mov di,mask MF_FIXUP_DS
mov bx,handle ThreeOfAKindDisplay
mov si,offset ThreeOfAKindDisplay
call ObjMessage
mov di,mask MF_FIXUP_DS
mov bx,handle TwoPairDisplay
mov si,offset TwoPairDisplay
call ObjMessage
mov di,mask MF_FIXUP_DS
mov bx,handle PairDisplay
mov si,offset PairDisplay
call ObjMessage
mov di,mask MF_FIXUP_DS
mov bx,handle LostDisplay
mov si,offset LostDisplay
call ObjMessage
.leave
ret
PokerSetViewBackgroundColor endp
;
; These strings are in the .ini file so do not have to be localizable
;
pokerCategoryString char "poker",0
pokerWhichBackString char "whichBack",0
pokerPlayTuneString char "playTunes",0
pokerWildString char "wild",0
if FADING
pokerFadingString char "fadeCards",0
endif
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
KlondikeSaveOptions
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: This routine saves the current settings of the options menu
to the .ini file.
CALLED BY: GLOBAL
PASS: es - idata
RETURN: nada
DESTROYED: various important but undocumented things
PSEUDO CODE/STRATEGY:
This page intentionally left blank
KNOWN BUGS/SIDE EFFECTS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
atw 1/ 3/91 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
PokerSaveOptions method PokerProcessClass, MSG_POKER_SAVE_OPTIONS
;
; Save which back
;
mov ax, MSG_GAME_GET_WHICH_BACK
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov di, mask MF_CALL
call ObjMessage ;CX <- starting level
mov bp, cx ;BP <- value
mov cx, cs
mov ds, cx
mov si, offset pokerCategoryString
mov dx, offset pokerWhichBackString
call InitFileWriteInteger
;
; Save wild mode
;
mov ax, MSG_GEN_ITEM_GROUP_GET_SELECTION
mov bx, handle WildList
mov si, offset WildList
mov di, mask MF_CALL
call ObjMessage ;AX <- wild boolean
EC < ERROR_C -1 >
mov bp, ax ;BP <- value
mov cx, ds
mov si, offset pokerCategoryString
mov dx, offset pokerWildString
call InitFileWriteInteger
if FADING
;
; Save fade mode
;
mov ax, MSG_GEN_BOOLEAN_GROUP_GET_SELECTED_BOOLEANS
mov bx, handle FadeList
mov si, offset FadeList
mov di, mask MF_CALL
call ObjMessage
call ObjMessage ;LES_ACTUAL_EXCL set if on...
and ax, 1 ;filter through fade bit
mov cx, ds
mov si, offset pokerCategoryString
mov dx, offset pokerFadingString
call InitFileWriteBoolean
endif
;
; Save sound setting
;
mov ax, MSG_GEN_ITEM_GROUP_GET_SELECTION
mov bx, handle SoundList
mov si, offset SoundList
mov di, mask MF_CALL
call ObjMessage
EC < ERROR_C -1 >
mov bp, ax
mov cx, ds
mov si, offset pokerCategoryString
mov dx, offset pokerPlayTuneString
call InitFileWriteInteger
call InitFileCommit
ret
PokerSaveOptions endm
PokerShutDown method PokerProcessClass,
MSG_GEN_PROCESS_CLOSE_APPLICATION
.enter
if 0
mov ax, MSG_GAME_SAVE_STATE
mov bx, handle MyPlayingTable
mov si, offset MyPlayingTable
mov di, mask MF_FIXUP_DS or mask MF_CALL
call ObjMessage
push cx ;save block
endif
CallObject MyPlayingTable, MSG_GAME_SHUTDOWN, MF_FIXUP_DS
mov di, segment PokerProcessClass
mov es, di
mov di, offset PokerProcessClass
mov ax, MSG_GEN_PROCESS_CLOSE_APPLICATION
call ObjCallSuperNoLock
if 0
pop cx
endif
.leave
ret
PokerShutDown endm
CommonCode ends ;end of CommonCode resource
| 24
| 80
| 0.599934
|
04166dd152df0576778764b19c55aac6b026247e
| 325
|
asm
|
Assembly
|
oeis/021/A021613.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/021/A021613.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/021/A021613.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A021613: Decimal expansion of 1/609.
; Submitted by Jon Maiga
; 0,0,1,6,4,2,0,3,6,1,2,4,7,9,4,7,4,5,4,8,4,4,0,0,6,5,6,8,1,4,4,4,9,9,1,7,8,9,8,1,9,3,7,6,0,2,6,2,7,2,5,7,7,9,9,6,7,1,5,9,2,7,7,5,0,4,1,0,5,0,9,0,3,1,1,9,8,6,8,6,3,7,1,1,0,0,1,6,4,2,0,3,6,1,2,4,7,9,4
add $0,1
mov $2,10
pow $2,$0
div $2,609
mov $0,$2
mod $0,10
| 29.545455
| 199
| 0.556923
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.