; flat assembler core
; Copyright (c) 1999-2013, Tomasz Grysztar.
; All rights reserved.
calculate_expression:
mov [current_offset],edi
mov [value_undefined],0
cmp byte [esi],0
je get_string_value
cmp byte [esi],'.'
je convert_fp
calculation_loop:
lods byte [esi]
cmp al,1
je get_byte_number
cmp al,2
je get_word_number
cmp al,4
je get_dword_number
cmp al,8
je get_qword_number
cmp al,0Fh
je value_out_of_range
cmp al,10h
je get_register
cmp al,11h
je get_label
cmp al,')'
je expression_calculated
cmp al,']'
je expression_calculated
cmp al,'!'
je invalid_expression
sub edi,14h
mov ebx,edi
sub ebx,14h
cmp al,0E0h
je calculate_rva
cmp al,0E1h
je calculate_plt
cmp al,0D0h
je calculate_not
cmp al,083h
je calculate_neg
mov dx,[ebx+8]
or dx,[edi+8]
cmp al,80h
je calculate_add
cmp al,81h
je calculate_sub
mov ah,[ebx+12]
or ah,[edi+12]
jz absolute_values_calculation
call recoverable_misuse
absolute_values_calculation:
cmp al,90h
je calculate_mul
cmp al,91h
je calculate_div
or dx,dx
jnz invalid_expression
cmp al,0A0h
je calculate_mod
cmp al,0B0h
je calculate_and
cmp al,0B1h
je calculate_or
cmp al,0B2h
je calculate_xor
cmp al,0C0h
je calculate_shl
cmp al,0C1h
je calculate_shr
jmp invalid_expression
expression_calculated:
sub edi,14h
cmp [value_undefined],0
je expression_value_ok
xor eax,eax
mov [edi],eax
mov [edi+4],eax
mov [edi+12],eax
expression_value_ok:
ret
get_byte_number:
xor eax,eax
lods byte [esi]
stos dword [edi]
xor al,al
stos dword [edi]
got_number:
and word [edi-8+8],0
and word [edi-8+12],0
and dword [edi-8+16],0
add edi,0Ch
jmp calculation_loop
get_word_number:
xor eax,eax
lods word [esi]
stos dword [edi]
xor ax,ax
stos dword [edi]
jmp got_number
get_dword_number:
movs dword [edi],[esi]
xor eax,eax
stos dword [edi]
jmp got_number
get_qword_number:
movs dword [edi],[esi]
movs dword [edi],[esi]
jmp got_number
get_register:
mov byte [edi+9],0
and word [edi+12],0
lods byte [esi]
mov [edi+8],al
mov byte [edi+10],1
xor eax,eax
mov [edi+16],eax
stos dword [edi]
stos dword [edi]
add edi,0Ch
jmp calculation_loop
get_label:
xor eax,eax
mov [edi+8],eax
mov [edi+12],eax
mov [edi+20],eax
lods dword [esi]
cmp eax,0Fh
jb predefined_label
je reserved_word_used_as_symbol
mov ebx,eax
mov ax,[current_pass]
mov [ebx+18],ax
mov cl,[ebx+9]
shr cl,1
and cl,1
neg cl
or byte [ebx+8],8
test byte [ebx+8],1
jz label_undefined
cmp ax,[ebx+16]
je unadjusted_label
test byte [ebx+8],4
jnz label_out_of_scope
test byte [ebx+9],1
jz unadjusted_label
mov eax,[ebx]
sub eax,dword [adjustment]
stos dword [edi]
mov eax,[ebx+4]
sbb eax,dword [adjustment+4]
stos dword [edi]
sbb cl,[adjustment_sign]
mov [edi-8+13],cl
mov eax,dword [adjustment]
or al,[adjustment_sign]
or eax,dword [adjustment+4]
jz got_label
or [next_pass_needed],-1
jmp got_label
unadjusted_label:
mov eax,[ebx]
stos dword [edi]
mov eax,[ebx+4]
stos dword [edi]
mov [edi-8+13],cl
got_label:
test byte [ebx+9],4
jnz invalid_use_of_symbol
cmp [symbols_file],0
je label_reference_ok
cmp [next_pass_needed],0
jne label_reference_ok
call store_label_reference
label_reference_ok:
mov al,[ebx+11]
mov [edi-8+12],al
mov eax,[ebx+12]
mov [edi-8+8],eax
cmp al,ah
jne labeled_registers_ok
shr eax,16
add al,ah
jo labeled_registers_ok
xor ah,ah
mov [edi-8+10],ax
mov [edi-8+9],ah
labeled_registers_ok:
mov eax,[ebx+20]
mov [edi-8+16],eax
add edi,0Ch
mov al,[ebx+10]
or al,al
jz calculation_loop
cmp [size_override],-1
je calculation_loop
cmp [size_override],0
je check_size
cmp [operand_size],0
jne calculation_loop
mov [operand_size],al
jmp calculation_loop
check_size:
xchg [operand_size],al
or al,al
jz calculation_loop
cmp al,[operand_size]
jne operand_sizes_do_not_match
jmp calculation_loop
current_offset_label:
mov eax,[current_offset]
make_current_offset_label:
xor edx,edx
xor ch,ch
mov ebp,[addressing_space]
sub eax,[ds:ebp]
sbb edx,[ds:ebp+4]
sbb ch,[ds:ebp+8]
jp current_offset_label_ok
call recoverable_overflow
current_offset_label_ok:
stos dword [edi]
mov eax,edx
stos dword [edi]
mov eax,[ds:ebp+10h]
stos dword [edi]
mov cl,[ds:ebp+9]
mov [edi-12+12],cx
mov eax,[ds:ebp+14h]
mov [edi-12+16],eax
add edi,8
jmp calculation_loop
org_origin_label:
mov eax,[addressing_space]
mov eax,[eax+18h]
jmp make_current_offset_label
counter_label:
mov eax,[counter]
make_dword_label_value:
stos dword [edi]
xor eax,eax
stos dword [edi]
add edi,0Ch
jmp calculation_loop
timestamp_label:
call make_timestamp
make_qword_label_value:
stos dword [edi]
mov eax,edx
stos dword [edi]
add edi,0Ch
jmp calculation_loop
predefined_label:
or eax,eax
jz current_offset_label
cmp eax,1
je counter_label
cmp eax,2
je timestamp_label
cmp eax,3
je org_origin_label
mov edx,invalid_value
jmp error_undefined
label_out_of_scope:
mov edx,symbol_out_of_scope
jmp error_undefined
label_undefined:
mov edx,undefined_symbol
error_undefined:
cmp [current_pass],1
ja undefined_value
force_next_pass:
or [next_pass_needed],-1
undefined_value:
or [value_undefined],-1
and word [edi+12],0
xor eax,eax
stos dword [edi]
stos dword [edi]
add edi,0Ch
cmp [error_line],0
jne calculation_loop
mov eax,[current_line]
mov [error_line],eax
mov [error],edx
mov [error_info],ebx
jmp calculation_loop
calculate_add:
xor ah,ah
mov ah,[ebx+12]
mov al,[edi+12]
or al,al
jz add_values
or ah,ah
jz add_relocatable
add ah,al
jnz invalid_add
mov ecx,[edi+16]
cmp ecx,[ebx+16]
je add_values
invalid_add:
call recoverable_misuse
jmp add_values
add_relocatable:
mov ah,al
mov ecx,[edi+16]
mov [ebx+16],ecx
add_values:
mov [ebx+12],ah
mov eax,[edi]
add [ebx],eax
mov eax,[edi+4]
adc [ebx+4],eax
mov al,[edi+13]
adc [ebx+13],al
jp add_sign_ok
call recoverable_overflow
add_sign_ok:
or dx,dx
jz calculation_loop
push esi
mov esi,ebx
mov cl,[edi+10]
mov al,[edi+8]
call add_register
mov cl,[edi+11]
mov al,[edi+9]
call add_register
pop esi
jmp calculation_loop
add_register:
or al,al
jz add_register_done
add_register_start:
cmp [esi+8],al
jne add_in_second_slot
add [esi+10],cl
jo value_out_of_range
jnz add_register_done
mov byte [esi+8],0
ret
add_in_second_slot:
cmp [esi+9],al
jne create_in_first_slot
add [esi+11],cl
jo value_out_of_range
jnz add_register_done
mov byte [esi+9],0
ret
create_in_first_slot:
cmp byte [esi+8],0
jne create_in_second_slot
mov [esi+8],al
mov [esi+10],cl
ret
create_in_second_slot:
cmp byte [esi+9],0
jne invalid_expression
mov [esi+9],al
mov [esi+11],cl
add_register_done:
ret
out_of_range:
jmp calculation_loop
calculate_sub:
xor ah,ah
mov ah,[ebx+12]
mov al,[edi+12]
or al,al
jz sub_values
or ah,ah
jz negate_relocatable
cmp al,ah
jne invalid_sub
xor ah,ah
mov ecx,[edi+16]
cmp ecx,[ebx+16]
je sub_values
invalid_sub:
call recoverable_misuse
jmp sub_values
negate_relocatable:
neg al
mov ah,al
mov ecx,[edi+16]
mov [ebx+16],ecx
sub_values:
mov [ebx+12],ah
mov eax,[edi]
sub [ebx],eax
mov eax,[edi+4]
sbb [ebx+4],eax
mov al,[edi+13]
sbb [ebx+13],al
jp sub_sign_ok
cmp [error_line],0
jne sub_sign_ok
call recoverable_overflow
sub_sign_ok:
or dx,dx
jz calculation_loop
push esi
mov esi,ebx
mov cl,[edi+10]
mov al,[edi+8]
call sub_register
mov cl,[edi+11]
mov al,[edi+9]
call sub_register
pop esi
jmp calculation_loop
sub_register:
or al,al
jz add_register_done
neg cl
jo value_out_of_range
jmp add_register_start
calculate_mul:
or dx,dx
jz mul_start
cmp word [ebx+8],0
jne mul_start
xor ecx,ecx
swap_values:
mov eax,[ebx+ecx]
xchg eax,[edi+ecx]
mov [ebx+ecx],eax
add ecx,4
cmp ecx,16
jb swap_values
mul_start:
push esi edx
mov esi,ebx
xor bl,bl
cmp byte [esi+13],0
je mul_first_sign_ok
xor bl,-1
mov eax,[esi]
mov edx,[esi+4]
not eax
not edx
add eax,1
adc edx,0
mov [esi],eax
mov [esi+4],edx
or eax,edx
jz mul_overflow
mul_first_sign_ok:
cmp byte [edi+13],0
je mul_second_sign_ok
xor bl,-1
cmp byte [esi+8],0
je mul_first_register_sign_ok
neg byte [esi+10]
jo invalid_expression
mul_first_register_sign_ok:
cmp byte [esi+9],0
je mul_second_register_sign_ok
neg byte [esi+11]
jo invalid_expression
mul_second_register_sign_ok:
mov eax,[edi]
mov edx,[edi+4]
not eax
not edx
add eax,1
adc edx,0
mov [edi],eax
mov [edi+4],edx
or eax,edx
jz mul_overflow
mul_second_sign_ok:
cmp dword [esi+4],0
jz mul_numbers
cmp dword [edi+4],0
jz mul_numbers
jnz mul_overflow
mul_numbers:
mov eax,[esi+4]
mul dword [edi]
or edx,edx
jnz mul_overflow
mov ecx,eax
mov eax,[esi]
mul dword [edi+4]
or edx,edx
jnz mul_overflow
add ecx,eax
jc mul_overflow
mov eax,[esi]
mul dword [edi]
add edx,ecx
jc mul_overflow
mov [esi],eax
mov [esi+4],edx
or bl,bl
jz mul_ok
not eax
not edx
add eax,1
adc edx,0
mov [esi],eax
mov [esi+4],edx
or eax,edx
jnz mul_ok
not bl
mul_ok:
mov [esi+13],bl
pop edx
or dx,dx
jz mul_calculated
cmp word [edi+8],0
jne invalid_value
cmp byte [esi+8],0
je mul_first_register_ok
call get_byte_scale
imul byte [esi+10]
mov dl,ah
cbw
cmp ah,dl
jne value_out_of_range
mov [esi+10],al
or al,al
jnz mul_first_register_ok
mov [esi+8],al
mul_first_register_ok:
cmp byte [esi+9],0
je mul_calculated
call get_byte_scale
imul byte [esi+11]
mov dl,ah
cbw
cmp ah,dl
jne value_out_of_range
mov [esi+11],al
or al,al
jnz mul_calculated
mov [esi+9],al
mul_calculated:
pop esi
jmp calculation_loop
mul_overflow:
pop edx esi
call recoverable_overflow
jmp calculation_loop
get_byte_scale:
mov al,[edi]
cbw
cwde
cdq
cmp edx,[edi+4]
jne value_out_of_range
cmp eax,[edi]
jne value_out_of_range
ret
calculate_div:
push esi edx
mov esi,ebx
call div_64
pop edx
or dx,dx
jz div_calculated
cmp byte [esi+8],0
je div_first_register_ok
call get_byte_scale
or al,al
jz value_out_of_range
mov al,[esi+10]
cbw
idiv byte [edi]
or ah,ah
jnz invalid_use_of_symbol
mov [esi+10],al
div_first_register_ok:
cmp byte [esi+9],0
je div_calculated
call get_byte_scale
or al,al
jz value_out_of_range
mov al,[esi+11]
cbw
idiv byte [edi]
or ah,ah
jnz invalid_use_of_symbol
mov [esi+11],al
div_calculated:
pop esi
jmp calculation_loop
calculate_mod:
push esi
mov esi,ebx
call div_64
mov [esi],eax
mov [esi+4],edx
mov [esi+13],bh
pop esi
jmp calculation_loop
calculate_and:
mov eax,[edi]
mov edx,[edi+4]
mov cl,[edi+13]
and [ebx],eax
and [ebx+4],edx
and [ebx+13],cl
jmp calculation_loop
calculate_or:
mov eax,[edi]
mov edx,[edi+4]
mov cl,[edi+13]
or [ebx],eax
or [ebx+4],edx
or [ebx+13],cl
jmp calculation_loop
calculate_xor:
mov eax,[edi]
mov edx,[edi+4]
mov cl,[edi+13]
xor [ebx],eax
xor [ebx+4],edx
xor [ebx+13],cl
jz calculation_loop
or cl,cl
jz xor_size_check
xor eax,[ebx]
xor edx,[ebx+4]
xor_size_check:
mov cl,[value_size]
cmp cl,1
je xor_byte_result
cmp cl,2
je xor_word_result
cmp cl,4
je xor_dword_result
cmp cl,6
je xor_pword_result
cmp cl,8
jne calculation_loop
xor edx,[ebx+4]
js xor_result_truncated
jmp calculation_loop
xor_pword_result:
test edx,0FFFF0000h
jnz calculation_loop
cmp word [ebx+6],-1
jne calculation_loop
xor dx,[ebx+4]
jns calculation_loop
not word [ebx+6]
jmp xor_result_truncated
xor_dword_result:
test edx,edx
jnz calculation_loop
cmp dword [ebx+4],-1
jne calculation_loop
xor eax,[ebx]
jns calculation_loop
not dword [ebx+4]
jmp xor_result_truncated
xor_word_result:
test edx,edx
jnz calculation_loop
test eax,0FFFF0000h
jnz calculation_loop
cmp dword [ebx+4],-1
jne calculation_loop
cmp word [ebx+2],-1
jne calculation_loop
xor ax,[ebx]
jns calculation_loop
not dword [ebx+4]
not word [ebx+2]
jmp xor_result_truncated
xor_byte_result:
test edx,edx
jnz calculation_loop
test eax,0FFFFFF00h
jnz calculation_loop
cmp dword [ebx+4],-1
jne calculation_loop
cmp word [ebx+2],-1
jne calculation_loop
cmp byte [ebx+1],-1
jne calculation_loop
xor al,[ebx]
jns calculation_loop
not dword [ebx+4]
not word [ebx+2]
not byte [ebx+1]
xor_result_truncated:
mov byte [ebx+13],0
jmp calculation_loop
shr_negative:
mov byte [edi+13],0
not dword [edi]
not dword [edi+4]
add dword [edi],1
adc dword [edi+4],0
jc shl_over
calculate_shl:
cmp byte [edi+13],0
jne shl_negative
mov edx,[ebx+4]
mov eax,[ebx]
cmp dword [edi+4],0
jne shl_over
movsx ecx,byte [ebx+13]
xchg ecx,[edi]
cmp ecx,64
je shl_max
ja shl_over
cmp ecx,32
jae shl_high
shld [edi],edx,cl
shld edx,eax,cl
shl eax,cl
mov [ebx],eax
mov [ebx+4],edx
jmp shl_done
shl_over:
cmp byte [ebx+13],0
jne shl_overflow
shl_max:
movsx ecx,byte [ebx+13]
cmp eax,ecx
jne shl_overflow
cmp edx,ecx
jne shl_overflow
xor eax,eax
mov [ebx],eax
mov [ebx+4],eax
jmp calculation_loop
shl_high:
sub cl,32
shld [edi],edx,cl
shld edx,eax,cl
shl eax,cl
mov [ebx+4],eax
and dword [ebx],0
cmp edx,[edi]
jne shl_overflow
shl_done:
movsx eax,byte [ebx+13]
cmp eax,[edi]
je calculation_loop
shl_overflow:
call recoverable_overflow
jmp calculation_loop
shl_negative:
mov byte [edi+13],0
not dword [edi]
not dword [edi+4]
add dword [edi],1
adc dword [edi+4],0
jnc calculate_shr
dec dword [edi+4]
calculate_shr:
cmp byte [edi+13],0
jne shr_negative
cmp byte [ebx+13],0
je do_shr
mov al,[value_size]
cmp al,1
je shr_negative_byte
cmp al,2
je shr_negative_word
cmp al,4
je shr_negative_dword
cmp al,6
je shr_negative_pword
cmp al,8
jne do_shr
shr_negative_qword:
test byte [ebx+7],80h
jz do_shr
shr_truncated:
mov byte [ebx+13],0
do_shr:
mov edx,[ebx+4]
mov eax,[ebx]
cmp dword [edi+4],0
jne shr_over
mov ecx,[edi]
cmp ecx,64
jae shr_over
push esi
movsx esi,byte [ebx+13]
cmp ecx,32
jae shr_high
shrd eax,edx,cl
shrd edx,esi,cl
mov [ebx],eax
mov [ebx+4],edx
pop esi
jmp calculation_loop
shr_high:
sub cl,32
shrd edx,esi,cl
mov [ebx],edx
mov [ebx+4],esi
pop esi
jmp calculation_loop
shr_over:
movsx eax,byte [ebx+13]
mov dword [ebx],eax
mov dword [ebx+4],eax
jmp calculation_loop
shr_negative_byte:
cmp dword [ebx+4],-1
jne do_shr
cmp word [ebx+2],-1
jne do_shr
cmp byte [ebx+1],-1
jne do_shr
test byte [ebx],80h
jz do_shr
not dword [ebx+4]
not word [ebx+2]
not byte [ebx+1]
jmp shr_truncated
shr_negative_word:
cmp dword [ebx+4],-1
jne do_shr
cmp word [ebx+2],-1
jne do_shr
test byte [ebx+1],80h
jz do_shr
not dword [ebx+4]
not word [ebx+2]
jmp shr_truncated
shr_negative_dword:
cmp dword [ebx+4],-1
jne do_shr
test byte [ebx+3],80h
jz do_shr
not dword [ebx+4]
jmp shr_truncated
shr_negative_pword:
cmp word [ebx+6],-1
jne do_shr
test byte [ebx+5],80h
jz do_shr
not word [ebx+6]
jmp shr_truncated
calculate_not:
cmp word [edi+8],0
jne invalid_expression
cmp byte [edi+12],0
je not_ok
call recoverable_misuse
not_ok:
mov al,[value_size]
cmp al,1
je not_byte
cmp al,2
je not_word
cmp al,4
je not_dword
cmp al,6
je not_pword
cmp al,8
je not_qword
not dword [edi]
not dword [edi+4]
not byte [edi+13]
add edi,14h
jmp calculation_loop
not_qword:
not dword [edi]
not dword [edi+4]
finish_not:
mov byte [edi+13],0
add edi,14h
jmp calculation_loop
not_byte:
cmp dword [edi+4],0
jne not_qword
cmp word [edi+2],0
jne not_qword
cmp byte [edi+1],0
jne not_qword
not byte [edi]
jmp finish_not
not_word:
cmp dword [edi+4],0
jne not_qword
cmp word [edi+2],0
jne not_qword
not word [edi]
jmp finish_not
not_dword:
cmp dword [edi+4],0
jne not_qword
not dword [edi]
jmp finish_not
not_pword:
cmp word [edi+6],0
jne not_qword
not word [edi+4]
not dword [edi]
jmp finish_not
calculate_neg:
cmp byte [edi+8],0
je neg_first_register_ok
neg byte [edi+10]
jo invalid_expression
neg_first_register_ok:
cmp byte [edi+9],0
je neg_second_register_ok
neg byte [edi+11]
jo invalid_expression
neg_second_register_ok:
neg byte [edi+12]
xor eax,eax
xor edx,edx
xor cl,cl
xchg eax,[edi]
xchg edx,[edi+4]
xchg cl,[edi+13]
sub [edi],eax
sbb [edi+4],edx
sbb [edi+13],cl
jp neg_sign_ok
call recoverable_overflow
neg_sign_ok:
add edi,14h
jmp calculation_loop
calculate_rva:
cmp word [edi+8],0
jne invalid_expression
mov al,[output_format]
cmp al,5
je calculate_gotoff
cmp al,4
je calculate_coff_rva
cmp al,3
jne invalid_expression
test [format_flags],8
jnz pe64_rva
mov al,2
bt [resolver_flags],0
jc rva_type_ok
xor al,al
rva_type_ok:
cmp byte [edi+12],al
je rva_ok
call recoverable_misuse
rva_ok:
mov byte [edi+12],0
mov eax,[code_start]
mov eax,[eax+34h]
xor edx,edx
finish_rva:
sub [edi],eax
sbb [edi+4],edx
sbb byte [edi+13],0
jp rva_finished
call recoverable_overflow
rva_finished:
add edi,14h
jmp calculation_loop
pe64_rva:
mov al,4
bt [resolver_flags],0
jc pe64_rva_type_ok
xor al,al
pe64_rva_type_ok:
cmp byte [edi+12],al
je pe64_rva_ok
call recoverable_misuse
pe64_rva_ok:
mov byte [edi+12],0
mov eax,[code_start]
mov edx,[eax+34h]
mov eax,[eax+30h]
jmp finish_rva
calculate_gotoff:
test [format_flags],8+1
jnz invalid_expression
calculate_coff_rva:
mov dl,5
cmp byte [edi+12],2
je change_value_type
incorrect_change_of_value_type:
call recoverable_misuse
change_value_type:
mov byte [edi+12],dl
add edi,14h
jmp calculation_loop
calculate_plt:
cmp word [edi+8],0
jne invalid_expression
cmp [output_format],5
jne invalid_expression
test [format_flags],1
jnz invalid_expression
mov dl,6
mov dh,2
test [format_flags],8
jz check_value_for_plt
mov dh,4
check_value_for_plt:
mov eax,[edi]
or eax,[edi+4]
jnz incorrect_change_of_value_type
cmp byte [edi+12],dh
jne incorrect_change_of_value_type
mov eax,[edi+16]
cmp byte [eax],80h
jne incorrect_change_of_value_type
jmp change_value_type
div_64:
xor ebx,ebx
cmp dword [edi],0
jne divider_ok
cmp dword [edi+4],0
jne divider_ok
cmp [next_pass_needed],0
je value_out_of_range
jmp div_done
divider_ok:
cmp byte [esi+13],0
je div_first_sign_ok
mov eax,[esi]
mov edx,[esi+4]
not eax
not edx
add eax,1
adc edx,0
mov [esi],eax
mov [esi+4],edx
or eax,edx
jz value_out_of_range
xor bx,-1
div_first_sign_ok:
cmp byte [edi+13],0
je div_second_sign_ok
mov eax,[edi]
mov edx,[edi+4]
not eax
not edx
add eax,1
adc edx,0
mov [edi],eax
mov [edi+4],edx
or eax,edx
jz value_out_of_range
xor bl,-1
div_second_sign_ok:
cmp dword [edi+4],0
jne div_high
mov ecx,[edi]
mov eax,[esi+4]
xor edx,edx
div ecx
mov [esi+4],eax
mov eax,[esi]
div ecx
mov [esi],eax
mov eax,edx
xor edx,edx
jmp div_done
div_high:
push ebx
mov eax,[esi+4]
xor edx,edx
div dword [edi+4]
mov ebx,[esi]
mov [esi],eax
and dword [esi+4],0
mov ecx,edx
mul dword [edi]
div_high_loop:
cmp ecx,edx
ja div_high_done
jb div_high_large_correction
cmp ebx,eax
jae div_high_done
div_high_correction:
dec dword [esi]
sub eax,[edi]
sbb edx,[edi+4]
jnc div_high_loop
div_high_done:
sub ebx,eax
sbb ecx,edx
mov edx,ecx
mov eax,ebx
pop ebx
jmp div_done
div_high_large_correction:
push eax edx
mov eax,edx
sub eax,ecx
xor edx,edx
div dword [edi+4]
shr eax,1
jz div_high_small_correction
sub [esi],eax
push eax
mul dword [edi+4]
sub dword [esp+4],eax
pop eax
mul dword [edi]
sub dword [esp+4],eax
sbb dword [esp],edx
pop edx eax
jmp div_high_loop
div_high_small_correction:
pop edx eax
jmp div_high_correction
div_done:
or bh,bh
jz remainder_ok
not eax
not edx
add eax,1
adc edx,0
mov ecx,eax
or ecx,edx
jnz remainder_ok
not bh
remainder_ok:
or bl,bl
jz div_ok
not dword [esi]
not dword [esi+4]
add dword [esi],1
adc dword [esi+4],0
mov ecx,[esi]
or ecx,[esi+4]
jnz div_ok
not bl
div_ok:
mov [esi+13],bl
ret
store_label_reference:
mov eax,[tagged_blocks]
mov dword [eax-4],2
mov dword [eax-8],4
sub eax,8+4
cmp eax,edi
jbe out_of_memory
mov [tagged_blocks],eax
mov [eax],ebx
ret
convert_fp:
inc esi
and word [edi+8],0
and word [edi+12],0
mov al,[value_size]
cmp al,2
je convert_fp_word
cmp al,4
je convert_fp_dword
test al,not 8
jnz invalid_value
convert_fp_qword:
xor eax,eax
xor edx,edx
cmp word [esi+8],8000h
je fp_qword_store
mov bx,[esi+8]
mov eax,[esi]
mov edx,[esi+4]
add eax,eax
adc edx,edx
mov ecx,edx
shr edx,12
shrd eax,ecx,12
jnc fp_qword_ok
add eax,1
adc edx,0
bt edx,20
jnc fp_qword_ok
and edx,1 shl 20 - 1
inc bx
shr edx,1
rcr eax,1
fp_qword_ok:
add bx,3FFh
cmp bx,7FFh
jge value_out_of_range
cmp bx,0
jg fp_qword_exp_ok
or edx,1 shl 20
mov cx,bx
neg cx
inc cx
cmp cx,52
ja value_out_of_range
cmp cx,32
jbe fp_qword_small_shift
sub cx,32
mov eax,edx
xor edx,edx
shr eax,cl
jmp fp_qword_shift_done
fp_qword_small_shift:
mov ebx,edx
shr edx,cl
shrd eax,ebx,cl
fp_qword_shift_done:
mov bx,0
jnc fp_qword_exp_ok
add eax,1
adc edx,0
test edx,1 shl 20
jz fp_qword_exp_ok
and edx,1 shl 20 - 1
inc bx
fp_qword_exp_ok:
shl ebx,20
or edx,ebx
fp_qword_store:
mov bl,[esi+11]
shl ebx,31
or edx,ebx
mov [edi],eax
mov [edi+4],edx
add esi,13
ret
convert_fp_word:
xor eax,eax
cmp word [esi+8],8000h
je fp_word_store
mov bx,[esi+8]
mov ax,[esi+6]
shl ax,1
shr ax,6
jnc fp_word_ok
inc ax
bt ax,10
jnc fp_word_ok
and ax,1 shl 10 - 1
inc bx
shr ax,1
fp_word_ok:
add bx,0Fh
cmp bx,01Fh
jge value_out_of_range
cmp bx,0
jg fp_word_exp_ok
or ax,1 shl 10
mov cx,bx
neg cx
inc cx
cmp cx,10
ja value_out_of_range
xor bx,bx
shr ax,cl
jnc fp_word_exp_ok
inc ax
test ax,1 shl 10
jz fp_word_exp_ok
and ax,1 shl 10 - 1
inc bx
fp_word_exp_ok:
shl bx,10
or ax,bx
fp_word_store:
mov bl,[esi+11]
shl bx,15
or ax,bx
mov [edi],eax
xor eax,eax
mov [edi+4],eax
add esi,13
ret
convert_fp_dword:
xor eax,eax
cmp word [esi+8],8000h
je fp_dword_store
mov bx,[esi+8]
mov eax,[esi+4]
shl eax,1
shr eax,9
jnc fp_dword_ok
inc eax
bt eax,23
jnc fp_dword_ok
and eax,1 shl 23 - 1
inc bx
shr eax,1
fp_dword_ok:
add bx,7Fh
cmp bx,0FFh
jge value_out_of_range
cmp bx,0
jg fp_dword_exp_ok
or eax,1 shl 23
mov cx,bx
neg cx
inc cx
cmp cx,23
ja value_out_of_range
xor bx,bx
shr eax,cl
jnc fp_dword_exp_ok
inc eax
test eax,1 shl 23
jz fp_dword_exp_ok
and eax,1 shl 23 - 1
inc bx
fp_dword_exp_ok:
shl ebx,23
or eax,ebx
fp_dword_store:
mov bl,[esi+11]
shl ebx,31
or eax,ebx
mov [edi],eax
xor eax,eax
mov [edi+4],eax
add esi,13
ret
get_string_value:
inc esi
lods dword [esi]
mov ecx,eax
cmp ecx,8
ja value_out_of_range
mov edx,edi
xor eax,eax
stos dword [edi]
stos dword [edi]
mov edi,edx
rep movs byte [edi],[esi]
mov edi,edx
inc esi
and word [edi+8],0
and word [edi+12],0
ret
get_byte_value:
mov [value_size],1
mov [size_override],-1
call calculate_value
or al,al
jz check_byte_value
call recoverable_misuse
check_byte_value:
mov eax,[edi]
mov edx,[edi+4]
cmp byte [edi+13],0
je byte_positive
cmp edx,-1
jne range_exceeded
cmp eax,-80h
jb range_exceeded
ret
byte_positive:
test edx,edx
jnz range_exceeded
cmp eax,100h
jae range_exceeded
return_byte_value:
ret
range_exceeded:
xor eax,eax
xor edx,edx
recoverable_overflow:
cmp [error_line],0
jne ignore_overflow
push [current_line]
pop [error_line]
mov [error],value_out_of_range
or [value_undefined],-1
ignore_overflow:
ret
recoverable_misuse:
cmp [error_line],0
jne ignore_misuse
push [current_line]
pop [error_line]
mov [error],invalid_use_of_symbol
ignore_misuse:
ret
get_word_value:
mov [value_size],2
mov [size_override],-1
call calculate_value
cmp al,2
jb check_word_value
call recoverable_misuse
check_word_value:
mov eax,[edi]
mov edx,[edi+4]
cmp byte [edi+13],0
je word_positive
cmp edx,-1
jne range_exceeded
cmp eax,-8000h
jb range_exceeded
ret
word_positive:
test edx,edx
jnz range_exceeded
cmp eax,10000h
jae range_exceeded
ret
get_dword_value:
mov [value_size],4
mov [size_override],-1
call calculate_value
cmp al,4
jne check_dword_value
mov [value_type],2
mov eax,[edi]
cdq
cmp edx,[edi+4]
jne range_exceeded
mov ecx,edx
shr ecx,31
cmp cl,[value_sign]
jne range_exceeded
ret
check_dword_value:
mov eax,[edi]
mov edx,[edi+4]
cmp byte [edi+13],0
je dword_positive
cmp edx,-1
jne range_exceeded
bt eax,31
jnc range_exceeded
ret
dword_positive:
test edx,edx
jne range_exceeded
ret
get_pword_value:
mov [value_size],6
mov [size_override],-1
call calculate_value
cmp al,4
jne check_pword_value
call recoverable_misuse
check_pword_value:
mov eax,[edi]
mov edx,[edi+4]
cmp byte [edi+13],0
je pword_positive
cmp edx,-8000h
jb range_exceeded
ret
pword_positive:
cmp edx,10000h
jae range_exceeded
ret
get_qword_value:
mov [value_size],8
mov [size_override],-1
call calculate_value
check_qword_value:
mov eax,[edi]
mov edx,[edi+4]
cmp byte [edi+13],0
je qword_positive
cmp edx,-80000000h
jb range_exceeded
qword_positive:
ret
get_count_value:
mov [value_size],8
mov [size_override],-1
call calculate_expression
cmp word [edi+8],0
jne invalid_value
mov [value_sign],0
mov al,[edi+12]
or al,al
jz check_count_value
call recoverable_misuse
check_count_value:
cmp byte [edi+13],0
jne invalid_count_value
mov eax,[edi]
mov edx,[edi+4]
or edx,edx
jnz invalid_count_value
ret
invalid_count_value:
cmp [error_line],0
jne zero_count
mov eax,[current_line]
mov [error_line],eax
mov [error],invalid_value
zero_count:
xor eax,eax
ret
get_value:
mov [operand_size],0
lods byte [esi]
call get_size_operator
cmp al,'('
jne invalid_value
mov al,[operand_size]
cmp al,1
je value_byte
cmp al,2
je value_word
cmp al,4
je value_dword
cmp al,6
je value_pword
cmp al,8
je value_qword
or al,al
jnz invalid_value
mov [value_size],al
call calculate_value
mov eax,[edi]
mov edx,[edi+4]
ret
calculate_value:
call calculate_expression
cmp word [edi+8],0
jne invalid_value
mov eax,[edi+16]
mov [symbol_identifier],eax
mov al,[edi+13]
mov [value_sign],al
mov al,[edi+12]
mov [value_type],al
ret
value_qword:
call get_qword_value
truncated_value:
mov [value_sign],0
ret
value_pword:
call get_pword_value
movzx edx,dx
jmp truncated_value
value_dword:
call get_dword_value
xor edx,edx
jmp truncated_value
value_word:
call get_word_value
xor edx,edx
movzx eax,ax
jmp truncated_value
value_byte:
call get_byte_value
xor edx,edx
movzx eax,al
jmp truncated_value
get_address_word_value:
mov [address_size],2
mov [value_size],2
mov [free_address_range],0
jmp calculate_address
get_address_dword_value:
mov [address_size],4
mov [value_size],4
mov [free_address_range],0
jmp calculate_address
get_address_qword_value:
mov [address_size],8
mov [value_size],8
mov [free_address_range],0
jmp calculate_address
get_address_value:
mov [address_size],0
mov [value_size],8
or [free_address_range],-1
calculate_address:
cmp byte [esi],'.'
je invalid_address
call calculate_expression
mov eax,[edi+16]
mov [address_symbol],eax
mov al,[edi+13]
mov [address_sign],al
mov al,[edi+12]
mov [value_type],al
cmp al,0
je address_size_ok
jg get_address_symbol_size
neg al
get_address_symbol_size:
cmp al,6
je special_address_type_32bit
cmp al,5
je special_address_type_32bit
ja invalid_address_type
test al,1
jnz invalid_address_type
shl al,5
jmp address_symbol_ok
invalid_address_type:
call recoverable_misuse
special_address_type_32bit:
mov al,40h
address_symbol_ok:
mov ah,[address_size]
or [address_size],al
shr al,4
or ah,ah
jz address_size_ok
cmp al,ah
je address_size_ok
cmp ax,0408h
je address_sizes_mixed
cmp ax,0804h
jne address_sizes_do_not_agree
address_sizes_mixed:
mov [value_type],2
mov eax,[edi]
cdq
cmp edx,[edi+4]
je address_size_ok
cmp [error_line],0
jne address_size_ok
call recoverable_overflow
address_size_ok:
xor ebx,ebx
xor ecx,ecx
mov cl,[value_type]
shl ecx,16
mov ch,[address_size]
cmp word [edi+8],0
je check_immediate_address
mov al,[edi+8]
mov dl,[edi+10]
call get_address_register
mov al,[edi+9]
mov dl,[edi+11]
call get_address_register
mov ax,bx
shr ah,4
shr al,4
cmp ah,0Ch
je check_vsib_address
cmp ah,0Dh
je check_vsib_address
cmp al,0Ch
je check_vsib_address
cmp al,0Dh
je check_vsib_address
or bh,bh
jz check_address_registers
or bl,bl
jz check_address_registers
cmp al,ah
jne invalid_address
check_address_registers:
or al,ah
mov ah,[address_size]
and ah,0Fh
jz address_registers_sizes_ok
cmp al,ah
jne address_sizes_do_not_match
address_registers_sizes_ok:
cmp al,4
je sib_allowed
cmp al,8
je sib_allowed
cmp al,0Fh
je check_ip_relative_address
cmp cl,1
ja invalid_address
cmp [free_address_range],0
jne check_qword_value
jmp check_word_value
address_sizes_do_not_match:
cmp al,0Fh
jne invalid_address
mov al,bh
and al,0Fh
cmp al,ah
jne invalid_address
check_ip_relative_address:
or bl,bl
jnz invalid_address
cmp bh,0F8h
je check_rip_relative_address
cmp bh,0F4h
jne invalid_address
cmp [free_address_range],0
jne check_qword_value
jmp check_dword_value
check_rip_relative_address:
mov eax,[edi]
cdq
cmp edx,[edi+4]
jne range_exceeded
cmp dl,[edi+13]
jne range_exceeded
ret
get_address_register:
or al,al
jz address_register_ok
cmp dl,1
jne scaled_register
or bh,bh
jnz scaled_register
mov bh,al
address_register_ok:
ret
scaled_register:
or bl,bl
jnz invalid_address
mov bl,al
mov cl,dl
jmp address_register_ok
sib_allowed:
or bh,bh
jnz check_index_with_base
cmp cl,3
je special_index_scale
cmp cl,5
je special_index_scale
cmp cl,9
je special_index_scale
cmp cl,2
jne check_index_scale
cmp bl,45h
jne special_index_scale
cmp [code_type],64
je special_index_scale
cmp [segment_register],4
jne special_index_scale
cmp [value_type],0
jne check_index_scale
mov al,[edi]
cbw
cwde
cmp eax,[edi]
jne check_index_scale
cdq
cmp edx,[edi+4]
jne check_immediate_address
special_index_scale:
mov bh,bl
dec cl
check_immediate_address:
cmp [free_address_range],0
jne check_qword_value
mov al,[address_size]
and al,0Fh
cmp al,2
je check_word_value
cmp al,4
je check_dword_value
cmp al,8
je check_qword_value
or al,al
jnz invalid_value
cmp [code_type],64
jne check_dword_value
jmp check_qword_value
check_index_with_base:
cmp cl,1
jne check_index_scale
cmp bl,44h
je swap_base_with_index
cmp bl,84h
je swap_base_with_index
cmp [code_type],64
je check_for_rbp_base
cmp bl,45h
jne check_for_ebp_base
cmp [segment_register],3
je swap_base_with_index
jmp check_immediate_address
check_for_ebp_base:
cmp bh,45h
jne check_immediate_address
cmp [segment_register],4
jne check_immediate_address
swap_base_with_index:
xchg bl,bh
jmp check_immediate_address
check_for_rbp_base:
cmp bh,45h
je swap_base_with_index
cmp bh,85h
je swap_base_with_index
jmp check_immediate_address
check_index_scale:
test cl,not 1111b
jnz invalid_address
mov al,cl
dec al
and al,cl
jz check_immediate_address
jmp invalid_address
check_vsib_address:
cmp ah,0Ch
je swap_vsib_registers
cmp ah,0Dh
jne check_vsib_base
swap_vsib_registers:
cmp cl,1
ja invalid_address
xchg bl,bh
mov cl,1
check_vsib_base:
test bh,bh
jz vsib_base_ok
mov al,bh
shr al,4
cmp al,4
je vsib_base_ok
cmp [code_type],64
jne invalid_address
cmp al,8
jne invalid_address
vsib_base_ok:
mov al,bl
shr al,4
cmp al,0Ch
je check_index_scale
cmp al,0Dh
je check_index_scale
jmp invalid_address
calculate_relative_offset:
cmp [value_undefined],0
jne relative_offset_ok
test bh,bh
setne ch
cmp bx,[ds:ebp+10h]
je origin_registers_ok
xchg bh,bl
xchg ch,cl
cmp bx,[ds:ebp+10h]
jne invalid_value
origin_registers_ok:
cmp cx,[ds:ebp+10h+2]
jne invalid_value
mov bl,[address_sign]
add eax,[ds:ebp]
adc edx,[ds:ebp+4]
adc bl,[ds:ebp+8]
sub eax,edi
sbb edx,0
sbb bl,0
mov [value_sign],bl
mov bl,[value_type]
mov ecx,[address_symbol]
mov [symbol_identifier],ecx
test bl,1
jnz relative_offset_unallowed
cmp bl,6
je plt_relative_offset
mov bh,[ds:ebp+9]
cmp bl,bh
je set_relative_offset_type
cmp bx,0402h
je set_relative_offset_type
relative_offset_unallowed:
call recoverable_misuse
set_relative_offset_type:
cmp [value_type],0
je relative_offset_ok
mov [value_type],0
cmp ecx,[ds:ebp+14h]
je relative_offset_ok
mov [value_type],3
relative_offset_ok:
ret
plt_relative_offset:
mov [value_type],7
cmp byte [ds:ebp+9],2
je relative_offset_ok
cmp byte [ds:ebp+9],4
jne recoverable_misuse
ret
calculate_logical_expression:
xor al,al
calculate_embedded_logical_expression:
mov [logical_value_wrapping],al
call get_logical_value
logical_loop:
cmp byte [esi],'|'
je logical_or
cmp byte [esi],'&'
je logical_and
ret
logical_or:
inc esi
or al,al
jnz logical_value_already_determined
push eax
call get_logical_value
pop ebx
or al,bl
jmp logical_loop
logical_and:
inc esi
or al,al
jz logical_value_already_determined
push eax
call get_logical_value
pop ebx
and al,bl
jmp logical_loop
logical_value_already_determined:
push eax
call skip_logical_value
jc invalid_expression
pop eax
jmp logical_loop
get_value_for_comparison:
mov [value_size],8
mov [size_override],-1
lods byte [esi]
call calculate_expression
cmp byte [edi+8],0
jne first_register_size_ok
mov byte [edi+10],0
first_register_size_ok:
cmp byte [edi+9],0
jne second_register_size_ok
mov byte [edi+11],0
second_register_size_ok:
mov eax,[edi+16]
mov [symbol_identifier],eax
mov al,[edi+13]
mov [value_sign],al
mov bl,[edi+12]
mov eax,[edi]
mov edx,[edi+4]
mov ecx,[edi+8]
ret
get_logical_value:
xor al,al
check_for_negation:
cmp byte [esi],'~'
jne negation_ok
inc esi
xor al,-1
jmp check_for_negation
negation_ok:
push eax
mov al,[esi]
cmp al,'{'
je logical_expression
cmp al,0FFh
je invalid_expression
cmp al,88h
je check_for_defined
cmp al,89h
je check_for_used
cmp al,'0'
je given_false
cmp al,'1'
je given_true
cmp al,'('
jne invalid_value
call get_value_for_comparison
mov bh,[value_sign]
push eax edx [symbol_identifier] ebx ecx
mov al,[esi]
or al,al
jz logical_number
cmp al,0Fh
je logical_number
cmp al,'}'
je logical_number
cmp al,'&'
je logical_number
cmp al,'|'
je logical_number
inc esi
mov [compare_type],al
cmp byte [esi],'('
jne invalid_value
call get_value_for_comparison
cmp bl,[esp+4]
jne values_not_relative
or bl,bl
jz check_values_registers
mov ebx,[symbol_identifier]
cmp ebx,[esp+8]
jne values_not_relative
check_values_registers:
cmp ecx,[esp]
je values_relative
ror ecx,16
xchg ch,cl
ror ecx,16
xchg ch,cl
cmp ecx,[esp]
je values_relative
values_not_relative:
cmp [compare_type],0F8h
jne invalid_comparison
add esp,12+8
jmp return_false
invalid_comparison:
call recoverable_misuse
values_relative:
pop ebx
shl ebx,16
mov bx,[esp]
add esp,8
pop ecx ebp
cmp [compare_type],'='
je check_equal
cmp [compare_type],0F1h
je check_not_equal
cmp [compare_type],0F8h
je return_true
test ebx,0FFFF0000h
jz check_less_or_greater
call recoverable_misuse
check_less_or_greater:
cmp [compare_type],'>'
je check_greater
cmp [compare_type],'<'
je check_less
cmp [compare_type],0F2h
je check_not_less
cmp [compare_type],0F3h
je check_not_greater
jmp invalid_expression
check_equal:
cmp bh,[value_sign]
jne return_false
cmp eax,ebp
jne return_false
cmp edx,ecx
jne return_false
jmp return_true
check_greater:
cmp bh,[value_sign]
jg return_true
jl return_false
cmp edx,ecx
jb return_true
ja return_false
cmp eax,ebp
jb return_true
jae return_false
check_less:
cmp bh,[value_sign]
jg return_false
jl return_true
cmp edx,ecx
jb return_false
ja return_true
cmp eax,ebp
jbe return_false
ja return_true
check_not_less:
cmp bh,[value_sign]
jg return_true
jl return_false
cmp edx,ecx
jb return_true
ja return_false
cmp eax,ebp
jbe return_true
ja return_false
check_not_greater:
cmp bh,[value_sign]
jg return_false
jl return_true
cmp edx,ecx
jb return_false
ja return_true
cmp eax,ebp
jb return_false
jae return_true
check_not_equal:
cmp bh,[value_sign]
jne return_true
cmp eax,ebp
jne return_true
cmp edx,ecx
jne return_true
jmp return_false
logical_number:
pop ecx ebx eax edx eax
or bl,bl
jnz invalid_logical_number
or cx,cx
jz logical_number_ok
invalid_logical_number:
call recoverable_misuse
logical_number_ok:
test bh,bh
jnz return_true
or eax,edx
jnz return_true
jmp return_false
check_for_defined:
or bl,-1
lods word [esi]
cmp ah,'('
jne invalid_expression
check_expression:
lods byte [esi]
or al,al
jz defined_string
cmp al,'.'
je defined_fp_value
cmp al,')'
je expression_checked
cmp al,'!'
je invalid_expression
cmp al,0Fh
je check_expression
cmp al,10h
je defined_register
cmp al,11h
je check_if_symbol_defined
cmp al,80h
jae check_expression
movzx eax,al
add esi,eax
jmp check_expression
defined_register:
inc esi
jmp check_expression
defined_fp_value:
add esi,12
jmp expression_checked
defined_string:
lods dword [esi]
add esi,eax
inc esi
jmp expression_checked
check_if_symbol_defined:
lods dword [esi]
cmp eax,-1
je invalid_expression
cmp eax,0Fh
jb check_expression
je reserved_word_used_as_symbol
test byte [eax+8],4
jnz no_prediction
test byte [eax+8],1
jz symbol_predicted_undefined
mov cx,[current_pass]
sub cx,[eax+16]
jz check_expression
cmp cx,1
ja symbol_predicted_undefined
or byte [eax+8],40h+80h
jmp check_expression
no_prediction:
test byte [eax+8],1
jz symbol_undefined
mov cx,[current_pass]
sub cx,[eax+16]
jz check_expression
jmp symbol_undefined
symbol_predicted_undefined:
or byte [eax+8],40h
and byte [eax+8],not 80h
symbol_undefined:
xor bl,bl
jmp check_expression
expression_checked:
mov al,bl
jmp logical_value_ok
check_for_used:
lods word [esi]
cmp ah,2
jne invalid_expression
lods dword [esi]
cmp eax,0Fh
jb invalid_use_of_symbol
je reserved_word_used_as_symbol
inc esi
test byte [eax+8],8
jz not_used
mov cx,[current_pass]
sub cx,[eax+18]
jz return_true
cmp cx,1
ja not_used
or byte [eax+8],10h+20h
jmp return_true
not_used:
or byte [eax+8],10h
and byte [eax+8],not 20h
jmp return_false
given_false:
inc esi
return_false:
xor al,al
jmp logical_value_ok
given_true:
inc esi
return_true:
or al,-1
jmp logical_value_ok
logical_expression:
lods byte [esi]
mov dl,[logical_value_wrapping]
push edx
call calculate_embedded_logical_expression
pop edx
mov [logical_value_wrapping],dl
push eax
lods byte [esi]
cmp al,'}'
jne invalid_expression
pop eax
logical_value_ok:
pop ebx
xor al,bl
ret
skip_symbol:
lods byte [esi]
or al,al
jz nothing_to_skip
cmp al,0Fh
je nothing_to_skip
cmp al,1
je skip_instruction
cmp al,2
je skip_label
cmp al,3
je skip_label
cmp al,4
je skip_special_label
cmp al,20h
jb skip_assembler_symbol
cmp al,'('
je skip_expression
cmp al,'['
je skip_address
skip_done:
clc
ret
skip_label:
add esi,2
skip_instruction:
add esi,2
skip_assembler_symbol:
inc esi
jmp skip_done
skip_special_label:
add esi,4
jmp skip_done
skip_address:
mov al,[esi]
and al,11110000b
cmp al,60h
jb skip_expression
cmp al,70h
ja skip_expression
inc esi
jmp skip_address
skip_expression:
lods byte [esi]
or al,al
jz skip_string
cmp al,'.'
je skip_fp_value
cmp al,')'
je skip_done
cmp al,']'
je skip_done
cmp al,'!'
je skip_expression
cmp al,0Fh
je skip_expression
cmp al,10h
je skip_register
cmp al,11h
je skip_label_value
cmp al,80h
jae skip_expression
movzx eax,al
add esi,eax
jmp skip_expression
skip_label_value:
add esi,3
skip_register:
inc esi
jmp skip_expression
skip_fp_value:
add esi,12
jmp skip_done
skip_string:
lods dword [esi]
add esi,eax
inc esi
jmp skip_done
nothing_to_skip:
dec esi
stc
ret
expand_path:
lods byte [esi]
cmp al,'%'
je environment_variable
stos byte [edi]
or al,al
jnz expand_path
cmp edi,[memory_end]
ja out_of_memory
ret
environment_variable:
mov ebx,esi
find_variable_end:
lods byte [esi]
or al,al
jz not_environment_variable
cmp al,'%'
jne find_variable_end
mov byte [esi-1],0
push esi
mov esi,ebx
call get_environment_variable
pop esi
mov byte [esi-1],'%'
jmp expand_path
not_environment_variable:
mov al,'%'
stos byte [edi]
mov esi,ebx
jmp expand_path
get_include_directory:
lods byte [esi]
cmp al,';'
je include_directory_ok
stos byte [edi]
or al,al
jnz get_include_directory
dec esi
dec edi
include_directory_ok:
cmp byte [edi-1],'/'
je path_separator_ok
cmp byte [edi-1],'\'
je path_separator_ok
mov al,'/'
stos byte [edi]
path_separator_ok:
ret