WIP FRND/FSQL for BK0010

Author: nzeemin

README.md

@@ -33,11 +33,11 @@ Current state of the project: **prototype**
  - полноценный парсинг всех конструкций языка, кроме оператора `DATA`
  - вычисление Integer и Single выражений, вычисление константных String выражений
  - `PRINT` для Integer/Single и константных строк, `INPUT` только для целых чисел
- - функции: `PI`, `ABS`, `FIX`, `INT`, `SGN`, `CINT`, `CSNG`, `PEEK`, `INP`, CSRLIN, POS
+ - функции: `PI`, `ABS`, `FIX`, `INT`, `SGN`, `CINT`, `CSNG`, `PEEK`, `INP`, `SQR`, `SIN`, `COS`, `TAN`, `ATN`, `RND`
  - операторы: `LET` (кроме `LET MID$`), `GOTO`, `GOSUB`, `RETURN`, `IF/THEN/ELSE`, `FOR`, `NEXT`, `ON/GOTO/GOSUB`, `STOP`, `END`, `REM`, `PRINT` (включая `AT`, `TAB`, `SPC`, запятая), `INPUT` (только для Integer), `POKE`, `OUT`, `CLS`, `COLOR`, `LOCATE`, `BEEP`
  - без работы со строками, без работы с файлами, без графики, без `DATA`/`READ`/`RESTORE`
+ - НЕ реализованы функции:, `CSRLIN`, `POS`, `EXP`, `LOG`, `FRE`, `CDBL`, `ASC`, `CHR$`, `LRN`, `MID$`, `STRING$`, `VAL`, `INKEY$`, `STR$`, `BIN$`, `OCT$`, `HEX$`, `LPOS`, `EOF`, `FN`, `USR`
  - НЕ реализованы операторы: `LET MID$`, `DIM`, `KEY`, `CLEAR`, `DATA`, `READ`, `RESTORE`, `DEF USR`, `DEF FN`, `PRINT` для строковых выражений, `INPUT` для Single и строк, `OPEN`, `CLOSE`, `SCREEN`, `PSET`, `PRESET`, `LINE`, `CIRCLE`, `PAINT`, `DRAW`, `TRON`, `TROFF`, `WIDTH`, `SYSTEM`, `MONIT`
- - НЕ реализованы функции: `SQR`, `SIN`, `COS`, `TAN`, `ATN`, `EXP`, `LOG`, `RND`, `FRE`, `CDBL`, `ASC`, `CHR$`, `LRN`, `MID$`, `STRING$`, `VAL`, `INKEY$`, `STR$`, `BIN$`, `OCT$`, `HEX$`, `LPOS`, `EOF`, `FN`, `USR`
 
 Возможные сценарии использования компилятора:
 

generator.cpp

