Subversion Repositories Kolibri OS

; Copyright (c) 1999-2011, Tomasz Grysztar.

; All rights reserved.

	push	ebp

	call	get_fp_value

	jnc	fp_expression

	mov	[current_offset],esp

      expression_loop:

	push	edi

	mov	edi,single_operand_operators

	call	get_operator

	pop	edi

	or	al,al

	jz	expression_element

	push	eax

	jmp	expression_loop

      expression_element:

	mov	al,[esi]

	cmp	al,1Ah

	je	expression_number

	cmp	al,22h

	je	expression_number

	cmp	al,'('

	je	expression_number

	mov	al,'!'

	stos	byte [edi]

	jmp	expression_operator

      expression_number:

	call	convert_number

      expression_operator:

	push	edi

	mov	edi,operators

	call	get_operator

	pop	edi

	or	al,al

	jz	expression_end

      operators_loop:

	cmp	esp,[current_offset]

	je	push_operator

	mov	bl,al

	and	bl,0F0h

	mov	bh,byte [esp]

	and	bh,0F0h

	cmp	bl,bh

	ja	push_operator

	pop	ebx

	mov	byte [edi],bl

	inc	edi

	jmp	operators_loop

      push_operator:

	push	eax

	jmp	expression_loop

      expression_end:

	cmp	esp,[current_offset]

	je	expression_converted

	pop	eax

	stos	byte [edi]

	jmp	expression_end

      expression_converted:

	pop	ebp

	ret

      fp_expression:

	mov	al,'.'

	stos	byte [edi]

	mov	eax,[fp_value]

	stos	dword [edi]

	mov	eax,[fp_value+4]

	stos	dword [edi]

	mov	eax,[fp_value+8]

	stos	dword [edi]

	pop	ebp

	ret

	lea	eax,[edi-10h]

	mov	edx,[memory_end]

	cmp	[source_start],0

	je	check_memory_for_number

	mov	edx,[labels_list]

      check_memory_for_number:

	cmp	eax,edx

	jae	out_of_memory

	mov	eax,esp

	sub	eax,100h

	jc	stack_overflow

	cmp	eax,[stack_limit]

	jb	stack_overflow

	cmp	byte [esi],'('

	je	expression_value

	inc	edi

	call	get_number

	jc	symbol_value

	or	ebp,ebp

	jz	valid_number

	mov	byte [edi-1],0Fh

	ret

      valid_number:

	cmp	dword [edi+4],0

	jne	qword_number

	cmp	word [edi+2],0

	jne	dword_number

	cmp	byte [edi+1],0

	jne	word_number

      byte_number:

	mov	byte [edi-1],1

	inc	edi

	ret

      qword_number:

	mov	byte [edi-1],8

	add	edi,8

	ret

      dword_number:

	mov	byte [edi-1],4

	scas	dword [edi]

	ret

      word_number:

	mov	byte [edi-1],2

	scas	word [edi]

	ret

      expression_value:

	inc	esi

	push	[current_offset]

	call	convert_expression

	pop	[current_offset]

	lods	byte [esi]

	cmp	al,')'

	jne	invalid_expression

	ret

      symbol_value:

	cmp	[source_start],0

	je	preprocessor_value

	push	edi

	mov	edi,address_registers

	call	get_operator

	or	al,al

	jnz	register_value

	mov	edi,directive_operators

	call	get_operator

	pop	edi

	or	al,al

	jnz	broken_value

	lods	byte [esi]

	cmp	al,1Ah

	jne	invalid_value

	lods	byte [esi]

	movzx	ecx,al

	call	get_label_id

      store_label_value:

	mov	byte [edi-1],11h

	stos	dword [edi]

	ret

      broken_value:

	mov	eax,0Fh

	jmp	store_label_value

      register_value:

	pop	edi

	mov	byte [edi-1],10h

	stos	byte [edi]

	ret

      preprocessor_value:

	dec	edi

	cmp	[hash_tree],0

	je	invalid_value

	lods	byte [esi]

	cmp	al,1Ah

	jne	invalid_value

	lods	byte [esi]

	mov	cl,al

	mov	ch,10b

	call	get_preprocessor_symbol

	jc	invalid_value

	push	esi

	mov	esi,[edx+8]

	push	[current_offset]

	call	convert_expression

	pop	[current_offset]

	pop	esi

	ret

	xor	ebp,ebp

	lods	byte [esi]

	cmp	al,22h

	je	get_text_number

	cmp	al,1Ah

	jne	not_number

	lods	byte [esi]

	movzx	ecx,al

	mov	[number_start],esi

	mov	al,[esi]

	cmp	al,'$'

	je	number_begin

	sub	al,30h

	cmp	al,9

	ja	invalid_number

      number_begin:

	mov	ebx,esi

	add	esi,ecx

	push	esi

	dec	esi

	mov	dword [edi],0

	mov	dword [edi+4],0

	cmp	byte [ebx],'$'

	je	pascal_hex_number

	cmp	word [ebx],'0x'

	je	get_hex_number

	mov	al,[esi]

	dec	esi

	cmp	al,'h'

	je	get_hex_number

	cmp	al,'b'

	je	get_bin_number

	cmp	al,'d'

	je	get_dec_number

	cmp	al,'o'

	je	get_oct_number

	cmp	al,'H'

	je	get_hex_number

	cmp	al,'B'

	je	get_bin_number

	cmp	al,'D'

	je	get_dec_number

	cmp	al,'O'

	je	get_oct_number

	inc	esi

      get_dec_number:

	mov	ebx,esi

	mov	esi,[number_start]

      get_dec_digit:

	cmp	esi,ebx

	ja	number_ok

	cmp	byte [esi],27h

	je	next_dec_digit

	xor	edx,edx

	mov	eax,[edi]

	shld	edx,eax,2

	shl	eax,2

	add	eax,[edi]

	adc	edx,0

	add	eax,eax

	adc	edx,edx

	mov	[edi],eax

	mov	eax,[edi+4]

	add	eax,eax

	jc	dec_out_of_range

	add	eax,eax

	jc	dec_out_of_range

	add	eax,[edi+4]

	jc	dec_out_of_range

	add	eax,eax

	jc	dec_out_of_range

	add	eax,edx

	jc	dec_out_of_range

	mov	[edi+4],eax

	movzx	eax,byte [esi]

	sub	al,30h

	jc	bad_number

	cmp	al,9

	ja	bad_number

	add	[edi],eax

	adc	dword [edi+4],0

	jc	dec_out_of_range

      next_dec_digit:

	inc	esi

	jmp	get_dec_digit

      dec_out_of_range:

	cmp	esi,ebx

	ja	dec_out_of_range_finished

	lods	byte [esi]

	cmp	al,27h

	je	bad_number

	sub	al,30h

	jc	bad_number

	cmp	al,9

	ja	bad_number

	jmp	dec_out_of_range

      dec_out_of_range_finished:

	or	ebp,-1

	jmp	number_ok

      bad_number:

	pop	eax

      invalid_number:

	mov	esi,[number_start]

	dec	esi

      not_number:

	dec	esi

	stc

	ret

      get_bin_number:

	xor	bl,bl

      get_bin_digit:

	cmp	esi,[number_start]

	jb	number_ok

	movzx	eax,byte [esi]

	cmp	al,27h

	je	bin_digit_skip

	sub	al,30h

	cmp	al,1

	ja	bad_number

	xor	edx,edx

	mov	cl,bl

	dec	esi

	cmp	bl,64

	je	bin_out_of_range

	inc	bl

	cmp	cl,32

	jae	bin_digit_high

	shl	eax,cl

	or	dword [edi],eax

	jmp	get_bin_digit

      bin_digit_high:

	sub	cl,32

	shl	eax,cl

	or	dword [edi+4],eax

	jmp	get_bin_digit

      bin_out_of_range:

	or	al,al

	jz	get_bin_digit

	or	ebp,-1

	jmp	get_bin_digit

      bin_digit_skip:

	dec	esi

	jmp	get_bin_digit

      pascal_hex_number:

	cmp	cl,1

	je	bad_number

      get_hex_number:

	xor	bl,bl

      get_hex_digit:

	cmp	esi,[number_start]

	jb	number_ok

	movzx	eax,byte [esi]

	cmp	al,27h

	je	hex_digit_skip

	cmp	al,'x'

	je	hex_number_ok

	cmp	al,'$'

	je	pascal_hex_ok

	sub	al,30h

	cmp	al,9

	jbe	hex_digit_ok

	sub	al,7

	cmp	al,15

	jbe	hex_letter_digit_ok

	sub	al,20h

	cmp	al,15

	ja	bad_number

      hex_letter_digit_ok:

	cmp	al,10

	jb	bad_number

      hex_digit_ok:

	xor	edx,edx

	mov	cl,bl

	dec	esi

	cmp	bl,64

	je	hex_out_of_range

	add	bl,4

	cmp	cl,32

	jae	hex_digit_high

	shl	eax,cl

	or	dword [edi],eax

	jmp	get_hex_digit

      hex_digit_high:

	sub	cl,32

	shl	eax,cl

	or	dword [edi+4],eax

	jmp	get_hex_digit

      hex_out_of_range:

	or	al,al

	jz	get_hex_digit

	or	ebp,-1

	jmp	get_hex_digit

      hex_digit_skip:

	dec	esi

	jmp	get_hex_digit

      get_oct_number:

	xor	bl,bl

      get_oct_digit:

	cmp	esi,[number_start]

	jb	number_ok

	movzx	eax,byte [esi]

	cmp	al,27h

	je	oct_digit_skip

	sub	al,30h

	cmp	al,7

	ja	bad_number

      oct_digit_ok:

	xor	edx,edx

	mov	cl,bl

	dec	esi

	cmp	bl,64

	jae	oct_out_of_range

	add	bl,3

	cmp	cl,30

	je	oct_digit_wrap

	ja	oct_digit_high

	shl	eax,cl

	or	dword [edi],eax

	jmp	get_oct_digit

      oct_digit_wrap:

	shl	eax,cl

	adc	dword [edi+4],0

	or	dword [edi],eax

	jmp	get_oct_digit

      oct_digit_high:

	sub	cl,32

	shl	eax,cl

	or	dword [edi+4],eax

	jmp	get_oct_digit

      oct_digit_skip:

	dec	esi

	jmp	get_oct_digit

      oct_out_of_range:

	or	al,al

	jz	get_oct_digit

	or	ebp,-1

	jmp	get_oct_digit

      hex_number_ok:

	dec	esi

      pascal_hex_ok:

	cmp	esi,[number_start]

	jne	bad_number

      number_ok:

	pop	esi

      number_done:

	clc

	ret

      get_text_number:

	lods	dword [esi]

	mov	edx,eax

	xor	bl,bl

	mov	dword [edi],0

	mov	dword [edi+4],0

      get_text_character:

	sub	edx,1

	jc	number_done

	movzx	eax,byte [esi]

	inc	esi

	mov	cl,bl

	cmp	bl,64

	je	text_out_of_range

	add	bl,8

	cmp	cl,32

	jae	text_character_high

	shl	eax,cl

	or	dword [edi],eax

	jmp	get_text_character

      text_character_high:

	sub	cl,32

	shl	eax,cl

	or	dword [edi+4],eax

	jmp	get_text_character

      text_out_of_range:

	or	ebp,-1

	jmp	get_text_character

	push	edi esi

	lods	byte [esi]

	cmp	al,1Ah

	je	fp_value_start

	cmp	al,'-'

	je	fp_sign_ok

	cmp	al,'+'

	jne	not_fp_value

      fp_sign_ok:

	lods	byte [esi]

	cmp	al,1Ah

	jne	not_fp_value

      fp_value_start:

	lods	byte [esi]

	movzx	ecx,al

	cmp	cl,1

	jbe	not_fp_value

	lea	edx,[esi+1]

	xor	ah,ah

      check_fp_value:

	lods	byte [esi]

	cmp	al,'.'

	je	fp_character_dot

	cmp	al,'E'

	je	fp_character_exp

	cmp	al,'e'

	je	fp_character_exp

	cmp	al,'F'

	je	fp_last_character

	cmp	al,'f'

	je	fp_last_character

      digit_expected:

	cmp	al,'0'

	jb	not_fp_value

	cmp	al,'9'

	ja	not_fp_value

	jmp	fp_character_ok

      fp_character_dot:

	cmp	esi,edx

	je	not_fp_value

	or	ah,ah

	jnz	not_fp_value

	or	ah,1

	lods	byte [esi]

	loop	digit_expected

      not_fp_value:

	pop	esi edi

	stc

	ret

      fp_last_character:

	cmp	cl,1

	jne	not_fp_value

	or	ah,4

	jmp	fp_character_ok

      fp_character_exp:

	cmp	esi,edx

	je	not_fp_value

	cmp	ah,1

	ja	not_fp_value

	or	ah,2

	cmp	ecx,1

	jne	fp_character_ok

	cmp	byte [esi],'+'

	je	fp_exp_sign

	cmp	byte [esi],'-'

	jne	fp_character_ok

      fp_exp_sign:

	inc	esi

	cmp	byte [esi],1Ah

	jne	not_fp_value

	inc	esi

	lods	byte [esi]

	movzx	ecx,al

	inc	ecx

      fp_character_ok:

	dec	ecx

	jnz	check_fp_value

	or	ah,ah

	jz	not_fp_value

	pop	esi

	lods	byte [esi]

	mov	[fp_sign],0

	cmp	al,1Ah

	je	fp_get

	inc	esi

	cmp	al,'+'

	je	fp_get

	mov	[fp_sign],1

      fp_get:

	lods	byte [esi]

	movzx	ecx,al

	xor	edx,edx

	mov	edi,fp_value

	mov	[edi],edx

	mov	[edi+4],edx

	mov	[edi+12],edx

	call	fp_optimize

	mov	[fp_format],0

	mov	al,[esi]

      fp_before_dot:

	lods	byte [esi]

	cmp	al,'.'

	je	fp_dot

	cmp	al,'E'

	je	fp_exponent

	cmp	al,'e'

	je	fp_exponent

	cmp	al,'F'

	je	fp_done

	cmp	al,'f'

	je	fp_done

	sub	al,30h

	mov	edi,fp_value+16

	xor	edx,edx

	mov	dword [edi+12],edx

	mov	dword [edi],edx

	mov	dword [edi+4],edx

	mov	[edi+7],al

	mov	dl,7

	mov	dword [edi+8],edx

	call	fp_optimize

	mov	edi,fp_value

	push	ecx

	mov	ecx,10

	call	fp_mul

	pop	ecx

	mov	ebx,fp_value+16

	call	fp_add

	loop	fp_before_dot

      fp_dot:

	mov	edi,fp_value+16

	xor	edx,edx

	mov	[edi],edx

	mov	[edi+4],edx

	mov	byte [edi+7],80h

	mov	[edi+8],edx

	mov	dword [edi+12],edx

	dec	ecx

	jz	fp_done

      fp_after_dot:

	lods	byte [esi]

	cmp	al,'E'

	je	fp_exponent

	cmp	al,'e'

	je	fp_exponent

	cmp	al,'F'

	je	fp_done

	cmp	al,'f'

	je	fp_done

	inc	[fp_format]

	cmp	[fp_format],80h

	jne	fp_counter_ok

	mov	[fp_format],7Fh

      fp_counter_ok:

	dec	esi

	mov	edi,fp_value+16

	push	ecx

	mov	ecx,10

	call	fp_div

	push	dword [edi]

	push	dword [edi+4]

	push	dword [edi+8]

	push	dword [edi+12]

	lods	byte [esi]

	sub	al,30h

	movzx	ecx,al

	call	fp_mul

	mov	ebx,edi

	mov	edi,fp_value

	call	fp_add

	mov	edi,fp_value+16

	pop	dword [edi+12]

	pop	dword [edi+8]

	pop	dword [edi+4]

	pop	dword [edi]

	pop	ecx

	dec	ecx

	jnz	fp_after_dot

	jmp	fp_done

      fp_exponent:

	or	[fp_format],80h

	xor	edx,edx

	xor	ebp,ebp

	dec	ecx

	jnz	get_exponent

	cmp	byte [esi],'+'

	je	fp_exponent_sign

	cmp	byte [esi],'-'

	jne	fp_done

	not	ebp

      fp_exponent_sign:

	add	esi,2

	lods	byte [esi]

	movzx	ecx,al

      get_exponent:

	movzx	eax,byte [esi]

	inc	esi

	sub	al,30h

	cmp	al,10

	jae	exponent_ok

	imul	edx,10

	cmp	edx,8000h

	jae	value_out_of_range

	add	edx,eax

	loop	get_exponent

      exponent_ok:

	mov	edi,fp_value

	or	edx,edx

	jz	fp_done

	mov	ecx,edx

	or	ebp,ebp

	jnz	fp_negative_power

      fp_power:

	push	ecx

	mov	ecx,10

	call	fp_mul

	pop	ecx

	loop	fp_power

	jmp	fp_done

      fp_negative_power:

	push	ecx

	mov	ecx,10

	call	fp_div

	pop	ecx

	loop	fp_negative_power

      fp_done:

	mov	edi,fp_value

	mov	al,[fp_format]

	mov	[edi+10],al

	mov	al,[fp_sign]

	mov	[edi+11],al

	test	byte [edi+15],80h

	jz	fp_ok

	add	dword [edi],1

	adc	dword [edi+4],0

	jnc	fp_ok

	mov	eax,[edi+4]

	shrd	[edi],eax,1

	shr	eax,1

	or	eax,80000000h

	mov	[edi+4],eax

	inc	word [edi+8]

      fp_ok:

	pop	edi

	clc

	ret

      fp_mul:

	or	ecx,ecx

	jz	fp_zero

	mov	eax,[edi+12]

	mul	ecx

	mov	[edi+12],eax

	mov	ebx,edx

	mov	eax,[edi]

	mul	ecx

	add	eax,ebx

	adc	edx,0

	mov	[edi],eax

	mov	ebx,edx

	mov	eax,[edi+4]

	mul	ecx

	add	eax,ebx

	adc	edx,0

	mov	[edi+4],eax

      .loop:

	or	edx,edx

	jz	.done

	mov	eax,[edi]

	shrd	[edi+12],eax,1

	mov	eax,[edi+4]

	shrd	[edi],eax,1

	shrd	eax,edx,1

	mov	[edi+4],eax

	shr	edx,1

	inc	dword [edi+8]

	cmp	dword [edi+8],8000h

	jge	value_out_of_range

	jmp	.loop

      .done:

	ret

      fp_div:

	mov	eax,[edi+4]

	xor	edx,edx

	div	ecx

	mov	[edi+4],eax

	mov	eax,[edi]

	div	ecx

	mov	[edi],eax

	mov	eax,[edi+12]

	div	ecx

	mov	[edi+12],eax

	mov	ebx,eax

	or	ebx,[edi]

	or	ebx,[edi+4]

	jz	fp_zero

      .loop:

	test	byte [edi+7],80h

	jnz	.exp_ok

	mov	eax,[edi]

	shld	[edi+4],eax,1

	mov	eax,[edi+12]

	shld	[edi],eax,1

	add	eax,eax

	mov	[edi+12],eax

	dec	dword [edi+8]

	add	edx,edx

	jmp	.loop

      .exp_ok:

	mov	eax,edx

	xor	edx,edx

	div	ecx

	add	[edi+12],eax

	adc	dword [edi],0

	adc	dword [edi+4],0

	jnc	.done

	mov	eax,[edi+4]

	mov	ebx,[edi]

	shrd	[edi],eax,1

	shrd	[edi+12],ebx,1

	shr	eax,1

	or	eax,80000000h

	mov	[edi+4],eax

	inc	dword [edi+8]

      .done:

	ret

      fp_add:

	cmp	dword [ebx+8],8000h

	je	.done

	cmp	dword [edi+8],8000h

	je	.copy

	mov	eax,[ebx+8]

	cmp	eax,[edi+8]

	jge	.exp_ok

	mov	eax,[edi+8]

      .exp_ok:

	call	.change_exp

	xchg	ebx,edi

	call	.change_exp

	xchg	ebx,edi

	mov	edx,[ebx+12]

	mov	eax,[ebx]

	mov	ebx,[ebx+4]

	add	[edi+12],edx

	adc	[edi],eax

	adc	[edi+4],ebx

	jnc	.done

	mov	eax,[edi]

	shrd	[edi+12],eax,1

	mov	eax,[edi+4]

	shrd	[edi],eax,1

	shr	eax,1

	or	eax,80000000h

	mov	[edi+4],eax

	inc	dword [edi+8]

      .done:

	ret

      .copy:

	mov	eax,[ebx]

	mov	[edi],eax

	mov	eax,[ebx+4]

	mov	[edi+4],eax

	mov	eax,[ebx+8]

	mov	[edi+8],eax

	mov	eax,[ebx+12]

	mov	[edi+12],eax

	ret

      .change_exp:

	push	ecx

	mov	ecx,eax

	sub	ecx,[ebx+8]

	mov	edx,[ebx+4]

	jecxz	.exp_done

      .exp_loop:

	mov	ebp,[ebx]

	shrd	[ebx+12],ebp,1

	shrd	[ebx],edx,1

	shr	edx,1

	inc	dword [ebx+8]

	loop	.exp_loop

      .exp_done:

	mov	[ebx+4],edx

	pop	ecx

	ret

      fp_optimize:

	mov	eax,[edi]

	mov	ebp,[edi+4]

	or	ebp,[edi]

	or	ebp,[edi+12]

	jz	fp_zero

      .loop:

	test	byte [edi+7],80h

	jnz	.done

	shld	[edi+4],eax,1

	mov	ebp,[edi+12]

	shld	eax,ebp,1

	mov	[edi],eax

	shl	dword [edi+12],1

	dec	dword [edi+8]

	jmp	.loop

      .done:

	ret

      fp_zero:

	mov	dword [edi+8],8000h

	ret

	xor	al,al

  preevaluate_embedded_logical_expression:

	mov	[logical_value_wrapping],al

	push	edi

	call	preevaluate_logical_value

      preevaluation_loop:

	cmp	al,0FFh

	je	invalid_logical_expression

	mov	dl,[esi]

	inc	esi

	cmp	dl,'|'

	je	preevaluate_or

	cmp	dl,'&'

	je	preevaluate_and

	cmp	dl,'}'

	je	preevaluation_done

	or	dl,dl

	jnz	invalid_logical_expression

      preevaluation_done:

	pop	edx

	dec	esi

	ret

      preevaluate_or:

	cmp	al,'1'

	je	quick_true

	cmp	al,'0'

	je	leave_only_following

	push	edi

	mov	al,dl

	stos	byte [edi]

	call	preevaluate_logical_value

	pop	ebx

	cmp	al,'0'

	je	leave_only_preceding

	cmp	al,'1'

	jne	preevaluation_loop

	stos	byte [edi]

	xor	al,al

	jmp	preevaluation_loop

      preevaluate_and:

	cmp	al,'0'

	je	quick_false

	cmp	al,'1'

	je	leave_only_following

	push	edi

	mov	al,dl

	stos	byte [edi]

	call	preevaluate_logical_value

	pop	ebx

	cmp	al,'1'

	je	leave_only_preceding

	cmp	al,'0'

	jne	preevaluation_loop

	stos	byte [edi]

	xor	al,al

	jmp	preevaluation_loop

      leave_only_following:

	mov	edi,[esp]

	call	preevaluate_logical_value

	jmp	preevaluation_loop

      leave_only_preceding:

	mov	edi,ebx

	xor	al,al

	jmp	preevaluation_loop

      quick_true:

	call	skip_logical_value

	jc	invalid_logical_expression

	mov	edi,[esp]

	mov	al,'1'

	jmp	preevaluation_loop

      quick_false:

	call	skip_logical_value

	jc	invalid_logical_expression

	mov	edi,[esp]

	mov	al,'0'

	jmp	preevaluation_loop

      invalid_logical_expression:

	pop	edi

	mov	esi,edi

	mov	al,0FFh

	stos	byte [edi]

	ret

  skip_logical_value:

	cmp	byte [esi],'~'

	jne	negation_skipped

	inc	esi

	jmp	skip_logical_value

      negation_skipped:

	mov	al,[esi]

	cmp	al,'{'

	jne	skip_simple_logical_value

	inc	esi

	xchg	al,[logical_value_wrapping]

	push	eax

      skip_logical_expression:

	call	skip_logical_value

	lods	byte [esi]

	or	al,al

	jz	wrongly_structured_logical_expression

	cmp	al,0Fh

	je	wrongly_structured_logical_expression

	cmp	al,'|'

	je	skip_logical_expression

	cmp	al,'&'

	je	skip_logical_expression

	cmp	al,'}'

	jne	wrongly_structured_logical_expression

	pop	eax

	mov	[logical_value_wrapping],al

      logical_value_skipped:

	clc

	ret

      wrongly_structured_logical_expression:

	pop	eax

	stc

	ret

      skip_simple_logical_value:

	mov	[logical_value_parentheses],0

      find_simple_logical_value_end:

	mov	al,[esi]

	or	al,al

	jz	logical_value_skipped

	cmp	al,0Fh

	je	logical_value_skipped

	cmp	al,'|'

	je	logical_value_skipped

	cmp	al,'&'

	je	logical_value_skipped

	cmp	al,'{'

	je	skip_logical_value_internal_parenthesis

	cmp	al,'}'

	jne	skip_logical_value_symbol

	sub	[logical_value_parentheses],1

	jnc	skip_logical_value_symbol

	cmp	[logical_value_wrapping],'{'

	jne	skip_logical_value_symbol

	jmp	logical_value_skipped

      skip_logical_value_internal_parenthesis:

	inc	[logical_value_parentheses]

      skip_logical_value_symbol:

	call	skip_symbol

	jmp	find_simple_logical_value_end

  preevaluate_logical_value:

	mov	ebp,edi

      preevaluate_negation:

	cmp	byte [esi],'~'

	jne	preevaluate_negation_ok

	movs	byte [edi],[esi]

	jmp	preevaluate_negation

      preevaluate_negation_ok:

	mov	ebx,esi

	cmp	byte [esi],'{'

	jne	preevaluate_simple_logical_value

	lods	byte [esi]

	stos	byte [edi]

	push	ebp

	mov	dl,[logical_value_wrapping]

	push	edx

	call	preevaluate_embedded_logical_expression

	pop	edx

	mov	[logical_value_wrapping],dl

	pop	ebp

	cmp	al,0FFh

	je	invalid_logical_value

	cmp	byte [esi],'}'

	jne	invalid_logical_value

	or	al,al

	jnz	preevaluated_expression_value

	movs	byte [edi],[esi]

	ret

      preevaluated_expression_value:

	inc	esi

	lea	edx,[edi-1]

	sub	edx,ebp

	test	edx,1

	jz	expression_negation_ok

	xor	al,1

      expression_negation_ok:

	mov	edi,ebp

	ret

      invalid_logical_value:

	mov	edi,ebp

	mov	al,0FFh

	ret

      preevaluate_simple_logical_value:

	xor	edx,edx

	mov	[logical_value_parentheses],edx

      find_logical_value_boundaries:

	mov	al,[esi]

	or	al,al

	jz	logical_value_boundaries_found

	cmp	al,'{'

	je	logical_value_internal_parentheses

	cmp	al,'}'

	je	logical_value_boundaries_parenthesis_close

	cmp	al,'|'

	je	logical_value_boundaries_found

	cmp	al,'&'

	je	logical_value_boundaries_found

	or	edx,edx

	jnz	next_symbol_in_logical_value

	cmp	al,0F0h

	je	preevaluable_logical_operator

	cmp	al,0F7h

	je	preevaluable_logical_operator

	cmp	al,0F6h

	jne	next_symbol_in_logical_value

      preevaluable_logical_operator:

	mov	edx,esi

      next_symbol_in_logical_value:

	call	skip_symbol

	jmp	find_logical_value_boundaries

      logical_value_internal_parentheses:

	inc	[logical_value_parentheses]

	jmp	next_symbol_in_logical_value

      logical_value_boundaries_parenthesis_close:

	sub	[logical_value_parentheses],1

	jnc	next_symbol_in_logical_value

	cmp	[logical_value_wrapping],'{'

	jne	next_symbol_in_logical_value

      logical_value_boundaries_found:

	or	edx,edx

	jz	non_preevaluable_logical_value

	mov	al,[edx]

	cmp	al,0F0h

	je	compare_symbols

	cmp	al,0F7h

	je	compare_symbol_types

	cmp	al,0F6h

	je	scan_symbols_list

      non_preevaluable_logical_value:

	mov	ecx,esi

	mov	esi,ebx

	sub	ecx,esi

	jz	invalid_logical_value

	cmp	esi,edi

	je	leave_logical_value_intact

	rep	movs byte [edi],[esi]

	xor	al,al

	ret

      leave_logical_value_intact:

	add	edi,ecx

	add	esi,ecx

	xor	al,al

	ret

      compare_symbols:

	lea	ecx,[esi-1]

	sub	ecx,edx

	mov	eax,edx

	sub	eax,ebx

	cmp	ecx,eax

	jne	preevaluated_false

	push	esi edi

	mov	esi,ebx

	lea	edi,[edx+1]

	repe	cmps byte [esi],[edi]

	pop	edi esi

	je	preevaluated_true

      preevaluated_false:

	mov	eax,edi

	sub	eax,ebp

	test	eax,1

	jnz	store_true

      store_false: