WebSVN – Kolibri OS – Diff – /programs/develop/fasm/trunk/assemble.inc


; flat assembler core
; Copyright (c) 1999-2013, Tomasz Grysztar.
; All rights reserved.
 
assembler:
	xor	eax,eax
	mov	[stub_size],eax
	mov	[current_pass],ax
	mov	[resolver_flags],eax
	mov	[number_of_sections],eax
	mov	[actual_fixups_size],eax
      assembler_loop:
	mov	eax,[labels_list]
	mov	[tagged_blocks],eax
	mov	eax,[additional_memory]
	mov	[free_additional_memory],eax
	mov	eax,[additional_memory_end]
	mov	[structures_buffer],eax
	mov	esi,[source_start]
	mov	edi,[code_start]
	xor	eax,eax
	mov	dword [adjustment],eax
	mov	dword [adjustment+4],eax
	mov	[addressing_space],eax
 
 
 
	mov	[error_line],eax
 
	mov	[counter],eax
	mov	[format_flags],eax
	mov	[number_of_relocations],eax
	mov	[undefined_data_end],eax
	mov	[file_extension],eax
	mov	[next_pass_needed],al
	mov	[output_format],al
	mov	[adjustment_sign],al
 
	mov	[code_type],16
 
 
	call	init_addressing_space
      pass_loop:
	call	assemble_line
	jnc	pass_loop
	mov	eax,[additional_memory_end]
	cmp	eax,[structures_buffer]
	je	pass_done
	sub	eax,18h
	mov	eax,[eax+4]
	mov	[current_line],eax
	jmp	missing_end_directive
      pass_done:
	call	close_pass
	mov	eax,[labels_list]
      check_symbols:
	cmp	eax,[memory_end]
	jae	symbols_checked
	test	byte [eax+8],8
	jz	symbol_defined_ok
	mov	cx,[current_pass]
	cmp	cx,[eax+18]
	jne	symbol_defined_ok
	test	byte [eax+8],1
	jz	symbol_defined_ok
	sub	cx,[eax+16]
	cmp	cx,1
	jne	symbol_defined_ok
	and	byte [eax+8],not 1
	or	[next_pass_needed],-1
      symbol_defined_ok:
	test	byte [eax+8],10h
	jz	use_prediction_ok
	mov	cx,[current_pass]
	and	byte [eax+8],not 10h
	test	byte [eax+8],20h
	jnz	check_use_prediction
	cmp	cx,[eax+18]
	jne	use_prediction_ok
	test	byte [eax+8],8
	jz	use_prediction_ok
	jmp	use_misprediction
      check_use_prediction:
	test	byte [eax+8],8
	jz	use_misprediction
	cmp	cx,[eax+18]
	je	use_prediction_ok
      use_misprediction:
	or	[next_pass_needed],-1
      use_prediction_ok:
	test	byte [eax+8],40h
	jz	check_next_symbol
	and	byte [eax+8],not 40h
	test	byte [eax+8],4
	jnz	define_misprediction
	mov	cx,[current_pass]
	test	byte [eax+8],80h
	jnz	check_define_prediction
	cmp	cx,[eax+16]
	jne	check_next_symbol
	test	byte [eax+8],1
	jz	check_next_symbol
	jmp	define_misprediction
      check_define_prediction:
	test	byte [eax+8],1
	jz	define_misprediction
	cmp	cx,[eax+16]
	je	check_next_symbol
      define_misprediction:
	or	[next_pass_needed],-1
      check_next_symbol:
	add	eax,LABEL_STRUCTURE_SIZE
	jmp	check_symbols
      symbols_checked:
	cmp	[next_pass_needed],0
	jne	next_pass
	mov	eax,[error_line]
	or	eax,eax
	jz	assemble_ok
	mov	[current_line],eax
	cmp	[error],undefined_symbol
	jne	error_confirmed
	mov	eax,[error_info]
	or	eax,eax
	jz	error_confirmed
	test	byte [eax+8],1
	jnz	next_pass
      error_confirmed:
	call	error_handler
      error_handler:
	mov	eax,[error]
	sub	eax,error_handler
	add	[esp],eax
	ret
      next_pass:
	inc	[current_pass]
	mov	ax,[current_pass]
	cmp	ax,[passes_limit]
	je	code_cannot_be_generated
	jmp	assembler_loop
      assemble_ok:
	ret
 
create_addressing_space:
	mov	ebx,[addressing_space]
	test	ebx,ebx
	jz	init_addressing_space
	test	byte [ebx+0Ah],1
	jnz	illegal_instruction
	mov	eax,edi
	sub	eax,[ebx+18h]
	mov	[ebx+1Ch],eax
      init_addressing_space:
	mov	ebx,[tagged_blocks]
	mov	dword [ebx-4],10h
	mov	dword [ebx-8],20h
	sub	ebx,8+20h
	cmp	ebx,edi
	jbe	out_of_memory
	mov	[tagged_blocks],ebx
	mov	[addressing_space],ebx
	xor	eax,eax
	mov	[ebx],edi
	mov	[ebx+4],eax
	mov	[ebx+8],eax
	mov	[ebx+10h],eax
	mov	[ebx+14h],eax
	mov	[ebx+18h],edi
	mov	[ebx+1Ch],eax
	ret
 
assemble_line:
	mov	eax,[tagged_blocks]
	sub	eax,100h
	cmp	edi,eax
	ja	out_of_memory
	lods	byte [esi]
	cmp	al,1
	je	assemble_instruction
	jb	source_end
	cmp	al,3
	jb	define_label
	je	define_constant
	cmp	al,4
	je	label_addressing_space
	cmp	al,0Fh
	je	new_line
	cmp	al,13h
	je	code_type_setting
	cmp	al,10h
	jne	illegal_instruction
	lods	byte [esi]
	jmp	segment_prefix
      code_type_setting:
	lods	byte [esi]
	mov	[code_type],al
	jmp	instruction_assembled
      new_line:
	lods	dword [esi]
	mov	[current_line],eax
	mov	[prefixed_instruction],0
	cmp	[symbols_file],0
	je	continue_line
	cmp	[next_pass_needed],0
	jne	continue_line
	mov	ebx,[tagged_blocks]
	mov	dword [ebx-4],1
	mov	dword [ebx-8],14h
	sub	ebx,8+14h
	cmp	ebx,edi
	jbe	out_of_memory
	mov	[tagged_blocks],ebx
	mov	[ebx],eax
	mov	[ebx+4],edi
	mov	eax,[addressing_space]
 
 
	mov	[ebx+8],eax
	mov	al,[code_type]
 
 
 
 
 
 
 
 
	mov	[ebx+10h],al
 
      continue_line:
	cmp	byte [esi],0Fh
	je	line_assembled
	jmp	assemble_line
      define_label:
	lods	dword [esi]
	cmp	eax,0Fh
	jb	invalid_use_of_symbol
	je	reserved_word_used_as_symbol
	mov	ebx,eax
	lods	byte [esi]
	mov	[label_size],al
	call	make_label
	jmp	continue_line
      make_label:
	mov	eax,edi
	xor	edx,edx
	xor	cl,cl
	mov	ebp,[addressing_space]
	sub	eax,[ds:ebp]
	sbb	edx,[ds:ebp+4]
	sbb	cl,[ds:ebp+8]
	jp	label_value_ok
	call	recoverable_overflow
      label_value_ok:
	mov	[address_sign],cl
	test	byte [ds:ebp+0Ah],1
	jnz	make_virtual_label
	or	byte [ebx+9],1
	xchg	eax,[ebx]
	xchg	edx,[ebx+4]
	mov	ch,[ebx+9]
	shr	ch,1
	and	ch,1
	neg	ch
	sub	eax,[ebx]
	sbb	edx,[ebx+4]
	sbb	ch,cl
	mov	dword [adjustment],eax
	mov	dword [adjustment+4],edx
	mov	[adjustment_sign],ch
	or	al,ch
	or	eax,edx
	setnz	ah
	jmp	finish_label
      make_virtual_label:
	and	byte [ebx+9],not 1
	cmp	eax,[ebx]
	mov	[ebx],eax
	setne	ah
	cmp	edx,[ebx+4]
	mov	[ebx+4],edx
	setne	al
	or	ah,al
      finish_label:
	mov	ebp,[addressing_space]
	mov	ch,[ds:ebp+9]
	mov	cl,[label_size]
	mov	edx,[ds:ebp+14h]
	mov	ebp,[ds:ebp+10h]
      finish_label_symbol:
	mov	al,[address_sign]
	xor	al,[ebx+9]
	and	al,10b
	or	ah,al
	xor	[ebx+9],al
	cmp	cl,[ebx+10]
	mov	[ebx+10],cl
	setne	al
	or	ah,al
	cmp	ch,[ebx+11]
	mov	[ebx+11],ch
	setne	al
	or	ah,al
	cmp	ebp,[ebx+12]
	mov	[ebx+12],ebp
	setne	al
	or	ah,al
	or	ch,ch
	jz	label_symbol_ok
	cmp	edx,[ebx+20]
	mov	[ebx+20],edx
	setne	al
	or	ah,al
      label_symbol_ok:
	mov	cx,[current_pass]
	xchg	[ebx+16],cx
	mov	edx,[current_line]
	mov	[ebx+28],edx
	and	byte [ebx+8],not 2
	test	byte [ebx+8],1
	jz	new_label
	cmp	cx,[ebx+16]
	je	symbol_already_defined
	btr	dword [ebx+8],10
	jc	requalified_label
	inc	cx
	sub	cx,[ebx+16]
	setnz	al
	or	ah,al
	jz	label_made
	test	byte [ebx+8],8
	jz	label_made
	mov	cx,[current_pass]
	cmp	cx,[ebx+18]
	jne	label_made
      requalified_label:
	or	[next_pass_needed],-1
      label_made:
	ret
      new_label:
	or	byte [ebx+8],1
	ret
      define_constant:
	lods	dword [esi]
	inc	esi
	cmp	eax,0Fh
	jb	invalid_use_of_symbol
	je	reserved_word_used_as_symbol
	mov	edx,[eax+8]
	push	edx
	cmp	[current_pass],0
	je	get_constant_value
	test	dl,4
	jnz	get_constant_value
	mov	cx,[current_pass]
	cmp	cx,[eax+16]
	je	get_constant_value
	or	dl,4
	mov	[eax+8],dl
      get_constant_value:
	push	eax
	mov	al,byte [esi-1]
	push	eax
	or	[size_override],-1
	call	get_value
	pop	ebx
	mov	ch,bl
	pop	ebx
	pop	ecx
	test	cl,4
	jnz	constant_referencing_mode_ok
	and	byte [ebx+8],not 4
      constant_referencing_mode_ok:
	xor	cl,cl
	mov	ch,[value_type]
	cmp	ch,3
	je	invalid_use_of_symbol
      make_constant:
	and	byte [ebx+9],not 1
	cmp	eax,[ebx]
	mov	[ebx],eax
	setne	ah
	cmp	edx,[ebx+4]
	mov	[ebx+4],edx
	setne	al
	or	ah,al
	mov	al,[value_sign]
	xor	al,[ebx+9]
	and	al,10b
	or	ah,al
	xor	[ebx+9],al
	cmp	cl,[ebx+10]
	mov	[ebx+10],cl
	setne	al
	or	ah,al
	cmp	ch,[ebx+11]
	mov	[ebx+11],ch
	setne	al
	or	ah,al
	xor	edx,edx
	cmp	edx,[ebx+12]
	mov	[ebx+12],edx
	setne	al
	or	ah,al
	or	ch,ch
	jz	constant_symbol_ok
	mov	edx,[symbol_identifier]
	cmp	edx,[ebx+20]
	mov	[ebx+20],edx
	setne	al
	or	ah,al
      constant_symbol_ok:
	mov	cx,[current_pass]
	xchg	[ebx+16],cx
	mov	edx,[current_line]
	mov	[ebx+28],edx
	test	byte [ebx+8],1
	jz	new_constant
	cmp	cx,[ebx+16]
	jne	redeclare_constant
	test	byte [ebx+8],2
	jz	symbol_already_defined
	or	byte [ebx+8],4
	and	byte [ebx+9],not 4
	jmp	instruction_assembled
      redeclare_constant:
	btr	dword [ebx+8],10
	jc	requalified_constant
	inc	cx
	sub	cx,[ebx+16]
	setnz	al
	or	ah,al
	jz	instruction_assembled
	test	byte [ebx+8],4
	jnz	instruction_assembled
	test	byte [ebx+8],8
	jz	instruction_assembled
	mov	cx,[current_pass]
	cmp	cx,[ebx+18]
	jne	instruction_assembled
      requalified_constant:
	or	[next_pass_needed],-1
	jmp	instruction_assembled
      new_constant:
	or	byte [ebx+8],1+2
	jmp	instruction_assembled
      label_addressing_space:
	lods	dword [esi]
	cmp	eax,0Fh
	jb	invalid_use_of_symbol
	je	reserved_word_used_as_symbol
	mov	cx,[current_pass]
	test	byte [eax+8],1
	jz	make_addressing_space_label
	cmp	cx,[eax+16]
	je	symbol_already_defined
	test	byte [eax+9],4
	jnz	make_addressing_space_label
	or	[next_pass_needed],-1
      make_addressing_space_label:
	mov	dx,[eax+8]
	and	dx,not (2 or 100h)
	or	dx,1 or 4 or 400h
	mov	[eax+8],dx
	mov	[eax+16],cx
	mov	edx,[current_line]
	mov	[eax+28],edx
	mov	ebx,[addressing_space]
	mov	[eax],ebx
	or	byte [ebx+0Ah],2
	jmp	continue_line
      assemble_instruction:
