SPF devel doc

( -- socket ior )

( -- socket ior )

( timeout socket -- ior )

( -- socket ior )

( -- socket ior )

( socket -- n ior )

сколько байт можно сейчас прочесть из сокета
можно использовать перед ReadSocket для того чтобы
избежать блокирования при n=0

( port ip s -- ior )

( IP port socket -- ior )

( s -- ior )

linger по умолчанию: graceful close без таймаута, устанавливаем таймаут на закрытие

( s -- ior )

( addr u s -- ior )

( addr u s -- ior )

( s -- ior )

( addr u s -- rlen ior )

( IP -- addr u ior )

( addr u -- addr u ior )

( addr u -- IP ior )

иначе пустой хост S" " дает 0 0

( s -- addr u ior )

( s -- IP ior )

( s -- IP port ior )

( -- ior )

( -- ior )

( port s -- ior )

( s -- ior )

( port s -- ior )

( s -- ior )

( s -- s2 ior )

SINLEN HERE

( IP -- addr u )

[ BASE @ HEX ]
>R 0 0 <# 2DROP R@ 1000000 U/ FF AND 0 #S [CHAR] . HOLD
2DROP R@ 10000 U/ FF AND 0 #S [CHAR] . HOLD
2DROP R@ 100 U/ FF AND 0 #S [CHAR] . HOLD
2DROP R> FF AND 0 #S
#>
[ BASE ! ]

( s -- s2 ior )

timeout 60 sec

( addr u -- IPab IPae ior )

Получить список IP multihomed-хоста
IPab IPae возвращаются в формате для последующего цикла DO, см. ConnectHost
иначе пустой хост S" " дает ior=0

( addr u port -- sock ior )

Подключиться к хосту addr u на порт port
с автоматическим перебором всех IP хоста.
Если коннект не удался, то ior - код ошибки (на последнем хосте из списка)
и socks=0.
Если удался, то sock - новый соединенный сокет, ior=0.

( a u socket -- ior )

( a u socket -- ior )

( addr u -- h )

( -- )

( -- )

( -- )

( pema pemu type \ c -- context )

( pema pemu type \ c -- context )

( depth context -- )

( pema pemu mode context -- )

( conn \ cert name mem -- cert addr u ior )

addr нужно после использования освобождать

( socket context -- conn_obj )

( socket context -- conn_obj )

( addr u conn_obj -- n )

>R SWAP R> SSL_write NIP NIP NIP

( addr u conn_obj -- n )

>R SWAP R> SSL_read NIP NIP NIP

( ior -- namea nameu cert )

( addr u verify s -- namea nameu cert )

addr u - имя файла с сертификатом и закрытым ключем в PEM-формате

( addr u verify s -- namea nameu cert )

addr u - имя файла с сертификатом и закрытым ключем в PEM-формате

( addr u s -- ior )

( addr u s -- ior )

( s -- ior )

( addr u s -- rlen ior )

( s -- ior )

( addr len socket -- )

прочесть ровно len байт из сокета socket и записать в addr

( -- )

( a u socket -- ior )

( a u socket -- ior )

( socket -- addr-S )

( addr-S -- addr1 u1 )

( u1 addr-S -- addr1 u2 )

( addr-S -- )

( addr-S -- ior )

( addr -- addr1 u1 )

SocketReadLine читает строку, ограниченную LF или CRLF
Сам ограничитель в возвращаемую строку не включается.
Если строка достигла размера буфера, но разделитель не
найден, то строка режется на текущей длине. Остаток будет
выдаваться следующими вызовами этой функции.
Если разделитель не найден, и в буфере еще есть куда
читать, то продолжается реальное чтение из сокета
(возможно блокирующее).

( port -- socket )

( socket -- IP port )

IP=0, если клиент уже отключился!

( addr u socket -- size IP port )

( IP port addr u socket -- )

( socketline -- socket )

( server port -- socketline )

( server port -- socketline )

( socketline -- )

: fclose ( socketline -- )
fsock CloseSocket THROW
;
fixed by Sergey Shisminzev [sergey@michint.kiev.ua]
лучше DROP

( socketline -- )

fixed by Sergey Shisminzev [sergey@michint.kiev.ua]
лучше DROP

