; X-Assembler

	IDEAL
	P386
	MODEL	TINY
	CODESEG
	ORG	100h
start:
	db	5*1024 dup(0)	;for packing

l_icl	=	1000
l_org	=	1000*2
l_lab	=	48000

STRUC	com
cod	db	?
nam	db	?,?,?
vec	dw	?
	ENDS

STRUC	icl
prev	dw	?
handle	dw	?
line	dd	?
nam	db	?
	ENDS

STRUC	lab
prev	dw	?
val	dw	?
flags	db	?
b_sign	=	7
m_sign	=	80h
m_lnus	=	40h
m_ukp1	=	20h
nam	db	?
	ENDS

STRUC	movt
cod	db	?
vec	dw	?
	ENDS

m_pass	=	80h
m_eofl	=	40h

eol	equ	13,10
eot	equ	13,10,'$'

MACRO	lda	_rg	;shorter than 'mov (e)ax, _rg'
_rge	SUBSTR	<_rg>, 1, 1
IFIDNI	_rge, <e>
	xchg	eax, _rg
ELSE
	xchg	ax, _rg
ENDIF
	ENDM

MACRO	sta	_rg	;shorter than 'mov _rg, (e)ax'
_rge	SUBSTR	<_rg>, 1, 1
IFIDNI	_rge, <e>
	xchg	_rg, eax
ELSE
	xchg	_rg, ax
ENDIF
	ENDM

MACRO	dos	_func
	IFNB	<_func>
	IF	_func and 0ff00h
	mov	ax, _func
	ELSE
	mov	ah, _func
	ENDIF
	ENDIF
	int	21h
	ENDM

MACRO	file	_func, _errtx
	mov	bp, offset _errtx
	IF	_func and 0ff00h
	mov	ax, _func
	ELSE
	mov	ah, _func
	ENDIF
	call	xdisk
	ENDM

MACRO	print	_text
	IFNB	<_text>
	mov	dx, offset _text
	ENDIF
	dos	9
	ENDM

MACRO	error	_err
	push	offset _err
	jmp	errln
	ENDM

MACRO	jpass1	_dest
	test	[flags], m_pass
	jz	_dest
	ENDM

MACRO	jpass2	_dest
	test	[flags], m_pass
	jnz	_dest
	ENDM

MACRO	cmd	_oper
_tp	SUBSTR	<_oper>, 4, 2
_tp	CATSTR	<0>, &_tp, <h>
	db	_tp
	IRP	_ct,<3,2,1>
_tp	SUBSTR	<_oper>, _ct, 1
%	db	'&_tp'
	ENDM
_tp	SUBSTR	<_oper>, 6
	dw	_tp
	ENDM

MACRO	opr	_oper
_tp	SUBSTR	<_oper>, 1, 1
	db	_tp
_tp	SUBSTR	<_oper>, 2
_tp	CATSTR	<v_>, _tp
	dw	_tp
	ENDM

;*****************************

	print	hello
	mov	di, 81h
	movzx	cx, [di-1]
	jcxz	usg
	mov	al, ' '
	repe	scasb
	je	usg
	dec	di
	inc	cx
	mov	[fnad], di
	mov	al, '?'
	repne	scasb
	jne	begin

usg:	print	usgtxt
	dos	4c02h

begin:	mov	[origin], 0
	call	ldname

opfile:	mov	bx, offset (icl).nam
	add	bx, [iclen]
	mov	si, di
srex2:	dec	si
	cmp	[byte si], '\'
	je	adex2
	cmp	[byte si], '.'
	je	lvex2
	cmp	si, bx
	ja	srex2
adex2:	mov	[byte di-1], '.'
	mov	eax, 'xsa'
	stosd
lvex2:	call	fopen

main:	test	[flags], m_eofl
	jnz	filend
	mov	bx, [iclen]
	mov	bx, [(icl bx).prev]
	inc	[(icl bx).line]
	inc	[lines]
	mov	di, offset line-1

gline1:	cmp	di, offset line+255
	jnb	linlon
	mov	cx, 1
	lea	dx, [di+1]
	push	dx
	call	fread
	pop	di
	jz	eof
	cmp	[byte di], 0ah
	jne	gline1
	jmp	syntax

eof:	or	[flags], m_eofl
	mov	[word di], 0a0dh

syntax:	mov	si, offset line
	mov	al, [si]
	cmp	al, 0dh
	je	main
	cmp	al, '*'
	je	main
	cmp	al, ';'
	je	main
	cmp	al, '|'
	je	main
	mov	[labvec], 0
	cmp	al, ' '
	je	s_cmd
	cmp	al, 9
	je	s_cmd
	jpass2	deflp2
	call	flabel
	jnc	ltwice
	push	si
	mov	si, offset tlabel
	mov	di, [laben]
	mov	[labvec], di
	scasw	;add di, 2
	mov	ax, [origin]
	stosw
	mov	al, m_lnus
	stosb
	mov	cx, dx
	rep	movsb
	mov	ax, di
	cmp	ax, offset t_lab+l_lab-5
	jnb	tmlab
	xchg	ax, [laben]
	stosw
	pop	si
	jmp	s_cmd

ltwice:	error	e_twice
tmlab:	error	e_tlab

deflp2:	call	rlabel
	mov	ax, [pslab]
	mov	[labvec], ax
	add	ax, offset (lab).nam
	add	ax, dx
	mov	[pslab], ax