;        mov     [operand_size],0
;        mov     [size_override],0
;        mov     [operand_prefix],0
;        mov     [opcode_prefix],0
	and	dword [operand_size],0
;        mov     [rex_prefix],0
;        mov     [vex_required],0
;        mov     [vex_register],0
;        mov     [immediate_size],0
	and	dword [rex_prefix],0
	call	instruction_handler
      instruction_handler:
	movzx	ebx,word [esi]
	mov	al,[esi+2]
	add	esi,3
	add	[esp],ebx
	ret
      instruction_assembled:
	mov	al,[esi]
	cmp	al,0Fh
	je	line_assembled
	or	al,al
	jnz	extra_characters_on_line
      line_assembled:
	clc
	ret
      source_end:
	dec	esi
	stc
	ret
 
org_directive:
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_qword_value
	mov	cl,[value_type]
	test	cl,1
	jnz	invalid_use_of_symbol
	push	eax
	mov	ebx,[addressing_space]
	mov	eax,edi
	sub	eax,[ebx+18h]
	mov	[ebx+1Ch],eax
	test	byte [ebx+0Ah],1
	jnz	in_virtual
	call	init_addressing_space
	jmp	org_space_ok
      in_virtual:
	call	close_virtual_addressing_space
	call	init_addressing_space
	or	byte [ebx+0Ah],1
      org_space_ok:
	pop	eax
	mov	[ebx+9],cl
	mov	cl,[value_sign]
	sub	[ebx],eax
	sbb	[ebx+4],edx
	sbb	byte [ebx+8],cl
	jp	org_value_ok
	call	recoverable_overflow
      org_value_ok:
	mov	edx,[symbol_identifier]
 
	mov	[ebx+14h],edx
	cmp	[output_format],1
	ja	instruction_assembled
	cmp	edi,[code_start]
	jne	instruction_assembled
	cmp	eax,100h
	jne	instruction_assembled
	bts	[format_flags],0
	jmp	instruction_assembled
label_directive:
	lods	byte [esi]
	cmp	al,2
	jne	invalid_argument
	lods	dword [esi]
	cmp	eax,0Fh
	jb	invalid_use_of_symbol
	je	reserved_word_used_as_symbol
	inc	esi
	mov	ebx,eax
	mov	[label_size],0
	lods	byte [esi]
	cmp	al,':'
	je	get_label_size
	dec	esi
	cmp	al,11h
	jne	label_size_ok
      get_label_size:
	lods	word [esi]
	cmp	al,11h
	jne	invalid_argument
	mov	[label_size],ah
      label_size_ok:
	cmp	byte [esi],80h
	je	get_free_label_value
	call	make_label
	jmp	instruction_assembled
      get_free_label_value:
	inc	esi
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	push	ebx ecx
 
	or	byte [ebx+8],4
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_address_value
	or	bh,bh
	setnz	ch
	xchg	ch,cl
	mov	bp,cx
	shl	ebp,16
	xchg	bl,bh
	mov	bp,bx
	pop	ecx ebx
	and	byte [ebx+8],not 4
	mov	ch,[value_type]
	test	ch,1
 
 
	jnz	invalid_use_of_symbol
 
 
      make_free_label:
	and	byte [ebx+9],not 1
	cmp	eax,[ebx]
	mov	[ebx],eax
	setne	ah
	cmp	edx,[ebx+4]
	mov	[ebx+4],edx
	setne	al
	or	ah,al
	mov	edx,[address_symbol]
	mov	cl,[label_size]
	call	finish_label_symbol
	jmp	instruction_assembled
load_directive:
	lods	byte [esi]
	cmp	al,2
	jne	invalid_argument
	lods	dword [esi]
	cmp	eax,0Fh
	jb	invalid_use_of_symbol
	je	reserved_word_used_as_symbol
	inc	esi
	push	eax
	mov	al,1
	cmp	byte [esi],11h
	jne	load_size_ok
	lods	byte [esi]
	lods	byte [esi]
      load_size_ok:
	cmp	al,8
	ja	invalid_value
	mov	[operand_size],al
	and	dword [value],0
	and	dword [value+4],0
	lods	byte [esi]
	cmp	al,82h
	jne	invalid_argument
	call	get_data_point
 
	jc	value_loaded
	push	esi edi
 
 
 
	mov	esi,ebx
 
 
 
 
 
 
 
 
	mov	edi,value
 
 
 
 
	rep	movs byte [edi],[esi]
 
 
 
	pop	edi esi
 
 
 
 
      value_loaded:
	mov	[value_sign],0
	mov	eax,dword [value]
	mov	edx,dword [value+4]
	pop	ebx
	xor	cx,cx
	jmp	make_constant
      get_data_point:
	mov	ebx,[addressing_space]
	mov	ecx,edi
	sub	ecx,[ebx+18h]
	mov	[ebx+1Ch],ecx
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],11h
	jne	get_data_address
	cmp	word [esi+1+4],'):'
	jne	get_data_address
	inc	esi
	lods	dword [esi]
	add	esi,2
	cmp	byte [esi],'('
	jne	invalid_argument
	inc	esi
	cmp	eax,0Fh
	jbe	reserved_word_used_as_symbol
	mov	edx,undefined_symbol
	test	byte [eax+8],1
	jz	addressing_space_unavailable
	mov	edx,symbol_out_of_scope
	mov	cx,[eax+16]
	cmp	cx,[current_pass]
	jne	addressing_space_unavailable
	test	byte [eax+9],4
	jz	invalid_use_of_symbol
	mov	ebx,eax
	mov	ax,[current_pass]
	mov	[ebx+18],ax
	or	byte [ebx+8],8
	cmp	[symbols_file],0
	je	get_addressing_space
	cmp	[next_pass_needed],0
	jne	get_addressing_space
	call	store_label_reference
      get_addressing_space:
	mov	ebx,[ebx]
      get_data_address:
	push	ebx
	cmp	byte [esi],'.'
	je	invalid_value
	or	[size_override],-1
	call	get_address_value
	pop	ebp
	call	calculate_relative_offset
	cmp	[next_pass_needed],0
	jne	data_address_type_ok
	cmp	[value_type],0
	jne	invalid_use_of_symbol
      data_address_type_ok:
	mov	ebx,edi
	xor	ecx,ecx
	add	ebx,eax
	adc	edx,ecx
	mov	eax,ebx
	sub	eax,[ds:ebp+18h]
	sbb	edx,ecx
	jnz	bad_data_address
	mov	cl,[operand_size]
	add	eax,ecx
	cmp	eax,[ds:ebp+1Ch]
	ja	bad_data_address
	clc
	ret
      addressing_space_unavailable:
	cmp	[error_line],0
	jne	get_data_address
	push	[current_line]
	pop	[error_line]
	mov	[error],edx
	mov	[error_info],eax
	jmp	get_data_address
      bad_data_address:
	call	recoverable_overflow
	stc
	ret