( str socketline -- )

( socketline -- str )

: fgets ( socketline -- str )
{ sock \ str }
"" -> str
sock SocketReadLine str STR!
str
;

( xt \ addr -- ior )

xt - процедура ( IP -- ), запускаемая для каждого IP

( ip -- flag )

( ip \ addr sp -- flag )

( addr u -- flag )

( addr u -- flag )

( addr u -- )

( x -- )

( addr u -- )

( af -- )

( af -- addr u )

( addr u af -- )

( addr u -- )

( addr -- )

( -- )

( type -- )

( -- )

( type -- n )

имеет смысл только если записи получались не по GetRRs,
а другим способом. При GetRRs список и так содержит только записи
одного (заказанного :) типа

( -- n )

( qtype addr u -- )

уже точно не получить затерявшиеся ответы на старые запросы!

( -- ... )

( -- addr u )

( -- )

( n -- )

( n -- )

( n -- )

( n -- )

( -- flag )

( hosta hostu type \ attempts -- n )

( hosta hostu type \ attempts -- n )

( domaina domainu -- flag )

( emaila emailu -- flag )

( addr u -- )

( domaina domainu -- n )

( domaina domainu -- n )

( -- servera serveru true | false )

( domaina domainu -- flag )

( domaina domainu -- flag )

( namea nameu -- n )

( type -- hosta hostu true | false )

( -- hosta hostu true | false )

( namea nameu ip -- err false | true )

( h s -- ior )

( -- )

( -- )

( -- )

( -- )

( S"oid" type S"host" -- )

( S"oid" type S"community" S"host" port -- )

( -- )

( S"oid" type S"community" S"host" port -- )

( S"oid" S"host" -- )

( S"oid" S"host" -- )

( addr u -- addr2 )

( x -- addr2 )

( n -- addr2 )

( n -- addr2 )

( n -- addr2 )

( addr u -- addr2 )

( n -- addr2 )

( addr u -- addr2 )

( index -- )

( index S"str" -- )

( index x -- )

OVER SnmpFreeVbIndex

( index n -- )

( index u -- )

( index u -- )

( index S"o.i.d" -- )

( index n -- )

( index S"o.i.d" -- )

MRTG def stats

.iso.org.dod.internet.private.enterprises.etype

( a u -- )

( filename -- )

( addr u -- )

( s \ mem offs -- )

|| s mem offs || (( s ))

( s -- a )

( port \ ss -- )

( port S"dir" -- task_id )

( c-addr1 u1 c-addr2-u2 hwnd)

Сначала имя приложения, затем версия

( addr u -- addr+4 )

( addr c -- addr+4 )

( addr c -- addr+4 )

( node -- )

( addr u -- addr+4 )

( addr c -- addr+4 )

( addr c -- addr+4 )

