Subversion Repositories Kolibri OS

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

; All rights reserved.

	mov	eax,[memory_end]

	mov	[labels_list],eax

	mov	eax,[additional_memory]

	mov	[free_additional_memory],eax

	xor	eax,eax

	mov	[current_locals_prefix],eax

	mov	[anonymous_reverse],eax

	mov	[anonymous_forward],eax

	mov	[hash_tree],eax

	push	[memory_end]

	mov	esi,[memory_start]

	mov	edi,[source_start]

      parser_loop:

	mov	[current_line],esi

	lea	eax,[edi+100h]

	cmp	eax,[memory_end]

	jae	out_of_memory

	cmp	byte [esi+16],0

	je	empty_line

	mov	al,0Fh

	stos	byte [edi]

	mov	eax,esi

	stos	dword [edi]

	add	esi,16

	call	parse_line

      parse_next_line:

	cmp	esi,[source_start]

	jb	parser_loop

	xor	al,al

	stos	byte [edi]

	mov	eax,[error_line]

	mov	[current_line],eax

	cmp	[anonymous_forward],0

	jne	invalid_value

	add	edi,0Fh

	and	edi,not 0Fh

	mov	[code_start],edi

	pop	[memory_end]

	ret

      empty_line:

	add	esi,17

	jmp	parse_next_line

	mov	[parenthesis_stack],0

      instruction_start:

	cmp	byte [esi],1Ah

	jne	empty_instruction

	push	edi

	add	esi,2

	movzx	ecx,byte [esi-1]

	cmp	byte [esi+ecx],':'

	je	simple_label

	cmp	byte [esi+ecx],'='

	je	constant_label

	cmp	byte [esi+ecx],1Ah

	jne	get_main_instruction

	push	esi ecx

	lea	esi,[esi+ecx+2]

	movzx	ecx,byte [esi-1]

	mov	edi,data_directives

	call	get_symbol

	jnc	data_label

	pop	ecx esi

      get_main_instruction:

	call	get_instruction

	jnc	parse_instruction

	mov	edi,data_directives

	call	get_symbol

	jnc	data_instruction

	mov	edi,symbols

	call	get_symbol

	pop	edi

	jc	unknown_instruction

	stos	word [edi]

	jmp	parse_arguments

      data_instruction:

	movzx	ebx,ah

	mov	bx,[data_handlers+ebx*2]

	jmp	parse_instruction

      unknown_instruction:

	sub	esi,2

	jmp	parse_arguments

      constant_label:

	pop	edi

	call	get_label_id

	mov	byte [edi],3

	inc	edi

	stos	dword [edi]

	xor	al,al

	stos	byte [edi]

	inc	esi

	jmp	parse_arguments

      data_label:

	pop	ecx ebx

	pop	edi

	push	eax esi

	mov	esi,ebx

	movzx	ecx,byte [esi-1]

	call	identify_label

	mov	byte [edi],2

	inc	edi

	stos	dword [edi]

	pop	esi eax

	stos	byte [edi]

	push	edi

	jmp	data_instruction

      simple_label:

	pop	edi

	call	identify_label

	mov	byte [edi],2

	inc	edi

	stos	dword [edi]

	inc	esi

	xor	al,al

	stos	byte [edi]

	jmp	instruction_start

      identify_label:

	cmp	byte [esi],'.'

	je	local_label_name

	call	get_label_id

	cmp	eax,10h

	jb	label_identified

	or	ebx,ebx

	jz	anonymous_label_name

	dec	ebx

	mov	[current_locals_prefix],ebx

      label_identified:

	ret

      anonymous_label_name:

	cmp	byte [esi-1],'@'

	je	anonymous_label_name_ok

	mov	eax,0Fh

      anonymous_label_name_ok:

	ret

      local_label_name:

	call	get_label_id

	ret

      parse_label_directive:

	cmp	byte [esi],1Ah

	jne	argument_parsed

	inc	esi

	movzx	ecx,byte [esi]

	inc	esi

	mov	al,2

	stos	byte [edi]

	call	identify_label

	stos	dword [edi]

	xor	al,al

	stos	byte [edi]

	jmp	argument_parsed

      parse_load_directive:

	cmp	byte [esi],1Ah

	jne	argument_parsed

	inc	esi

	movzx	ecx,byte [esi]

	inc	esi

	mov	al,2

	stos	byte [edi]

	call	get_label_id

	stos	dword [edi]

	xor	al,al

	stos	byte [edi]

	jmp	argument_parsed

      parse_prefix_instruction:

	cmp	byte [esi],1Ah

	jne	parse_arguments

	push	edi

	inc	esi

	movzx	ecx,byte [esi]

	inc	esi

	jmp	get_main_instruction

      parse_instruction:

	pop	edi

	mov	dl,al

	mov	al,1

	stos	byte [edi]

	mov	ax,bx

	stos	word [edi]

	mov	al,dl

	stos	byte [edi]

	cmp	bx,prefix_instruction-assembler

	je	parse_prefix_instruction

	cmp	bx,end_directive-assembler

	je	parse_prefix_instruction

	cmp	bx,label_directive-assembler

	je	parse_label_directive

	cmp	bx,segment_directive-assembler

	je	parse_label_directive

	cmp	bx,load_directive-assembler

	je	parse_load_directive

	cmp	bx,extrn_directive-assembler

	je	parse_extrn_directive

	cmp	bx,public_directive-assembler

	je	parse_public_directive

      parse_arguments:

	lods	byte [esi]

	cmp	al,':'

	je	instruction_separator

	cmp	al,','

	je	separator

	cmp	al,'='

	je	separator

	cmp	al,'|'

	je	separator

	cmp	al,'&'

	je	separator

	cmp	al,'~'

	je	separator

	cmp	al,'>'

	je	greater

	cmp	al,'<'

	je	less

	cmp	al,')'

	je	close_parenthesis

	or	al,al

	jz	line_parsed

	cmp	al,'['

	je	address_argument

	cmp	al,']'

	je	separator

	cmp	al,'{'

	je	unallowed_character

	cmp	al,'}'

	je	unallowed_character

	cmp	al,'#'

	je	unallowed_character

	cmp	al,'`'

	je	unallowed_character

	dec	esi

	cmp	al,1Ah

	jne	expression_argument

	push	edi

	mov	edi,directive_operators

	call	get_operator

	or	al,al

	jnz	operator_argument

	inc	esi

	movzx	ecx,byte [esi]

	inc	esi

	mov	edi,symbols

	call	get_symbol

	jnc	symbol_argument

	mov	edi,formatter_symbols

	call	get_symbol

	jnc	symbol_argument

	cmp	ecx,1

	jne	check_argument

	cmp	byte [esi],'?'

	jne	check_argument

	pop	edi

	movs	byte [edi],[esi]

	jmp	argument_parsed

      symbol_argument:

	pop	edi

	stos	word [edi]

	jmp	argument_parsed

      operator_argument:

	pop	edi

	cmp	al,85h

	je	ptr_argument

	stos	byte [edi]

	cmp	al,80h

	je	forced_expression

	cmp	al,81h

	je	forced_parenthesis

	cmp	al,82h

	je	parse_from_operator

	cmp	al,89h

	je	parse_label_operator

	jmp	argument_parsed

      parse_public_directive:

	cmp	byte [esi],1Ah

	jne	parse_arguments

	inc	esi

	push	esi

	movzx	ecx,byte [esi]

	inc	esi

	mov	al,2

	stos	byte [edi]

	call	get_label_id

	stos	dword [edi]

	mov	ax,8600h

	stos	word [edi]

	pop	ebx

	push	ebx esi edi

	mov	edi,directive_operators

	call	get_operator

	pop	edi edx ebx

	cmp	al,86h

	je	argument_parsed

	mov	esi,edx

	xchg	esi,ebx

	movzx	ecx,byte [esi]

	inc	esi

	mov	ax,'('

	stos	word [edi]

	mov	eax,ecx

	stos	dword [edi]

	rep	movs byte [edi],[esi]

	xor	al,al

	stos	byte [edi]

	xchg	esi,ebx

	jmp	argument_parsed

      parse_extrn_directive:

	cmp	byte [esi],22h

	je	parse_quoted_extrn

	cmp	byte [esi],1Ah

	jne	parse_arguments

	push	esi

	movzx	ecx,byte [esi+1]

	add	esi,2

	mov	ax,'('

	stos	word [edi]

	mov	eax,ecx

	stos	dword [edi]

	rep	movs byte [edi],[esi]

	mov	ax,8600h

	stos	word [edi]

	pop	esi

      parse_label_operator:

	cmp	byte [esi],1Ah

	jne	argument_parsed

	inc	esi

	movzx	ecx,byte [esi]

	inc	esi

	mov	al,2

	stos	byte [edi]

	call	get_label_id

	stos	dword [edi]

	xor	al,al

	stos	byte [edi]

	jmp	argument_parsed

      parse_from_operator:

	cmp	byte [esi],22h

	jne	forced_expression

	jmp	argument_parsed

      parse_quoted_extrn:

	inc	esi

	mov	ax,'('

	stos	word [edi]

	lods	dword [esi]

	mov	ecx,eax

	stos	dword [edi]

	rep	movs byte [edi],[esi]

	xor	al,al

	stos	byte [edi]

	push	esi edi

	mov	edi,directive_operators

	call	get_operator

	mov	edx,esi

	pop	edi esi

	cmp	al,86h

	jne	argument_parsed

	stos	byte [edi]

	mov	esi,edx

	jmp	parse_label_operator

      ptr_argument:

	call	parse_address

	jmp	address_parsed

      check_argument:

	push	esi ecx

	sub	esi,2

	mov	edi,single_operand_operators

	call	get_operator

	pop	ecx esi

	or	al,al

	jnz	not_instruction

	call	get_instruction

	jnc	parse_instruction

	mov	edi,data_directives

	call	get_symbol

	jnc	data_instruction

      not_instruction:

	pop	edi

	sub	esi,2

      expression_argument:

	cmp	byte [esi],22h

	jne	not_string

	mov	eax,[esi+1]

	lea	ebx,[esi+5+eax]

	push	ebx ecx esi edi

	mov	al,'('

	stos	byte [edi]

	call	convert_expression

	mov	al,')'

	stos	byte [edi]

	pop	eax edx ecx ebx

	cmp	esi,ebx

	jne	expression_parsed

	mov	edi,eax

	mov	esi,edx

      string_argument:

	inc	esi

	mov	ax,'('

	stos	word [edi]

	lods	dword [esi]

	mov	ecx,eax

	stos	dword [edi]

	shr	ecx,1

	jnc	string_movsb_ok

	movs	byte [edi],[esi]

      string_movsb_ok:

	shr	ecx,1

	jnc	string_movsw_ok

	movs	word [edi],[esi]

      string_movsw_ok:

	rep	movs dword [edi],[esi]

	xor	al,al

	stos	byte [edi]

	jmp	expression_parsed

      not_string:

	cmp	byte [esi],'('

	jne	expression

	mov	eax,esp

	sub	eax,100h

	jc	stack_overflow

	cmp	eax,[stack_limit]

	jb	stack_overflow

	push	esi edi

	inc	esi

	mov	al,'{'

	stos	byte [edi]

	inc	[parenthesis_stack]

	jmp	parse_arguments

      expression:

	mov	al,'('

	stos	byte [edi]

	call	convert_expression

	mov	al,')'

	stos	byte [edi]

	jmp	expression_parsed

      forced_expression:

	mov	al,'('

	stos	byte [edi]

	call	convert_expression

	mov	al,')'

	stos	byte [edi]

	jmp	argument_parsed

      address_argument:

	call	parse_address

	lods	byte [esi]

	cmp	al,']'

	jne	invalid_address

      address_parsed:

	mov	al,']'

	stos	byte [edi]

	jmp	argument_parsed

      parse_address:

	mov	al,'['

	stos	byte [edi]

	cmp	word [esi],021Ah

	jne	convert_address

	push	esi

	add	esi,4

	lea	ebx,[esi+1]

	cmp	byte [esi],':'

	pop	esi

	jne	convert_address

	add	esi,2

	mov	ecx,2

	push	ebx edi

	mov	edi,symbols

	call	get_symbol

	pop	edi esi

	jc	invalid_address

	cmp	al,10h

	jne	invalid_address

	mov	al,ah

	and	ah,11110000b

	cmp	ah,60h

	jne	invalid_address

	stos	byte [edi]

      convert_address:

	cmp	byte [esi],1Ah

	jne	convert_expression

	push	esi

	lods	word [esi]

	movzx	ecx,ah

	push	edi

	mov	edi,address_sizes

	call	get_symbol

	pop	edi

	jc	no_size_prefix

	mov	al,ah

	add	al,70h

	stos	byte [edi]

	add	esp,4

	jmp	convert_expression

      no_size_prefix:

	pop	esi

	jmp	convert_expression

      forced_parenthesis:

	cmp	byte [esi],'('

	jne	argument_parsed

	inc	esi

	mov	al,'{'

	jmp	separator

      unallowed_character:

	mov	al,0FFh

	jmp	separator

      close_parenthesis:

	mov	al,'}'

      separator:

	stos	byte [edi]

	jmp	argument_parsed

      instruction_separator:

	stos	byte [edi]

	jmp	instruction_start

      greater:

	cmp	byte [esi],'='

	jne	separator

	inc	esi

	mov	al,0F2h

	jmp	separator

      less:

	cmp	byte [edi-1],0F6h

	je	separator

	cmp	byte [esi],'>'

	je	not_equal

	cmp	byte [esi],'='

	jne	separator

	inc	esi

	mov	al,0F3h

	jmp	separator

      not_equal:

	inc	esi

	mov	al,0F1h

	jmp	separator

      argument_parsed:

	cmp	[parenthesis_stack],0

	je	parse_arguments

	dec	[parenthesis_stack]

	add	esp,8

	jmp	argument_parsed

      expression_parsed:

	cmp	[parenthesis_stack],0

	je	parse_arguments

	cmp	byte [esi],')'

	jne	argument_parsed

	dec	[parenthesis_stack]

	pop	edi esi

	jmp	expression

      empty_instruction:

	lods	byte [esi]

	or	al,al

	jz	line_parsed

	cmp	al,':'

	je	invalid_name

	cmp	al,3Bh

	je	skip_preprocessed_symbol

	dec	esi

	jmp	parse_arguments

      skip_preprocessed_symbol:

	lods	byte [esi]

	movzx	eax,al

	add	esi,eax

      skip_next:

	lods	byte [esi]

	or	al,al

	jz	line_parsed

	cmp	al,1Ah

	je	skip_preprocessed_symbol

	cmp	al,3Bh

	je	skip_preprocessed_symbol

	cmp	al,22h

	je	skip_preprocessed_string

	jmp	skip_next

      skip_preprocessed_string:

	lods	dword [esi]

	add	esi,eax

	jmp	skip_next

      line_parsed:

	cmp	[parenthesis_stack],0

	jne	invalid_expression

	ret

	cmp	byte [esi],1Ah

	jne	get_simple_operator

	mov	edx,esi

	push	ebp

	inc	esi

	lods	byte [esi]

	movzx	ebp,al

	push	edi

	mov	ecx,ebp

	call	lower_case

	pop	edi

      check_operator:

	mov	esi,converted

	movzx	ecx,byte [edi]

	jecxz	no_operator

	inc	edi

	mov	ebx,edi

	add	ebx,ecx

	cmp	ecx,ebp

	jne	next_operator

	repe	cmps byte [esi],[edi]

	je	operator_found

      next_operator:

	mov	edi,ebx

	inc	edi

	jmp	check_operator

      no_operator:

	mov	esi,edx

	mov	ecx,ebp

	pop	ebp

      no_simple_operator:

	xor	al,al

	ret

      operator_found:

	lea	esi,[edx+2+ebp]

	mov	ecx,ebp

	pop	ebp

	mov	al,[edi]

	ret

      get_simple_operator:

	mov	al,[esi]

	cmp	al,22h

	je	no_simple_operator

      simple_operator:

	cmp	byte [edi],1

	jb	no_simple_operator

	ja	simple_next_operator

	cmp	al,[edi+1]

	je	simple_operator_found

      simple_next_operator:

	movzx	ecx,byte [edi]

	lea	edi,[edi+1+ecx+1]

	jmp	simple_operator

      simple_operator_found:

	inc	esi

	mov	al,[edi+2]

	ret

	mov	edx,esi

	mov	ebp,ecx

	push	edi

	call	lower_case

	pop	edi

      scan_symbols:

	mov	esi,converted

	movzx	eax,byte [edi]

	or	al,al

	jz	no_symbol

	mov	ecx,ebp

	inc	edi

	mov	ebx,edi

	add	ebx,eax

	mov	ah,[esi]

	cmp	ah,[edi]

	jb	no_symbol

	ja	next_symbol

	cmp	cl,al

	jne	next_symbol

	repe	cmps byte [esi],[edi]

	jb	no_symbol

	je	symbol_ok

      next_symbol:

	mov	edi,ebx

	add	edi,2

	jmp	scan_symbols

      no_symbol:

	mov	esi,edx

	mov	ecx,ebp

	stc

	ret

      symbol_ok:

	lea	esi,[edx+ebp]

	mov	ax,[ebx]

	clc

	ret

	mov	edx,esi

	mov	ebp,ecx

	call	lower_case

	mov	ecx,ebp

	cmp	cl,11

	ja	no_instruction

	sub	cl,2

	jc	no_instruction

	movzx	edi,word [instructions+ecx*2]

	add	edi,instructions

      scan_instructions:

	mov	esi,converted

	mov	al,[edi]

	or	al,al

	jz	no_instruction

	mov	ecx,ebp

	mov	ebx,edi

	add	ebx,ecx

	repe	cmps byte [esi],[edi]

	jb	no_instruction

	je	instruction_ok

      next_instruction:

	mov	edi,ebx

	add	edi,3

	jmp	scan_instructions

      no_instruction:

	mov	esi,edx

	mov	ecx,ebp

	stc

	ret

      lower_case:

	mov	edi,converted

	mov	ebx,characters

      convert_case:

	lods	byte [esi]

	xlat	byte [ebx]

	stos	byte [edi]

	loop	convert_case

      case_ok:

	ret

      instruction_ok:

	lea	esi,[edx+ebp]

	mov	al,[ebx]

	mov	bx,[ebx+1]

	clc

	ret

	cmp	ecx,100h

	jae	name_too_long

	cmp	byte [esi],'@'

	je	anonymous_label

	cmp	byte [esi],'.'

	jne	standard_label

	cmp	byte [esi+1],'.'

	je	standard_label

	cmp	[current_locals_prefix],0

	je	standard_label

	push	edi

	mov	edi,[memory_end]

	sub	edi,2

	sub	edi,ecx

	push	ecx esi

	mov	esi,[current_locals_prefix]

	lods	byte [esi]

	movzx	ecx,al

	sub	edi,ecx

	cmp	edi,[esp+8]

	jb	out_of_memory

	mov	[memory_end],edi

	mov	word [edi],0

	add	edi,2

	mov	ebx,edi

	rep	movs byte [edi],[esi]

	pop	esi ecx

	add	al,cl

	jc	name_too_long

	rep	movs byte [edi],[esi]

	pop	edi

	push	esi

	movzx	ecx,al

	mov	byte [ebx-1],al

	mov	esi,ebx

	call	get_label_id

	pop	esi

	ret

      anonymous_label:

	cmp	ecx,2

	jne	standard_label

	mov	al,[esi+1]

	mov	ebx,characters

	xlat	byte [ebx]

	cmp	al,'@'

	je	new_anonymous

	cmp	al,'b'

	je	anonymous_back

	cmp	al,'r'

	je	anonymous_back

	cmp	al,'f'

	jne	standard_label

	add	esi,2

	mov	eax,[anonymous_forward]

	or	eax,eax

	jnz	anonymous_ok

	mov	eax,[current_line]

	mov	[error_line],eax

	mov	eax,[labels_list]

	sub	eax,24

	mov	[labels_list],eax

	mov	[anonymous_forward],eax

      anonymous_ok:

	xor	ebx,ebx

	ret

      anonymous_back:

	add	esi,2

	mov	eax,[anonymous_reverse]

	or	eax,eax

	jz	invalid_value

	jmp	anonymous_ok

      new_anonymous:

	add	esi,2

	mov	eax,[anonymous_forward]

	or	eax,eax

	jnz	new_anonymous_ok

	mov	eax,[labels_list]

	sub	eax,24

	mov	[labels_list],eax

      new_anonymous_ok:

	mov	[anonymous_reverse],eax

	mov	[anonymous_forward],0

	jmp	anonymous_ok

      standard_label:

	cmp	byte [esi],'%'

	je	get_predefined_id

	cmp	byte [esi],'$'

	jne	find_label

	cmp	ecx,2

	ja	find_label

	inc	esi

	jb	get_current_offset_id

	inc	esi

	cmp	byte [esi-1],'$'

	je	get_org_origin_id

	sub	esi,ecx

	jmp	find_label

      get_current_offset_id:

	xor	eax,eax

	ret

      get_counter_id:

	mov	eax,1

	ret

      get_timestamp_id:

	mov	eax,2

	ret

      get_org_origin_id:

	mov	eax,3

	ret

      get_predefined_id:

	cmp	ecx,2

	ja	find_label

	inc	esi

	cmp	cl,1

	je	get_counter_id

	lods	byte [esi]

	mov	ebx,characters

	xlat	[ebx]

	cmp	al,'t'

	je	get_timestamp_id

	sub	esi,2

      find_label:

	xor	ebx,ebx

	mov	eax,2166136261

	mov	ebp,16777619

      hash_label:

	xor	al,[esi+ebx]

	mul	ebp

	inc	bl

	cmp	bl,cl

	jb	hash_label

	mov	ebp,eax

	shl	eax,8

	and	ebp,0FFh shl 24

	xor	ebp,eax

	or	ebp,ebx

	mov	[label_hash],ebp

	push	edi esi

	push	ecx

	mov	ecx,32

	mov	ebx,hash_tree

      follow_tree:

	mov	edx,[ebx]

	or	edx,edx

	jz	extend_tree

	xor	eax,eax

	shl	ebp,1

	adc	eax,0

	lea	ebx,[edx+eax*4]

	dec	ecx

	jnz	follow_tree

	mov	[label_leaf],ebx

	pop	edx

	mov	eax,[ebx]

	or	eax,eax

	jz	add_label

	mov	ebx,esi

	mov	ebp,[label_hash]

      compare_labels:

	mov	esi,ebx

	mov	ecx,edx

	mov	edi,[eax+4]

	repe	cmps byte [esi],[edi]

	je	label_found

	mov	eax,[eax]

	or	eax,eax

	jnz	compare_labels

	jmp	add_label

      label_found:

	add	esp,4

	pop	edi

	mov	ebx,[eax+4]

	mov	eax,[eax+8]

	ret

      extend_tree:

	mov	edx,[free_additional_memory]

	lea	eax,[edx+8]

	cmp	eax,[additional_memory_end]

	ja	out_of_memory

	mov	[free_additional_memory],eax

	xor	eax,eax

	mov	[edx],eax

	mov	[edx+4],eax

	shl	ebp,1

	adc	eax,0

	mov	[ebx],edx

	lea	ebx,[edx+eax*4]

	dec	ecx

	jnz	extend_tree

	mov	[label_leaf],ebx

	pop	edx

      add_label:

	mov	ecx,edx

	pop	esi

	cmp	byte [esi-2],0

	je	label_name_ok

	mov	al,[esi]

	cmp	al,30h

	jb	name_first_char_ok

	cmp	al,39h

	jbe	invalid_name

      name_first_char_ok:

	cmp	ecx,1

	jne	check_for_reserved_word

	cmp	al,'$'

	je	reserved_word

      check_for_reserved_word:

	call	get_instruction

	jnc	reserved_word

	mov	edi,data_directives

	call	get_symbol

	jnc	reserved_word

	mov	edi,symbols

	call	get_symbol

	jnc	reserved_word

	mov	edi,formatter_symbols

	call	get_symbol

	jnc	reserved_word

	sub	esi,2

	mov	edi,operators

	call	get_operator

	or	al,al

	jnz	reserved_word

	mov	edi,single_operand_operators

	call	get_operator

	or	al,al

	jnz	reserved_word

	mov	edi,directive_operators

	call	get_operator

	or	al,al

	jnz	reserved_word

	inc	esi

	movzx	ecx,byte [esi]

	inc	esi

      label_name_ok:

	mov	edx,[free_additional_memory]

	lea	eax,[edx+12]

	cmp	eax,[additional_memory_end]

	ja	out_of_memory

	mov	[free_additional_memory],eax

	mov	[edx+4],esi

	mov	ebx,esi

	add	esi,ecx

	mov	eax,[label_leaf]

	mov	edi,[eax]

	mov	[edx],edi

	mov	[eax],edx

	mov	eax,[labels_list]

	sub	eax,24

	mov	[labels_list],eax

	mov	[edx+8],eax

	pop	edi

	ret

      reserved_word:

	mov	eax,0Fh

	pop	edi

	ret

 db 1,'+',80h

 db 1,'-',81h

 db 1,'*',90h

 db 1,'/',91h

 db 3,'mod',0A0h

 db 3,'and',0B0h

 db 2,'or',0B1h

 db 3,'xor',0B2h

 db 3,'shl',0C0h

 db 3,'shr',0C1h

 db 0

 db 1,'+',0

 db 1,'-',0D1h

 db 3,'not',0D0h

 db 3,'rva',0E0h

 db 0

 db 2,'as',86h

 db 2,'at',80h

 db 7,'defined',88h

 db 3,'dup',81h

 db 2,'eq',0F0h

 db 6,'eqtype',0F7h

 db 4,'from',82h

 db 2,'in',0F6h

 db 2,'on',84h

 db 3,'ptr',85h

 db 4,'used',89h

 db 0

>