s_cmd:	lodsb
	cmp	al, ' '
	je	s_cmd
	cmp	al, 9
	je	s_cmd
	cmp	al, 0dh
	jne	s_cmd1
	cmp	[byte high labvec], 0
	je	main
	jmp	uneol
s_cmd1:	dec	si
	lodsw
 	and	ax, 0dfdfh
	xchg	al, ah
	shl	eax, 16
	mov	ah, 0dfh
	and	ah, [si]
	inc	si
	mov	di, offset comtab
	mov	bx, 64*size com
sfcmd1:	mov	al, [(com di+bx).cod]
	cmp	eax, [dword (com di+bx).cod]
	jb	sfcmd3
	jne	sfcmd2

	mov	[cod], al
	call	[(com di+bx).vec]
	call	linend
	jmp	main

sfcmd2:	add	di, bx
	cmp	di, offset comend
	jb	sfcmd3
	sub	di, bx
sfcmd3:	shr	bx, 1
	cmp	bl, 3
	ja	sfcmd1
	mov	bl, 0
	je	sfcmd1
	error	e_inst

filend:	and	[flags], not m_eofl
	call	fclose
	cmp	bx, offset t_icl
	ja	main
	jpass2	fin

	or	[flags], m_pass
	call	putorg
	call	ldname
	mov	si, di
srex1:	dec	si
	cmp	[byte si], '\'
	je	adex1
	cmp	[byte si], '.'
	je	chex1
	cmp	si, offset (icl t_icl).nam
	ja	srex1
	jmp	adex1
chex1:	lea	di, [si+1]
adex1:	mov	[byte di-1], '.'
	mov	[dword di], 'moc'
	mov	dx, offset (icl t_icl).nam
	xor	cx, cx
	file	3ch, e_creat
	mov	[ohand], ax
	mov	ax, 0ffffh
	call	putwor
	mov	[orgvec], offset t_org
	xor	ax, ax
	call	pheadr
	jmp	begin

fin:	mov	bx, [ohand]
	file	3eh, e_writ
	mov	eax, [lines]
	shr	eax, 1
	call	pridec
	print	lintxt
	mov	eax, [bytes]
	call	pridec
	print	byttxt
	mov	ax, [exitcod]
	dos

linlon:	push	offset e_long
	jmp	erron

; ERROR
errln:	call	ppline
erron:	call	prname
	print	errtxt
	pop	si
	call	prline
	dos	4c02h

; WARNING
warln:	call	ppline
waron:	call	prname
	print	wartxt
	pop	ax
	pop	si
	push	ax
	mov	[byte exitcod], 1
	jmp	prline

prname:	mov	bx, [iclen]
	cmp	bx, offset t_icl
	jna	prnamx
	mov	di, [(icl bx).prev]
	push	di
	lea	dx, [(icl di).nam]
	mov	[byte bx-1], '$'
	print
	mov	dl, ' '
	dos	2
	mov	dl, '('
	dos	2
	pop	bx
	mov	eax, [(icl bx).line]
	call	pridec
	mov	dl, ')'
	dos	2
	mov	dl, ' '
	dos	2
prnamx:	ret

ppline:	mov	si, offset line
prline:	mov	dl, [si]
	dos	2
	inc	si
	cmp	[byte si-1], 0ah
	jne	prline
	ret

; I/O
xdisk:	push	bp
	dos
	jc	erron
	pop	bp
	ret

icler:	push	offset e_icl
	jmp	erron

fopen:	cmp	di, offset t_icl+l_icl-2
	jnb	icler
	mov	bx, [iclen]
	mov	[(icl bx).line], 0
	lea	dx, [(icl bx).nam]
	mov	[(icl di).prev], bx
	mov	[iclen], di
	file	3d00h, e_open
	mov	bx, [iclen]
	mov	bx, [(icl bx).prev]
	mov	[(icl bx).handle], ax
	ret

fread:	mov	ah, 3fh
freacl:	mov	bx, [iclen]
	mov	bx, [(icl bx).prev]
	mov	bx, [(icl bx).handle]
	mov	bp, offset e_read
	call	xdisk
	test	ax, ax
	ret

fclose:	mov	ah, 3eh
	call	freacl
	mov	bx, [iclen]
	mov	bx, [(icl bx).prev]
	mov	[iclen], bx
	ret

putwor:	push	ax
	call	putbyt
	pop	ax
	mov	al, ah
putbyt:	mov	cx, 1
	jpass1	putx
	mov	[oper], al
	mov	dx, offset oper
	mov	bx, [ohand]
	file	40h, e_writ
	inc	[bytes]
putx:	ret

savwor:	inc	[origin]
	inc	[origin]
	jmp	putwor

savbyt:	inc	[origin]
	jmp	putbyt

; Przepisuje nazwe z linii komend
ldname:	mov	si, [fnad]
	mov	di, offset (icl t_icl).nam
ldnam1:	lodsb
	stosb
	cmp	al, 0dh
	jne	ldnam1
	mov	[byte di-1], 0
	ret

; Wyswietla dziesietnie EAX
pridec:	mov	di, offset dectxt+10
	mov	ebx, 10
pride1:	cdq
	div	ebx
	add	dl, '0'
	dec	di
	mov	[di], dl
	test	eax, eax
	jnz	pride1
	mov	dx, di
	print
	ret

; Zapisuje hex AX od [DI]
phword:	push	ax
	mov	al, ah
	call	phbyte
	pop	ax