( "state-table -- )

( res -- )

( -- )

( x y -- )

( r g b -- )

( w h -- )

( xt -- n )

( -- )

( node -- f)

( addr -- addr1 u1 )

получить строку addr1 u1 из строки со счетчиком addr
счетчик - ячейчка, а не байт, в отличие от обычного COUNT

( node -- value )

получить значение элемента списка

( node1 -- node2 | 0 )

( list -- node )

( xt list -- )

выполнить токен xt для каждого элемента (node, а не value) списка list
xt ( node -- )

( addr u list -- flag )

проверяет, находится ли строка addr u в списке строк list

( node -- )

( list -- )

освобождает динамическую память, занимаемую структурами списка.
Не освобождает память, выделенную элементам списка, если эти
элементы - внешние значения, например строки.

( value list -- )

добавляет value в список list

( list -- )

развернуть порядок элементов в списке на обратный

( list -- )

( list -- )

На случай если данные узлов - указатели на исполняемые слова

( list xt -- )

Исполняет xt с параметром `указатель на данные узлов`
Если xt возващает -1 то заканчиваем итерации, если 0 - продолжаем

( list xt -- f )

Возвращает параметр плюс xt получает параметры до вызова

( "name" -- )

( list "name" -- )

Создает новый список, но наследует предыдущий

( list "name" -- )

( list -- addr | 0 )

Получить первый элемент списка

( list -- addr | 0 )

Найти последний элемент списка проходом по нему

( list -- addr | 0 )

Получить последний элемент списка

( list - u )

Вернуть размер элемента списка

( node -- node1 )

Вернуть следующий элемент списка, после последнего - первый

( node -- node1 )

Вернуть предыдущий элемент списка, после первого - последний

( addr list )

Вставить элемент addr в начало списка list, связать.

( addr node list -- )

( addr list )

( u -- addr )

Выделить память в хипе, обнулить

( u -- addr )

Выделить память в словаре, обнулить

( list -- addr | 0 )

Создать элемент списка в хипе, вставить в список, вернуть адрес
list addr

( list -- addr | 0 )

Создать элемент списка в хипе, вставить в список, вернуть адрес
list addr

( list -- addr )

Создать элемент списка в словаре, вставить в список, вернуть адрес
list addr

( list -- addr )

Создать элемент списка в словаре, вставить в список, вернуть адрес
list addr

( u "ccc" )

Создать в словаре именованный список с данным размером элемента

( u -- addr )

Создать в хипе список с данным размером элемента, вернуть адрес

( u -- addr )

Создать в словаре список с данным размером элемента, вернуть адрес

( xt list -- )

Выполнить xt для каждого элемента списка
xt ( node -- )

( xt node -- node | 0 )

Выполнить xt для каждого элемента списка начиная с элемента node
xt ( node -- f ) если f = 0 то прекратить обход

( xt list -- node | 0 )

xt ( node -- f ) если f = 0 то прекратить обход

( node -- )

Удалить элемент списка

( list -- )

Удалить все элементы списка

( list -- u )

( n list -- node | 0)

( list -- )

( hlist -- node )

node=hlist, если список пуст

( h1 h2 -- )

( i*x i list -- )

( list -- i*x i )

( list -- )

( list -- )

( value hlist -- )

( value hlist -- )

добавляю узел вниз

( value hlist -- )

( hlist -- )

( xt hList -- )

xt ( value -- )

( hList xt -- )

xt ( value -- )

( value hlist -- flag )

( value hlist -- node )

( xt hList -- )

xt ( -- )

( xt hList -- )

xt ( -- )

( node -- value )

CELL+ @

( hlist -- node )

( -- node )

( node -- )

освободить память занимаемую элементом списка

( node1 node2 -- )

установить связь node1->node2

( val -- node )

создать новый элемент списка с данными val

( node -- ? )

TRUE - элемент пуст, нет перехода
FALSE - иначе

( node1 -- node2 )

перейти к следующему элементу в списке после элемента node1

( node -- val )

содержимое ячейки данных элемента node

( val node -- )

установить данные ячейки

сокращения :)

( node -- node2 )

пройти по цепочке элементов до последнего - указывающего на ()

( node1 node2 -- node1 )

Добавить элемент в начало списка и вернуть получившийся список
node1->node2

( value node -- node1 )

node1(value)->node

( node1 node2 -- node )

Присоединить весь список node1 в начало списка node2

( xt node1 -- )

Применить xt ко всем элементам списка node1
xt: ( node -- ) \ xt получает параметром каждый элемент на нетронутом стеке

( xt node -- )

Применить xt к данным всех элементов списка node1
xt: ( node.car -- ) \ xt получает параметром car ячейку каждого элемента на нетронутом стеке

( n node -- node )

Получить n-ый элемент списка, прямым проходом

( node -- n )

получить длину списка - прямым проходом до конца списка

( node -- )

освободить память занятую списком

( node1 node2 -- )

node2->...->node1->nil

( node1 node2 -- node )

добавить элемент node1 в конец списка node2 (перед пустым элементом)
node2->...->node1->nil

( node -- node1 )

развернуть список в обратную сторону

( n node -- ? )

Проверка на принадлежность

( node -- x1 x2 ... xn )

Элементы списка на стек

( node -- node )

( node -- node )

( node -- )

( node -- ? )

( node -- ? )

( node -- ? )

( node -- n )

( -- list )

( list -- )

( node -- )

( u -- )

( u -- )

Добавить u как значение в текущий список

( l -- )

Добавить l как элемент-список в текущий список

