WIP FADD/FSUB for BK0010

Author: nzeemin

README.md

@@ -96,6 +96,7 @@ VARIA:	.WORD	0	; A%
 Так же, как и в оригинале Бейсик Вильнюс:
  - Один оператор на строку.
  - Имена переменных опознаются по двум первым буквам + тип.
+ - Булевого типа нет, вместо него используется целый тип. Результат логических операторов (`=`, `<>`, `>`, `<` и т.п.) это либо -1 ("истина") либо 0 ("ложь").
 
 Отличия от оригинала:
  - Ключевые слова нужно писать полностью, сокращения НЕ допускаются.
@@ -104,7 +105,7 @@ VARIA:	.WORD	0	; A%
  - Под оператором `IF` в `THEN`/`ELSE` НЕ допускается ставить операторы `FOR`/`NEXT`/`DIM`/`DATA`
  - Аргумент функций `CSRLIN` и `POS` необязательный, но если есть, то вычисляется (если он не константный), но результат вычисления не используется.
  - `ON .. GOTO/GOSUB`: отрицательное значение выражения под `ON` не приводит к ошибке, просто переходим на строку, следующую после этого оператора.
- - Добавлена функция `IIF` с тремя аргументами: `X=IIF(<ЛОГ.ВЫРЖЕНИЕ>,<АРИФМ.ВЫРАЖЕНИЕ>,<АРИФМ.ВЫРАЖЕНИЕ>)`. Вычисляется первый аргумент; если он ненулевой (т.е. TRUE), то результатом будет значение второго выражения, иначе (для FALSE) - значение третьего выражения. Вычисляется только то выражение, результат которого нам нужен. Тип результата зависит от типов второго и третьего аргументов: если они оба Integer, то и результат Integer; если хотя бы один из них Single, то и результат Single.
+ - Добавлена функция `IIF` с тремя аргументами: `X=IIF(<ЛОГ.ВЫРАЖЕНИЕ>,<АРИФМ.ВЫРАЖЕНИЕ>,<АРИФМ.ВЫРАЖЕНИЕ>)`. Вычисляется первый аргумент; если он ненулевой (т.е. TRUE), то результатом будет значение второго выражения, иначе (для FALSE) - значение третьего выражения. Вычисляется только то выражение, результат которого будет использоваться. Тип результата зависит от типов второго и третьего аргументов: если они оба Integer, то и результат Integer; если хотя бы один из них Single, то и результат Single.
  - Команды/операторы, которые не реализованы и НЕ БУДУТ реализованы в будущем:
    - `RUN`, `CONT`
    - `KEY` (переназначение функциональных клавиш)

runtime-BK0010.tmac

@@ -500,7 +500,7 @@ FCMP:
 	BLT	5$
 2$:	CMP	R1,R2		; сравнить старшие слова
 	BNE	3$
-	CMP	4(SP),@SP	; сравнить младшие слова
+	CMP	4(SP),(SP)	; сравнить младшие слова
 	BNE	3$
 	CLR	R0		; равны
 3$:	ROR	R0		; знак в старший бит
@@ -570,7 +570,7 @@ FUNPK:
 ; После обработки R2 будет содержать истинную экспоненту (со знаком),
 ; а R0 и R1 - мантиссу (R0 - старшие 16 бит, R1 - младшие 16 бит).
 	ROL	R0		; сдвигаем старшее слово, чтобы извлечь знак
-	ROR	@SP		; знак (C) помещается в младший бит слова, на которое указывает SP
+	ROR	(SP)		; знак (C) помещается в младший бит слова, на которое указывает SP
 				; (это сохранённое значение 7, используется как флаг)
 	SWAB	R0		; меняем байты местами, чтобы ст.байт (эксп-та+мантисса) оказался в младшем
 	BISB	R0,R2		; R2 получает ст.байт исходного R0 (экспонента + старшие биты мантиссы)
@@ -647,12 +647,12 @@ KLIOP:	CALL	APVAL		; 
 	BLT	1$		; если цифр меньше -1, пропускаем
 	CMP	R5,6(SP)	; сравниваем с 7
 	BGT	1$		; если больше 7, пропускаем
-	CLRB	@SP		; сбрасываем флаг (слово на вершине стека)
+	CLRB	(SP)		; сбрасываем флаг (слово на вершине стека)
 	ADD	R5,R2		; корректируем указатель
 1$:	SUB	#4,10(SP)	; уменьшаем указатель конца буфера на 4 (резервируем место)
 E:	ADD	10(SP),R2	; R2 = R2 + конец буфера (теперь R2 указывает на позицию для цифр)
 	MOV	R2,R3		; R3 - текущий указатель в буфере
