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


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

Subversion Repositories Kolibri OS

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