( s -- )

Добавить s как элемент-строку (~ac/lib/str4.f) в текущий список

( -- )

начать новый список - добавлять элементы с помощью %

( -- list )

завершить создание списка

( node -- )

освободить память занимаемую самим списком, а также данными каждого элемента
используется информация о типах
для строк - STRFREE
для списков - рекурсивно FREE-LIST
для value - ничего

( xt node1 -- node2 )

Вызвать xt для каждого элемента списка
Если xt возвращает 0 - элемент удаляется из списка (память занимаемая самой ячейкой освобождается)
Иначе остаётся
Возвращается результирующий список
xt: ( node -- ? ) \ TRUE - remain, FALSE - free node

( xt node -- node1 -1 | empty-list 0 )

Поиск по списку
В случае успеха (xt вернул -1) возвращается node1 на которой поиск был остановлен
иначе - пустой список
xt: ( node -- ? ) \ TRUE - stop scan, FALSE - continue

( xt node -- )

( xt node1 -- )

( val node -- node1 )

Вариация с использованием динамического xt
тут используем тот факт что axt=> работает на чистом стеке то есть можно
передавать параметр node в bac4th-вызов и возвращать результат из вызова напрямую на стеке

( xt node -- )

Модифицировать каждый элемент списка с помощью xt
xt: ( node-car -- val ) \ val будет записано в текущий обрабатываемый элемент списка

( lst -- )

удалить из списка lst все значения-дубликаты

( addr )

( list -- xt )

создать xt который при каждом вызове будет оставлять на стеке очередной элемент списка
xt: ( -- node1 )

( v1 ... vn n -- l )

создать список as-value длиной n из элементов на стеке v1...vn

( node --> node1 \ <-- )

bac4th-итератор по списку

( node --> node1 \ <-- )

bac4th-итератор по списку

( node1 list -- )

Вставить элемент node1 в список list после первого элемента
если list пуст - ничего не делать
list->...->nil
list->node1->...->nil

( xt node1 -- )

применить xt последовательно к парам соседних элементов
и сохранить результат в элемент списка
При этом весь список укорачивается на один элемент
xt: ( node1-car node2-car )

( xt node1 -- )

применить xt последовательно к каждым двум соседним элементам
xt: ( node1-car node2-car )

( xt node1 node2 -- )

применить xt к "соответствующим" парам элементов списков node1 node2
xt: ( node1i node2i -- )

( node1 node2 -- ? )

Проверка на равенство по значению

( n -- a u )

выбрать n символов из входного потока

( n -- )

( s -- )

( s -- )

( node -- )

( node -- )

Распечатать список, удобный для интерактива вариант, длинные сроки затроеточиваются

( node -- )

( node -- )

Распечатать список, строковое представление пригодное для восстановление EVALUATE'ом
В момент выполнения EVALUATE потребуются слова
>STR из ~ac/lib/str5.f
lst( % %l %s )lst из ~ygrek/lib/list/ext.f
PARSE-DATA из этой либы

( node -- )

( node -- )

Распечатать список, без лишней обработки - просто адреса

( "name" -- old-current )

( old-current -- )

( offset "new-name" -- offset+cell )

( offset "new-name" -- offset+cell )

( -- )

( obj offset -- )

( obj cells offset -- )

( "name" -- old-current )

( old-current -- )

( offset "new-name" -- offset+cell )

( offset "new-name" -- offset+cell )

( -- queue )

( x pr queue \ newel -- )

включить элемент x в очередь queue с приоритетом pr

( queue -- x true | false )

исключить из очереди первый элемент (c наименьшим численным значением pr),
оставить элемент на стеке и true, в случае успеха
или false в случае не успеха (пустая очередь).

( queue -- )

( q -- )

( q -- count )

( q xt \ e -- )

xt ( value pr -- )