-	TSTB	@SP		; проверяем флаг (был ли установлен особый формат)
+	TSTB	(SP)		; проверяем флаг (был ли установлен особый формат)
 	BNE	1$		; если флаг установлен, переход к другой ветке
 	TST	R5		; проверяем количество цифр
 	BLE	TRUP		; если цифр <= 0, идём на TRUP
@@ -671,7 +671,7 @@ PNUL:	CMP	R3,10(SP)	; 
 	MOVB	#60,(R3)+	; заполняем нулями
 	BR	PNUL
 SKAITM:	MOV	R2,R3		; восстанавливаем указатель
-	TSTB	@SP		; проверяем флаг
+	TSTB	(SP)		; проверяем флаг
 	BEQ	1$
 	DEC	R3		; коррекция
 	BR	OPA
@@ -702,7 +702,7 @@ VIENZ:	ADD	#72,R5		; 
 VISKA1:	MOV	R3,R2		; сохраняем конечный указатель
 VISKAS:	MOVB	#40,(R2)+	; записываем пробел
 	MOV	(SP)+,R5	; восстанавливаем R5
-	MOV	(SP)+,@SP	; восстанавливаем SP ??
+	MOV	(SP)+,(SP)	; восстанавливаем SP ??
 	SUB	4(SP),R2	; вычисляем длину строки
 	MOV	R2,2(SP)	; сохраняем длину
 
@@ -725,7 +725,7 @@ IRDAR:	CALL	DL4		; 
 DARSYK:	CALL	DALYT2		; разделить на 2 (теперь всего деление на 8 от исходного)
 	ADD	2(SP),R1	; прибавить сохранённое (исходное/2) к текущему
 	ADC	R0
-	ADD	@SP,R0		; прибавить старшее слово (исходное/2)
+	ADD	(SP),R0		; прибавить старшее слово (исходное/2)
 	NEG	R4		; изменить знак счётчика (управление циклами)
 	BLT	DARSYK		; если R4 отрицательный, повторить внутренний цикл
 	DEC	R4		; иначе уменьшить счётчик
@@ -768,7 +768,7 @@ DAUG8:	MOV	#3,-(SP)	; 
 DG2:	ASL	R1		; сдвиг влево младшего слова (умножение на 2)
 	ROL	R0		; сдвиг влево среднего слова с переносом из младшего
 	ROL	R4		; сдвиг влево старшего байта с переносом из среднего
-	DEC	@SP		; уменьшаем счётчик
+	DEC	(SP)		; уменьшаем счётчик
 	BGT	DG2		; повторяем 3 раза - всего умножение на 2^3 = 8
 	TST	(SP)+		; удаляем счётчик из стека
 	RETURN
@@ -834,10 +834,10 @@ ZENKL:	MOV	R3,14(SP)	; 
 ; На выходе: в буфер вставляется десятичная точка, дробные цифры,
 ;            возможно, округление; R3 становится указателем на следующий свободный байт.
 FORMSK:	MOV	R2,-(SP)	; сохраняем R2 (указатель на начало целой части)
-	DEC	@SP		; уменьшаем его на 1 (для удобства сравнений)
+	DEC	(SP)		; уменьшаем его на 1 (для удобства сравнений)
 	CMP	#12,R4		; сравниваем R4 с 10.
 	BGT	NEDVIZ		; если цифра >10, пропускаем вставку десятичной точки
-	MOV	R3,@SP		; иначе сохраняем текущий указатель в стеке
+	MOV	R3,(SP)		; иначе сохраняем текущий указатель в стеке
 	MOVB	#61,(R3)+	; записываем символ '=' - возможно, десятичная точка?
 	SUB	#12,R4		; вычитаем 10 из R4 (коррекция для следующего шага)
 NEDVIZ:	CMP	R2,R3		; сравниваем указатель начала целой части и текущий
@@ -847,7 +847,7 @@ NETASK:	CMP	14(SP),R3	; 
 	BLOS	GRIZT		; если R3 <= конец буфера, выходим
 	TST	R4		; проверяем, есть ли цифра для вывода
 	BEQ	1$		; если нет, пропускаем