phbyte:	push	ax
	shr	al, 4
	call	phdig
	pop	ax
	and	al, 0fh
phdig:	cmp	al, 10
	sbb	al, 69h
	das
	stosb
	ret

; Pobiera znak (eol=error)
get:	lodsb
	cmp	al, 0dh
	je	uneol
	ret
uneol:	error	e_uneol

ilchar:	error	e_char

; Omija spacje i tabulatory
spaces:	call	get
	cmp	al, ' '
	je	space1
	cmp	al, 9
	je	space1
	error	e_spac
space1:	call	get
	cmp	al, ' '
	je	space1
	cmp	al, 9
	je	space1
	dec	si
rstret:	ret

; Stwierdza blad, jesli nie spacja, tab lub eol
linend:	lodsb
	cmp	al, 0dh
	je	rstret
	cmp	al, ' '
	je	rstret
	cmp	al, 9
	je	rstret
	error	e_xtra

; Czyta nazwe pliku
rfname:	call	spaces
	mov	di, offset (icl).nam
	add	di, [iclen]
; Czyta lancuch i zapisuje do [di]
rstr:	call	get
	cmp	al, "'"
	jne	strer
	mov	dx, di
rstr1:	call	get
	stosb
	cmp	al, "'"
	jne	rstr1
	lodsb
	cmp	al, "'"
	je	rstr1
	dec	si
	mov	[byte di-1], 0
	lea	cx, [di-1]
	sub	cx, dx
	jnz	rstret

strer:	error	e_str

; Przepisuje etykiete do tlabel (wyj: dx-dl.etykiety)
rlabel:	mov	di, offset tlabel
	mov	[byte di], 0
rlab1:	lodsb
	cmp	al, '0'
	jb	rlabx
	cmp	al, '9'
	jbe	rlab2
	cmp	al, 'A'
	jb	rlabx
	cmp	al, 'Z'
	jbe	rlab2
	cmp	al, '_'
	je	rlab2
	cmp	al, 'a'
	jb	rlabx
	cmp	al, 'z'
	ja	rlabx
	add	al, 'A'-'a'
rlab2:	stosb
	jmp	rlab1
rlabx:	mov	dx, di
	mov	di, offset tlabel
	cmp	[byte di], 'A'
	jb	ilchar
	sub	dx, di
	dec	si
	ret

; Czyta etykiete i szuka w t_lab
; wyj: dx-dlugosc etykiety
; C=0: znaleziona, bx=adres wpisu
; C=1: nie ma jej
flabel:	call	rlabel
	push	si
	mov	bx, [laben]
flab1:	cmp	bx, offset t_lab
	jb	flabx
	lea	cx, [bx-5]
	mov	bx, [(lab bx).prev]
	sub	cx, bx
	cmp	cx, dx
	jne	flab1
	lea	si, [(lab bx).nam]
	mov	di, offset tlabel
	repe	cmpsb
	jne	flab1
	clc
flabx:	pop	si
	ret

wropar:	error	e_wpar

spaval:	call	spaces
; Czyta wyrazenie i zwraca jego wartosc w [val]
; (C=1 wartosc nieokreslona w pass 1)
getval:	xor	bx, bx
	mov	[ukp1], bh
	push	bx

v_lop:
v_par1:	inc	bh
	call	get
	cmp	al, '['
	je	v_par1
	cmp	al, '('
	je	wropar
	cmp	al, '-'
	je	valuem
	dec	si
	mov	al, '+'
valuem:	mov	bl, al
	xor	eax, eax
	call	get
	cmp	al, '*'
	je	valorg
	cmp	al, "'"
	je	valchr
	cmp	al, '^'
	je	valreg
	mov	bp, -1
	xor	edx, edx
	mov	ecx, 16
	cmp	al, '$'
	je	rdnum3
	mov	cl, 2
	cmp	al, '%'
	je	rdnum3
	mov	cl, 10
	cmp	al, '0'
	jb	ilchar
	cmp	al, '9'
	ja	vlabel

rdnum1:	cmp	al, '9'
	jbe	rdnum2
	and	al, 0dfh
	cmp	al, 'A'
	jb	value0
	add	al, '0'+10-'A'
rdnum2:	sub	al, '0'
	cmp	al, cl
	jnb	value0
	movzx	ebp, al
	lda	edx
	mul	ecx
	add	eax, ebp
	js	toobig
	adc	edx, edx
	jnz	toobig
	sta	edx
rdnum3:	lodsb
	jmp	rdnum1

vlabel:	push	bx
	dec	si
	call	flabel
	jnc	vlabfn
	jpass1	vlukp1
	error	e_undec
vlabfn:	test	[(lab bx).flags], m_ukp1
	jz	vlabkn
	jpass1	vlukp1
	cmp	bx, [pslab]
	jb	vlukp1
	error	e_fref
vlukp1:	mov	[ukp1], 0ffh
vlabkn:	bt	[word (lab bx).flags], b_sign
	sbb	eax, eax
	mov	ax, [(lab bx).val]
	pop	bx
	jmp	value1

valorg:	mov	ax, [origin]
	jmp	value1

valchr:	call	get
	cmp	al, "'"
	jne	valch1
	lodsb
	cmp	al, "'"
	jne	strer
valch1:	cmp	[byte si], "'"
	jne	strer
	inc	si
	cmp	[byte si], '*'
	jne	value1
	inc	si
	xor	al, 80h
	jmp	value1