( x -- x' )

===========================================================================

( x -- x' )

( x -- y )

( x -- yl yh )

( x -- y )

( x mask -- x' elem )

replace non-zero bits in mask by bits from x producing elem;
x' contains remaining bits

( x mask -- elem )

( x field mask -- x.mask:=field )

( x' opc-elem mask -- x )

extract the bits from opc-elem masked by mask; append them to x'

( x mask -- x' )

( a u -- )

( -- )

создать пустое множество в словаре

( -- a-set )

динамически создать пустое множество. освобождение по FREE

( char a-set -- a-byte byte-mask )

( char a-set -- f )

проверить элемент

( char a-set -- )

включить элемент

( char a-set -- )

исключить элемент

( addr u a-set -- )

включить все символы из заданной строки во множество

( a-set -- )

( i j -- i j ~f )

( i j -- k )

( i -- )

( -- )

( m -- m )

( -- )

( -- )

( a b f -- i 0|-1 )

binary-search неудобный! Используйте reverse-function

( a b --> c \ <-- flag )

Цикл двоичного поиска. Выдаёт значения c и ожидает получить флаг,
указывающий куда ему идти дальше (если щуп найдёт то что нужно,
то это должна будет обработать внешняя процедура).
Каждый нырок этого слова -- это закидывание щупа и определение
где его кинуть в следующий раз
На входе: начальный диапазон (a,b)

( a b res --> x \ x flag <-- x' )

Ищет в диапазоне (a,b) такое значение x, что функция
(записанная в шитом коде после неё) равна res
Если найдено flag=TRUE и x -- значение, где f(x)=res
Если не найдено, то flag=FALSE и x -- равно либо
floor(x'), где f(x')=res, либо равно одному из краевых
значений если искомого значения аргумента вообще нет в
заданном диапазоне.
Только для линейных функций, само собой.
PRO .. CONT не работают из-за того что PREDICATE .. SUCCEEDS тоже используют L-стек
поэтому адрес успеха сохраняем в локальной переменной и вызываем вручную

( -- )

время компиляции ( -- orig1 xt )

( -- xt )

время компиляции ( orig1 xt -- )
код внутри конструкции LAMBDA{ } не выполняется, возвращается xt на этот код.

( -- resolve xt id)

( -- resolve xt id)

( n )

( -- n )

( x -- s: x )

( s: x -- x )

( s: x -- s: x x )

( s: x )

( s: x y -- s: y x )

( s: x y -- s: x y x )

( n )

( s: x -- c: x )

( c: x -- s: x )

( n -- s: x )

( a )

( a )

( a )

( a )

( -- s: 0 )

( a -- s: x )

( a s: x )

( a n )

( a )

( x y -- z )

( s: x y -- s: z )

( n -- s: n )

( a -- s: a )

( s: x )

( s: x -- ? )

( s: x -- ? )

( s: x -- ? )

( s: x -- ? )

( s: x -- s: y )

( s: x -- s: y )

( s: x y )

( s: x y )

( n s: ... -- s: x )

( -- n )

( n s: ... -- s: x )

( s: x y -- ? )

( s: x y -- ? )

( n s: x -- s: y )

( n s: x -- s: y )

( s: f )

( s: x f )

( s: x e -- s: e )

( s: x -- s: y )

( s: x f )

( i s: e -- j )

( s: x -- n )

( s: x z f -- s: y )

( s: x e -- s: y )

( s: x -- s: y )

( s: x e -- s: y )

( s: x -- s: y )

( s: f x e -- s: y )

( s: x f -- s: y )

( s: x -- s: y )

( s: x y -- s: z )

( s: f x e -- s: y )

( s: x f -- s: y )

( a -- s: f )

( a -- s: f )

( a -- s: f )

( s: x )

( s: x )

( -- n )

( "name" -- )

( xt -- )

Выполнение вектора исполнения xt

( f -- )

( f -- )

Откат если f=true, то есть _пропускает_ только f=0

: R@ENTER, SetOP 0xFF C, 0x14 C, 0x24 C, ; ( \ CALL [ESP]

: R>ENTER, SetOP 0x5B C, SetOP 0xFF C, 0xD3 C, ; ( \ POP EBX CALL EBX

: CONT L> >R R@ ENTER R> >L ; (

( xt -- )

MOV EBX, EAX
MOV EAX, 0 [EBP]
LEA EBP, 4 [EBP]
JMP EBX

( "name )

( n --> n / n <-- )

Не изменяя стек при прямом проходе, на откатном ходу кладёт на стек сохранённое значение вершины стека
: RESTB ( n --> n / n <-- ) R> OVER >R ENTER R> ; (
POP EBX
PUSH EAX
CALL EBX
MOV -4 [EBP] , EAX
POP EAX
LEA EBP, -4 [EBP]

Аналог RESTB для двойных значений
: 2RESTB ( d --> d / d <-- ) R> -ROT 2DUP 2>R ROT ENTER 2R> ; (
POP EBX
PUSH [EBP]
PUSH EAX
CALL EBX
MOV -4 [EBP] , EAX
POP EAX
LEA EBP, -8 [EBP]
POP [EBP]

( a b <--> b a )

Откатываемый SWAP, т.е. выполняет SWAP и на прямом и на обратном ходу,
откатывая стек к начальному положению

( a b --> a b \ b a <-- a b )

SWAP при откате, т.е. на прямом ходу ничего не делает, на обратном ходу
-- выполняет SWAP.

( n <--> )

Откатываемый DROP

( n --> n / <-- n )

DROP при откате, этим словом можно приводить одиночные значения на стеке
к итерируемым значениям, нужных для некоторых агрегаторов (типа seq{ }seq)

( n --> n / <-- n )

Двойной DROP при откате

Восстановление значения переменной addr при откате
: KEEP ( addr --> / <-- ) R> SWAP DUP @ 2>R ENTER 2R> SWAP ! ; (
POP EBX
PUSH EAX
MOV EAX , [EAX]
PUSH EAX
MOV EAX , 0 [EBP]
LEA EBP , 4 [EBP]
CALL EBX
POP EBX
POP EDX
MOV [EDX] , EBX

( n addr --> / <-- )

Запись значения в переменную addr с восстановлением при откате
: KEEP! ( n addr --> / <-- ) R> OVER DUP @ 2>R -ROT ! ENTER 2R> SWAP ! ; (

Задать действия при откате ( BACK .. TRACKING ), или, иначе говоря,
положить адрес начала последовательности шитого кода между словами
BACK ... TRACKING на стек возвратов

( -- org dest $TART )

Открывающая скобка "суперцикла"

Рекурсивный нырок внутри суперцикла в самое себя

Закрывающая скобка "суперцикла"

Восстановление стека
Нужно для обеспечения баланса стека при прямом и обратном ходе, при наличии таких
опасных процедур как отсечения (NOT: -NOT или CUT: -CUT)

Квантор отрицания

Предикат, преобразование успеха/неуспеха в логическое значение

квантор общности, выраженный через два вложенных квантора отрицания

Почему-то у mlg в дипломке согласно иллюстрации OTHER делает так (я несколько месяцев честно пытался понять этот перехлёст):
: OTHER ?COMP N0T ?PAIRS >RESOLVE2 POSTPONE (-NOT) ; IMMEDIATE
но должно так:

отсечение
адр. вершины стека возвр.--> на L-стек
а при откате - убрать эту отметку

убрать точки возврата до отметки

блок альтернатив

( -- )

храним значение накопителя

( intermed -- )

Выдача промежуточного накапливаемого в данный момент значения агрегатора
из накопителя

( agg succ -- )

Во время исполнения на стеке должно лежать значение которое надо
при-обработать к начальному (добавить, сконкатенировать, умножить и т.д.)

Сумматор итерируемых значений

Определение максимума среди итерируемых значений

Произведение итерируемых значений

Лог. произведение итерируемых значений

Лог. сложение итерируемых значений

Выдача промежуточных результатов простых агрегаторов ( +{ ... }+ и прочие)

Блок AMONG ... EACH ... ITERATE
порождается код:
(among) (among>) {addr} ... (each) ... (iterate) addr: код_за_циклом
Адрес (AMONG>)
При откате убрать указатель трассы итератора
Указатель начала трассы итератора
(AMONG>): успех цикла при неуспехе итератора

Адрес ссылки на код за циклом
Сохранить указатель начала трассы

Адрес тела цикла
Новый адрес конца трассы итератора
При откате убрать адрес конца трассы
и саму трассу итератора

Убрать адрес кода, находящегося за циклом
Указатели на начало и конец трассы итератора
Сохранить указатели трассы итератора
Убрать новый указатель начала трассы и
восстановить старые указатели
при откате
Адрес конца и длина трассы итератора
Новый адрес начала трассы итератора
Отвести место на стеке возвратов
Скопировать трассу итератора

( addr u -- xt )

создаём виртуальный кодофайл
подключаем словарь с своими структурами управления
компилируем строку в виртуальный кодофайл
отключаем его по окончании компиляции
ставим команду выхода
оставляем исполняемый адрес начала кодофайла

( addr u --> xt \ <-- )

компилируем строку, берём исполняемый адрес кода
по окончании обработки очистить кодофайл
и кидаем его наверх

( s --> xt \ <-- )

То же самое что и compiledCode , но с динамическими строками из ~ac/lib/str5.f
Это позволяет писать код в несколько строк
Поданая на вход строка сразу после использования освобождается

( addr u --> xt \ <-- )

( s --> xt \ <-- )

( -- addr n )

addr - адрес массива с хэндлами хипов
n - к-во хэндлов в массиве

( xt h -- )

( entry -- )

( entry -- )

( u addr )

( u -- addr ior )

( n -- addr ior )

( addr u -- addr1 )

( addr -- ior )

AllocList listSize CR ." Size - " .

( addr n -- addr2 ior )

( -- )

FreeList is broken?

( -- size n )

( threadId -- )

( -- )

( threadId -- )

( -- n )

Установить новую отметку и вернуть её номер

( n -- )

В отчёте MemReport показывать только те блоки памяти что были выделены после отметки n
0 для того чтобы показывать все блоки

( -- )

( -- )

компилирует строковый литерал - u - номер текущей строки

компилирует строковый литерал - имя текущего файла трансляции

( addr u n -- )

( n -- )

компилирует текст до ) если n > ACCERT-LEVEL-1
иначе пропускает его

( -- )

( -- ms )

( -- )

( -- )

( -<commandline>- )

( CFA -- NFA )

( a -- )

( a -- )

( a u -- d-ticks u-rets true | false )

( -- )

( -- )

старый вариант. узнает слово с таймеров по идендификатору.
( вывод ограничен контекстом словарей )

( -- )

новый варинат. выводит все по списку.

( CFA_last_word -- )

( errno -- )

( -- )

( -- )

RECORD DEPTH
IF THERE IS SOMETHING ON STACK
SAVE THEM

(ACTUAL) CONTENTS.
IF DEPTHS MATCH
IF THERE IS SOMETHING ON THE STACK
FOR EACH STACK ITEM
COMPARE ACTUAL WITH EXPECTED

( addr u addr1 u1 )

comparing arrays

( -- ? )

( ? -- )

( -- u )

( u -- )

( F: r -- )

( F: r -- )

Младшие шесть бит маскируют ошибки #I #D #Z #O #U #P
потому что #P реагирует на ноль

( F: r -- )

( addr u -- d )

( u -- R: 10^u )

( c-addr1 u -- c-addr2 u flag )

( addr u -- d )

( addr u -- F: r )

( addr u -- F: r D: bool )

( addr u max min addr2 u2 -- addr2 u2 bool )

( addr u max min -- addr2 u2 bool )

( addr u max min -- addr2 u2 bool )

( addr u max min -- addr2 u2 bool )

( addr u max min -- addr2 u2 bool )

( addr u -- bool )

( addr u -- F: r true | false )

Если нет маски, то ругаемся

( F: r1 -- r2 )

( F: r1 -- r2 )

( -- n )

Дает число знаков целой части числа

( c-addr u -- n flag1 flag2 )

from http://www.alphalink.com.au/~edsa/represent.html

( c-addr u1 -- c-addr u2 )

trim trailing '0's

( n -- )

( ud1 -- ud2 )

( F: r -- r )

( n1 n2 )

n1 - exponent
n2 - sign

( r -- )

( r -- )

( r)

( n - n' 1|2|3 )

( r)

( c )

( addr u )

( F: r -- addr u )

( addr1 -- addr2 )

( n1 -- n2 )

( addr1 -- addr2 )

( n1 -- n2 )

( F: r -- )

( F1 F2 F3 -- FLAG )