store_directive:
	cmp	byte [esi],11h
	je	sized_store
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	call	get_byte_value
	xor	edx,edx
	movzx	eax,al
	mov	[operand_size],1
	jmp	store_value_ok
      sized_store:
	or	[size_override],-1
	call	get_value
      store_value_ok:
	cmp	[value_type],0
	jne	invalid_use_of_symbol
	mov	dword [value],eax
	mov	dword [value+4],edx
	lods	byte [esi]
	cmp	al,80h
	jne	invalid_argument
	call	get_data_point
 
 
 
	jc	instruction_assembled
	push	esi edi
	mov	esi,value
 
 
 
 
 
 
 
 
 
 
 
 
	mov	edi,ebx
 
	rep	movs byte [edi],[esi]
 
	mov	eax,edi
	pop	edi esi
	cmp	ebx,[undefined_data_end]
	jae	instruction_assembled
	cmp	eax,[undefined_data_start]
	jbe	instruction_assembled
	mov	[undefined_data_start],eax
	jmp	instruction_assembled
 
 
 
 
 
display_directive:
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],0
	jne	display_byte
	inc	esi
	lods	dword [esi]
	mov	ecx,eax
	push	edi
	mov	edi,[tagged_blocks]
	sub	edi,8
	sub	edi,eax
	cmp	edi,[esp]
	jbe	out_of_memory
	mov	[tagged_blocks],edi
	rep	movs byte [edi],[esi]
	stos	dword [edi]
	xor	eax,eax
	stos	dword [edi]
	pop	edi
	inc	esi
	jmp	display_next
      display_byte:
	call	get_byte_value
	push	edi
	mov	edi,[tagged_blocks]
	sub	edi,8+1
	mov	[tagged_blocks],edi
	stos	byte [edi]
	mov	eax,1
	stos	dword [edi]
	dec	eax
	stos	dword [edi]
	pop	edi
      display_next:
	cmp	edi,[tagged_blocks]
	ja	out_of_memory
	lods	byte [esi]
	cmp	al,','
	je	display_directive
	dec	esi
	jmp	instruction_assembled
show_display_buffer:
	mov	eax,[tagged_blocks]
	or	eax,eax
	jz	display_done
	mov	esi,[labels_list]
	cmp	esi,eax
	je	display_done
      display_messages:
	sub	esi,8
	mov	eax,[esi+4]
	mov	ecx,[esi]
	sub	esi,ecx
	test	eax,eax
	jnz	skip_block
	push	esi
	call	display_block
	pop	esi
      skip_block:
	cmp	esi,[tagged_blocks]
	jne	display_messages
      display_done:
	ret
 
times_directive:
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_count_value
	cmp	eax,0
	je	zero_times
	cmp	byte [esi],':'
	jne	times_argument_ok
	inc	esi
      times_argument_ok:
	push	[counter]
	push	[counter_limit]
	mov	[counter_limit],eax
	mov	[counter],1
      times_loop:
	mov	eax,esp
	sub	eax,100h
	jc	stack_overflow
	cmp	eax,[stack_limit]
	jb	stack_overflow
	push	esi
	or	[prefixed_instruction],-1
	call	continue_line
	mov	eax,[counter_limit]
	cmp	[counter],eax
	je	times_done
	inc	[counter]
	pop	esi
	jmp	times_loop
      times_done:
	pop	eax
	pop	[counter_limit]
	pop	[counter]
	jmp	instruction_assembled
      zero_times:
	call	skip_symbol
	jnc	zero_times
	jmp	instruction_assembled
 
virtual_directive:
	lods	byte [esi]
	cmp	al,80h
	jne	virtual_at_current
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_address_value
	mov	ebp,[address_symbol]
	or	bh,bh
	setnz	ch
	jmp	set_virtual
      virtual_at_current:
	dec	esi
	mov	ebp,[addressing_space]
	mov	al,[ds:ebp+9]
	mov	[value_type],al
	mov	eax,edi
 
	xor	edx,edx
	xor	cl,cl
	sub	eax,[ds:ebp]
	sbb	edx,[ds:ebp+4]
	sbb	cl,[ds:ebp+8]
	mov	[address_sign],cl
	mov	bx,[ds:ebp+10h]
	mov	cx,[ds:ebp+10h+2]
	xchg	bh,bl
	xchg	ch,cl
	mov	ebp,[ds:ebp+14h]
      set_virtual:
	xchg	bl,bh
	xchg	cl,ch
	shl	ecx,16
	mov	cx,bx
	push	ecx eax
	call	allocate_structure_data
	mov	word [ebx],virtual_directive-instruction_handler
	mov	ecx,[addressing_space]
	mov	[ebx+12],ecx
	mov	[ebx+8],edi
	mov	ecx,[current_line]
	mov	[ebx+4],ecx
	mov	ebx,[addressing_space]
	mov	eax,edi
	sub	eax,[ebx+18h]
	mov	[ebx+1Ch],eax
	call	init_addressing_space
	or	byte [ebx+0Ah],1
	pop	eax
	mov	cl,[address_sign]
	not	eax
	not	edx
	not	cl
	add	eax,1
	adc	edx,0
	adc	cl,0
	add	eax,edi
	adc	edx,0
	adc	cl,0
	mov	[ebx],eax
 
 
 
	mov	[ebx+4],edx
	mov	[ebx+8],cl
 
 
 
 
 
 
 
 
	pop	dword [ebx+10h]
 
 
	mov	[ebx+14h],ebp
 
	mov	al,[value_type]
 
 
 
 
	test	al,1
	jnz	invalid_use_of_symbol
	mov	[ebx+9],al
	jmp	instruction_assembled
      allocate_structure_data:
	mov	ebx,[structures_buffer]
	sub	ebx,18h
	cmp	ebx,[free_additional_memory]
	jb	out_of_memory
	mov	[structures_buffer],ebx
	ret
      find_structure_data:
	mov	ebx,[structures_buffer]
      scan_structures:
	cmp	ebx,[additional_memory_end]
	je	no_such_structure
	cmp	ax,[ebx]
	je	structure_data_found
	add	ebx,18h
	jmp	scan_structures
      structure_data_found:
	ret
      no_such_structure:
	stc
	ret
      end_virtual:
	call	find_structure_data
	jc	unexpected_instruction
	push	ebx
 
 
	call	close_virtual_addressing_space
 
 
 
 
	pop	ebx
 
	mov	eax,[ebx+12]
 
 
 
 
 
	mov	[addressing_space],eax
 
 
	mov	edi,[ebx+8]
 
 
      remove_structure_data:
	push	esi edi
	mov	ecx,ebx
	sub	ecx,[structures_buffer]
	shr	ecx,2
	lea	esi,[ebx-4]
	lea	edi,[esi+18h]
	std
	rep	movs dword [edi],[esi]
	cld
	add	[structures_buffer],18h
	pop	edi esi
	ret
      close_virtual_addressing_space:
	mov	ebx,[addressing_space]
	mov	eax,edi
	sub	eax,[ebx+18h]
	mov	[ebx+1Ch],eax
	test	byte [ebx+0Ah],2
	jz	addressing_space_closed
	push	esi edi ecx edx
	mov	ecx,eax
	mov	eax,[tagged_blocks]
	mov	dword [eax-4],11h
	mov	dword [eax-8],ecx
	sub	eax,8
	sub	eax,ecx
	mov	[tagged_blocks],eax
	lea	edi,[eax+ecx-1]
	xchg	eax,[ebx+18h]
	lea	esi,[eax+ecx-1]
	mov	eax,edi
	sub	eax,esi
	std
	shr	ecx,1
	jnc	virtual_byte_ok
	movs	byte [edi],[esi]
      virtual_byte_ok:
	dec	esi
	dec	edi
	shr	ecx,1
	jnc	virtual_word_ok
	movs	word [edi],[esi]
      virtual_word_ok:
	sub	esi,2
	sub	edi,2
	rep	movs dword [edi],[esi]
	cld
	xor	edx,edx
	add	[ebx],eax
	adc	dword [ebx+4],edx
	adc	byte [ebx+8],dl
	pop	edx ecx edi esi
      addressing_space_closed:
	ret
repeat_directive:
	cmp	[prefixed_instruction],0
	jne	unexpected_instruction
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_count_value
	cmp	eax,0
	je	zero_repeat
	call	allocate_structure_data
	mov	word [ebx],repeat_directive-instruction_handler
	xchg	eax,[counter_limit]
	mov	[ebx+10h],eax
	mov	eax,1
	xchg	eax,[counter]
	mov	[ebx+14h],eax
	mov	[ebx+8],esi
	mov	eax,[current_line]
	mov	[ebx+4],eax
	jmp	instruction_assembled
      end_repeat:
	cmp	[prefixed_instruction],0
	jne	unexpected_instruction
	call	find_structure_data
	jc	unexpected_instruction
	mov	eax,[counter_limit]
	inc	[counter]
	cmp	[counter],eax
	jbe	continue_repeating
      stop_repeat:
	mov	eax,[ebx+10h]
	mov	[counter_limit],eax
	mov	eax,[ebx+14h]
	mov	[counter],eax
	call	remove_structure_data
	jmp	instruction_assembled
      continue_repeating:
	mov	esi,[ebx+8]
	jmp	instruction_assembled
      zero_repeat:
	mov	al,[esi]
	or	al,al
	jz	missing_end_directive
	cmp	al,0Fh
	jne	extra_characters_on_line
	call	find_end_repeat
	jmp	instruction_assembled
      find_end_repeat:
	call	find_structure_end
	cmp	ax,repeat_directive-instruction_handler
	jne	unexpected_instruction
	ret
while_directive:
	cmp	[prefixed_instruction],0
	jne	unexpected_instruction
	call	allocate_structure_data
	mov	word [ebx],while_directive-instruction_handler
	mov	eax,1
	xchg	eax,[counter]
	mov	[ebx+10h],eax
	mov	[ebx+8],esi
	mov	eax,[current_line]
	mov	[ebx+4],eax
      do_while:
	push	ebx
	call	calculate_logical_expression
	or	al,al
	jnz	while_true
	mov	al,[esi]
	or	al,al
	jz	missing_end_directive
	cmp	al,0Fh
	jne	extra_characters_on_line
      stop_while:
	call	find_end_while
	pop	ebx
	mov	eax,[ebx+10h]
	mov	[counter],eax
	call	remove_structure_data
	jmp	instruction_assembled
      while_true:
	pop	ebx
	jmp	instruction_assembled
      end_while:
	cmp	[prefixed_instruction],0
	jne	unexpected_instruction
	call	find_structure_data
	jc	unexpected_instruction
	mov	eax,[ebx+4]
	mov	[current_line],eax
	inc	[counter]
	jz	too_many_repeats
	mov	esi,[ebx+8]
	jmp	do_while
      find_end_while:
	call	find_structure_end
	cmp	ax,while_directive-instruction_handler
	jne	unexpected_instruction
	ret