-	MOV	R3,@SP		; сохраняем указатель
+	MOV	R3,(SP)		; сохраняем указатель
 1$:	ADD	#60,R4		; преобразуем цифру (0?9) в ASCII-символ
 	MOVB	R4,(R3)+	; записываем цифру
 	CLR	R4		; обнуляем R4 (цифра использована)
@@ -863,30 +863,175 @@ GRIZT:	MOV	(SP)+,R3	; 
 
 ;#####################################################################
 ;## FADD
-; Сложение для float, эмуляция FIS, параметры B и A на стеке
+;## Need ERRR
+; Сложение для плавающих чисел, эмуляция FIS, параметры B и A на стеке.
+; На основе кода процедуры ADR из реализации Бейсик Вильнюс для БК-0010.
 ; На входе: (SP) - адрес возврата
 ;           (SP+2)(SP+4) - плавающее число B (старшее, младшее слово)
 ;           (SP+6)(SP+10) - плавающее число A (старшее, младшее слово)
 ; Результат: (SP)(SP+2) - плавающее число (старшее слово, младшее слово)
 FADD:
-
-;TODO
-	RETURN ;STUB
+	CLR	-(SP)		; МЕСТО ДЛЯ ЗНАКОВ СЛАГАЕМЫХ
+	CLR	R2		; под порядок A
+	CLR	R3		; под порядок B
+; Анализ операндов
+	ASL	6(SP)
+	ROL	4(SP)
+	BISB	5(SP),R3 	; порядок B -> R3
+	BEQ	50$		; B=0 => A - результат
+	ROLB	(SP)		; запомнить знак B
+;
+	ASL	12(SP)
+	ROL	10(SP)
+	BISB	11(SP),R2	; порядок операнда A -> R2
+	BNE	1$
+;
+	RORB	(SP)		; восстановить B
+	ROR	4(SP)
+	ROR	6(SP)
+	MOV	4(SP),10(SP)
+	MOV	6(SP),12(SP)
+	BR	50$		; X=0 => РЕЗУЛЬТАТ - B
+;A1:
+1$:	ROLB	1(SP)		; запомнить знак A
+	MOVB	#1,11(SP)
+	MOVB	#1,5(SP)
+	SUB	R3,R2		; РАЗНОСТЬ ПОРЯДКОВ ЧИСЕЛ А И B => R2
+	BGT	2$
+;
+	MOV	10(SP),R0	; В R0,R1 - МАНТИССА ЧИСЛА
+	MOV	12(SP),R1	; С МЕНЬШИМ ПОРЯДКОМ
+	BR	20$
+;A2:
+2$:	ADD	R2,R3
+	MOV	4(SP),R0
+	MOV	6(SP),R1
+	MOV	10(SP),4(SP)
+	MOV	12(SP),6(SP)
+	SWAB	(SP)
+	NEG	R2
+;CMZ:
+20$:	CMPB	1(SP),(SP)	; ЕСЛИ ЗНАКИ ЧИСЕЛ НЕ=
+	BEQ	21$		; ИЗМЕНИТЬ ЗНАК МЕНЬШЕГО ЧИСЛА
+	NEG	R1
+	ADC	R0
+	NEG	R0
+;Z1:
+21$:	TST	R2		; ЕСЛИ R2 = 0 - выполнить сложение
+	BEQ	30$
+	CMP	#-31,R2		; ЕСЛИ R2 > 31 => REZ=ЧИСЛО С БОЛЬШИМ ПОРЯДКОМ
+	BLE	22$
+	MOV	4(SP),R0
+	MOV	6(SP),R1
+	BR	7$
+;Z2
+22$:	CMP	#-10,R2		; ПРИВЕСТИ СЛАГАЕМЫЕ К ОДИНАКОВОМУ
+	BLE	6$		;     ПОРЯДКУ
+	CLR	R4
+	TST	R0
+	BPL	3$
+	COM	R4
+;A3:
+3$:	CMP	#-20,R2
+	BLT	4$
+	MOV	R0,R1
+	MOV	R4,R0
+	ADD	#20,R2
+	BEQ	30$
+4$:	CMP	#-10,R2
+	BLE	6$
+	ADD	#20,R2
+5$:	ASL	R1
+	ROL	R0
+	ROL	R4
+	DEC	R2
+	BGT	5$
+	MOV	R0,R1
+	MOV	R4,R0
+	BR	30$
+;A6:
+6$:	ASR	R0
+	ROR	R1
+	INC	R2
+	BLT	6$
+;SUM:
+30$:	ADD	4(SP),R0	;  СЛОЖИТЬ ЧИСЛА
+	ADD	6(SP),R1
+	ADC	R0
+;
+	CMPB	1(SP),(SP)	; ЗНАКИ СЛАГАЕМЫХ РАЗЛИЧНЫ ?
+	BNE	8$
+	BIT	R0,#1000	; РЕЗУЛЬТАТ НОРМАЛИЗОВАН?
+	BEQ	7$
+	ASR	R0
+	ROR	R1
+	INC	R3
+7$:	SWAB	R3
+	BNE	FADD$O		; переполнение порядка
+;
+	BISB	R0,R3
+	ROR	(SP)		; СФОРМИРОВАТЬ РЕЗ-Т В ВИДЕ ЧИСЛА
+	ROR	R3		; С ПЛАВАЮЩЕЙ ЗАПЯТОЙ
+	ROR	R1
+	ADC	R1
+	ADC	R3
+	BVS	FADD$O
+	BCS	FADD$O
+13$:	MOV	R3, 10(SP)	; сохранить старшее слово результата на место A
+	MOV	R1, 12(SP)	; сохранить младшее слово результата
+;REZ:
+50$:	TST	(SP)+		; удалить слово знаков
+	MOV	(SP)+,R5	; адрес возврата
+	CMP	(SP)+,(SP)+	; удаление числа B со стека
+	JMP	@R5		; возврат
+;A8:
+8$:	TST	R0
+	BGT	9$
+	BEQ	10$
+	NEG	R0		; ИЗМЕНИТЬ ЗНАК РЕЗУЛЬТАТА
+	NEG	R1
+	SBC	R0
+	SWAB	(SP)
+;A9:
+9$:	BIT	R0,#400		; НОРМАЛИЗОВАТЬ МАНТИССУ РЕЗУЛЬТАТА
+	BNE	11$
+	DEC	R3
+	ASL	R1
+	ROL	R0
+	BR	9$
+;A10:
+10$:	TST	R1
+	BEQ	12$
+	SWAB	R1		; НОРМАЛИЗОВАТЬ МАНТИССУ РЕЗУЛЬТАТА
+	BISB	R1,R0
+	CLRB	R1
+	SUB	#10,R3
+	BR	9$
+;A11:
+11$:	TST	R3
+	BGT	7$
+	CLR	R1
+12$:	CLR	R3
+	BR	13$
+;
+; Ошибка: переполнение
+FADD$O:	MOV	(SP), R5	; откуда вызвали
+	MOV	#2806., R0	; Ошибка: переполнение
+	JMP	ERRR
 
 ;#####################################################################
 ;## FSUB
 ;## Need FADD
 ; Вычитание для float, эмуляция FIS, параметры B и A на стеке.