@@ -2643,6 +2643,15 @@ void Generator::GenerateFuncRnd(const ExpressionModel& expr, const ExpressionNod
     const ExpressionModel& expr1 = node.args[0];
     assert(expr1.GetExpressionValueType() != ValueTypeString);
 
+    // Special case for RND(0): return RNDSAV value
+    if (expr1.IsConstExpression() && std::floor(expr1.GetConstExpressionDValue()) == 0.0)
+    {
+        AddLine("\tMOV\tRNDSAV+2, -(SP)\t; RND(0)");
+        AddLine("\tMOV\tRNDSAV, -(SP)");
+        m_runtimeneeds.insert(RuntimeFRND);
+        return;
+    }
+
     GenerateExpression(expr1);
     if (expr1.GetExpressionValueType() == ValueTypeInteger)
         AddRuntimeCall(RuntimeITOF, "to Single");  // result on stack

runtime-BK0010.tmac

@@ -105,7 +105,7 @@ WRSNG:
 	CALL	FUNPK		; число печатается в буфер BUFOUT
 	MOV	#BUFOUT, R0
 	CALL	WRST		; выводим строку на экран
-9$:	JMP	@#000000
+9$:	JMP	@#000000	; возврат, адрес подставляется в начале
 
 ;#####################################################################
 ;## WRST
@@ -896,6 +896,177 @@ GRIZT:	MOV	(SP)+,R3	; 
 	MOV	R2,R3		; иначе восстанавливаем R2
 2$:	RETURN
 
+;#####################################################################
+;## FRND
+;## Need FADD
+;## Need FSUB
+;## Need FMUL
+;## Need FDIV
+; Генератор псевдо-случайных чисел.
+; На основе кода процедуры RAN из реализации Бейсик Вильнюс для УКНЦ.
+; На входе: (SP) адрес возврата
+;           (SP+2)(SP+4) = управляющий параметр:
+;   >0: получить очередное псевдо-случайное число
+;   <0: задаёт начальное значение
+;   0: вернуть предыдущее псевдо-случайное число
+; Результат: (SP)(SP+2) псевдо-случайное число в диапазоне [0,1)
+FRND:
+	MOV	(SP)+, FRND$X+2	; сохраняем адрес для выхода
+	TST	(SP)		; проверяем старшее слово параметра
+	BEQ	26$		; параметр 0 => отдать текущее значение
+	BPL	1$		; > 0 => генерация следующего
+; Параметр < 0 ? инициализация
+	CLR	RNDSAV		; сбросить сохранённое значение
+	MOV	#040311, FRND$I	; начальное состояние = PI/2
+	MOV	#007733, FRND$I+2
+1$:	MOV	#FRND$I, R2	; адрес состояния (старшее слово)
+	MOV	#FRND$I+2, R3	; адрес состояния (младшее слово)
+	MOV	(R2), R0	; загрузить текущее состояние
+	MOV	(R3), R1
+	BEQ	21$		; если ноль, особая инициализация
+; state = (state * 3 + 1) mod 2^31
+	ASL	R1		; умножить на 2
+	ROL	R0
+	ADD	(R2), R0	; state*3
+	ADD	(R3), R1
+	ADC	R0
+	ADD	(R3), R0	; + state (младшее слово) -> state*3 + 1
+	BPL	2$		; если нет переполнения знакового бита
+	ADD	#100000,R0	; инвертировать знаковый бит
+;RAN2:
+2$:	MOV	R0, (R2)	; сохранить новое состояние в III
+	MOV	R1, (R3)
+	MOV	#201,R2		; начальная экспонента = 129.
+4$:	ASL	R1		; нормализация:
+	ROL	R0		; сдвигать мантиссу, пока старшая единица не выйдет в C
+	BCS	23$
+	DEC	R2		; уменьшать экспоненту
+	BR	4$
+;RAN3: Упаковка в формат float: знак = 0, экспонента = R2, мантисса из старших битов R0,R1
+23$:	CLRB	R1
+	BISB	R0,R1
+	SWAB	R1
+	CLRB	R0
+	BISB	R2,R0
+	SWAB	R0
+	ROR	R0		; знак = 0
+	ROR	R1
+	BR	25$
+;RAN1: Если состояние обнулилось (например, при инициализации нулём), используем (1,3)
+21$:	MOV	#3,R1
+	INC	R0
+	BR	2$
+;RAN5:
+25$:	TST	RNDSAV		; RNDSAV ещё не заполнено? первый вызов после инициализации
+	BNE	27$		; не ноль, значит уже было ? просто сохраняем новое
+; Первое после инициализации: преобразуем целое состояние в float [0,1)
+	MOV	R1,-(SP)	; поместить полученное число (R0,R1) на стек
+	MOV	R0,-(SP)
+	CLR	R5		; R5 = 0 (счётчик масштабирования)
+	MOV	6(SP),-(SP)	; Дублируем число для операций
+	MOV	6(SP),-(SP)
+	BIC	#100000,(SP)	; сбросить знак (работаем с положительным числом)
+; Цикл приведения в диапазон [0,1)
+13$:	CMP	#040200,(SP)	; сравнить старшее слово с 1.0
+	BGT	11$		; если > 1.0 -> уменьшить
+	DEC	R5		; иначе увеличиваем счётчик
+	BGE	15$		; если R5 >= 0, выходим (достигли нужного интервала)
+; Число < 1.0, но R5 < 0 -> нужно делить на 10.0
+	CLR	-(SP)		; константа 10.0 младшее слово
+	MOV	#041040,-(SP)	; константа 10.0 старшее слово
+	CALL	FDIV		; разделить число на 10.0
+	BR	13$		; продолжить цикл
+11$:	MOV	SP,R2
+	MOV	(R2)+,6(R2)	; копирование числа
+	MOV	(R2)+,6(R2)
+	INC	R5
+	BLE	15$
+	CLR	-(SP)		; константа 10.0 младшее слово
+	MOV	#041040,-(SP)	; константа 10.0 старшее слово
+	CALL	FMUL		; умножить на 10.0
+	BR	13$		; продолжить цикл
+;
+15$:	ADD	#4,SP		; удаляем временные копии числа
+; Теперь требуется ещё отбросить целую часть
+	CLR	-(SP)		; константа 10.0 младшее слово
+	MOV	#041040,-(SP)	; константа 10.0 старшее слово
+	CALL	FDIV		; деление на 10.0
+	CLR	-(SP)		; положить 1.0 младшее слово
+	MOV	#040200,-(SP)	; положить 1.0 старшее слово
+	CALL	FADD		; сложить с 1.0
+	CALL	FSUB		; вычитание
+;
+17$:	BIC	#100000,(SP)	; сбросить знак результата
+	MOV	SP,R2
+	MOV	(R2)+, FRND$I	; сохранить результат в III
+	MOV	(R2)+, FRND$I+2
+	MOV	-(R2), R1	; восстановить R0,R1
+	MOV	-(R2), R0
+;RAN7:
+27$:	MOV	R1, RNDSAV+2	; сохранить сгенерированное значение
+	MOV	R0, RNDSAV
+;RAN6:
+26$:	MOV	RNDSAV+2, 2(SP)	; заменяем параметр на стеке на результат
+	MOV	RNDSAV, (SP)
+FRND$X:	JMP	@#000000	; возврат, адрес подставляется в начале
+;
+FRND$I:	.WORD	040101, 027076	; III: Рабочие ячейки FRND
+RNDSAV:	.WORD	040101, 027076	; Предыдущее псевдо-случайное число: старшее, младшее
+
+;#####################################################################
+;## FSQR
+;## Need FADD
+;## Need FDIV
+;## Need ERRR
+; Квадратный корень из плавающего числа (float).
+; На основе кода процедуры SQRG из реализации Бейсик Вильнюс для УКНЦ.
+; Для отрицательных чисел выдаётся ошибка; для 0.0 результат 0.0.
+; Алгоритм: итерационный метод Ньютона с начальным приближением
+; На входе: (SP) - адрес возврата
+;           (SP+2)(SP+4) - число с плавающей точкой (старшее слово, младшее слово)
+; На выходе: (SP)(SP+2) - результат
+FSQR:
+	MOV	(SP)+, FSQR$X+2	; адрес возврата
+	CLR	-(SP)		; выделить слово для счётчика итераций (3)
+	MOV	SP,R4		; R4 указывает на вершину стека (временный указатель)
+	TST	(R4)+		; пропустить младшее слово аргумента
+	MOV	(R4), R1	; R1 = старшее слово аргумента
+	BMI	FSQR$K		; если отрицательное - ошибка
+	BEQ	0$		; если ноль - результат 0
+	MOV	#3,-(SP)	; счётчик итераций (3) на стек
+	ASR	R1		; экспоненту делим на 2 (приближение)
+	ADD	#20100, R1	; коррекция мантиссы (начальное приближение)
+	CLR	-(SP)		; младшее слово приближения = 0
+	MOV	R1, -(SP)	; старшее слово приближения на стек
+	CLR	-(SP)		; младшее слово аргумента (0)
+	MOV	(R4), -(SP)	; старшее слово аргумента (копия)
+	CLR	-(SP)		; младшее слово для операции
+	MOV	R1, -(SP)	; старшее слово приближения (второй операнд)
+3$:	CALL	FDIV		; деление: аргумент / приближение
+	CALL	FADD		; сложение: (приближение + результат деления)
+	SUB	#200, (SP)	; поделить результат на 2
+	DEC	4(SP)		; уменьшить счётчик итераций
+	BEQ	2$		; если счётчик = 0, выходим
+	MOV	12(SP), -(SP)	; иначе скопировать тек.приближение для следующей итерации
+	MOV	12(SP), -(SP)
+	MOV	6(SP), -(SP)
+	MOV	6(SP), -(SP)
+	BR	3$		; повторить
+2$:	MOV	(SP)+, R0	; снять старшее слово результата
+	MOV	(SP)+, R1	; снять младшее слово результата
+	TST	(SP)+		; удалить счётчик итераций
+	BR	FSQR$E		; получили результат, выходим
+0$:	CLR	R0		; результат 0.0
+	CLR	R1
+; R0,R1 - старшее и младшее слова результата
+FSQR$E:	MOV	R0, (SP)	; заменяем старшее слово результатом
+	MOV	R1, 2(SP)	; заменяем младшее слово
+FSQR$X:	JMP	@#000000	; возврат, адрес подставляется в начале
+;
+FSQR$K:	MOV	FSQR$X+2, R5	; откуда вызвали
+	MOV	#3605., R0	; Ошибка: корень из отрицательного числа
+	JMP	ERRR
+
 ;#####################################################################
 ;## FADD
 ;## Need ERRR
@@ -1155,7 +1326,7 @@ FMUL$M:	MOV	R0,10(SP)	; 
 	MOV	(SP)+,R4
 	MOV	(SP)+,R5
 	CMP	(SP)+,(SP)+	; удаление числа B из стека
-FMUL$X:	JMP	@#000000	; возврат
+FMUL$X:	JMP	@#000000	; возврат, адрес подставляется в начале
 ;
 ;MREZ0: Формирование нулевого результата
 FMUL$0:	TST	(SP)+		; очистка стека
@@ -1302,7 +1473,7 @@ FDIV$D:	MOV	(SP)+,R4	; 
 FDIV$E:	MOV	(SP)+,R4	; восстановление регистров
 	MOV	(SP)+,R5
 	CMP	(SP)+,(SP)+	; удаление числа B из стека
-FDIV$X:	JMP	@#000000	; возврат
+FDIV$X:	JMP	@#000000	; возврат, адрес подставляется в начале
 ;
 ;DALYT: Подпрограмма деления мантисс
 FDIV$T:	ASL	R5		; сдвиг результата

runtime-UKNC.tmac

@@ -122,7 +122,7 @@ WRSNG:
 	CALL	FUNPK		; число печатается в буфер BUFOUT
 	MOV	#BUFOUT, R0
 	CALL	WRST		; выводим строку на экран
-9$:	JMP	@#000000
+9$:	JMP	@#000000	; возврат, адрес подставляется в начале
 
 ;#####################################################################
 ;## WRST
@@ -875,10 +875,10 @@ FRND:
 	BPL	1$		; > 0 => генерация следующего
 ; Параметр < 0 ? инициализация
 	CLR	RNDSAV		; сбросить сохранённое значение
-	MOV	#040311, III	; начальное состояние = PI/2
-	MOV	#007733, III+2
-1$:	MOV	#III, R2	; адрес состояния (старшее слово)
-	MOV	#III+2, R3	; адрес состояния (младшее слово)
+	MOV	#040311, FRND$I	; начальное состояние = PI/2
+	MOV	#007733, FRND$I+2
+1$:	MOV	#FRND$I, R2	; адрес состояния (старшее слово)
+	MOV	#FRND$I+2, R3	; адрес состояния (младшее слово)
 	MOV	(R2), R0	; загрузить текущее состояние
 	MOV	(R3), R1
 	BEQ	21$		; если ноль, особая инициализация
@@ -956,8 +956,8 @@ FRND:
 ;
 17$:	BIC	#100000,(SP)	; сбросить знак результата
 	MOV	SP,R2
-	MOV	(R2)+, III	; сохранить результат в III
-	MOV	(R2)+, III+2
+	MOV	(R2)+, FRND$I	; сохранить результат в III
+	MOV	(R2)+, FRND$I+2
 	MOV	-(R2), R1	; восстановить R0,R1
 	MOV	-(R2), R0
 ;RAN7:
@@ -968,8 +968,8 @@ FRND:
 	MOV	RNDSAV, (SP)
 FRND$X:	JMP	@#000000	; возврат, адрес подставляется в начале
 ;
-III:	.WORD	040101, 027076	; Рабочие ячейки FRND
-RNDSAV:	.WORD	040101, 027076	; Предыдущее псевдо-случайере число
+FRND$I:	.WORD	040101, 027076	; III: Рабочие ячейки FRND
+RNDSAV:	.WORD	040101, 027076	; Предыдущее псевдо-случайное число: старшее, младшее
 
 ;#####################################################################
 ;## FSQR
@@ -982,7 +982,7 @@ RNDSAV:	.WORD	040101, 027076	; 
 ;           (SP+2)(SP+4) - число с плавающей точкой (старшее слово, младшее слово)
 ; На выходе: (SP)(SP+2) - результат
 FSQR:
-	MOV	(SP)+, R5	; адрес возврата
+	MOV	(SP)+, FSQR$X+2	; адрес возврата
 	CLR	-(SP)		; выделить слово для счётчика итераций (3)
 	MOV	SP,R4		; R4 указывает на вершину стека (временный указатель)
 	TST	(R4)+		; пропустить младшее слово аргумента
@@ -1017,9 +1017,9 @@ FSQR:
 ; R0,R1 - старшее и младшее слова результата
 FSQR$E:	MOV	R0, (SP)	; заменяем старшее слово результатом
 	MOV	R1, 2(SP)	; заменяем младшее слово
-	JMP	@R5		; возврат
+FSQR$X:	JMP	@#000000	; возврат, адрес подставляется в начале
 ;
-FSQR$K:	MOV	(SP), R5	; откуда вызвали
+FSQR$K:	MOV	FSQR$X+2, R5	; откуда вызвали
 	MOV	#3605., R0	; Ошибка: корень из отрицательного числа
 	JMP	ERRR