if_directive:
	cmp	[prefixed_instruction],0
	jne	unexpected_instruction
	call	calculate_logical_expression
	mov	dl,al
	mov	al,[esi]
	or	al,al
	jz	missing_end_directive
	cmp	al,0Fh
	jne	extra_characters_on_line
	or	dl,dl
	jnz	if_true
	call	find_else
	jc	instruction_assembled
	mov	al,[esi]
	cmp	al,1
	jne	else_true
	cmp	word [esi+1],if_directive-instruction_handler
	jne	else_true
	add	esi,4
	jmp	if_directive
      if_true:
	xor	al,al
      make_if_structure:
	call	allocate_structure_data
	mov	word [ebx],if_directive-instruction_handler
	mov	byte [ebx+2],al
	mov	eax,[current_line]
	mov	[ebx+4],eax
	jmp	instruction_assembled
      else_true:
	or	al,al
	jz	missing_end_directive
	cmp	al,0Fh
	jne	extra_characters_on_line
	or	al,-1
	jmp	make_if_structure
      else_directive:
	cmp	[prefixed_instruction],0
	jne	unexpected_instruction
	mov	ax,if_directive-instruction_handler
	call	find_structure_data
	jc	unexpected_instruction
	cmp	byte [ebx+2],0
	jne	unexpected_instruction
      found_else:
	mov	al,[esi]
	cmp	al,1
	jne	skip_else
	cmp	word [esi+1],if_directive-instruction_handler
	jne	skip_else
	add	esi,4
	call	find_else
	jnc	found_else
	call	remove_structure_data
	jmp	instruction_assembled
      skip_else:
	or	al,al
	jz	missing_end_directive
	cmp	al,0Fh
	jne	extra_characters_on_line
	call	find_end_if
	call	remove_structure_data
	jmp	instruction_assembled
      end_if:
	cmp	[prefixed_instruction],0
	jne	unexpected_instruction
	call	find_structure_data
	jc	unexpected_instruction
	call	remove_structure_data
	jmp	instruction_assembled
      find_else:
	call	find_structure_end
	cmp	ax,else_directive-instruction_handler
	je	else_found
	cmp	ax,if_directive-instruction_handler
	jne	unexpected_instruction
	stc
	ret
      else_found:
	clc
	ret
      find_end_if:
	call	find_structure_end
	cmp	ax,if_directive-instruction_handler
	jne	unexpected_instruction
	ret
      find_structure_end:
	push	[error_line]
	mov	eax,[current_line]
	mov	[error_line],eax
      find_end_directive:
	call	skip_symbol
	jnc	find_end_directive
	lods	byte [esi]
	cmp	al,0Fh
	jne	no_end_directive
	lods	dword [esi]
	mov	[current_line],eax
      skip_labels:
	cmp	byte [esi],2
	jne	labels_ok
	add	esi,6
	jmp	skip_labels
      labels_ok:
	cmp	byte [esi],1
	jne	find_end_directive
	mov	ax,[esi+1]
	cmp	ax,prefix_instruction-instruction_handler
	je	find_end_directive
	add	esi,4
	cmp	ax,repeat_directive-instruction_handler
	je	skip_repeat
	cmp	ax,while_directive-instruction_handler
	je	skip_while
	cmp	ax,if_directive-instruction_handler
	je	skip_if
	cmp	ax,else_directive-instruction_handler
	je	structure_end
	cmp	ax,end_directive-instruction_handler
	jne	find_end_directive
	cmp	byte [esi],1
	jne	find_end_directive
	mov	ax,[esi+1]
	add	esi,4
	cmp	ax,repeat_directive-instruction_handler
	je	structure_end
	cmp	ax,while_directive-instruction_handler
	je	structure_end
	cmp	ax,if_directive-instruction_handler
	jne	find_end_directive
      structure_end:
	pop	[error_line]
	ret
      no_end_directive:
	mov	eax,[error_line]
	mov	[current_line],eax
	jmp	missing_end_directive
      skip_repeat:
	call	find_end_repeat
	jmp	find_end_directive
      skip_while:
	call	find_end_while
	jmp	find_end_directive
      skip_if:
	call	skip_if_block
	jmp	find_end_directive
      skip_if_block:
	call	find_else
	jc	if_block_skipped
	cmp	byte [esi],1
	jne	skip_after_else
	cmp	word [esi+1],if_directive-instruction_handler
	jne	skip_after_else
	add	esi,4
	jmp	skip_if_block
      skip_after_else:
	call	find_end_if
      if_block_skipped:
	ret
end_directive:
	lods	byte [esi]
	cmp	al,1
	jne	invalid_argument
	lods	word [esi]
	inc	esi
	cmp	ax,virtual_directive-instruction_handler
	je	end_virtual
	cmp	ax,repeat_directive-instruction_handler
	je	end_repeat
	cmp	ax,while_directive-instruction_handler
	je	end_while
	cmp	ax,if_directive-instruction_handler
	je	end_if
	cmp	ax,data_directive-instruction_handler
	je	end_data
	jmp	invalid_argument
break_directive:
	mov	ebx,[structures_buffer]
	mov	al,[esi]
	or	al,al
	jz	find_breakable_structure
	cmp	al,0Fh
	jne	extra_characters_on_line
      find_breakable_structure:
	cmp	ebx,[additional_memory_end]
	je	unexpected_instruction
	mov	ax,[ebx]
	cmp	ax,repeat_directive-instruction_handler
	je	break_repeat
	cmp	ax,while_directive-instruction_handler
	je	break_while
	cmp	ax,if_directive-instruction_handler
	je	break_if
	add	ebx,18h
	jmp	find_breakable_structure
      break_if:
	push	[current_line]
	mov	eax,[ebx+4]
	mov	[current_line],eax
	call	remove_structure_data
	call	skip_if_block
	pop	[current_line]
	mov	ebx,[structures_buffer]
	jmp	find_breakable_structure
      break_repeat:
	push	ebx
	call	find_end_repeat
	pop	ebx
	jmp	stop_repeat
      break_while:
	push	ebx
	jmp	stop_while
 
data_bytes:
	call	define_data
	lods	byte [esi]
	cmp	al,'('
	je	get_byte
	cmp	al,'?'
	jne	invalid_argument
	mov	eax,edi
	mov	byte [edi],0
	inc	edi
	jmp	undefined_data
      get_byte:
	cmp	byte [esi],0
	je	get_string
	call	get_byte_value
	stos	byte [edi]
	ret
      get_string:
	inc	esi
	lods	dword [esi]
	mov	ecx,eax
	lea	eax,[edi+ecx]
	cmp	eax,[tagged_blocks]
	ja	out_of_memory
	rep	movs byte [edi],[esi]
	inc	esi
	ret
      undefined_data:
	mov	ebp,[addressing_space]
	test	byte [ds:ebp+0Ah],1
	jz	mark_undefined_data
	ret
      mark_undefined_data:
	cmp	eax,[undefined_data_end]
	je	undefined_data_ok
	mov	[undefined_data_start],eax
      undefined_data_ok:
	mov	[undefined_data_end],edi
	ret
      define_data:
	cmp	edi,[tagged_blocks]
	jae	out_of_memory
	cmp	byte [esi],'('
	jne	simple_data_value
	mov	ebx,esi
	inc	esi
	call	skip_expression
	xchg	esi,ebx
	cmp	byte [ebx],81h
	jne	simple_data_value
	inc	esi
	call	get_count_value
	inc	esi
	or	eax,eax
	jz	duplicate_zero_times
	cmp	byte [esi],'{'
	jne	duplicate_single_data_value
	inc	esi
      duplicate_data:
	push	eax esi
      duplicated_values:
	cmp	edi,[tagged_blocks]
	jae	out_of_memory
	call	near dword [esp+8]
	lods	byte [esi]
	cmp	al,','
	je	duplicated_values
	cmp	al,'}'
	jne	invalid_argument
	pop	ebx eax
	dec	eax
	jz	data_defined
	mov	esi,ebx
	jmp	duplicate_data
      duplicate_single_data_value:
	cmp	edi,[tagged_blocks]
	jae	out_of_memory
	push	eax esi
	call	near dword [esp+8]
	pop	ebx eax
	dec	eax
	jz	data_defined
	mov	esi,ebx
	jmp	duplicate_single_data_value
      duplicate_zero_times:
	cmp	byte [esi],'{'
	jne	skip_single_data_value
	inc	esi
      skip_data_value:
	call	skip_symbol
	jc	invalid_argument
	cmp	byte [esi],'}'
	jne	skip_data_value
	inc	esi
	jmp	data_defined
      skip_single_data_value:
	call	skip_symbol
	jmp	data_defined
      simple_data_value:
	cmp	edi,[tagged_blocks]
	jae	out_of_memory
	call	near dword [esp]
      data_defined:
	lods	byte [esi]
	cmp	al,','
	je	define_data
	dec	esi
	add	esp,4
	jmp	instruction_assembled
data_unicode:
	or	[base_code],-1
	jmp	define_words
data_words:
	mov	[base_code],0
      define_words:
	call	define_data
	lods	byte [esi]
	cmp	al,'('
	je	get_word
	cmp	al,'?'
	jne	invalid_argument
	mov	eax,edi
	and	word [edi],0
	scas	word [edi]
	jmp	undefined_data
	ret
      get_word:
	cmp	[base_code],0
	je	word_data_value
	cmp	byte [esi],0
	je	word_string
      word_data_value:
	call	get_word_value
	call	mark_relocation
	stos	word [edi]
	ret
      word_string:
	inc	esi
	lods	dword [esi]
	mov	ecx,eax
	jecxz	word_string_ok
	lea	eax,[edi+ecx*2]
	cmp	eax,[tagged_blocks]
	ja	out_of_memory
	xor	ah,ah
      copy_word_string:
	lods	byte [esi]
	stos	word [edi]
	loop	copy_word_string
      word_string_ok:
	inc	esi
	ret