valreg:	call	get
	cmp	al, '4'
	ja	ilchar
	sub	al, '0'
	jb	ilchar
	add	al, 0d0h
	mov	ah, al
	call	get
	cmp	al, '9'
	jbe	valre1
	and	al, 0dfh
	cmp	al, 'A'
	jb	ilchar
	add	al, '0'+10-'A'
valre1:	sub	al, '0'
	cmp	al, 0fh
	ja	ilchar	
	cmp	ah, 0d1h
	jne	value1
	sub	ax, 0f0h
valre2:	jmp	value1

value0:	dec	si
	test	bp, bp
	js	ilchar
	lda	edx
value1:	cmp	bl, '-'
	jne	value2
	neg	eax
value2:	push	eax
v_par2:	dec	bh
	js	mbrack
	lodsb
	cmp	al, ']'
	je	v_par2

	mov	ah, [si]
	mov	di, offset opert2
	mov	cx, noper2
	repne	scasw
	je	foper2
	mov	cx, noper1
	repne	scasb
	je	foper1
	test	bh, bh
	jnz	mbrack
	dec	si
	mov	di, offset opert1
foper1:	sub	di, offset opert1
	jmp	goper
foper2:	inc	si
	sub	di, offset opert2
	shr	di, 1
	add	di, noper1
goper:	lea	ax, [di+operpa]
	add	di, di
	add	di, ax
	mov	bl, [di]
	mov	bp, [di+1]
	pop	eax
v_com:	pop	cx
	cmp	cx, bx
	jb	v_xcm
	pop	ecx
	xchg	eax, ecx
	pop	dx
	push	offset v_com
	push	dx
	ret
v_xcm:	cmp	bl, 1
	jbe	v_xit
	push	cx bp eax bx
	jmp	v_lop
v_xit:	mov	[dword val], eax
	cmp	[ukp1], 1
	cmc
	jc	v_ret
	cmp	eax, 10000h
	cmc
	jnb	v_ret
	cmp	eax, -0ffffh
	jb	orange
	ret

brange:	cmp	eax, 100h
	jb	v_ret
	cmp	eax, -0ffh
	jb	orange
	ret

spauns:	call	spaces
getuns:	call	getval
	jc	v_ret
	test	eax, eax
	jns	v_ret
orange:	error	e_range

mbrack:	error	e_brack

toobig:	error	e_nbig

v_add:	add	eax, ecx
	jmp	v_cov

v_sub:	sub	eax, ecx
v_cov:	jno	v_ret
oflow:	error	e_over

div0:	error	e_div0

v_mul:	mov	edx, ecx
	xor	ecx, eax
	imul	edx
	test	ecx, ecx
	js	v_mu1
	test	edx, edx
	jnz	oflow
	test	eax, eax
	js	oflow
	ret
v_mu1:	inc	edx
	jnz	oflow
	test	eax, eax
	jns	oflow
	ret

v_div:	jecxz	div0
	cdq
	idiv	ecx
	ret

v_mod:	jecxz	div0
	cdq
	idiv	ecx
	sta	edx
v_ret:	ret

v_sln:	neg	ecx
v_sal:	test	ecx, ecx
	js	v_srn
	jz	v_ret
	cmp	ecx, 20h
	jb	v_sl1
	test	eax, eax
	jnz	oflow
	ret
v_sl1:	add	eax, eax
	jo	oflow
	loop	v_sl1
	ret

v_srn:	neg	ecx
v_sar:	test	ecx, ecx
	js	v_sln
	cmp	ecx, 20h
	jb	v_sr1
	mov	cl, 1fh
v_sr1:	sar	eax, cl
	ret

v_and:	and	eax, ecx
	ret

v_or:	or	eax, ecx
	ret

v_xor:	xor	eax, ecx
	ret

v_equ:	cmp	eax, ecx
	je	v_one
v_zer:	xor	eax, eax
	ret
v_one:	mov	eax, 1
	ret

v_neq:	cmp	eax, ecx
	jne	v_one
	jmp	v_zer

v_les:	cmp	eax, ecx
	jl	v_one
	jmp	v_zer

v_grt:	cmp	eax, ecx
	jg	v_one
	jmp	v_zer

v_leq:	cmp	eax, ecx
	jle	v_one
	jmp	v_zer

v_geq:	cmp	eax, ecx
	jge	v_one
	jmp	v_zer

v_anl:	jecxz	v_zer
	test	eax, eax
	jz	v_ret
	jmp	v_one

v_orl:	or	eax, ecx
	jz	v_ret
	jmp	v_one

; Pobiera operand rozkazu i rozpoznaje tryb adresowania
getadr:	call	spaces
	lodsb
	xor	dx, dx
	cmp	al, '@'
	je	getadx
	cmp	al, '#'
	je	getaim
	cmp	al, '<'
	je	getaim
	cmp	al, '>'
	je	getaim
	mov	dl, 8
	cmp	al, '('
	je	getad1
	dec	si
	lodsw
	and	al, 0dfh
	mov	dl, 2
	cmp	ax, ':A'
	je	getad1
	inc	dx
	cmp	ax, ':Z'
	je	getad1
	dec	si
	dec	si
	xor	dx, dx
	
getad1:	push	dx
	call	getuns
	sbb	al, al
	jnz	getad2
	mov	al, [byte high val]
