include io.asm    

	PTree struc
		Elem db 8 dup (?)
		Re dw ?
		L dw ?
		R dw ?
	PTree ends

stack segment stack
     dw 128 dup (?)
stack ends

data  segment
	X db 161 dup (?)
	Wo db 8 dup (?)
	inpText db 'Please insert words$'
	er0 db 'Incorrect word! Try again!$'
	er1 db 'Big word (more than 9 symbols)! Try again!$'
	er2 db 'There are a lot of words (more than 21)! Try again!$'
	er3 db 'Empty word! Try again!$'
	Nil equ 0
	root dw ?
data  ends

heap segment
	hsize equ 20
	heap_ptr dw ?
	PTree 20 dup (<>)
heap ends

code segment
    assume ss:stack, ds:data, cs:code 
	
;;;Инициализация
init_heap proc far
	push si
	push bx
	push cx
	mov cx, heap
	mov es, cx
	mov cx, hsize
	mov bx, nil
	mov si, 14*19+2 ;;;;;;;;наверно
Init1:
	mov es:[si].R, bx
	mov bx, si
	sub si, 14
	loop Init1
	mov es:heap_ptr, bx
	pop cx
	pop bx
	pop si
	ret	
init_heap endp	

;;;Новый эл-т	
New proc
	mov di, es:heap_ptr
	push es:[di].R
	pop es:heap_ptr
	ret
New endp

;;;Удалить эл-т
Dispose proc
	push es:heap_ptr
	pop es:[di].R
	mov es:heap_ptr, di
	ret
Dispose endp


;;;Ввод текста
Input proc
	push bp
	push dx
	push bx
	push si
	push cx
	push ax
	lea dx, inpText
	outstr
Again:
	mov bx, [bp+4]
	newline
	outch '>'
	xor ax, ax ;счетчик слов
	xor si, si ;модефикатор по X
	xor cx, cx ;счетчик символов в слове
	inc ax
Inp:
	inc cx
	inch [bx][si]
	cmp [bx][si], ','
	je Next
	cmp [bx][si], '.'
	je EndInp
	cmp [bx][si], 'A'
	jb Err0 ;Некорректное слово
	cmp [bx][si], 'Z'
	ja Err0
	cmp cx, 9
	je Err1 ;Большое слово
	inc si
	jmp Inp
Next:
	cmp cx, 1
	je Err3 ;Пустое слово
	cmp ax, 21
	je Err2 ;Много слов
L1:	cmp cx, 9
	je Ok1
	mov [bx][si], ' '
	inc cx
	inc si
	jmp L1
Ok1:	
	xor cx, cx
	inc ax
	jmp Inp
EndInp: 
	cmp ax, 1
	je Err3
	cmp ax, 21
	jae Err2
L2:	cmp cx, 9
	je Work
	mov [bx][si], ' '
	inc cx
	inc si
	jmp L2
Err0:
	lea dx, er0
	jmp Error
Err1:
	lea dx, er1
	jmp Error
Err2:
	lea dx, er2
	jmp Error
Err3:
	lea dx, er3
Error:
	outstr
	flush
	newline
	jmp Again
;;Все Ok. Работаем дальше!
Work:	mov [bx][si], '$'
	pop ax
	pop cx
	pop si
	pop bx
	pop cx
	pop bp
	ret 2
Input endp

Adding proc
	push bp
	mov bp,sp
	push si
	push di
	push ax
	push bx
	push cx
	push dx

	mov bx,[bp+6]
;выделяем место в памяти
	call new
	mov ax,di

	cmp bx,nil
	jne zz2       ;;дерево есть, начинаем сравнение
;если дерева нет, меняем ссылку на него на первый элемент
	mov bx,[bp+4]
	mov [bx],di

	jmp FIN
;сравниваем слова
zz2:
	mov si,[bp+8]
	mov di,0
	mov cx,8
z1:
	mov dl,[si]
	cmp dl,es:[bx].elem[di]
	ja A1
	jb B1
	inc si
	inc di
	loop z1

;если слова равны, увеличиваем счётчик
	mov di,ax
	call dispose
	inc es:[bx].re

jmp FIN2
;новое слово больше идём по правой ветке


A1:
	cmp es:[bx].R,nil
	jne A2
	mov es:[bx].R,ax
	jmp FIN
A2:
	mov bx,es:[bx].R
	jmp ZZ2
;новое слово меньше идём по левой ветке
B1:
	cmp es:[bx].L,nil
	jne B2
	mov es:[bx].L,ax
	jmp FIN
B2:
	mov bx,es:[bx].L
	jmp zz2
FIN:

	mov di,ax
	mov cx,8
	mov si,[bp+8]
	mov bx,0

F1:
	mov ah,[si]
	mov es:[di].elem[bx],ah
	inc si
	inc bx
	loop F1

	mov es:[di].R,nil
	mov es:[di].L,nil
	mov es:[di].re,1


FIN2:
	pop dx
	pop cx
	pop bx
	pop ax
	pop di
	pop si
	pop bp

ret 2*3
Adding endp


Output proc
	push bp
	mov bp, sp
	push si
	push cx
	push bx
	mov si, [bp+4]
	
	cmp es:[si].L, nil
	je Cur
	push es:[si].L
	call Output
Cur:	
	cmp es:[si].re, 1
	jbe Right
	mov cx, es:[si].re
NewOut:
	push cx
	mov bx, 0
	mov cx, 8
N2:	cmp es:[si].elem[bx], ' '
	jne N5
	outch '.'
	jmp N4
N5:	outch es:[si].elem[bx]
N4:	inc bx
	Loop N2
	mov cx, 5
N3:	outch '.'
	Loop N3
	outint es:[si].re
	newline
	pop cx
	Loop NewOut

Right:
	cmp es:[si].R, nil
	je Exit
	push es:[si].R
	call Output
	
Exit:
	pop bx
	pop cx
	pop si
	pop bp
	ret 2
Output endp

Count proc
	push bp
	mov bp, sp
	push bx
	mov bx, [bp+4]
	xor ax, ax
Next0:
	cmp [bx], '$'
	je End1
	inc ax
	inc bx
	jmp Next0
End1:
	pop bx
	pop bp
	ret 2
Count endp

Kill proc
	push bp
	mov bp, sp
	push si
	mov si, [bp+4]
	cmp es:[si].L, nil
	je Rig
	push es:[si].L
	call Kill
Rig:
	cmp es:[si].R, nil
	je Exit2
	push es:[si].R
	call Kill
Exit2:
	mov di, es:[si]
	call dispose
	outch '+'
	newline
	pop si
	pop bp
	ret 2	
Kill endp

start:
    	mov ax,data
    	mov ds,ax
	mov root, nil
	lea ax, X
	push ax
	call Input
	call Init_heap
	lea dx, x
	push dx
	call Count
	mov bl, 8
	div bl
	mov cl, al
	xor ch, ch ;;;;В CX кол-во слов
;----
	xor si, si
L3:	lea dx, x[si]
	push dx
	push root
 	lea ax, offset root
	push ax
	call Adding

	add si, 8
	Loop L3

	push root	
	call Output
	
	push root	
	call Kill
    finish
code ends
    end start