data_dwords:
	call	define_data
	lods	byte [esi]
	cmp	al,'('
	je	get_dword
	cmp	al,'?'
	jne	invalid_argument
	mov	eax,edi
	and	dword [edi],0
	scas	dword [edi]
	jmp	undefined_data
      get_dword:
	push	esi
	call	get_dword_value
	pop	ebx
	cmp	byte [esi],':'
	je	complex_dword
	call	mark_relocation
	stos	dword [edi]
	ret
      complex_dword:
	mov	esi,ebx
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_word_value
	push	eax
	inc	esi
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_operand
	mov	al,[value_type]
	push	eax
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_word_value
	call	mark_relocation
	stos	word [edi]
	pop	eax
	mov	[value_type],al
	pop	eax
	call	mark_relocation
	stos	word [edi]
	ret
data_pwords:
	call	define_data
	lods	byte [esi]
	cmp	al,'('
	je	get_pword
	cmp	al,'?'
	jne	invalid_argument
	mov	eax,edi
	and	dword [edi],0
	scas	dword [edi]
	and	word [edi],0
	scas	word [edi]
	jmp	undefined_data
      get_pword:
	push	esi
	call	get_pword_value
	pop	ebx
	cmp	byte [esi],':'
	je	complex_pword
	call	mark_relocation
	stos	dword [edi]
	mov	ax,dx
	stos	word [edi]
	ret
      complex_pword:
	mov	esi,ebx
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_word_value
	push	eax
	inc	esi
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_operand
	mov	al,[value_type]
	push	eax
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_dword_value
	call	mark_relocation
	stos	dword [edi]
	pop	eax
	mov	[value_type],al
	pop	eax
	call	mark_relocation
	stos	word [edi]
	ret
data_qwords:
	call	define_data
	lods	byte [esi]
	cmp	al,'('
	je	get_qword
	cmp	al,'?'
	jne	invalid_argument
	mov	eax,edi
	and	dword [edi],0
	scas	dword [edi]
	and	dword [edi],0
	scas	dword [edi]
	jmp	undefined_data
      get_qword:
	call	get_qword_value
	call	mark_relocation
	stos	dword [edi]
	mov	eax,edx
	stos	dword [edi]
	ret
data_twords:
	call	define_data
	lods	byte [esi]
	cmp	al,'('
	je	get_tword
	cmp	al,'?'
	jne	invalid_argument
	mov	eax,edi
	and	dword [edi],0
	scas	dword [edi]
	and	dword [edi],0
	scas	dword [edi]
	and	word [edi],0
	scas	word [edi]
	jmp	undefined_data
      get_tword:
	cmp	byte [esi],'.'
	jne	complex_tword
	inc	esi
	cmp	word [esi+8],8000h
	je	fp_zero_tword
	mov	eax,[esi]
	stos	dword [edi]
	mov	eax,[esi+4]
	stos	dword [edi]
	mov	ax,[esi+8]
	add	ax,3FFFh
	jo	value_out_of_range
	cmp	ax,7FFFh
	jge	value_out_of_range
	cmp	ax,0
	jg	tword_exp_ok
	mov	cx,ax
	neg	cx
	inc	cx
	cmp	cx,64
	jae	value_out_of_range
	cmp	cx,32
	ja	large_shift
	mov	eax,[esi]
	mov	edx,[esi+4]
	mov	ebx,edx
	shr	edx,cl
	shrd	eax,ebx,cl
	jmp	tword_mantissa_shift_done
      large_shift:
	sub	cx,32
	xor	edx,edx
	mov	eax,[esi+4]
	shr	eax,cl
      tword_mantissa_shift_done:
	jnc	store_shifted_mantissa
	add	eax,1
	adc	edx,0
      store_shifted_mantissa:
	mov	[edi-8],eax
	mov	[edi-4],edx
	xor	ax,ax
	test	edx,1 shl 31
	jz	tword_exp_ok
	inc	ax
      tword_exp_ok:
	mov	bl,[esi+11]
	shl	bx,15
	or	ax,bx
	stos	word [edi]
	add	esi,13
	ret
      fp_zero_tword:
	xor	eax,eax
	stos	dword [edi]
	stos	dword [edi]
	mov	al,[esi+11]
	shl	ax,15
	stos	word [edi]
	add	esi,13
	ret
      complex_tword:
	call	get_word_value
	push	eax
	cmp	byte [esi],':'
	jne	invalid_operand
	inc	esi
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_operand
	mov	al,[value_type]
	push	eax
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_qword_value
	call	mark_relocation
	stos	dword [edi]
	mov	eax,edx
	stos	dword [edi]
	pop	eax
	mov	[value_type],al
	pop	eax
	call	mark_relocation
	stos	word [edi]
	ret
data_file:
	lods	word [esi]
	cmp	ax,'('
	jne	invalid_argument
	add	esi,4
	call	open_binary_file
	mov	eax,[esi-4]
	lea	esi,[esi+eax+1]
	mov	al,2
	xor	edx,edx
	call	lseek
	push	eax
	xor	edx,edx
	cmp	byte [esi],':'
	jne	position_ok
	inc	esi
	cmp	byte [esi],'('
	jne	invalid_argument
	inc	esi
	cmp	byte [esi],'.'
	je	invalid_value
	push	ebx
	call	get_count_value
	pop	ebx
	mov	edx,eax
	sub	[esp],edx
	jc	value_out_of_range
      position_ok:
	cmp	byte [esi],','
	jne	size_ok
	inc	esi
	cmp	byte [esi],'('
	jne	invalid_argument
	inc	esi
	cmp	byte [esi],'.'
	je	invalid_value
	push	ebx edx
	call	get_count_value
	pop	edx ebx
	cmp	eax,[esp]
	ja	value_out_of_range
	mov	[esp],eax
      size_ok:
	xor	al,al
	call	lseek
	pop	ecx
	mov	edx,edi
	add	edi,ecx
	jc	out_of_memory
	cmp	edi,[tagged_blocks]
	ja	out_of_memory
	call	read
	jc	error_reading_file
	call	close
	lods	byte [esi]
	cmp	al,','
	je	data_file
	dec	esi
	jmp	instruction_assembled
      open_binary_file:
	push	esi
	push	edi
	mov	eax,[current_line]
      find_current_source_path: 
	mov	esi,[eax] 
	test	byte [eax+7],80h 
	jz	get_current_path 
	mov	eax,[eax+8]
	jmp	find_current_source_path
      get_current_path:
	lodsb
	stosb
	or	al,al
	jnz	get_current_path
      cut_current_path:
	cmp	edi,[esp]
	je	current_path_ok
	cmp	byte [edi-1],'\'
	je	current_path_ok
	cmp	byte [edi-1],'/'
	je	current_path_ok
	dec	edi
	jmp	cut_current_path
      current_path_ok:
	mov	esi,[esp+4]
	call	expand_path
	pop	edx
	mov	esi,edx
	call	open
	jnc	file_opened
	mov	edx,[include_paths]
      search_in_include_paths:
	push	edx esi
	mov	edi,esi
	mov	esi,[esp+4]
	call	get_include_directory
	mov	[esp+4],esi
	mov	esi,[esp+8]
	call	expand_path
	pop	edx
	mov	esi,edx
	call	open
	pop	edx
	jnc	file_opened
	cmp	byte [edx],0
	jne	search_in_include_paths
	mov	edi,esi
	mov	esi,[esp]
	push	edi
	call	expand_path
	pop	edx
	mov	esi,edx
	call	open
	jc	file_not_found
      file_opened:
	mov	edi,esi
	pop	esi
	ret
reserve_bytes:
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_count_value
	mov	ecx,eax
	mov	edx,ecx
	add	edx,edi
	jc	out_of_memory
	cmp	edx,[tagged_blocks]
	ja	out_of_memory
	push	edi
	cmp	[next_pass_needed],0
	je	zero_bytes
	add	edi,ecx
	jmp	reserved_data
      zero_bytes:
	xor	eax,eax
	shr	ecx,1
	jnc	bytes_stosb_ok
	stos	byte [edi]
      bytes_stosb_ok:
	shr	ecx,1
	jnc	bytes_stosw_ok
	stos	word [edi]
      bytes_stosw_ok:
	rep	stos dword [edi]
      reserved_data:
	pop	eax
	call	undefined_data
	jmp	instruction_assembled
reserve_words:
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_count_value
	mov	ecx,eax
	mov	edx,ecx
	shl	edx,1
	jc	out_of_memory
	add	edx,edi
	jc	out_of_memory
	cmp	edx,[tagged_blocks]
	ja	out_of_memory
	push	edi
	cmp	[next_pass_needed],0
	je	zero_words
	lea	edi,[edi+ecx*2]
	jmp	reserved_data
      zero_words:
	xor	eax,eax
	shr	ecx,1
	jnc	words_stosw_ok
	stos	word [edi]
      words_stosw_ok:
	rep	stos dword [edi]
	jmp	reserved_data
reserve_dwords:
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_count_value
	mov	ecx,eax
	mov	edx,ecx
	shl	edx,1
	jc	out_of_memory
	shl	edx,1
	jc	out_of_memory
	add	edx,edi
	jc	out_of_memory
	cmp	edx,[tagged_blocks]
	ja	out_of_memory
	push	edi
	cmp	[next_pass_needed],0
	je	zero_dwords
	lea	edi,[edi+ecx*4]
	jmp	reserved_data
      zero_dwords:
	xor	eax,eax
	rep	stos dword [edi]
	jmp	reserved_data
reserve_pwords:
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_count_value
	mov	ecx,eax
	shl	ecx,1
	jc	out_of_memory
	add	ecx,eax
	mov	edx,ecx
	shl	edx,1
	jc	out_of_memory
	add	edx,edi
	jc	out_of_memory
	cmp	edx,[tagged_blocks]
	ja	out_of_memory
	push	edi
	cmp	[next_pass_needed],0
	je	zero_words
	lea	edi,[edi+ecx*2]
	jmp	reserved_data
reserve_qwords:
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_count_value
	mov	ecx,eax
	shl	ecx,1
	jc	out_of_memory
	mov	edx,ecx
	shl	edx,1
	jc	out_of_memory
	shl	edx,1
	jc	out_of_memory
	add	edx,edi
	jc	out_of_memory
	cmp	edx,[tagged_blocks]
	ja	out_of_memory
	push	edi
	cmp	[next_pass_needed],0
	je	zero_dwords
	lea	edi,[edi+ecx*4]
	jmp	reserved_data