getad2:	pop	dx
	cmp	dl, 8
	jae	getaid
	cmp	dl, 2
	jae	getad3
	cmp	al, 1
	adc	dl, 2
getad3:	lodsw
	and	ah, 0dfh
	mov	bl, 2
	cmp	ax, 'X,'
	je	getabi
	mov	bl, 4
	cmp	ax, 'Y,'
	je	getabi
	dec	si
	dec	si
	jmp	getadx
getabi:	add	dl, bl
getaxt:	lodsb
	cmp	al, '+'
	je	getabx
	inc	bx
	cmp	al, '-'
	je	getabx
	dec	si
	jmp	getadx
getabx:	mov	dh, bl
getadx:	lda	dx
	mov	[word amod], ax
	ret

getaim:	cmp	al, '<'
	pushf
	call	getval
	popf
	jb	getai2
	je	getai1
	mov	al, ah
getai1:	movzx	eax, al
	mov	[dword val], eax
getai2:	mov	dx, 1
	jmp	getadx

getaid:	lodsb
	cmp	al, ','
	je	getaix
	cmp	al, ')'
	jne	mparen
	lodsw
	mov	dx, 709h
	cmp	ax, '0,'
	je	getadx
	xor	dh, dh
	mov	bl, 4
	and	ah, 0dfh
	cmp	ax, 'Y,'
	je	getaxt
	inc	dx
	dec	si
	dec	si
	jmp	getadx
getaix:	lodsw
	mov	dh, 6
	cmp	ax, ')0'
	je	getadx
	xor	dh, dh
	and	al, 0dfh
	cmp	ax, ')X'
	je	getadx
	jmp	ilchar
	
p_imp	=	savbyt

p_ads:	call	getadr
	mov	al, [cod]
	call	savbyt
	mov	al, 60h
	cmp	[cod], 18h
	je	p_as1
	mov	al, 0e0h
p_as1:	mov	[cod], al
	jmp	p_ac1

p_acc:	call	getadr
p_ac1:	mov	ax, [word amod]
	cmp	al, 7
	jne	acc1
	dec	[amod]
acc1:	cmp	ah, 6
	jb	acc3
	mov	ax, 0a2h
	je	acc2
	mov	al, 0a0h
acc2:	call	savwor
acc3:	mov	al, [amod]
	mov	bx, offset acctab
	xlat
	test	al, al
	jz	ilamod
	or	al, [cod]
	cmp	al, 89h
	jne	putsfx
ilamod:	error	e_amod

p_srt:	call	getadr
	cmp	al, 6
	jnb	ilamod
	cmp	al, 1
	je	ilamod
	mov	bx, offset srttab
	xlat
	or	al, [cod]
	cmp	al, 0c0h
	je	ilamod
	cmp	al, 0e0h
	je	ilamod
putsfx:	call	putcmd
	mov	al, [amod+1]
	mov	bx, offset sfxtab
	xlat
	test	al, al
	jnz	savbyt
putret:	ret
	
p_inw:	call	getadr
	cmp	al, 6
	jnb	ilamod
	sub	al, 2
	jb	ilamod
	mov	bx, offset inwtab
	xlat
	push	ax
	call	putcmd
	inc	[val]
	mov	ax, 03d0h
	test	[amod], 1
	jz	p_iw1
	dec	ah
p_iw1:	call	savwor
	pop	ax
	jmp	putsfx

p_ldi:	call	getadr
p_ld1:	mov	al, [amod]
	cmp	al, 1
	jb	ilamod
	cmp	al, 4
	jb	ldi1
	and	al, 0feh
	xor	al, [cod]
	cmp	al, 0a4h
	jne	ilamod
	mov	al, [amod]
ldi1:	mov	bx, offset lditab
	xlat
putcod:	or	al, [cod]
	jmp	putsfx

putcmd:	call	savbyt
	mov	al, [amod]
	mov	bx, offset lentab
	xlat
	cmp	al, 2
	jb	putret
	mov	eax, [dword val]
	jne	savwor
	jpass1	putcm1
	call	brange
putcm1:	jmp	savbyt

p_sti:	call	getadr
p_st1:	mov	al, [amod]
	cmp	al, 2
	jb	ilamod
	je	cod8
	cmp	al, 3
	je	cod0
	and	al, 0feh
	xor	al, [cod]
	cmp	al, 80h
	jne	ilamod
	or	[amod], 1
	mov	al, 10h
	jmp	putcod
cod8:	mov	al, 8
	jmp	putcod
cod0:	xor	al, al
	jmp	putcod

p_cpi:	call	getadr
	cmp	al, 1
	jb	ilamod
	cmp	al, 4
	jnb	ilamod
	cmp	al, 2
	jb	cod0
	je	cod8
	mov	al, 4
	jmp	putcod

p_bra:	call	getadr
	jpass1	bra1
	mov	ax, [val]
	sub	ax, [origin]
	add	ax, 7eh
	test	ah, ah
	jnz	toofar
	add	al, 80h
	mov	[byte val], al
	mov	al, [cod]
bra1:	call	savbyt
	mov	al, [byte val]
	jmp	savbyt

toofar:	cmp	ax, 8080h
	jae	toofa1
	sub	ax, 0ffh
	neg	ax
toofa1:	neg	ax
	mov	di, offset brout
	call	phword
	error	e_bra

p_jsr:	call	getadr
	mov	al, 20h
	jmp	p_abs

