Ох, чувствую, что в процессе реализации float самой сложной частью станет перевод из текстового представления в двоичное... :zombypc;

[quote="Total Vacuum"]Зажировка - увеличение разрядности команд процессора и количества одновременно выполняемых инструкций с целью повышения быстродействия :) [/quote]
Если уж вводить термины, то такие вкусненькие :))

[quote="Total Vacuum"]А в Мануле нет возможности делать call/jmp по вычисленному адресу (в стеке)?[/quote]
Есть, это в целом несложно.
[quote="Total Vacuum"] Хотя, наверное, такое можно провернуть через >r и ret[/quote]
А вот стек возвратов смешивать со стеком данных мне давно не нравится, особенно в форт-процессорах. И разрядность в целом не совпадает, и операция начинает вклиниваться в основной путь обработки данных, который идет через вершину стека. А главное, стилистически оно плохо выглядит.

Зажировка - увеличение разрядности команд процессора и количества одновременно выполняемых инструкций с целью повышения быстродействия :)

А в Мануле нет возможности делать call/jmp по вычисленному адресу (в стеке)? Хотя, наверное, такое можно провернуть через >r и ret

[quote="Total Vacuum"]там этот порядок вызова подпрограмм вполне естественный и к тому же единственный: сначала кладем в стек адрес, а потом выполняем команду call.[/quote]
В целом это для форт-процессоров действительно естественно... но не для манула! У него зажировка :) Не то чтобы это можно было термином вводить, но очень уж похоже :))