reserve_twords:
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_count_value
	mov	ecx,eax
	shl	ecx,2
	jc	out_of_memory
	add	ecx,eax
	mov	edx,ecx
	shl	edx,1
	jc	out_of_memory
	add	edx,edi
	jc	out_of_memory
	cmp	edx,[tagged_blocks]
	ja	out_of_memory
	push	edi
	cmp	[next_pass_needed],0
	je	zero_words
	lea	edi,[edi+ecx*2]
	jmp	reserved_data
align_directive:
	lods	byte [esi]
	cmp	al,'('
	jne	invalid_argument
	cmp	byte [esi],'.'
	je	invalid_value
	call	get_count_value
	mov	edx,eax
	dec	edx
	test	eax,edx
	jnz	invalid_align_value
	or	eax,eax
	jz	invalid_align_value
	cmp	eax,1
	je	instruction_assembled
	mov	ecx,edi
	mov	ebp,[addressing_space]
	sub	ecx,[ds:ebp]
	cmp	dword [ds:ebp+10h],0
	jne	section_not_aligned_enough
	cmp	byte [ds:ebp+9],0
	je	make_alignment
	cmp	[output_format],3
	je	pe_alignment
	mov	ebx,[ds:ebp+14h]
	cmp	byte [ebx],0
	jne	section_not_aligned_enough
	cmp	eax,[ebx+10h]
	jbe	make_alignment
	jmp	section_not_aligned_enough
      pe_alignment:
	cmp	eax,1000h
	ja	section_not_aligned_enough
      make_alignment:
	dec	eax
	and	ecx,eax
	jz	instruction_assembled
	neg	ecx
	add	ecx,eax
	inc	ecx
	mov	edx,ecx
	add	edx,edi
	jc	out_of_memory
	cmp	edx,[tagged_blocks]
	ja	out_of_memory
	push	edi
	cmp	[next_pass_needed],0
	je	nops
	add	edi,ecx
	jmp	reserved_data
      invalid_align_value:
	cmp	[error_line],0
	jne	instruction_assembled
	mov	eax,[current_line]
	mov	[error_line],eax
	mov	[error],invalid_value
	jmp	instruction_assembled
      nops:
	mov	eax,90909090h
	shr	ecx,1
	jnc	nops_stosb_ok
	stos	byte [edi]
      nops_stosb_ok:
	shr	ecx,1
	jnc	nops_stosw_ok
	stos	word [edi]
      nops_stosw_ok:
	rep	stos dword [edi]
	jmp	reserved_data
err_directive:
	mov	al,[esi]
	cmp	al,0Fh
	je	invoked_error
	or	al,al
	jz	invoked_error
	jmp	extra_characters_on_line
assert_directive:
	call	calculate_logical_expression
	or	al,al
	jnz	instruction_assembled
	cmp	[error_line],0
	jne	instruction_assembled
	mov	eax,[current_line]
	mov	[error_line],eax
	mov	[error],assertion_failed
	jmp	instruction_assembled