p_bit:	call	getadr
	cmp	al, 2
	mov	al, 2ch
	je	putcmd
	cmp	[amod], 3
	jne	ilamod
	mov	al, 24h
	jmp	putcmd

p_juc:	call	getadr
	mov	al, [cod]
	mov	ah, 3
	call	savwor
	jmp	p_jp1

p_jmp:	call	getadr
p_jp1:	cmp	[amod], 10
	je	chkbug
	jpass1	p_jpu
	cmp	[cod], 4ch
	je	p_jpu
	mov	ax, [val]
	sub	ax, [origin]
	add	ax, 80h
	test	ah, ah
	jnz	p_jpu
	push	si
	push	offset w_bras
	call	warln
	pop	si
p_jpu:	mov	al, 4ch
p_abs:	and	[amod], 0feh
	cmp	[amod], 2
	je	p_jpp
	jmp	ilamod
chkbug:	jpass1	p_jid
	cmp	[byte val], 0ffh
	jne	p_jid
	push	si
	push	offset w_bugjp
	call	warln
	pop	si
p_jid:	mov	al, 6ch
p_jpp:	jmp	putcmd

getops:	call	getadr
	mov	di, offset op1
	call	stop
	push	[word ukp1]
	call	getadr
	pop	[word ukp1]
	mov	[tempsi], si
	mov	di, offset op2
	call	stop
	movzx	bx, [cod]
	add	bx, offset movtab
ldop1:	mov	si, offset op1
ldop:	lodsd
	mov	[dword val], eax
	lodsw
	mov	[word amod], ax
	ret
stop:	mov	eax, [dword val]
	stosd
	mov	ax, [word amod]
	stosw
	ret

mcall1:	mov	al, [(movt bx).cod]
	mov	[cod], al
	push	bx
	call	[(movt bx).vec]
	pop	bx
	ret

mcall2:	mov	al, [(movt bx+3).cod]
	mov	[cod], al
	push	bx
	call	[(movt bx+3).vec]
	pop	bx
	ret

p_mvs:	call	getops
	call	mcall1
	mov	si, offset op2
	call	ldop
p_mvx:	call	mcall2
	mov	si, [tempsi]
	ret

p_mws:	call	getops
	mov	ax, [word amod]
	cmp	ax, 8
	jae	ilamod
	cmp	al, 1
	jne	p_mw1
	mov	[byte high val], 0
	mov	[word val+2], 0
p_mw1:	call	mcall1
	mov	si, offset op2
	call	ldop
	cmp	[word amod], 8
	jae	ilamod
	call	mcall2
	call	ldop1
	cmp	[amod], 1
	je	p_mwi
	inc	[val]
	jmp	p_mw2
p_mwi:	movzx	eax, [byte high val]
	cmp	[ukp1], ah	;0
	jnz	p_mwh
	cmp	al, [byte val]
	je	p_mw3
p_mwh:	mov	[dword val], eax
p_mw2:	call	mcall1
p_mw3:	mov	si, offset op2
	call	ldop
	inc	[val]
	jmp	p_mvx

p_opt:	error	e_opt

p_ert:	call	spaval
	jpass1	equret
	test	eax, eax
	jz	equret
	error	e_user

p_equ:	mov	di, [labvec]
	test	di, di
	jz	nolabl
	mov	[(lab di).val], 0
	and	[(lab di).flags], not m_sign
	call	spaval
	mov	di, [labvec]
	jnc	equ1
	or	[(lab di).flags], m_ukp1
equ1:	mov	[(lab di).val], ax
	test	eax, eax
	jns	equret
	or	[(lab di).flags], m_sign
equret:	ret

nolabl:	error	e_label

p_org:	call	spauns
	jc	unknow
p_org1:	jpass2	org1
	call	putorg
	stc
org1:	mov	ax, [val]
	mov	[origin], ax
	jc	pheart
pheadr:	mov	bx, [orgvec]
	cmp	ax, [bx]
	je	pheart
	call	putwor
	mov	bx, [orgvec]
	mov	ax, [bx]
	dec	ax
	call	putwor
pheart:	add	[orgvec], 2
	ret

putorg:	mov	bx, [orgvec]
	cmp	bx, offset t_org+l_org-2
	jnb	tmorgs
	mov	ax, [origin]
	mov	[bx], ax
	ret

tmorgs:	error	e_orgs

p_rui:	mov	ah, 2
	mov	[val], ax
	call	p_org1
	call	spauns
	mov	ax, [val]
	jmp	savwor

valuco:	call	getval
	jc	unknow
	call	get
	cmp	al, ','
	jne	badsin
	mov	ax, [val]
	ret
badsin:	error	e_sin

p_dta:	call	spaces
dta1:	call	get
	and	al, 0dfh
	mov	[cod], al
	cmp	al, 'A'
	je	dtan1
	cmp	al, 'B'
	je	dtan1
	cmp	al, 'L'
	je	dtan1
	cmp	al, 'H'
	je	dtan1
	cmp	al, 'C'
	je	dtat1
	cmp	al, 'D'
	je	dtat1
	jmp	ilchar

dtan1:	lodsb
	cmp	al, '('
	jne	mparen