-; На основе кода процедуры $DSUB$ из реализации Бейсик Вильнюс для БК-0010.
 ; На входе: (SP) - адрес возврата
 ;           (SP+2)(SP+4) - плавающее число B (старшее, младшее слово)
 ;           (SP+6)(SP+10) - плавающее число A (старшее, младшее слово)
 ; Результат: (SP)(SP+2) - плавающее число (старшее слово, младшее слово)
 FSUB:
-	TST	2(SP)		; ZERO?
-	BEQ	FADD		; YES, SO IT CAN'T BE NEGATED
-	ADD	#100000,2(SP)	; NEGATE SIGN OF B ON STACK
-	BR	FADD		; FALL THROUGH AND DO AN ADDITION (A-B=A+(-B))
+	TST	2(SP)		; проверяем старше слово
+	BEQ	1$		; ноль =>
+	ADD	#100000,2(SP)	; изменить знак операнда
+1$:	JMP	FADD		; идём на сложение: A-B = A+(-B)
 
 ;#####################################################################
 ;## FMUL

runtime-UKNC.tmac

@@ -978,7 +978,6 @@ RNDSAV:	.WORD	040101, 027076	; 
 ; На основе кода процедуры SQRG из реализации Бейсик Вильнюс для УКНЦ.
 ; Для отрицательных чисел выдаётся ошибка; для 0.0 результат 0.0.
 ; Алгоритм: итерационный метод Ньютона с начальным приближением
-; На основе кода процедуры SQRG из реализации Бейсик Вильнюс для УКНЦ.
 ; На входе: (SP) - адрес возврата
 ;           (SP+2)(SP+4) - число с плавающей точкой (старшее слово, младшее слово)
 ; На выходе: (SP)(SP+2) - результат