Rev 2665	Rev 4039
1	; flat assembler core	1	; flat assembler core
2	; Copyright (c) 1999-2012, Tomasz Grysztar.	2	; Copyright (c) 1999-2013, Tomasz Grysztar.
3	; All rights reserved.	3	; All rights reserved.
4		4
5	assembler:	5	assembler:
6	xor eax,eax	6	xor eax,eax
7	mov [stub_size],eax	7	mov [stub_size],eax
8	mov [current_pass],ax	8	mov [current_pass],ax
9	mov [resolver_flags],eax	9	mov [resolver_flags],eax
10	mov [number_of_sections],eax	10	mov [number_of_sections],eax
11	mov [actual_fixups_size],eax	11	mov [actual_fixups_size],eax
12	assembler_loop:	12	assembler_loop:
13	mov eax,[labels_list]	13	mov eax,[labels_list]
14	mov [display_buffer],eax	14	mov [tagged_blocks],eax
15	mov eax,[additional_memory]	15	mov eax,[additional_memory]
16	mov [free_additional_memory],eax	16	mov [free_additional_memory],eax
17	mov eax,[additional_memory_end]	17	mov eax,[additional_memory_end]
18	mov [structures_buffer],eax	18	mov [structures_buffer],eax
19	mov esi,[source_start]	19	mov esi,[source_start]
20	mov edi,[code_start]	20	mov edi,[code_start]
21	xor eax,eax	21	xor eax,eax
22	mov dword [adjustment],eax	22	mov dword [adjustment],eax
23	mov dword [adjustment+4],eax	23	mov dword [adjustment+4],eax
24	mov dword [org_origin],edi	24	mov [addressing_space],eax
25	mov dword [org_origin+4],eax	-
26	mov [org_start],edi	-
27	mov [org_registers],eax	-
28	mov [org_symbol],eax	25	mov [error_line],eax
29	mov [error_line],eax	-
30	mov [counter],eax	26	mov [counter],eax
31	mov [format_flags],eax	27	mov [format_flags],eax
32	mov [number_of_relocations],eax	28	mov [number_of_relocations],eax
33	mov [undefined_data_end],eax	29	mov [undefined_data_end],eax
34	mov [file_extension],eax	30	mov [file_extension],eax
35	mov [next_pass_needed],al	31	mov [next_pass_needed],al
36	mov [output_format],al	32	mov [output_format],al
37	mov [org_origin_sign],al	33	mov [adjustment_sign],al
38	mov [adjustment_sign],al	-
39	mov [labels_type],al	34	mov [code_type],16
40	mov [virtual_data],al	-
41	mov [code_type],16	-
42	pass_loop:	35	call init_addressing_space
-		36	pass_loop:
43	call assemble_line	37	call assemble_line
44	jnc pass_loop	38	jnc pass_loop
45	mov eax,[additional_memory_end]	39	mov eax,[additional_memory_end]
46	cmp eax,[structures_buffer]	40	cmp eax,[structures_buffer]
47	je pass_done	41	je pass_done
48	sub eax,20h	42	sub eax,18h
49	mov eax,[eax+4]	43	mov eax,[eax+4]
50	mov [current_line],eax	44	mov [current_line],eax
51	jmp missing_end_directive	45	jmp missing_end_directive
52	pass_done:	46	pass_done:
53	call close_pass	47	call close_pass
54	mov eax,[labels_list]	48	mov eax,[labels_list]
55	check_symbols:	49	check_symbols:
56	cmp eax,[memory_end]	50	cmp eax,[memory_end]
57	jae symbols_checked	51	jae symbols_checked
58	test byte [eax+8],8	52	test byte [eax+8],8
59	jz symbol_defined_ok	53	jz symbol_defined_ok
60	mov cx,[current_pass]	54	mov cx,[current_pass]
61	cmp cx,[eax+18]	55	cmp cx,[eax+18]
62	jne symbol_defined_ok	56	jne symbol_defined_ok
63	test byte [eax+8],1	57	test byte [eax+8],1
64	jz symbol_defined_ok	58	jz symbol_defined_ok
65	sub cx,[eax+16]	59	sub cx,[eax+16]
66	cmp cx,1	60	cmp cx,1
67	jne symbol_defined_ok	61	jne symbol_defined_ok
68	and byte [eax+8],not 1	62	and byte [eax+8],not 1
69	or [next_pass_needed],-1	63	or [next_pass_needed],-1
70	symbol_defined_ok:	64	symbol_defined_ok:
71	test byte [eax+8],10h	65	test byte [eax+8],10h
72	jz use_prediction_ok	66	jz use_prediction_ok
73	mov cx,[current_pass]	67	mov cx,[current_pass]
74	and byte [eax+8],not 10h	68	and byte [eax+8],not 10h
75	test byte [eax+8],20h	69	test byte [eax+8],20h
76	jnz check_use_prediction	70	jnz check_use_prediction
77	cmp cx,[eax+18]	71	cmp cx,[eax+18]
78	jne use_prediction_ok	72	jne use_prediction_ok
79	test byte [eax+8],8	73	test byte [eax+8],8
80	jz use_prediction_ok	74	jz use_prediction_ok
81	jmp use_misprediction	75	jmp use_misprediction
82	check_use_prediction:	76	check_use_prediction:
83	test byte [eax+8],8	77	test byte [eax+8],8
84	jz use_misprediction	78	jz use_misprediction
85	cmp cx,[eax+18]	79	cmp cx,[eax+18]
86	je use_prediction_ok	80	je use_prediction_ok
87	use_misprediction:	81	use_misprediction:
88	or [next_pass_needed],-1	82	or [next_pass_needed],-1
89	use_prediction_ok:	83	use_prediction_ok:
90	test byte [eax+8],40h	84	test byte [eax+8],40h
91	jz check_next_symbol	85	jz check_next_symbol
92	and byte [eax+8],not 40h	86	and byte [eax+8],not 40h
93	test byte [eax+8],4	87	test byte [eax+8],4
94	jnz define_misprediction	88	jnz define_misprediction
95	mov cx,[current_pass]	89	mov cx,[current_pass]
96	test byte [eax+8],80h	90	test byte [eax+8],80h
97	jnz check_define_prediction	91	jnz check_define_prediction
98	cmp cx,[eax+16]	92	cmp cx,[eax+16]
99	jne check_next_symbol	93	jne check_next_symbol
100	test byte [eax+8],1	94	test byte [eax+8],1
101	jz check_next_symbol	95	jz check_next_symbol
102	jmp define_misprediction	96	jmp define_misprediction
103	check_define_prediction:	97	check_define_prediction:
104	test byte [eax+8],1	98	test byte [eax+8],1
105	jz define_misprediction	99	jz define_misprediction
106	cmp cx,[eax+16]	100	cmp cx,[eax+16]
107	je check_next_symbol	101	je check_next_symbol
108	define_misprediction:	102	define_misprediction:
109	or [next_pass_needed],-1	103	or [next_pass_needed],-1
110	check_next_symbol:	104	check_next_symbol:
111	add eax,LABEL_STRUCTURE_SIZE	105	add eax,LABEL_STRUCTURE_SIZE
112	jmp check_symbols	106	jmp check_symbols
113	symbols_checked:	107	symbols_checked:
114	cmp [next_pass_needed],0	108	cmp [next_pass_needed],0
115	jne next_pass	109	jne next_pass
116	mov eax,[error_line]	110	mov eax,[error_line]
117	or eax,eax	111	or eax,eax
118	jz assemble_ok	112	jz assemble_ok
119	mov [current_line],eax	113	mov [current_line],eax
120	cmp [error],undefined_symbol	114	cmp [error],undefined_symbol
121	jne error_confirmed	115	jne error_confirmed
122	mov eax,[error_info]	116	mov eax,[error_info]
123	or eax,eax	117	or eax,eax
124	jz error_confirmed	118	jz error_confirmed
125	test byte [eax+8],1	119	test byte [eax+8],1
126	jnz next_pass	120	jnz next_pass
127	error_confirmed:	121	error_confirmed:
128	call error_handler	122	call error_handler
129	error_handler:	123	error_handler:
130	mov eax,[error]	124	mov eax,[error]
131	sub eax,error_handler	125	sub eax,error_handler
132	add [esp],eax	126	add [esp],eax
133	ret	127	ret
134	next_pass:	128	next_pass:
135	inc [current_pass]	129	inc [current_pass]
136	mov ax,[current_pass]	130	mov ax,[current_pass]
137	cmp ax,[passes_limit]	131	cmp ax,[passes_limit]
138	je code_cannot_be_generated	132	je code_cannot_be_generated
139	jmp assembler_loop	133	jmp assembler_loop
140	assemble_ok:	134	assemble_ok:
141	ret	135	ret
142		136
-		137	create_addressing_space:
-		138	mov ebx,[addressing_space]
-		139	test ebx,ebx
-		140	jz init_addressing_space
-		141	test byte [ebx+0Ah],1
-		142	jnz illegal_instruction
-		143	mov eax,edi
-		144	sub eax,[ebx+18h]
-		145	mov [ebx+1Ch],eax
-		146	init_addressing_space:
-		147	mov ebx,[tagged_blocks]
-		148	mov dword [ebx-4],10h
-		149	mov dword [ebx-8],20h
-		150	sub ebx,8+20h
-		151	cmp ebx,edi
-		152	jbe out_of_memory
-		153	mov [tagged_blocks],ebx
-		154	mov [addressing_space],ebx
-		155	xor eax,eax
-		156	mov [ebx],edi
-		157	mov [ebx+4],eax
-		158	mov [ebx+8],eax
-		159	mov [ebx+10h],eax
-		160	mov [ebx+14h],eax
-		161	mov [ebx+18h],edi
-		162	mov [ebx+1Ch],eax
-		163	ret
-		164
143	assemble_line:	165	assemble_line:
144	mov eax,[display_buffer]	166	mov eax,[tagged_blocks]
145	sub eax,100h	167	sub eax,100h
146	cmp edi,eax	168	cmp edi,eax
147	ja out_of_memory	169	ja out_of_memory
148	lods byte [esi]	170	lods byte [esi]
149	cmp al,1	171	cmp al,1
150	je assemble_instruction	172	je assemble_instruction
151	jb source_end	173	jb source_end
152	cmp al,3	174	cmp al,3
153	jb define_label	175	jb define_label
154	je define_constant	176	je define_constant
155	cmp al,0Fh	177	cmp al,4
-		178	je label_addressing_space
-		179	cmp al,0Fh
156	je new_line	180	je new_line
157	cmp al,13h	181	cmp al,13h
158	je code_type_setting	182	je code_type_setting
159	cmp al,10h	183	cmp al,10h
160	jne illegal_instruction	184	jne illegal_instruction
161	lods byte [esi]	185	lods byte [esi]
162	jmp segment_prefix	186	jmp segment_prefix
163	code_type_setting:	187	code_type_setting:
164	lods byte [esi]	188	lods byte [esi]
165	mov [code_type],al	189	mov [code_type],al
166	jmp line_assembled	190	jmp instruction_assembled
167	new_line:	191	new_line:
168	lods dword [esi]	192	lods dword [esi]
169	mov [current_line],eax	193	mov [current_line],eax
170	mov [prefixed_instruction],0	194	mov [prefixed_instruction],0
171	cmp [symbols_file],0	195	cmp [symbols_file],0
172	je continue_line	196	je continue_line
173	cmp [next_pass_needed],0	197	cmp [next_pass_needed],0
174	jne continue_line	198	jne continue_line
175	mov ebx,[display_buffer]	199	mov ebx,[tagged_blocks]
176	mov dword [ebx-4],1	200	mov dword [ebx-4],1
177	mov dword [ebx-8],1Ch	201	mov dword [ebx-8],14h
178	sub ebx,8+1Ch	202	sub ebx,8+14h
179	cmp ebx,edi	203	cmp ebx,edi
180	jbe out_of_memory	204	jbe out_of_memory
181	mov [display_buffer],ebx	205	mov [tagged_blocks],ebx
182	mov [ebx],eax	206	mov [ebx],eax
183	mov [ebx+4],edi	207	mov [ebx+4],edi
184	mov eax,dword [org_origin]	208	mov eax,[addressing_space]
185	mov edx,dword [org_origin+4]	-
186	mov ecx,[org_registers]	-
187	mov [ebx+8],eax	209	mov [ebx+8],eax
188	mov [ebx+8+4],edx	210	mov al,[code_type]
189	mov [ebx+10h],ecx	-
190	mov edx,[org_symbol]	-
191	; mov al,[virtual_data]	-
192	; mov ah,[org_origin_sign]	-
193	; shl eax,16	-
194	; mov al,[labels_type]	-
195	; mov ah,[code_type]	-
196	mov eax,dword [labels_type]	-
197	mov [ebx+14h],edx	211	mov [ebx+10h],al
198	mov [ebx+18h],eax	-
199	continue_line:	212	continue_line:
200	cmp byte [esi],0Fh	213	cmp byte [esi],0Fh
201	je line_assembled	214	je line_assembled
202	jmp assemble_line	215	jmp assemble_line
203	define_label:	216	define_label:
204	lods dword [esi]	217	lods dword [esi]
205	cmp eax,0Fh	218	cmp eax,0Fh
206	jb invalid_use_of_symbol	219	jb invalid_use_of_symbol
207	je reserved_word_used_as_symbol	220	je reserved_word_used_as_symbol
208	mov ebx,eax	221	mov ebx,eax
209	lods byte [esi]	222	lods byte [esi]
210	mov [label_size],al	223	mov [label_size],al
211	call make_label	224	call make_label
212	jmp continue_line	225	jmp continue_line
213	make_label:	226	make_label:
214	mov eax,edi	227	mov eax,edi
215	xor edx,edx	228	xor edx,edx
216	xor cl,cl	229	xor cl,cl
217	sub eax,dword [org_origin]	230	mov ebp,[addressing_space]
-		231	sub eax,[ds:ebp]
218	sbb edx,dword [org_origin+4]	232	sbb edx,[ds:ebp+4]
219	sbb cl,[org_origin_sign]	233	sbb cl,[ds:ebp+8]
220	jp label_value_ok	234	jp label_value_ok
221	call recoverable_overflow	235	call recoverable_overflow
222	label_value_ok:	236	label_value_ok:
223	mov [address_sign],cl	237	mov [address_sign],cl
224	cmp [virtual_data],0	238	test byte [ds:ebp+0Ah],1
225	jne make_virtual_label	239	jnz make_virtual_label
226	or byte [ebx+9],1	240	or byte [ebx+9],1
227	xchg eax,[ebx]	241	xchg eax,[ebx]
228	xchg edx,[ebx+4]	242	xchg edx,[ebx+4]
229	mov ch,[ebx+9]	243	mov ch,[ebx+9]
230	shr ch,1	244	shr ch,1
231	and ch,1	245	and ch,1
232	neg ch	246	neg ch
233	sub eax,[ebx]	247	sub eax,[ebx]
234	sbb edx,[ebx+4]	248	sbb edx,[ebx+4]
235	sbb ch,cl	249	sbb ch,cl
236	mov dword [adjustment],eax	250	mov dword [adjustment],eax
237	mov dword [adjustment+4],edx	251	mov dword [adjustment+4],edx
238	mov [adjustment_sign],ch	252	mov [adjustment_sign],ch
239	or al,ch	253	or al,ch
240	or eax,edx	254	or eax,edx
241	setnz ah	255	setnz ah
242	jmp finish_label	256	jmp finish_label
243	make_virtual_label:	257	make_virtual_label:
244	and byte [ebx+9],not 1	258	and byte [ebx+9],not 1
245	cmp eax,[ebx]	259	cmp eax,[ebx]
246	mov [ebx],eax	260	mov [ebx],eax
247	setne ah	261	setne ah
248	cmp edx,[ebx+4]	262	cmp edx,[ebx+4]
249	mov [ebx+4],edx	263	mov [ebx+4],edx
250	setne al	264	setne al
251	or ah,al	265	or ah,al
252	finish_label:	266	finish_label:
253	mov ch,[labels_type]	267	mov ebp,[addressing_space]
-		268	mov ch,[ds:ebp+9]
254	mov cl,[label_size]	269	mov cl,[label_size]
255	mov ebp,[org_registers]	270	mov edx,[ds:ebp+14h]
256	mov edx,[org_symbol]	271	mov ebp,[ds:ebp+10h]
257	finish_label_symbol:	272	finish_label_symbol:
258	mov al,[address_sign]	273	mov al,[address_sign]
259	xor al,[ebx+9]	274	xor al,[ebx+9]
260	and al,10b	275	and al,10b
261	or ah,al	276	or ah,al
262	xor [ebx+9],al	277	xor [ebx+9],al
263	cmp cl,[ebx+10]	278	cmp cl,[ebx+10]
264	mov [ebx+10],cl	279	mov [ebx+10],cl
265	setne al	280	setne al
266	or ah,al	281	or ah,al
267	cmp ch,[ebx+11]	282	cmp ch,[ebx+11]
268	mov [ebx+11],ch	283	mov [ebx+11],ch
269	setne al	284	setne al
270	or ah,al	285	or ah,al
271	cmp ebp,[ebx+12]	286	cmp ebp,[ebx+12]
272	mov [ebx+12],ebp	287	mov [ebx+12],ebp
273	setne al	288	setne al
274	or ah,al	289	or ah,al
275	or ch,ch	290	or ch,ch
276	jz label_symbol_ok	291	jz label_symbol_ok
277	cmp edx,[ebx+20]	292	cmp edx,[ebx+20]
278	mov [ebx+20],edx	293	mov [ebx+20],edx
279	setne al	294	setne al
280	or ah,al	295	or ah,al
281	label_symbol_ok:	296	label_symbol_ok:
282	mov cx,[current_pass]	297	mov cx,[current_pass]
283	xchg [ebx+16],cx	298	xchg [ebx+16],cx
284	mov edx,[current_line]	299	mov edx,[current_line]
285	mov [ebx+28],edx	300	mov [ebx+28],edx
286	and byte [ebx+8],not 2	301	and byte [ebx+8],not 2
287	test byte [ebx+8],1	302	test byte [ebx+8],1
288	jz new_label	303	jz new_label
289	cmp cx,[ebx+16]	304	cmp cx,[ebx+16]
290	je symbol_already_defined	305	je symbol_already_defined
291	inc cx	306	btr dword [ebx+8],10
-		307	jc requalified_label
-		308	inc cx
292	sub cx,[ebx+16]	309	sub cx,[ebx+16]
293	setnz al	310	setnz al
294	or ah,al	311	or ah,al
295	jz label_made	312	jz label_made
296	test byte [ebx+8],8	313	test byte [ebx+8],8
297	jz label_made	314	jz label_made
298	mov cx,[current_pass]	315	mov cx,[current_pass]
299	cmp cx,[ebx+18]	316	cmp cx,[ebx+18]
300	jne label_made	317	jne label_made
301	or [next_pass_needed],-1	318	requalified_label:
-		319	or [next_pass_needed],-1
302	label_made:	320	label_made:
303	ret	321	ret
304	new_label:	322	new_label:
305	or byte [ebx+8],1	323	or byte [ebx+8],1
306	ret	324	ret
307	define_constant:	325	define_constant:
308	lods dword [esi]	326	lods dword [esi]
309	inc esi	327	inc esi
310	cmp eax,0Fh	328	cmp eax,0Fh
311	jb invalid_use_of_symbol	329	jb invalid_use_of_symbol
312	je reserved_word_used_as_symbol	330	je reserved_word_used_as_symbol
313	mov edx,[eax+8]	331	mov edx,[eax+8]
314	push edx	332	push edx
315	cmp [current_pass],0	333	cmp [current_pass],0
316	je get_constant_value	334	je get_constant_value
317	test dl,4	335	test dl,4
318	jnz get_constant_value	336	jnz get_constant_value
319	mov cx,[current_pass]	337	mov cx,[current_pass]
320	cmp cx,[eax+16]	338	cmp cx,[eax+16]
321	je get_constant_value	339	je get_constant_value
322	and dl,not 1	340	or dl,4
323	mov [eax+8],dl	341	mov [eax+8],dl
324	get_constant_value:	342	get_constant_value:
325	push eax	343	push eax
326	mov al,byte [esi-1]	344	mov al,byte [esi-1]
327	push eax	345	push eax
328	or [size_override],-1	346	or [size_override],-1
329	call get_value	347	call get_value
330	pop ebx	348	pop ebx
331	mov ch,bl	349	mov ch,bl
332	pop ebx	350	pop ebx
333	pop dword [ebx+8]	351	pop ecx
334	cmp ebx,0Fh	352	test cl,4
335	jb invalid_use_of_symbol	353	jnz constant_referencing_mode_ok
336	je reserved_word_used_as_symbol	354	and byte [ebx+8],not 4
-		355	constant_referencing_mode_ok:
337	xor cl,cl	356	xor cl,cl
338	mov ch,[value_type]	357	mov ch,[value_type]
339	cmp ch,3	358	cmp ch,3
340	je invalid_use_of_symbol	359	je invalid_use_of_symbol
341	make_constant:	360	make_constant:
342	and byte [ebx+9],not 1	361	and byte [ebx+9],not 1
343	cmp eax,[ebx]	362	cmp eax,[ebx]
344	mov [ebx],eax	363	mov [ebx],eax
345	setne ah	364	setne ah
346	cmp edx,[ebx+4]	365	cmp edx,[ebx+4]
347	mov [ebx+4],edx	366	mov [ebx+4],edx
348	setne al	367	setne al
349	or ah,al	368	or ah,al
350	mov al,[value_sign]	369	mov al,[value_sign]
351	xor al,[ebx+9]	370	xor al,[ebx+9]
352	and al,10b	371	and al,10b
353	or ah,al	372	or ah,al
354	xor [ebx+9],al	373	xor [ebx+9],al
355	cmp cl,[ebx+10]	374	cmp cl,[ebx+10]
356	mov [ebx+10],cl	375	mov [ebx+10],cl
357	setne al	376	setne al
358	or ah,al	377	or ah,al
359	cmp ch,[ebx+11]	378	cmp ch,[ebx+11]
360	mov [ebx+11],ch	379	mov [ebx+11],ch
361	setne al	380	setne al
362	or ah,al	381	or ah,al
363	xor edx,edx	382	xor edx,edx
364	cmp edx,[ebx+12]	383	cmp edx,[ebx+12]
365	mov [ebx+12],edx	384	mov [ebx+12],edx
366	setne al	385	setne al
367	or ah,al	386	or ah,al
368	or ch,ch	387	or ch,ch
369	jz constant_symbol_ok	388	jz constant_symbol_ok
370	mov edx,[symbol_identifier]	389	mov edx,[symbol_identifier]
371	cmp edx,[ebx+20]	390	cmp edx,[ebx+20]
372	mov [ebx+20],edx	391	mov [ebx+20],edx
373	setne al	392	setne al
374	or ah,al	393	or ah,al
375	constant_symbol_ok:	394	constant_symbol_ok:
376	mov cx,[current_pass]	395	mov cx,[current_pass]
377	xchg [ebx+16],cx	396	xchg [ebx+16],cx
378	mov edx,[current_line]	397	mov edx,[current_line]
379	mov [ebx+28],edx	398	mov [ebx+28],edx
380	test byte [ebx+8],1	399	test byte [ebx+8],1
381	jz new_constant	400	jz new_constant
382	cmp cx,[ebx+16]	401	cmp cx,[ebx+16]
383	jne redeclare_constant	402	jne redeclare_constant
384	test byte [ebx+8],2	403	test byte [ebx+8],2
385	jz symbol_already_defined	404	jz symbol_already_defined
386	or byte [ebx+8],4	405	or byte [ebx+8],4
387	jmp instruction_assembled	406	and byte [ebx+9],not 4
-		407	jmp instruction_assembled
388	redeclare_constant:	408	redeclare_constant:
389	inc cx	409	btr dword [ebx+8],10
-		410	jc requalified_constant
-		411	inc cx
390	sub cx,[ebx+16]	412	sub cx,[ebx+16]
391	setnz al	413	setnz al
392	or ah,al	414	or ah,al
393	jz instruction_assembled	415	jz instruction_assembled
394	test byte [ebx+8],4	416	test byte [ebx+8],4
395	jnz instruction_assembled	417	jnz instruction_assembled
396	test byte [ebx+8],8	418	test byte [ebx+8],8
397	jz instruction_assembled	419	jz instruction_assembled
398	mov cx,[current_pass]	420	mov cx,[current_pass]
399	cmp cx,[ebx+18]	421	cmp cx,[ebx+18]
400	jne instruction_assembled	422	jne instruction_assembled
401	or [next_pass_needed],-1	423	requalified_constant:
-		424	or [next_pass_needed],-1
402	jmp instruction_assembled	425	jmp instruction_assembled
403	new_constant:	426	new_constant:
404	or byte [ebx+8],1+2	427	or byte [ebx+8],1+2
405	jmp instruction_assembled	428	jmp instruction_assembled
406	assemble_instruction:	429	label_addressing_space:
-		430	lods dword [esi]
-		431	cmp eax,0Fh
-		432	jb invalid_use_of_symbol
-		433	je reserved_word_used_as_symbol
-		434	mov cx,[current_pass]
-		435	test byte [eax+8],1
-		436	jz make_addressing_space_label
-		437	cmp cx,[eax+16]
-		438	je symbol_already_defined
-		439	test byte [eax+9],4
-		440	jnz make_addressing_space_label
-		441	or [next_pass_needed],-1
-		442	make_addressing_space_label:
-		443	mov dx,[eax+8]
-		444	and dx,not (2 or 100h)
-		445	or dx,1 or 4 or 400h
-		446	mov [eax+8],dx
-		447	mov [eax+16],cx
-		448	mov edx,[current_line]
-		449	mov [eax+28],edx
-		450	mov ebx,[addressing_space]
-		451	mov [eax],ebx
-		452	or byte [ebx+0Ah],2
-		453	jmp continue_line
-		454	assemble_instruction:
407	; mov [operand_size],0	455	; mov [operand_size],0
408	; mov [size_override],0	456	; mov [size_override],0
409	; mov [operand_prefix],0	457	; mov [operand_prefix],0
410	; mov [opcode_prefix],0	458	; mov [opcode_prefix],0
411	and dword [operand_size],0	459	and dword [operand_size],0
412	; mov [rex_prefix],0	460	; mov [rex_prefix],0
413	; mov [vex_required],0	461	; mov [vex_required],0
414	; mov [vex_register],0	462	; mov [vex_register],0
415	; mov [immediate_size],0	463	; mov [immediate_size],0
416	and dword [rex_prefix],0	464	and dword [rex_prefix],0
417	call instruction_handler	465	call instruction_handler
418	instruction_handler:	466	instruction_handler:
419	movzx ebx,word [esi]	467	movzx ebx,word [esi]
420	mov al,[esi+2]	468	mov al,[esi+2]
421	add esi,3	469	add esi,3
422	add [esp],ebx	470	add [esp],ebx
423	ret	471	ret
424	instruction_assembled:	472	instruction_assembled:
425	mov al,[esi]	473	mov al,[esi]
426	cmp al,0Fh	474	cmp al,0Fh
427	je line_assembled	475	je line_assembled
428	or al,al	476	or al,al
429	jnz extra_characters_on_line	477	jnz extra_characters_on_line
430	line_assembled:	478	line_assembled:
431	clc	479	clc
432	ret	480	ret
433	source_end:	481	source_end:
434	dec esi	482	dec esi

Subversion Repositories Kolibri OS

(root)/programs/develop/fasm/trunk/assemble.inc @ 4039 – Rev 2665 → 4039