dtan2:	lodsd
	and	eax, 0ffdfdfdfh
	cmp	eax, '(NIS'
	jne	dtansi
	call	valuco
	mov	[sinadd], ax
	call	valuco
	mov	[sinamp], ax
	call	getuns
	jc	unknow
	mov	ax, [val]
	test	ax, ax
	jz	badsin
	mov	[sinsiz], ax
	mov	[sinmin], 0
	dec	ax
	mov	[sinmax], ax
	call	get
	cmp	al, ')'
	je	presin
	cmp	al, ','
	jne	badsin
	call	valuco
	test	eax, eax
	js	badsin
	mov	[sinmin], ax
	call	getuns
	jc	unknow
	mov	ax, [val]
	cmp	ax, [sinmin]
	jb	badsin
	mov	[sinmax], ax
	lodsb
	cmp	al, ')'
	jne	mparen
presin:	finit
	fldpi
	fld	st
	faddp	st(1), st
	fidiv	[sinsiz]
gensin:	fild	[sinmin]
	fmul	st, st(1)
	fsin
	fimul	[sinamp]
	fistp	[val]
	inc	[sinmin]
	mov	ax, [sinadd]
	add	[val], ax
	jmp	dtasto
	
dtansi:	sub	si, 4
	call	getval
dtasto:	jpass1	dtan3
	mov	al, [cod]
	cmp	al, 'B'
	je	dtanb
	cmp	al, 'L'
	je	dtanl
	cmp	al, 'H'
	je	dtanh
	mov	ax, [val]
	call	savwor
	jmp	dtanx

dtanb:	mov	eax, [dword val]
	call	brange
	jmp	dtans

dtanl:	mov	al, [byte low val]
	jmp	dtans

dtanh:	mov	al, [byte high val]

dtans:	call	savbyt
	jmp	dtanx

dtan3:	cmp	[cod], 'A'+1
	adc	[origin], 1
	
dtanx:	mov	ax, [sinmin]
	cmp	ax, [sinmax]
	jbe	gensin
	lodsb
	cmp	al, ','
	je	dtan2
	cmp	al, ')'
	je	dtanxt

mparen:	error	e_paren

unknow:	error	e_uknow

dtat1:	mov	di, offset tlabel
	call	rstr
	lodsb
	mov	ah, 80h
	cmp	al, '*'
	je	dtat2
	dec	si
	xor	ah, ah
dtat2:	push	si
	mov	si, dx
dtatm:	lodsb
	xor	al, ah
	cmp	[cod], 'D'
	jne	ascinx
	mov	dl, 60h
	and	dl, al
	jz	ascin1
	cmp	dl, 60h
	je	ascinx
	sub	al, 60h
ascin1:	add	al, 40h
ascinx:	push	ax cx si
	call	savbyt
	pop	si cx ax
	loop	dtatm
	pop	si
dtanxt:	lodsb
	cmp	al, ','
	je	dta1
	dec	si
	ret

p_icl:	call	rfname
	pop	ax
	call	linend
	jmp	opfile

p_ins:	call	rfname
	call	fopen
	push	si
p_in1:	mov	cx, 256
	mov	dx, offset tlabel
	call	fread
	jz	p_in2
	add	[origin], ax
	cwde
	mov	bx, [iclen]
	mov	bx, [(icl bx).prev]
	add	[(icl bx).line], eax
	jpass1	p_in1
	add	[bytes], eax
	sta	cx
	mov	bx, [ohand]
	mov	dx, offset tlabel
	file	40h, e_writ
	jmp	p_in1
p_in2:	call	fclose
	pop	si
	ret

p_end:	pop	ax
	call	linend
	jmp	filend

; addressing modes:
; 0-@ 1-# 2-A 3-Z 4-A,X 5-Z,X 6-A,Y 7-Z,Y 8-(Z,X) 9-(Z),Y 10-(A)
lentab	db	1,2,3,2,3,2,3,2,2,2,3
acctab	db	0,9,0dh,5,1dh,15h,19h,19h,1,11h,0
srttab	db	0ah,0,0eh,6,1eh,16h
lditab	db	0,0,0ch,4,1ch,14h,1ch,14h
inwtab	db	0eeh,0e6h,0feh,0f6h
; pseudo-adr modes: 2-X+ 3-X- 4-Y+ 5-Y- 6-,0) 7-),0
sfxtab	db	0,0,0e8h,0cah,0c8h,088h,0,0

movtab	movt	<0a0h,p_ac1>,<080h,p_ac1>
	movt	<0a2h,p_ld1>,<086h,p_st1>
	movt	<0a0h,p_ld1>,<084h,p_st1>