Да, указатели на функции теперь тоже работают. Проще всего транслировать в классический Форт (['] для взятия адреса и EXECUTE для вызова). Например, такой код[code]extern void printn (int n);
extern void prints (char *s);

void hi () `S" hi" TYPE`
void bye () {prints("bye");}

int add (int x, int y) `+`
int sub (int x, int y) {return x-y;}

void (*msg) ();
int (*fptr) (int x, int y);

void main () {
msg = hi;
msg();
fptr = add;
printn(fptr(3,2));
fptr = sub;
printn(fptr(3,2));
msg = bye;
msg();
}[/code]транслируется в[code]: hi ( -- )
S" hi" TYPE ( forth )
; ( ret )
: bye <enter> ( -- )
S" bye " <asciiz> prints
<leave> ; ( ret )
: add ( x y -- n )
+ ( forth )
; ( ret )
: sub <enter> ( x y -- n )
OVER OVER - NIP NIP <leave> EXIT ( ret )
<leave> ; ( ret )
1 <var> msg ( var )
1 <var> fptr ( var )
: main <enter> ( -- )
msg ['] hi <=> DROP
msg @ EXECUTE
fptr ['] add <=> DROP
3 2 fptr @ EXECUTE printn
fptr ['] sub <=> DROP
3 2 fptr @ EXECUTE printn
msg ['] bye <=> DROP
msg @ EXECUTE
<leave> ; ( ret )
main[/code]и выводит[code]hi5 1 bye[/code]Примерно так же просто получается под мои Форт-процессоры, т.к. там этот порядок вызова подпрограмм вполне естественный и к тому же единственный: сначала кладем в стек адрес, а потом выполняем команду call. Еще сделал под x86 (с ассемблерными вставками), а для других целевых платформ пока не делал.

Так что не будет преувеличением, если скажу, что готов минималистичный транслятор Си, который с учетом исходных самоограничений (отсутствие float, битовых полей и объявлений в стиле K&R) соответствует стандарту C89. Сверх того, реализованы вещи, которые появились лишь в более поздних стандартах (inline, двоичные числа, объявление переменных в любом месте блока). Поддерживаются функции с переменным числом параметров, но в этой части допущены некоторые вольности и имеются отличия от стандартов. Да, есть несколько различий в версиях под разные целевые платформы. Так, например, continue и goto не завезли под forth32/forth64/irbis, а указатели на функции пока работают только в моих forth-процессорах, x86 и в классическом Форте. Ну и несколько косметических недоделок/шероховатостей есть, но формально первый этап успешно завершен. Так что дальше в планах причесывать код (там сейчас лютый трэш), допиливать недоделки, добивать препроцессор (на одних #include и #define далеко не уедешь) и, наверное, float. Битовые поля и старый стиль K&R ни разу не пригодились, отряд не заметил потери таких бойцов. А вот float иногда хочется. Покой нам только снится :)

А дальше еще смешнее. :)
Зашил интерпретатор в Форт-процессор в ПЛИС, частоту поставил 1.5MHz, тест с ферзями выполняется за 2:11. Если сравнивать с соседями по турнирной таблице отсюда [url]https://www.hpmuseum.org/cgi-bin/articles.cgi?read=700[/url] (рассматривал только те, которые на бейсике и для которых в этом же документе указана частота процессора)[code]2:45 SHARP PC-1248 @ 1.024MHz
2:29 TEXAS INSTRUMENTS CC-40 TMS70C20 @ 2.5MHz
2:18 TEXAS INSTRUMENTS TI-74 BASICALC TMS70C46 @ 2MHz
2:00 ЭЛЕКТРОНИКА МК-85 (Fast Mode x5.3) КА1013ВМ1 @ 0.36x5.3=1.9MHz[/code], то мой подопечный смотрится вполне достойно[code]2:11 f44 @ 1.5MHz[/code]При этом сам бейсик скомпилирован самодельным транслятором Си, качество кода на выходе которого оставляет желать лучшего. Но главное, что текст программы в моем случае пока хранится в неизменном текстовом виде, в то время как в ретро-бейсиках для экономии места и увеличения скорости традиционно выполняется "предварительная компиляция": команды языка кодируются одним байтом, числа и адреса прыжков переводятся в двоичный вид и т.д. Т.е. сейчас каждый раз для интерпретируемого слова выполняется сравнение строк (вместо многократно более быстрого сравнения чисел), при каждом прыжке заново производится поиск метки (снова сравнение строк!) в тексте программы (вместо того, чтобы один раз при запуске вычислить адрес перехода и дальше прыгать по этому адресу), а числа каждый раз набиваются поразрядно домножением текущего значения на 10 и добавлением очередного разряда (вместо того, чтобы однократно перегнать число из текстового представления в двоичное). И боюсь даже представить, как сильно вырастет скорость, если переписать интерпретатор BASIC на Форте/ассемблере и/или реализовать предварительную компиляцию. :)

[img]http://totalvacuum.ru/UB/nq0.jpg[/img]
[url=http://totalvacuum.ru/UB/nq0.jpg]ссылка на изображение[/url]
[img]http://totalvacuum.ru/UB/nq1.jpg[/img]
[url=http://totalvacuum.ru/UB/nq1.jpg]ссылка на изображение[/url]

:) Немного подлечил транслятор basic-в-esoteric forth.
[url]http://totalvacuum.ru/UB/ubasic.zip[/url]
Раньше в нем были ровно те же ограничения, что и в целевой платформе (ef \ esoteric forth \): не умел компилировать 2/3/...-разрядные числа и переменные с именами c/b/h/s/x/o/g, т.к. эти имена были задействованы в библиотеке ввода-вывода. Теперь понимает и длинные числа и переменные a-z. А еще двухсимвольные операторы сравнения <= <> >= добавились в дополнение к односимвольным < = >. И операторы poke/push/pop, а также функция peek. Компилируется теперь под win, а не под dos. Но транслятор до сих пор так и весит в районе 100 строк, а в скомпилированном виде - 3 с хвостиком Kb.
Оно выглядит смешно и даже "игрушечно", но легко транслирует простые тесты или, например, калькуляторный тест с ферзями отсюда: [url]https://www.hpmuseum.org/cgi-bin/articles.cgi?read=700[/url] А вообще тут главное идея: трансляция с языка высокого уровня в форт-подобное представление - это просто. :)

[quote="Victor__v"]Лесолёд[/quote]Достаточно спорное утверждение

[quote="Total Vacuum"]Запускаю программу[code]print "bezzlobie?"[/code]Но выводит мистическое[code]hryukostyag![/code]К чему бы это?[/quote]
Лесолёд

Запускаю программу[code]print "bezzlobie?"[/code]Но выводит мистическое[code]hryukostyag![/code]К чему бы это?

[quote="Victor__v"][*] CLEAR – очистка кэша
[*] LIST – создание списка
[*] RUN – запуск сторонней программы из оболочки форта[/list][/quote]
Наверное, это задумывалось как одна сверхмощная суперкоманда "начать с чистого листа", но Гоголь-переводчик сплоховал и выдал "clear list run" :)

Вот этот вот бейсик у меня накидан на скорую руку в нескольких вариантах:
- компилятор, транслирует в uf \ micro forth \ или ef \ esoteric forth \
- интерпретатор, исполняет код из файла через командную строку;
- интерпретатор, запускается в интерактивном режиме и ожидает ввода текста программы с клавиатуры
И только в последнем варианте нужны clear/list/run, более того, сюда же следует добавить exit.
Но вообще в каждом варианте примерно 100 строк и 3-5Kb в скомпилированном виде. При этом легко расширяется. Допустим, добавляем peek/poke, после чего спокойно запускаем калькуляторный тест с ферзями отсюда: [url]https://www.hpmuseum.org/cgi-bin/articles.cgi?read=700[/url]
Типа такого:
[code] 1 let x = 0 let s = 0
2 let r = 8
3 let a = 3000
4 if x = r goto 18
5 let x = x + 1
6 poke ( a + x ) r
7 let s = s + 1
8 let y = x
9 let y = y - 1
10 if y = 0 goto 4
11 let t = peek ( a + x ) - peek ( a + y )
12 if t = 0 goto 14
13 if t < 0 let t = - t if x - y <> t goto 9
14 poke ( a + x ) ( peek ( a + x ) - 1 )
15 if peek ( a + x ) <> 0 goto 7
16 let x = x - 1
17 if x <> 0 goto 14
18 print s[/code]

А если еще добавить push/pop для передачи в функции/из функций параметров/результатов, то такой бейсик превращается в виртуальный процессор с регистрами a-z, командами перехода (goto), в т.ч. и по условию (if), подпрограммами (gosub/return), командами для доступа к памяти и периферии (peek/poke) и небольшим количеством арифметики :) Получится вполне достаточная для написания любых программ "система команд"

[quote]А вообще странно, что они сделали CLEAR/LIST/RUN частью спецификации.[/quote]
Идём в ногу со временем [сарказм]

Я бы дал этим словам такой функционал
[list]
[*] CLEAR – очистка кэша
[*] LIST – создание списка
[*] RUN – запуск сторонней программы из оболочки форта[/list]

[quote="Total Vacuum"]Вот есть такое: [url]https://en.wikipedia.org/wiki/Tiny_BASIC[/url]
Грамматика в части операторов там совсем простая:[code]
statement ::= PRINT expr-list
IF expression relop expression THEN statement
GOTO expression
INPUT var-list
LET var = expression
GOSUB expression
RETURN
CLEAR
LIST
RUN
END[/code][/quote]
А вообще странно, что они сделали CLEAR/LIST/RUN частью спецификации. Скорее уж это команды редактора или даже операционной системы, но никак не самого языка. Где-то они могут быть полезны (например, при построчном вводе программы через терминал), а где-то полноценный встроенный редактор и запуск по F9, либо внешний редактор и интерпретация или компиляция файлов через командную строку, и вот здесь-то эти команды точно не нужны.
Впрочем, спецификация Tiny BASIC уходит корнями в покрытую мхом почтенную древность, так что простительно. :) В этом даже какой-то шарм безвозвратно ушедшей в прошлое 8-битной эпохи.
Ну а в текущих реалиях надо отделять мух от котлет: редактор (если он вообще нужен) будет отдельно, а интерпретатор (BASIC, Forth, любой другой или все сразу) - отдельно.

Собственно, лежит тут: [url]http://totalvacuum/UB/ubasic.zip[/url]
Сам ubasic.c компилировал при помощи TCC, но должно любым сишным компилироваться. В скомпилированном виде весит 3K. В папке TEST пара тестов, перекомпилируются при помощи соответствующих *.bat по схеме basic => ef => asm => com, хотя можно и под win сделать, если транслятор ef \ esoteric forth \ подменить.
Натравил на него свой сишный транслятор, там меньше 2K исполняемый файл получается, правда это 16-битный com-файл. Для форт-процессора будет и того меньше, раза в 2, наверное.

Интерпретатор в 100 строк, скорее всего, не уложится, он будет сложнее компилятора, но точно не в разы.

Да, кстати, для добавления poke/peek (а это ведь по сути фортовские !/@) достаточно в stmt() перед label дописать строки[code] if (t("poke")) {expr(); expr(); op(ASSIGN);} else
if (t("peek")) {var(); expr(); op(LOAD); op(ASSIGN);} else[/code]
А, например, для push/pop:[code] if (t("push")) {expr();} else
if (t("pop")) {var(); op("!");} else[/code]
Хотя peek можно оформить в виде функции, чтобы была возможность использования в выражениях. В этом случае нужно добавить в prim() строку[code] else if (t("peek")) {unary(); op(LOAD);}[/code]

Забавно будет, если по итогу интерпретатор BASIC на борту Форт-процессора в ПЛИС окажется шустрее спектрумовского :D