comtab:	cmd	ADC60p_acc
	cmd	ADD18p_ads
	cmd	AND20p_acc
	cmd	ASL00p_srt
	cmd	BCC90p_bra
	cmd	BCSb0p_bra
	cmd	BEQf0p_bra
	cmd	BIT2cp_bit
	cmd	BMI30p_bra
	cmd	BNEd0p_bra
	cmd	BPL10p_bra
	cmd	BRK00p_imp
	cmd	BVC50p_bra
	cmd	BVS70p_bra
	cmd	CLC18p_imp
	cmd	CLDd8p_imp
	cmd	CLI58p_imp
	cmd	CLVb8p_imp
	cmd	CMPc0p_acc
	cmd	CPXe0p_cpi
	cmd	CPYc0p_cpi
	cmd	DECc0p_srt
	cmd	DEXcap_imp
	cmd	DEY88p_imp
	cmd	DTA00p_dta
	cmd	END00p_end
	cmd	EOR40p_acc
	cmd	EQU00p_equ
	cmd	ERT00p_ert
	cmd	ICL00p_icl
	cmd	INCe0p_srt
	cmd	INIe2p_rui
	cmd	INS00p_ins
	cmd	INW00p_inw
	cmd	INXe8p_imp
	cmd	INYc8p_imp
	cmd	JCCb0p_juc
	cmd	JCS90p_juc
	cmd	JEQd0p_juc
	cmd	JMI10p_juc
	cmd	JMP4cp_jmp
	cmd	JNEf0p_juc
	cmd	JPL30p_juc
	cmd	JSR20p_jsr
	cmd	JVC70p_juc
	cmd	JVS50p_juc
	cmd	LDAa0p_acc
	cmd	LDXa2p_ldi
	cmd	LDYa0p_ldi
	cmd	LSR40p_srt
	cmd	MVA00p_mvs
	cmd	MVX06p_mvs
	cmd	MVY0cp_mvs
	cmd	MWA00p_mws
	cmd	MWX06p_mws
	cmd	MWY0cp_mws
	cmd	NOPeap_imp
	cmd	OPT00p_opt
	cmd	ORA00p_acc
	cmd	ORG00p_org
	cmd	PHA48p_imp
	cmd	PHP08p_imp
	cmd	PLA68p_imp
	cmd	PLP28p_imp
	cmd	ROL20p_srt
	cmd	ROR60p_srt
	cmd	RTI40p_imp
	cmd	RTS60p_imp
	cmd	RUNe0p_rui
	cmd	SBCe0p_acc
	cmd	SEC38p_imp
	cmd	SEDf8p_imp
	cmd	SEI78p_imp
	cmd	STA80p_acc
	cmd	STX86p_sti
	cmd	STY84p_sti
	cmd	SUB38p_ads
	cmd	TAXaap_imp
	cmd	TAYa8p_imp
	cmd	TSXbap_imp
	cmd	TXA8ap_imp
	cmd	TXS9ap_imp
	cmd	TYA98p_imp
comend:

operpa:	opr	1ret
	opr	5add
	opr	5sub
	opr	6mul
	opr	6div
	opr	6mod
	opr	6and
	opr	5or
	opr	5xor
	opr	4equ
	opr	4les
	opr	4grt
	opr	6sal
	opr	6sar
	opr	4leq
	opr	4geq
	opr	4neq
	opr	4neq
	opr	3anl
	opr	2orl

opert2	db	'<<>><=>=<>!=&&||'
noper2	=	($-opert2)/2
opert1	db	'+-*/%&|^=<>'
noper1	=	$-opert1

hello	db	'X-Assembler 1.6 by Fox/Taquart',eot
usgtxt	db	'Give a source filename. Default extension is .ASX.',eol
	db	'Object file will be written with .COM extension.',eot
lintxt	db	' lines assembled',eot
byttxt	db	' bytes written',eot
dectxt	db	10 dup(' '),'$'
wartxt	db	'WARNING: $'
w_bugjp	db	'Buggy indirect jump',eol
w_bras	db	'Branch would be sufficient',eol
errtxt	db	'ERROR: $'
e_open	db	'Can''t open file',eol
e_read	db	'Disk read error',eol
e_creat	db	'Can''t write destination',eol
e_writ	db	'Disk write error',eol
e_icl	db	'Too many files nested',eol
e_long	db	'Line too long',eol
e_uneol	db	'Unexpected eol',eol
e_char	db	'Illegal character',eol
e_twice	db	'Label declared twice',eol
e_inst	db	'Illegal instruction',eol
e_nbig	db	'Number too big',eol
e_xtra	db	'Extra characters on line',eol
e_label	db	'Label name required',eol
e_str	db	'String error',eol
e_orgs	db	'Too many ORGs',eol
e_paren	db	'Need parenthesis',eol
e_tlab	db	'Too many labels',eol
e_amod	db	'Illegal addressing mode',eol
e_bra	db	'Branch out of range by $'
brout	db	'     bytes',eol
e_sin	db	'Bad or missing sinus parameter',eol
e_spac	db	'Space expected',eol
e_opt	db	'OPT directive not supported',eol
e_over	db	'Arithmetic overflow',eol
e_div0	db	'Divide by zero',eol
e_range	db	'Value out of range',eol
e_uknow	db	'Label not defined before',eol
e_undec	db	'Undeclared label',eol
e_fref	db	'Illegal forward reference',eol
e_wpar	db	'Use square brackets instead',eol
e_brack	db	'Not matching brackets',eol
e_user	db	'User error',eol

exitcod	dw	4c00h
flags	db	0
lines	dd	0
bytes	dd	0
iclen	dw	t_icl
laben	dw	t_lab-2
pslab	dw	t_lab-2
orgvec	dw	t_org
sinmin	dw	1
sinmax	dw	0
sinadd	dw	?
sinamp	dw	?
sinsiz	dw	?
ohand	dw	?
val	dw	?,?
amod	db	?,?
ukp1	db	?,?
oper	db	?
cod	db	?
origin	dw	?
labvec	dw	?
fnad	dw	?
tempsi	dw	?
op1	dd	?
	dw	?
op2	dd	?
	dw	?

line	db	258 dup(?)
tlabel	db	256 dup(?)
t_icl	db	l_icl dup(?)
t_org	db	l_org dup(?)
t_lab	db	l_lab dup(?)

	ENDS
	END	start