#bits/byte (-- n )
#bits/cell (-- n )
#bits/char (-- n )
+" ("ccc<quote>" -- )
+field (structure-sys n "<spaces>name" -- structure-sys ; addr1 -- addr2 )
,\" ("ccc<quote>" -- )
0! (a-addr -- )
0e+0 (F: -- r )
1+! (a-addr -- )
1-! (a-addr -- )
1e+0 (F: -- r )
2e+0 (F: -- r )
<=> (n1 n2 -- n )
>enum: (enum-sys n "<spaces>name" -- enum-sys ; -- n )
?0 (x -- )
?d (d1 d2 -- )
?false (flag -- )
?free (addr -- ior )
?nil (addr -- )
?r (r1 r2 -- )
?s (n1 n2 -- )
?str (c-addr1 u1 c-addr2 u2 -- )
?true (flag -- )
?u (u1 u2 -- )
?ud (ud1 ud2 -- )
@! (x1 a-addr -- x2 )
a32% (-- n )
a32+to-string (u -- c-addr u )
a32-create ("<spaces>name" -- ; -- a32 )
a32-dump (a32 -- )
a32-finish (a32 -- u )
a32-free (a32 -- )
a32-init (a32 -- )
a32-length@ (a32 -- u )
a32-new (-- a32 )
a32-reset (a32 -- )
a32-update (c-addr u a32 -- )
a32^combine (a32 a32 -- u )
acn% (-- n )
acn-dump (acn -- )
acn-free (acn -- )
acn-init (x1 x2 acn1 acn2 -- )
acn-new (x1 x2 acn1 -- acn2 )
act% (-- n )
act-(free) (act -- )
act-clear (act -- )
act-compare! (xt act -- )
act-compare@ (act -- xt )
act-create ("<spaces>name" -- ; -- act )
act-delete (x1 act -- false | x2 true )
act-dump (act -- )
act-empty? (act -- flag )
act-execute (i*x xt act -- i*x )
act-execute? (i*x xt bct -- j*x flag )
act-free (act -- )
act-get (x1 act -- false | x2 true )
act-has? (x1 act -- flag )
act-init (act -- )
act-insert (x1 x2 act -- )
act-length@ (act -- u )
act-new (-- act )
arg% (-- n )
arg-(free) (arg -- )
arg-add-help-option (arg -- )
arg-add-option (char c-addr1 u1 c-addr2 u2 flag n arg -- )
arg-add-version-option (arg -- )
arg-create (c-addr1 u1 c-addr2 u2 c-addr3 u3 c-addr4 u4 "<spaces>name" -- ; -- arg )
arg-free (arg -- )
arg-init (c-addr1 u1 c-addr2 u2 c-addr3 u3 c-addr4 u4 arg -- )
arg-new (c-addr1 u1 c-addr2 u2 c-addr3 u3 c-addr4 u4 -- arg )
arg-parse (arg -- c-addr u n | n )
arg-print-help (arg -- )
arg-print-version (arg -- )
arg.cols (-- n )
arg.done (-- n )
arg.error (-- n )
arg.help-option (-- n )
arg.non-option (-- n )
arg.version-option (-- n )
b64-decode (c-addr1 u1 str -- c-addr2 u2 )
b64-encode (c-addr1 u1 str -- c-addr2 u2 )
bar% (-- n )
bar-(free) (bar -- )
bar-count (bar -- u )
bar-count-bits (+n1 n2 bar -- u )
bar-create (+n "<spaces>name" -- ; -- bar )
bar-dump (bar -- )
bar-execute (i*x xt bar -- j*x )
bar-free (bar -- )
bar-get-bit (n bar -- flag )
bar-index? (n bar -- flag )
bar-init (+n bar -- )
bar-invert (bar -- )
bar-invert-bit (n bar -- )
bar-invert-bits (u n bar -- )
bar-length@ (bar -- +n )
bar-new (n -- bar )
bar-reset (bar -- )
bar-reset-bit (n bar -- )
bar-reset-bits (u n bar -- )
bar-reset-list (nu .. n1 u bar -- )
bar-set (bar -- )
bar-set-bit (n bar -- )
bar-set-bits (u n bar -- )
bar-set-list (nu .. n1 u bar -- )
bar^and (bar1 bar2 -- )
bar^move (bar1 bar2 -- )
bar^or (bar1 bar2 -- )
bar^xor (bar1 bar2 -- )
bci% (-- n )
bci-create (bct "<spaces>name" -- ; -- bci )
bci-dump (bci -- )
bci-first (bci -- x true | false )
bci-first? (bci -- flag )
bci-free (bci -- )
bci-get (bci -- false | x true )
bci-init (bct bci -- )
bci-key (bci -- false | x true )
bci-last (bci -- x true | false )
bci-last? (bci -- flag )
bci-move (x bci -- flag )
bci-new (bct -- bci )
bci-next (bci -- x true | false )
bci-prev (bci -- x true | false )
bci-set (x bci -- )
bcn% (-- n )
bcn-cell! (bcn1 -- bcn2 )
bcn-cell@ (bcn1 -- bcn2 )
bcn-dump (bcn -- )
bcn-free (bcn -- )
bcn-init (x1 x2 bcn1 bcn2 -- )
bcn-new (x1 x2 bcn1 -- bcn2 )
bct% (-- n )
bct-(free) (bct -- )
bct-clear (bct -- )
bct-compare! (xt bct -- )
bct-compare@ (bct -- xt )
bct-create ("<spaces>name" -- ; -- bct )
bct-delete (x1 bct -- false | x2 true )
bct-dump (bct -- )
bct-empty? (bct -- flag )
bct-execute (i*x xt bct -- j*x )
bct-execute? (i*x xt bct -- j*x flag )
bct-free (bct -- )
bct-get (x1 bct -- false | x2 true )
bct-has? (x1 bct -- flag )
bct-init (bct -- )
bct-insert (x1 x2 bct -- )
bct-length@ (bct -- u )
bct-new (-- bct )
begin-enumeration (-- enum-sys )
begin-stringtable ("<spaces>name" -- stringtable-sys ; n -- c-addr u )
begin-structure ("<spaces>name" -- structure-sys ; -- n )
bigendian? (-- flag )
bis% (-- n )
bis-bits>bytes (bis -- )
bis-bytes>bits (bis -- )
bis-create ("<spaces>name" -- ; -- bis )
bis-dump (bis -- )
bis-fetch-bits (u1 bis -- u2 )
bis-free (bis -- )
bis-get (bis -- c-addr u )
bis-get-bit (bis -- false | u true )
bis-init (bis -- )
bis-need-bits (n bis -- flag )
bis-new (-- bis )
bis-next-bits (n bis -- )
bis-read-bytes (n1 bis -- false | n2 true )
bis-reset (bis -- )
bis-set (c-addr u bis -- )
bni% (-- n )
bni-create (bnt "<spaces>name" -- ; -- bni )
bni-dump (bni -- )
bni-first (bni -- bnn | nil )
bni-first? (bni -- flag )
bni-free (bni -- )
bni-get (bni -- bnn | nil )
bni-init (bnt bni -- )
bni-key (bni -- false | x true )
bni-last (bni -- bnn | nil )
bni-last? (bni -- flag )
bni-new (bnt -- bni )
bni-next (bni -- bnn | nil )
bni-prev (bni -- bnn | nil )
bnn% (-- n )
bnn-dump (bnn -- )
bnn-free (bnn -- )
bnn-init (x bnn1 bnn2 -- )
bnn-key@ (bnn -- x )
bnn-new (x bnn1 -- bnn2 )
bnt% (-- n )
bnt-(free) (xt bnt -- )
bnt-clear (xt bnt -- )
bnt-compare! (xt bnt -- )
bnt-compare@ (bnt -- xt )
bnt-create ("<spaces>name" -- ; -- bnt )
bnt-delete (x bnt -- false | bnn true )
bnt-dump (bnt -- )
bnt-empty? (bnt -- flag )
bnt-execute (i*x xt bnt -- j*x )
bnt-execute? (i*x xt bnt -- j*x flag )
bnt-free (bnt -- )
bnt-get (x bnt -- false | bnn true )
bnt-has? (x1 bnt -- flag )
bnt-init (bnt -- )
bnt-insert (i*x xt x bct -- bnn1 true | i*x bnn2 false )
bnt-length@ (bnt -- u )
bnt-new (-- bnt )
car% (-- n )
car+extra! (u -- )
car+extra@ (-- u )
car-(free) (car -- )
car-append (x car -- )
car-clear (car -- )
car-compare! (xt car -- )
car-compare@ (car -- xt )
car-count (x car -- u )
car-create (n "<spaces>name" -- ; -- car )
car-delete (n car -- x )
car-dequeue (car -- x )
car-dump (car -- )
car-enqueue (x car -- )
car-execute (i*x xt car -- j*x )
car-extra! (u car -- )
car-extra@ (car -- u )
car-find (x car -- n )
car-find-sorted (x car -- n flag )
car-free (car -- )
car-get (n car -- x )
car-has-sorted? (x car -- flag )
car-has? (x car -- flag )
car-index? (n car -- flag )
car-init (+n car -- )
car-insert (x n car -- )
car-insert-sorted (x car -- )
car-length@ (car -- u )
car-new (n -- car )
car-pop (car -- x )
car-prepend (x car -- )
car-push (x car -- )
car-set (x n car -- )
car-size! (+n car -- )
car-sort (car -- )
car-tos (car -- x )
cbf% (-- n )
cbf+extra! (u -- )
cbf+extra@ (-- u )
cbf-(free) (cbf -- )
cbf-access! (xt1 xt2 cbf -- )
cbf-access@ (cbf -- xt1 xt2 )
cbf-clear (cbf -- )
cbf-create (+n1 +n2 "<spaces>name" -- ; -- cbf )
cbf-dequeue (cbf -- i*x | addr true | false )
cbf-dump (cbf -- )
cbf-enqueue (i*x | addr cbf -- )
cbf-extra! (u cbf -- )
cbf-extra@ (cbf -- u )
cbf-fetch (addr u1 cbf -- u2 )
cbf-free (cbf -- )
cbf-get (addr u1 cbf -- u2 )
cbf-init (+n1 +n2 cbf -- )
cbf-length@ (cbf -- u )
cbf-new (+n1 +n2 -- cbf )
cbf-pop (cbf -- i*x | addr true | false )
cbf-push (i*x | addr cbf -- )
cbf-set (addr u cbf -- )
cbf-size! (+n cbf -- )
cbf-skip (+n1 cbf -- +n2 )
cbf-tos (cbf -- i*x | addr true | false )
cfield: (structure-sys "<spaces>name" -- structure-sys ; addr1 -- addr2 )
cfields: (structure-sys n "<spaces>name" -- structure-sys ; addr1 -- addr2 )
chr-alnum? (char -- flag )
chr-alpha? (char -- flag )
chr-ascii? (char -- flag )
chr-base (char -- false | u true )
chr-blank? (char -- flag )
chr-cntrl? (char -- flag )
chr-digit? (char -- flag )
chr-graph? (char -- flag )
chr-hexdigit? (char -- flag )
chr-lower (char1 -- char2 )
chr-lower? (char -- flag )
chr-octdigit? (char -- flag )
chr-print? (char -- flag )
chr-punct? (char -- flag )
chr-range? (char1 char2 char3 -- flag )
chr-space? (char -- flag )
chr-string? (c-addr u char -- flag )
chr-upper (char1 -- char2 )
chr-upper? (char -- flag )
chr.ack (-- char )
chr.bel (-- char )
chr.bs (-- char )
chr.can (-- char )
chr.cr (-- char )
chr.dc1 (-- char )
chr.dc2 (-- char )
chr.dc3 (-- char )
chr.dc4 (-- char )
chr.del (-- char )
chr.dle (-- char )
chr.em (-- char )
chr.enq (-- char )
chr.eot (-- char )
chr.esc (-- char )
chr.etb (-- char )
chr.etx (-- char )
chr.ff (-- char )
chr.fs (-- char )
chr.gs (-- char )
chr.ht (-- char )
chr.lf (-- char )
chr.nak (-- char )
chr.nul (-- char )
chr.rs (-- char )
chr.si (-- char )
chr.sm (-- char )
chr.soh (-- char )
chr.sp (-- char )
chr.stx (-- char )
chr.sub (-- char )
chr.syn (-- char )
chr.us (-- char )
chr.vt (-- char )
chs% (-- n )
chs-char? (char chs -- flag )
chs-create ("<spaces>name" -- ; -- chs )
chs-dump (chs -- )
chs-execute (i*x xt chs -- j*x )
chs-free (chs -- )
chs-init (chs -- )
chs-invert (chs -- )
chs-new (-- chs )
chs-reset (chs -- )
chs-reset-alnum (chs -- )
chs-reset-alpha (chs -- )
chs-reset-blank (chs -- )
chs-reset-char (char chs -- )
chs-reset-chars (char1 char2 chs -- )
chs-reset-cntrl (chs -- )
chs-reset-digit (chs -- )
chs-reset-graph (chs -- )
chs-reset-list (charu .. char1 u chs -- )
chs-reset-lower (chs -- )
chs-reset-print (chs -- )
chs-reset-punct (chs -- )
chs-reset-space (chs -- )
chs-reset-string (c-addr u chs -- )
chs-reset-upper (chs -- )
chs-reset-word (chs -- )
chs-reset-xdigit (chs -- )
chs-set (chs -- )
chs-set-alnum (chs -- )
chs-set-alpha (chs -- )
chs-set-blank (chs -- )
chs-set-char (char chs -- )
chs-set-chars (char1 char2 chs -- )
chs-set-cntrl (chs -- )
chs-set-digit (chs -- )
chs-set-graph (chs -- )
chs-set-list (charu .. char1 u chs -- )
chs-set-lower (chs -- )
chs-set-print (chs -- )
chs-set-punct (chs -- )
chs-set-space (chs -- )
chs-set-string (c-addr u chs -- )
chs-set-upper (chs -- )
chs-set-word (chs -- )
chs-set-xdigit (chs -- )
chs^and (chs1 chs2 -- )
chs^move (chs1 chs2 -- )
chs^or (chs1 chs2 -- )
chs^xor (chs1 chs2 -- )
cpx% (-- n )
cpx+abs (F: r1 r2 -- r3 )
cpx+acos (F: r1 r2 -- r3 r4 )
cpx+acosh (F: r1 r2 -- r3 r4 )
cpx+add (F: r1 r2 r3 r4 -- r5 r6 )
cpx+asin (F: r1 r2 -- r3 r4 )
cpx+asinh (F: r1 r2 -- r3 r4 )
cpx+atan (F: r1 r2 -- r3 r4 )
cpx+atanh (F: r1 r2 -- r3 r4 )
cpx+conj (F: r1 r2 -- r3 r4 )
cpx+cos (F: r1 r2 -- r3 r4 )
cpx+cosh (F: r1 r2 -- r3 r4 )
cpx+div (F: r1 r2 r3 r4 -- r5 r6 )
cpx+equal? (F: r1 r2 r3 r4 -- ; -- flag )
cpx+exp (F: r1 r2 -- r3 r4 )
cpx+from-polar (F: r1 r2 -- r3 r4 )
cpx+imul (F: r1 r2 r3 -- r4 r5 )
cpx+ln (F: r1 r2 -- r3 r4 )
cpx+mul (F: r1 r2 r3 r4 -- r5 r6 )
cpx+nrm (F: r1 r2 -- r3 )
cpx+rmul (F: r1 r2 r3 -- r4 r5 )
cpx+sin (F: r1 r2 -- r3 r4 )
cpx+sinh (F: r1 r2 -- r3 r4 )
cpx+sqrt (F: r1 r2 -- r3 r4 )
cpx+sub (F: r1 r2 r3 r4 -- r5 r6 )
cpx+tan (F: r1 r2 -- r3 r4 )
cpx+tanh (F: r1 r2 -- r3 r4 )
cpx+to-polar (F: r1 r2 -- r3 r4 )
cpx+to-string (F: r1 r2 -- ; -- c-addr u )
cpx-create ("<spaces>name" -- ; -- cpx )
cpx-dump (cpx -- )
cpx-free (cpx -- )
cpx-get (F: -- r1 r2 ; cpx -- )
cpx-im@ (F: -- r ; cpx -- )
cpx-init (cpx -- )
cpx-new (-- cpx )
cpx-re@ (F: -- r ; cpx -- )
cpx-set (F: r1 r2 -- ; cpx -- )
cpx^equal? (cpx2 cpx1 -- flag )
cpx^move (cpx2 cpx1 -- )
crc% (-- n )
crc+calc-crc32 (c-addr u -- u1 )
crc+calc-poly (u1 .. un n -- u )
crc-(free) (crc -- )
crc-create ("<spaces>name" -- ; -- crc )
crc-finish (crc -- u )
crc-free (crc -- )
crc-init (crc -- )
crc-new (-- crc )
crc-poly! (u crc -- )
crc-poly@ (crc -- u )
crc-reset (crc -- )
crc-update (c-addr u crc -- )
dbm% (-- n )
dbm+hash (c-addr u -- +n )
dbm-(free) (dbm -- )
dbm-close (dbm -- ior )
dbm-create ("<spaces>name" -- ; -- dbm )
dbm-delete (c-addr u dbm -- flag ior )
dbm-dump (dbm -- )
dbm-exist (c-addr u dbm -- flag ior )
dbm-fetch (c-addr u dbm -- c-addr u ior )
dbm-first-key (dmb -- c-addr u ior )
dbm-free (dbm -- )
dbm-init (dbm -- )
dbm-new (-- dbm )
dbm-next-key (dbm -- c-addr u ior )
dbm-open (c-addr u +n1 n2 dbm -- ior )
dbm-reorganize (dbm -- ior )
dbm-store (c-addr1 u1 c-addr2 u2 n dbm -- ior )
dbm-sync (dbm -- ior )
dbm.insert (-- n )
dbm.newdb (-- n )
dbm.reader (-- n )
dbm.replace (-- n )
dbm.sync (-- n )
dbm.wrcreat (-- n )
dbm.writer (-- n )
dci% (-- n )
dci-create (dcl "<spaces>name" -- ; -- dci )
dci-dump (dci -- )
dci-first (dci -- x true | false )
dci-first? (dci -- flag )
dci-free (dci -- )
dci-get (dci -- x true | false )
dci-init (dcl dci -- )
dci-insert-after (x dci -- )
dci-last (dci -- x true | false )
dci-last? (dci -- flag )
dci-move (x dci -- false )
dci-new (dcl -- dci )
dci-next (dci -- x true | false )
dci-prev (dci -- x true | false )
dci-set (x dci -- )
dcl% (-- n )
dcl-(free) (dnl -- )
dcl-append (x dcl -- )
dcl-clear (dnl -- )
dcl-compare! (xt dcl -- )
dcl-compare@ (dcl -- xt )
dcl-count (x dcl -- u )
dcl-create ("<spaces>name" -- ; -- dcl )
dcl-delete (n dcl -- x )
dcl-dump (dcl -- )
dcl-empty? (dcl -- flag )
dcl-execute (i*x xt dcl -- j*x )
dcl-find (x dcl -- n )
dcl-free (dcl -- )
dcl-get (n dcl -- x )
dcl-has? (x dcl -- flag )
dcl-index? (n dcl -- flag )
dcl-init (dcl -- )
dcl-insert (x n dcl -- )
dcl-insert-sorted (x dcl -- )
dcl-length@ (dcl -- u )
dcl-new (-- dcl )
dcl-prepend (x dcl -- )
dcl-remove (x dcl -- flag )
dcl-reverse (dcl -- )
dcl-set (x n dcl -- )
dcn% (-- n )
dcn-cell! (x dcn -- )
dcn-cell@ (dcn -- x )
dcn-dump (dcn -- )
dcn-free (dcn -- )
dcn-init (x dcn -- )
dcn-new (x -- dcn )
debug" ("ccc<quote>" -- )
dffield: (structure-sys "<spaces>name" -- structure-sys ; addr1 -- addr2 )
dfield: (structure-sys "<spaces>name" -- structure-sys ; addr1 -- addr2 )
dfields: (structure-sys n "<spaces>name" -- structure-sys ; addr1 -- addr2 )
dni% (-- n )
dni-create (dnl "<spaces>name" -- ; -- dni )
dni-dump (dni -- )
dni-first (dni -- dnn | nil )
dni-first? (dni -- flag )
dni-free (dni -- )
dni-get (dni -- dnn | nil )
dni-init (dnl dni -- )
dni-last (dni -- dnn | nil )
dni-last? (dni -- flag )
dni-new (dnl -- dni )
dni-next (dni -- dnn | nil )
dni-prev (dni -- dnn | nil )
dnl% (-- n )
dnl-(free) (xt dnl -- )
dnl-append (dnn dnl -- )
dnl-create ("<spaces>name" -- ; -- dnl )
dnl-delete (n dnl -- dnn )
dnl-dequeue (dnl -- dnn | nil )
dnl-dump (dnl -- )
dnl-empty? (dnl -- flag )
dnl-enqueue (dnn dnl -- )
dnl-execute (i*x xt dnl -- j*x )
dnl-first@ (dnl -- dnn | nil )
dnl-free (dnl -- )
dnl-get (n dnl -- dnn )
dnl-index? (n dnl -- flag )
dnl-init (dnl -- )
dnl-insert (dnn n dnl -- )
dnl-insert-after (dnn1 dnn2 dnl -- )
dnl-insert-before (dnn1 dnn2 dnl -- )
dnl-last@ (dnl -- dnn | nil )
dnl-length@ (dnl -- u )
dnl-new (-- dnl )
dnl-pop (dnl -- dnn | nil )
dnl-prepend (dnn dnl -- )
dnl-push (dnn dnl -- )
dnl-remove (dnn dnl -- )
dnl-reverse (dnl -- )
dnl-tos (dnl -- dnn | nil )
dnn% (-- n )
dnn-dump (dnn -- )
dnn-free (dnn -- )
dnn-init (dnn -- )
dnn-new (-- dnn )
dnn-next! (dnn1 dnn2 -- )
dnn-next@ (dnn1 -- dnn2 )
dnn-prev! (dnn1 dnn2 -- )
dnn-prev@ (dnn1 -- dnn2 )
do-log (c-addr u n -- )
dom% (-- n )
dom-(free) (dom -- )
dom-append-node (i*x n dom -- )
dom-child (dom -- n true | false )
dom-children (dom -- n )
dom-children? (dom -- flag )
dom-create ("<spaces>name" -- ; -- dom )
dom-document (dom -- true | false )
dom-document? (dom -- flag )
dom-dump (dom - )
dom-first (dom -- n true | false )
dom-first? (dom -- flag )
dom-free (dom -- )
dom-get (dom -- n true | false )
dom-get-name (dom -- c-addr u )
dom-get-type (dom -- n )
dom-get-value (dom -- c-addr u )
dom-init (dom -- )
dom-insert-node-after (i*x n -- )
dom-insert-node-before (i*x n dom -- )
dom-last (dom -- n true | false )
dom-last? (dom -- flag )
dom-new (-- dom )
dom-next (dom -- n true | false )
dom-parent (dom -- n true | false )
dom-prev (dom -- n true | false )
dom-read-reader (x xt flag1 dom -- flag2 )
dom-read-string (c-addr u flag1 dom -- flag2 )
dom-remove (dom -- flag )
dom-set (i*x dom -- )
dom-write-string (dom -- c-addr u true | false )
dom-write-writer (x xt dom -- flag )
dom.attribute (-- n )
dom.cdata (-- n )
dom.comment (-- n )
dom.doc-fragment (-- n )
dom.doc-type (-- n )
dom.document (-- n )
dom.element (-- n )
dom.entity (-- n )
dom.entity-ref (-- n )
dom.not-used (-- n )
dom.notation (-- n )
dom.pi (-- n )
dom.text (-- n )
dos-write-12hour (dtm tos -- )
dos-write-24hour (dtm tos -- )
dos-write-2year (dtm tos -- )
dos-write-abbr-month-name (dtm tos -- )
dos-write-abbr-weekday-name (dtm tos -- )
dos-write-american-date (dtm tos -- )
dos-write-ampm (dtm tos -- )
dos-write-ampm-time (dtm tos -- )
dos-write-century (dtm tos -- )
dos-write-date (dtm tos -- )
dos-write-date-time (dtm tos -- )
dos-write-format (dtm c-addr u tos -- )
dos-write-hhmm-time (dtm tos -- )
dos-write-hhmmss-time (dtm tos -- )
dos-write-iso8601-date (dtm tos -- )
dos-write-minute (dtm tos -- )
dos-write-month (dtm tos -- )
dos-write-month-name (dtm tos -- )
dos-write-monthday (dtm tos -- )
dos-write-seconds (dtm tos -- )
dos-write-seconds-since-epoch (dtm tos -- )
dos-write-spaced-12hour (dtm tos -- )
dos-write-spaced-24hour (dtm tos -- )
dos-write-spaced-monthday (dtm tos -- )
dos-write-time (dtm tos -- )
dos-write-upper-ampm (dtm tos -- )
dos-write-week-number (dtm tos -- )
dos-write-weekday (dtm tos -- )
dos-write-weekday-name (dtm tos -- )
dos-write-year (dtm tos -- )
dos-write-yearday (dtm tos -- )
dti-day+ (dtm -- )
dti-day- (dtm -- )
dti-days+ (d dtm -- )
dti-days- (d dtm -- )
dti-hour+ (dtm -- )
dti-hour- (dtm -- )
dti-milli+ (dtm -- )
dti-milli- (dtm -- )
dti-minute+ (dtm -- )
dti-minute- (dtm -- )
dti-month+ (dtm -- )
dti-month- (dtm -- )
dti-second+ (dtm -- )
dti-second- (dtm -- )
dti-seconds+ (d dtm -- )
dti-seconds- (d dtm -- )
dti-year+ (dtm -- )
dti-year- (dtm -- )
dtm% (-- n )
dtm+calc-leap-years (n1 n2 -- n3 )
dtm+day? (n1 n2 n3 -- flag )
dtm+days-in-month (n1 n2 -- n3 )
dtm+days-in-year (n1 -- n2 )
dtm+days-till-month (n1 n2 -- n3 )
dtm+hour? (n -- flag )
dtm+leap-year? (n -- flag )
dtm+milli? (n -- flag )
dtm+minute? (n -- flag )
dtm+month? (n -- flag )
dtm+second? (n -- flag )
dtm+year? (n -- flag )
dtm-calc-days-since-epoch (n dtm -- d )
dtm-calc-seconds-since-epoch (n dtm -- d )
dtm-compare (n1 n2 n3 n4 n5 n6 n7 dtm -- n )
dtm-create ("<spaces>name" -- ; -- dtm )
dtm-day! (n dtm -- )
dtm-day@ (dtm -- n )
dtm-dump (dtm -- )
dtm-free (dtm -- )
dtm-get (dtm -- n1 n2 n3 n4 n5 n6 n7 )
dtm-get-date (dtm -- n1 n2 n3 )
dtm-get-time (dtm -- n1 n2 n3 n4 )
dtm-hour! (n dtm -- )
dtm-hour@ (dtm -- n )
dtm-init (dtm -- )
dtm-iso-weeknumber (dtm -- n1 n2 )
dtm-milli! (n dtm -- )
dtm-milli@ (dtm -- n )
dtm-minute! (n dtm -- )
dtm-minute@ (dtm -- n )
dtm-month! (n dtm -- )
dtm-month@ (dtm -- n )
dtm-new (-- dtm )
dtm-second! (n dtm -- )
dtm-second@ (dtm -- n )
dtm-set (n1 n2 n3 n4 n5 n6 n7 dtm -- )
dtm-set-date (n1 n2 n3 dtm -- )
dtm-set-now (dtm -- )
dtm-set-time (n1 n2 n3 n4 dtm -- )
dtm-set-with-days (d1 n2 dtm -- )
dtm-set-with-seconds (d n dtm -- )
dtm-weekday (dtm -- n )
dtm-year! (n dtm -- )
dtm-year@ (dtm -- n )
dtm-yearday (dtm -- n )
dtm.april (-- n )
dtm.august (-- n )
dtm.december (-- n )
dtm.february (-- n )
dtm.friday (-- n )
dtm.january (-- n )
dtm.july (-- n )
dtm.june (-- n )
dtm.march (-- n )
dtm.may (-- n )
dtm.monday (-- n )
dtm.november (-- n )
dtm.october (-- n )
dtm.saturday (-- n )
dtm.september (-- n )
dtm.start-epoch (-- n )
dtm.sunday (-- n )
dtm.thursday (-- n )
dtm.tuesday (-- n )
dtm.unix-epoch (-- n )
dtm.wednesday (-- n )
dtm^compare (dtm1 dtm2 -- n )
end-enumeration (enum-sys -- )
end-of-line (-- c-addr )
end-stringtable (stringtable-sys -- )
end-structure (structure-sys -- )
enum: (enum-sys "<spaces>name" -- enum-sys ; -- n )
error" ("ccc<quote>" -- )
exp-index-out-of-range (-- n )
exp-invalid-data (-- n )
exp-invalid-parameters (-- n )
exp-invalid-state (-- n )
exp-no-data (-- n )
exp-wrong-checksum (-- n )
exp-wrong-file-data (-- n )
exp-wrong-file-type (-- n )
exp-wrong-file-version (-- n )
exp-wrong-length (-- n )
f-rot (F: r1 r2 r3 -- r3 r1 r2 )
f2dup (F: r1 r2 -- r1 r2 r1 r2 )
f>r (F: r -- ; R: -- r )
fatal" ("ccc<quote>" -- )
ffield: (structure-sys "<spaces>name" -- structure-sys ; addr1 -- addr2 )
ffields: (structure-sys n "<spaces>name" -- structure-sys ; addr1 -- addr2 )
field: (structure-sys "<spaces>name" -- structure-sys ; addr1 -- addr2 )
fields: (structure-sys n "<spaces>name" -- structure-sys ; addr1 -- addr2 )
fr> (F: -- r ; R: r -- )
fr@ (F: -- r ; R: r -- r )
frc% (-- n )
frc+abs (n1 n2 -- n3 n4 )
frc+add (n1 n2 n3 n4 -- n5 n6 )
frc+calc-gcd (n1 n2 -- +n )
frc+calc-lcm (n1 n2 -- +n )
frc+compare (n1 n2 n3 n4 -- n )
frc+divide (n1 n2 n3 n4 -- n5 n6 )
frc+invert (n1 n2 -- n3 n4 )
frc+multiply (n1 n2 n3 n4 -- n5 n6 )
frc+negate (n1 n2 -- n3 n4 )
frc+norm (n1 n2 -- n3 n4 )
frc+subtract (n1 n2 n3 n4 -- n5 n6 )
frc+to-float (n1 n2 -- r )
frc+to-string (n1 n2 -- c-addr u )
frc-create ("<spaces>name" -- ; -- frc )
frc-denom@ (frc -- n )
frc-dump (frc -- )
frc-free (frc -- )
frc-get (frc -- n1 n2 )
frc-init (frc -- )
frc-new (-- frc )
frc-num@ (frc -- n )
frc-set (n1 n2 frc )
frc^compare (frc2 frc1 -- n )
frc^move (frc2 frc1 -- )
fsm% (-- n )
fsm-(free) (fsm -- )
fsm-any-transition (x xt c-addr1 u1 fst1 fst2 fsm -- ftr )
fsm-create ("<spaces>name" +n -- ; -- fsm )
fsm-dump (fsm -- )
fsm-feed (n fsm -- fst | nil )
fsm-find-state (c-addr u fsm -- fst | nil )
fsm-free (fsm -- )
fsm-init (+n fsm -- )
fsm-new (+n -- fsm )
fsm-new-state (x xt1 xt2 c-addr1 u1 fsm -- fst )
fsm-new-transition (x xt c-addr1 u1 fst1 fst2 fsm -- ftr )
fsm-start (fsm -- )
fsm-start! (fst fsm -- )
fsm-start@ (fsm -- fst )
fsm-to-dot (c-addr u tos fsm -- )
fsm-try (n fsm -- fst | nil )
fst% (-- n )
fst-(free) (fst -- )
fst-any-transition (x xt c-addr u fst1 fst -- ftr )
fst-attributes! (c-addr u fst -- )
fst-attributes@ (fst -- c-addr u )
fst-data! (x fst -- )
fst-data@ (fst -- x )
fst-dump (fst -- )
fst-entry@ (fst -- xt )
fst-exit@ (fst -- xt )
fst-feed (n fst -- fst | nil )
fst-find-transition (c-addr u fst -- ftr | nil )
fst-free (fst -- )
fst-id@ (fst -- n )
fst-init (x xt1 xt2 c-addr u n fst -- )
fst-label? (c-addr u fst -- c-addr u false | fst true )
fst-label@ (fst -- c-addr u )
fst-new (x xt1 xt2 c-addr u n -- fst )
fst-new-transition (x xt c-addr u fst1 n fst -- ftr )
fst-try (n fst -- fst | nil )
ftr% (-- n )
ftr-(free) (ftr -- )
ftr-action@ (ftr -- xt )
ftr-attributes! (c-addr u ftr -- )
ftr-attributes@ (ftr -- c-addr u )
ftr-condition@ (ftr -- bar )
ftr-data! (x ftr -- )
ftr-data@ (ftr -- x )
ftr-dump (ftr -- )
ftr-feed (n ftr -- n false | fst true )
ftr-fire (n ftr -- fst )
ftr-free (ftr -- )
ftr-init (x xt c-addr u fst +n ftr -- )
ftr-label? (c-addr u ftr -- ftr true | c-addr u false )
ftr-label@ (ftr -- c-addr u )
ftr-new (x xt c-addr u fst +n -- ftr )
ftr-try (n ftr -- n false | fst true )
gmo-read (c-addr u msc -- 0 | ior )
gsv+call (c-addr1 u1 -- c-addr2 u2 )
gsv+close (-- ior )
gsv+connect (c-addr u -- ior )
gsv+disconnect (-- ior )
gsv+open (c-addr1 u1 c-addr2 u2 -- ior )
gsv+server-connect (n1 c-addr1 u1 n2 -- c-addr2 u2 )
gsv+server-connect-after (n1 c-addr1 u1 n2 -- c-addr2 u2 )
gzf% (-- n )
gzf-(free) (gzf -- )
gzf-comment! (c-addr u gzf -- )
gzf-comment@ (gzf -- c-addr u )
gzf-create ("<spaces>name" -- ; -- gzf )
gzf-dump (gzf -- )
gzf-flags! (u gzf -- )
gzf-flags@ (gzf -- u )
gzf-free (gzf -- )
gzf-init (gzf -- )
gzf-mtime! (u gzf -- )
gzf-mtime@ (gzf -- u )
gzf-name! (c-addr u gzf -- )
gzf-name@ (gzf -- c-addr u )
gzf-new (-- gzf )
gzf-os! (n gzf -- )
gzf-os@ (gzf -- n )
gzf-reset (gzf -- )
gzf-text! (flag gzf -- )
gzf-text@ (gzf -- flag )
gzf.acorn (-- n )
gzf.amiga (-- n )
gzf.atari (-- n )
gzf.cp/m (-- n )
gzf.deflate (-- n )
gzf.fat (-- n )
gzf.hpfs (-- n )
gzf.macintos (-- n )
gzf.ntfs (-- n )
gzf.qdos (-- n )
gzf.tops-20 (-- n )
gzf.unix (-- n )
gzf.unknown (-- n )
gzf.vm/cms (-- n )
gzf.vms (-- n )
gzf.z-system (-- n )
gzi% (-- n )
gzi-(free) (gzi -- )
gzi-create ("<spaces>name" u -- ; -- gzi )
gzi-dump (gzi -- )
gzi-end-inflate (gzi -- )
gzi-free (gzi -- )
gzi-inflate (gzi -- ior )
gzi-init (u gzi -- )
gzi-init-inflate (gzi -- )
gzi-lbf@ (gzi -- lbf )
gzi-new (-- gzi )
gzi-reduce-output (gzi -- )
gzi.done (-- n )
gzi.more (-- n )
gzi.ok (-- n )
gzi.states (-- n )
hci% (-- n )
hci-create (hct "<spaces>name" -- ; -- hci )
hci-dump (hci -- )
hci-first (hci -- x true | false )
hci-first? (hci -- flag )
hci-free (hci -- )
hci-get (hci -- false | x true )
hci-init (hct hci -- )
hci-key (hci -- c-addr u )
hci-last? (hci -- flag )
hci-move (x hci -- flag )
hci-new (hct -- hci )
hci-next (hci -- x true | false )
hci-set (x hci -- )
hcn% (- n )
hcn-(free) (hcn -- )
hcn-dump (hcn -- )
hcn-free (hcn -- )
hcn-init (x c-addr u u2 hcn -- )
hcn-new (x c-addr u u2 -- hcn )
hct% (-- n )
hct+hash (c-addr1 u1 -- u2 )
hct-(free) (hct -- )
hct-count (x hct -- u )
hct-create (u "<spaces>name" -- ; -- hct )
hct-delete (c-addr u hct -- false | x true )
hct-dump (hct -- )
hct-empty? (hct -- flag )
hct-execute (i*x xt hct -- j*x )
hct-free (hct -- )
hct-get (c-addr u hct -- false | x true )
hct-has? (c-addr u hct -- flag )
hct-init (u hct -- )
hct-insert (x c-addr u hct -- )
hct-length@ (hct -- u )
hct-load! (u hct -- )
hct-load@ (hct -- u )
hct-new (u -- hct )
hct-size! (u hct -- )
hni% (-- n )
hni-create (hnt "<spaces>name" -- ; -- hni )
hni-dump (hni -- )
hni-first (hni -- hnn | nil )
hni-first? (hni -- flag )
hni-free (hni -- )
hni-get (hni -- hnn | nil )
hni-init (hnt hni -- )
hni-key (hni -- c-addr u )
hni-last? (hni -- flag )
hni-new (hnt -- hni )
hni-next (hni -- hnn | nil )
hnn% (-- n )
hnn-(free) (hnn -- )
hnn-dump (hnn -- )
hnn-free (hnn -- )
hnn-init (c-addr u u2 hnn -- )
hnn-key@ (hnn -- c-addr u )
hnn-new (c-addr u u2 -- hnn )
hnt% (-- n )
hnt+hash (c-addr1 u1 -- u2 )
hnt-(free) (xt hnt -- )
hnt-create (u "<spaces>name" -- ; -- hnt )
hnt-delete (c-addr u hnt -- nil | hnn )
hnt-dump (hnt -- )
hnt-empty? (hnt -- flag )
hnt-execute (i*x xt hnt -- j*x )
hnt-free (hnt -- )
hnt-get (c-addr u hnt -- nil | hnn )
hnt-has? (c-addr u hnt -- flag )
hnt-init (u hnt -- )
hnt-insert (hnn hnt -- )
hnt-length@ (hnt -- u )
hnt-load! (u hnt -- )
hnt-load@ (hnt -- u )
hnt-new (u -- hnt )
hnt-search (c-addr u hnt -- u hnn )
hnt-size! (u hnt -- )
icompare (c-addr1 u1 c-addr2 u2 -- n )
index2offset (n1 n2 -- n3 )
info" ("ccc<quote>" -- )
lbf% (-- n )
lbf+extra! (u -- )
lbf+extra@ (-- u )
lbf-(free) (lbf -- )
lbf-access! (xt1 xt2 lbf -- )
lbf-access@ (lbf -- xt1 xt2 )
lbf-clear (lbf -- )
lbf-copy (u1 u2 lbf -- )
lbf-create (+n1 +n2 "<spaces>name" -- ; -- lbf )
lbf-dequeue (lbf -- i*x true | addr true | false )
lbf-dump (lbf -- )
lbf-enqueue (i*x lbf | addr lbf -- )
lbf-extra! (u lbf -- )
lbf-extra@ (lbf -- u )
lbf-fetch (u1 lbf -- addr u2 | 0 )
lbf-free (lbf -- )
lbf-gap@ (lbf -- u )
lbf-get (u1 lbf -- addr u2 | 0 )
lbf-get' (u1 lbf -- addr u2 | 0 )
lbf-init (+n1 +n2 lbf -- )
lbf-length'@ (lbf -- u )
lbf-length@ (lbf -- u )
lbf-new (+n1 +n2 -- lbf )
lbf-pop (lbf -- i*x true | addr true | false )
lbf-push (i*x lbf | addr lbf -- )
lbf-reduce (u lbf -- )
lbf-set (addr u lbf -- )
lbf-size! (+n lbf -- )
lbf-skip (u1 lbf -- u2 )
lbf-tos (lbf -- i*x true | addr true | false )
log-from-level (n -- )
log-stack-depth (n -- )
log-to-callback (xt -- )
log-to-console (-- )
log-to-file (fileid -- )
log-to-rolling (c-addr u n1 n2 -- )
log-with-time&date (flag -- )
log.debug (-- n )
log.error (-- n )
log.fatal (-- n )
log.info (-- n )
log.none (-- n )
log.trace (-- n )
log.warning (-- n )
lroll (u1 u2 -- u3 )
max-ms@ (-- u )
md5% (-- n )
md5+to-string (u1 u2 u3 u4 -- c-addr u )
md5-create ("<spaces>name" -- ; -- md5 )
md5-dump (md5 -- )
md5-finish (md5 -- u1 u2 u3 u4 )
md5-free (md5 -- )
md5-init (md5 -- )
md5-new (-- md5 )
md5-reset (md5 -- )
md5-update (c-addr u md5 -- )
ms@ (-- u )
msc% (-- n )
msc-(free) (msc -- )
msc-add (c-addr1 u1 c-addr2 u2 msc -- )
msc-create ("<spaces>name" -- ; -- msc )
msc-dump (msc -- )
msc-free (msc -- )
msc-init (msc -- )
msc-new (-- msc )
msc-remove (c-addr u msc -- flag )
msc-translate (c-addr1 u1 msc -- c-addr2 u2 )
msc-translate? (c-addr1 u2 msc -- c-addr2 u2 true | false )
nci% (-- n )
nci-append-child (x nci -- )
nci-child (nci -- x true | false )
nci-children (nci -- n )
nci-children? (nci -- flag )
nci-create (nct "<spaces>name" -- ; -- nci )
nci-dump (nci -- )
nci-first (nci -- x true | false )
nci-first? (nci -- flag )
nci-free (nci -- )
nci-get (nci -- x true | false )
nci-init (nct nci -- )
nci-insert-after (x nci -- )
nci-insert-before (x nci -- )
nci-last (nci -- x true | false )
nci-last? (nci -- flag )
nci-new (nct -- nci )
nci-next (nci -- x true | false )
nci-parent (nci -- x true | false )
nci-prepend-child (x nci -- )
nci-prev (nci -- x true | false )
nci-remove (nci -- x true | false )
nci-root (nci -- x true | false )
nci-root? (nci -- flag )
ncn% (-- n )
ncn-cell! (x ncn -- )
ncn-cell@ (ncn -- x )
ncn-dump (ncn -- )
ncn-free (ncn -- )
ncn-init (x ncn -- )
ncn-new (x -- ncn )
nct% (-- n )
nct-(free) (nct -- )
nct-clear (nct -- )
nct-count (x nct -- u )
nct-create ("<spaces>name" -- ; -- nct )
nct-dump (nct -- )
nct-empty? (nct -- flag )
nct-execute (i*x xt nct -- j*x )
nct-execute? (i*x xt nct -- j*x flag )
nct-free (nct -- )
nct-has? (x nct -- flag )
nct-init (nct -- )
nct-length@ (nct -- u )
nct-new (-- nct )
nfe% (-- n )
nfe+free-expression (nfe -- )
nfe-(free) (nfe -- )
nfe-alternation (nfs1 nfs2 nfs3 nfs4 nfe -- nfs5 nfs6 )
nfe-clear (nfe -- )
nfe-close (nfs1 nfs2 nfe -- nfs3 )
nfe-concat (nfs1 nfs2 nfs3 nfs4 nfe -- nfs5 nfs6 )
nfe-create ("<spaces>name" -- ; -- nfe )
nfe-dump (nfe -- )
nfe-expression@ (nfe -- a-addr )
nfe-free (nfe -- )
nfe-init (nfe -- )
nfe-level+@ (nfe -- n )
nfe-match? (c-addr u flag nfe -- flag )
nfe-new (-- nfe )
nfe-one-or-more (nfs1 nfs2 nfe -- nfs3 nfs4 )
nfe-paren (nfs1 nfs2 n nfe -- nfs3 nfs4 )
nfe-parens@ (nfe -- n )
nfe-result (n1 nfe -- n2 n3 )
nfe-search (c-addr u flag nfe -- n )
nfe-single (x n nfe -- nfs1 nfs2 )
nfe-states@ (nfe -- n )
nfe-visit++ (nfe -- n )
nfe-visit@ (nfe -- n )
nfe-zero-or-more (nfs1 nfs2 nfe -- nfs3 nfs4 )
nfe-zero-or-one (nfs1 nfs2 nfe -- nfs3 nfs4 )
nfs% (-- n )
nfs-data@ (nfs -- x )
nfs-dump (nfs -- )
nfs-free (nfs -- )
nfs-id@ (nfs -- n )
nfs-init (x n1 n2 nfs -- )
nfs-new (x n1 n2 -- nfs )
nfs-out1! (nfs1 nfs2 -- )
nfs-out1@ (nfs1 -- nfs2 )
nfs-out2! (nfs1 nfs2 -- )
nfs-out2@ (nfs1 -- nfs2 )
nfs-type@ (nfs -- n )
nfs-visit! (n nfs -- )
nfs-visit@ (nfs -- n )
nfs.any (-- n )
nfs.char (-- n )
nfs.class (-- n )
nfs.lparen (-- n )
nfs.match (-- n )
nfs.rparen (-- n )
nfs.split (-- n )
nil! (a-addr -- )
nil<> (addr -- flag )
nil<>? (addr -- false | addr true )
nil= (addr -- flag )
nni% (-- n )
nni-append-child (nnn nni -- )
nni-child (nni -- nnn | nil )
nni-children (nni -- n )
nni-children? (nni -- flag )
nni-create (nnt "<spaces>name" -- ; -- nni )
nni-dump (nni -- )
nni-first (nni -- nnn )
nni-first? (nni -- flag )
nni-free (nni -- )
nni-get (nni -- nnn | nil )
nni-init (nnt nni -- )
nni-insert-after (nnn nni -- )
nni-insert-before (nnn nni -- )
nni-last (nni -- nnn )
nni-last? (nni -- flag )
nni-new (nnt -- nni )
nni-next (nni -- nnn | nil )
nni-parent (nni -- nnn | nil )
nni-prepend-child (nnn nni -- )
nni-prev (nni -- nnn | nil )
nni-remove (nni -- nnn )
nni-root (nni -- nnn | nil )
nni-root? (nni -- flag )
nnn% (-- n )
nnn-dump (nnn -- )
nnn-free (nnn -- )
nnn-init (nnn -- )
nnn-new (-- nnn )
nnn-parent! (nnn1 nnn2 -- )
nnn-parent@ (nnn1 -- nnn2 )
nnt% (-- n )
nnt-(free) (xt nnt -- )
nnt-create ("<spaces>name" -- ; -- nnt )
nnt-dump (nnt -- )
nnt-empty? (nnt -- flag )
nnt-execute (i*x xt nnt -- j*x )
nnt-execute? (i*x xt nnt -- j*x flag )
nnt-free (nnt -- )
nnt-init (nnt -- )
nnt-length@ (nnt -- u )
nnt-new (-- nnt )
nnt-root@ (nnt -- nnn | nil )
parse-esc (c-addr1 u1 c-addr2 -- c-addr3 u3 )
parse\" ("ccc<quote>" -- c-addr u )
r'@ (R: x1 x2 -- x1 x2; -- x1 )
rdg% (-- n )
rdg-beta (F: r1 r2 -- r3 ; rdg -- )
rdg-binomial (F: r -- ; u1 rdg -- u2 )
rdg-create (x xt "<spaces>name" -- ; -- rdg )
rdg-exponential (F: r1 -- r2 ; rdg -- )
rdg-free (rdg -- )
rdg-gamma (F: r1 r2 -- r3 ; rdg -- )
rdg-init (x xt rdg -- )
rdg-new (x xt -- rdg )
rdg-normal (F: r1 r2 -- r3 ; rdg -- )
rdg-pareto (F: r1 r2 -- r3 ; rdg -- )
rdg-poisson (F: r -- ; rdg -- u )
rdg-uniform (F: r1 r2 -- r3 ; rdg -- )
rdg-weibull (F: r1 r2 -- r3 ; rdg -- )
rgx% (-- n )
rgx-cmatch? (c-addr u rgx -- flag )
rgx-compile (c-addr u rgx -- true | n false )
rgx-create ("<spaces>name" -- ; -- rgx )
rgx-csearch (c-addr u rgx -- n )
rgx-dump (rgx -- )
rgx-free (rgx -- )
rgx-imatch? (c-addr u rgx -- flag )
rgx-init (rgx -- )
rgx-isearch (c-addr u rgx -- n:index )
rgx-new (-- rgx )
rgx-result (n rgx -- n1 n2 )
rng% (-- n )
rng-create (u "<spaces>name" -- ; -- rng )
rng-dump (rng -- )
rng-free (rng -- )
rng-init (u rng -- )
rng-new (u -- rng )
rng-next-float (rng -- r )
rng-next-number (rng -- n )
rng-seed (u rng -- )
rroll (u1 u2 -- u3 )
s\" ("ccc<quote>" -- c-addr u )
scf" ("ccc<quote>" c-addr u -- i*x j*r n )
scf+scan (c-addr1 u1 c-addr2 u2 -- i*x j*r n )
sci% (-- n )
sci-create (scl "<spaces>name" -- ; -- sci )
sci-dump (sci -- )
sci-first (sci -- x true | false )
sci-first? (sci -- flag )
sci-free (sci -- )
sci-get (sci -- x true | false )
sci-init (scl sci -- )
sci-insert-after (x sci -- )
sci-last? (sci -- flag )
sci-move (x sci -- flag )
sci-new (scl -- sci )
sci-next (sci -- x true | false )
sci-set (x sci -- )
scl% (-- n )
scl-(free) (scl -- )
scl-append (x scl -- )
scl-clear (scl -- )
scl-compare! (xt scl -- )
scl-compare@ (scl -- xt )
scl-count (x scl -- u )
scl-create ("<spaces>name" -- ; -- scl )
scl-delete (n scl -- x )
scl-dump (scl -- )
scl-empty? (scl -- flag )
scl-execute (i*x xt scl -- j*x )
scl-find (x scl -- n )
scl-free (scl -- )
scl-get (n scl -- x )
scl-has? (x scl -- flag )
scl-index? (n scl -- flag )
scl-init (scl -- )
scl-insert (x n scl -- )
scl-insert-sorted (x scl -- )
scl-length@ (scl -- u )
scl-new (-- scl )
scl-prepend (x scl -- )
scl-remove (x scl -- flag )
scl-reverse (scl -- )
scl-set (x n scl -- )
scn% (-- n )
scn-cell! (x scn -- )
scn-cell@ (scn -- x )
scn-dump (scn -- )
scn-free (scn -- )
scn-init (x scn -- )
scn-new (x -- scn )
sffield: (structure-sys "<spaces>name" -- structure-sys ; addr1 -- addr2 )
sh1% (-- n )
sh1+to-string (u1 u2 u3 u4 u5 -- c-addr u )
sh1-create ("<spaces>name" -- ; -- sh1 )
sh1-dump (sh1 -- )
sh1-finish (sh1 -- u1 u2 u3 u4 u5 )
sh1-free (sh1 -- )
sh1-init (sh1 -- )
sh1-new (-- sh1 )
sh1-reset (sh1 -- )
sh1-update (c-addr u sh1 -- )
sh2% (-- n )
sh2+to-string (u1 u2 u3 u4 u5 u6 u7 u8 -- c-addr u )
sh2-create ("<spaces>name" -- ; -- sh2 )
sh2-dump (sh2 -- )
sh2-finish (sh2 -- u1 u2 u3 u4 u5 u6 u7 u8 )
sh2-free (sh2 -- )
sh2-init (sh2 -- )
sh2-new (-- sh2 )
sh2-reset (sh2 -- )
sh2-update (c-addr u sh2 -- )
sni% (-- n )
sni-create (snl "<spaces>name" -- ; -- sni )
sni-dump (sni -- )
sni-first (sni -- snn | nil )
sni-first? (sni -- flag )
sni-free (sni -- )
sni-get (sni -- snn | nil )
sni-init (snl sni -- )
sni-last? (sni -- flag )
sni-new (snl -- sni )
sni-next (sni -- snn | nil )
snl% (-- n )
snl-(free) (xt scl -- )
snl-append (snn snl -- )
snl-create ("<spaces>name" -- ; -- snl )
snl-delete (n snl -- snn )
snl-dequeue (snl -- snn | nil )
snl-dump (snl -- )
snl-empty? (snl -- flag )
snl-enqueue (snn snl -- )
snl-execute (i*x xt snl -- j*x )
snl-execute? (i*x xt snl -- j*x flag )
snl-first@ (snl -- snn | nil )
snl-free (snl -- )
snl-get (n snl -- snn )
snl-index? (n snl -- flag )
snl-init (snl -- )
snl-insert (snn n snl -- )
snl-insert-after (snn1 snn2 snl -- )
snl-last@ (snl -- snn | nil )
snl-length@ (snl -- u )
snl-new (-- snl )
snl-pop (snl -- snn | nil )
snl-prepend (snn snl -- )
snl-push (snn snl -- )
snl-remove-after (snn1 snl -- snn2 | nil )
snl-remove-first (snl -- snn | nil )
snl-reverse (snl -- )
snl-tos (snl -- snn | nil )
snn% (- n )
snn-dump (snn -- )
snn-free (snn -- )
snn-init (snn -- )
snn-new (-- snn )
snn-next! (snn1 snn2 -- )
snn-next@ (snn1 -- snn2 )
spf" ("ccc<quote>" i*x j*r str -- )
spf-append (i*x j*r c-addr u str -- k*x l*r )
spf-set (i*x j*r c-addr u str -- )
str% (-- n )
str+columns (c-addr u n -- c-addrn un ... c-addr1 u1 n )
str+extra! (u -- )
str+extra@ (-- u )
str+strip (c-addr1 u1 -- c-addr2 u2 )
str+strip-leading (c-addr1 u1 -- c-addr2 u2 )
str+strip-trailing (c-addr u1 -- c-addr u2 )
str-(free) (str -- )
str-align-left (u str -- )
str-align-right (u str -- )
str-append-char (char str -- )
str-append-chars (char u str -- )
str-append-string (c-addr u str -- )
str-bounds (str -- c-addr+u c-addr )
str-cap-words (str -- )
str-capatilize (str -- )
str-ccompare (c-addr u str -- n )
str-center (u str -- )
str-clear (str -- )
str-count (c-addr u str -- u )
str-create ("<spaces>name" -- ; -- str )
str-data@ (str -- c-addr )
str-delete (u n str -- )
str-delete-char (n str -- )
str-dequeue-char (char str -- )
str-dump (str -- )
str-empty? (str -- flag )
str-enqueue-char (char str -- )
str-execute (i*x xt str -- j*x )
str-expand-tabs (u str -- )
str-extra! (u str -- )
str-extra@ (str -- u )
str-find (c-addr u n1 str -- n2 )
str-free (str -- )
str-get (str -- c-addr u )
str-get-char (n str -- char )
str-get-substring (u n str -- c-addr u )
str-get-zstring (str -- c-addr )
str-icompare (c-addr u str -- n )
str-index? (n str -- flag )
str-init (str -- )
str-insert-char (char n str -- )
str-insert-chars (char u n str -- )
str-insert-string (c-addr u n str -- )
str-length! (u str -- )
str-length@ (str -- u )
str-lower (str -- )
str-new (-- str )
str-pop-char (str -- char )
str-prepend-char (char str -- )
str-prepend-chars (char u str -- )
str-prepend-string (c-addr u str -- )
str-push-char (char str -- )
str-replace (c-addr1 u1 c-addr2 u2 str -- )
str-set (c-addr u str -- )
str-set-char (char n str -- )
str-set-zstring (c-addr str -- )
str-size! (u str -- )
str-strip (str -- )
str-strip-leading (str -- )
str-strip-trailing (str -- )
str-upper (str -- )
str^ccompare (str1 str2 -- n )
str^icompare (str1 str2 -- n )
tis% (-- n )
tis-(free) (tis -- )
tis-cmatch-char (char tis -- flag )
tis-cmatch-chars (c-addr u tis -- false | char true )
tis-cmatch-string (c-addr u tis -- flag )
tis-create ("<spaces>name" -- ; -- tis )
tis-dump (tis -- )
tis-eof? (tis -- flag )
tis-fetch-char (tis -- false | char true )
tis-fetch-chars (n tis -- 0 | addr u )
tis-free (tis -- )
tis-get (tis -- 0 | addr u )
tis-imatch-char (char tis -- flag )
tis-imatch-string (c-addr u tis -- flag )
tis-init (tis -- )
tis-iscan-string (c-addr1 n1 tis -- false | c-addr2 u2 true )
tis-match-set (chs tis - false | char true )
tis-new (-- tis )
tis-next-char (tis -- )
tis-next-chars (n tis -- )
tis-pntr! (n tis -- flag )
tis-pntr+! (n tis -- flag )
tis-pntr@ (tis -- u )
tis-read-all (tis -- 0 | c-addr u )
tis-read-char (tis -- false | char true )
tis-read-double (tis -- false | d true )
tis-read-line (tis -- 0 | c-addr u )
tis-read-more (tis -- flag )
tis-read-number (tis -- false | n true )
tis-read-string (n tis -- 0 | c-addr u )
tis-reduce (tis -- )
tis-reset (tis -- )
tis-scan-char (char tis -- false | c-addr u true )
tis-scan-chars (c-addr1 n1 tis -- false | c-addr2 u2 char true )
tis-scan-set (chs tis - false | c-addr u char true )
tis-scan-string (c-addr1 n2 tis -- false | c-addr1 u2 true )
tis-set (c-addr u tis -- )
tis-set-reader (x xt tis -- )
tis-skip-spaces (tis -- n )
tmr% (- n )
tmr-create (u "<spaces>name" -- ; -- tmr )
tmr-dump (tmr -- )
tmr-expired? (tmr -- flag )
tmr-free (tmr -- )
tmr-init (u tmr -- )
tmr-new (u -- tmr )
tmr-restart (tmr -- )
tmr-start (u tmr -- )
tmr-timeout@ (tmr -- u )
tmr-timer@ (tmr -- u )
tmr-wait (tmr -- )
tos% (-- n )
tos-(free) (tos -- )
tos-align (char u1 u2 tos -- )
tos-align-left (char u tos -- )
tos-align-right (char u tos -- )
tos-center (char u tos -- )
tos-create ("<spaces>name" -- ; -- tos )
tos-dump (tos -- )
tos-flush (tos -- )
tos-free (tos -- )
tos-init (tos -- )
tos-msc! (msc tos -- )
tos-msc@ (tos -- msc | nil )
tos-new (-- tos )
tos-pntr! (n tos -- flag )
tos-pntr+! (n tos -- flag )
tos-pntr@ (tos -- u )
tos-rewrite (tos -- )
tos-set-writer (x xt tos -- )
tos-write-char (char tos -- )
tos-write-chars (char u tos -- )
tos-write-double (d tos -- )
tos-write-float (r tos -- )
tos-write-line (tos -- )
tos-write-number (n tos -- )
tos-write-string (c-addr u tos -- )
trace" ("ccc<quote>" -- )
trm+activate-console (u -- )
trm+clear-all-leds (-- )
trm+clear-all-tab-stops (-- )
trm+clear-tab-stop (-- )
trm+delete-chars (u -- )
trm+delete-lines (u -- )
trm+erase-chars (u -- )
trm+erase-display (-- )
trm+erase-display-down (-- )
trm+erase-display-up (-- )
trm+erase-end-of-line (-- )
trm+erase-line (-- )
trm+erase-start-of-line (-- )
trm+insert-lines (u -- )
trm+insert-spaces (u -- )
trm+move-cursor (u1 u2 -- )
trm+move-cursor-down (u -- )
trm+move-cursor-left (u -- )
trm+move-cursor-right (u -- )
trm+move-cursor-up (u -- )
trm+reset (-- )
trm+restore-current-state (-- )
trm+restore-cursor (-- )
trm+save-current-state (-- )
trm+save-cursor (-- )
trm+scroll-down (-- )
trm+scroll-up (-- )
trm+select-alternate-font (-- )
trm+select-default (-- )
trm+select-default-font (-- )
trm+select-graphics-font2 (-- )
trm+select-UTF-8 (-- )
trm+set-attributes (u1 .. un n -- )
trm+set-caps-led (-- )
trm+set-default-attributes (-- )
trm+set-num-led (-- )
trm+set-screen-blank-timeout (u -- )
trm+set-scroll-led (-- )
trm+set-scroll-region (u1 u2 -- )
trm+set-tab-stop (-- )
trm+unblank-screen (-- )
trm.background-black (-- u )
trm.background-blue (-- u )
trm.background-brown (-- u )
trm.background-cyan (-- u )
trm.background-default (-- u )
trm.background-green (-- u )
trm.background-magenta (-- u )
trm.background-red (-- u )
trm.background-white (-- u )
trm.blink-off (-- u )
trm.blink-on (-- u )
trm.bold (-- u )
trm.foreground-black (-- u )
trm.foreground-blue (-- u )
trm.foreground-brown (-- u )
trm.foreground-cyan (-- u )
trm.foreground-def-underline (-- u )
trm.foreground-default (-- u )
trm.foreground-green (-- u )
trm.foreground-magenta (-- u )
trm.foreground-red (-- u )
trm.foreground-white (-- u )
trm.half-bright (-- u )
trm.normal-intensity (-- u )
trm.reset (-- u )
trm.reverse-off (-- u )
trm.reverse-on (-- u )
trm.underline-off (-- u )
trm.underscore-on (-- u )
tst-get-result (-- u1 u2 u3 )
tst-reset-tests (-- )
t{ (-- )
warning" ("ccc<quote>" -- )
xis% (-- n )
xis-(free) (xis -- )
xis-create ("<spaces>name" -- ; -- xis )
xis-free (xis -- )
xis-init (xis -- )
xis-msc! (msc xis -- )
xis-msc@ (xis -- msc )
xis-new (-- xis )
xis-read (xis -- i*x n )
xis-set-reader (x xt xis -- )
xis-set-string (c-addr u xis -- )
xis-strip! (flag xis -- )
xis-strip@ (xis -- flag )
xis.cdata (-- n )
xis.comment (-- n )
xis.done (-- n )
xis.empty-element (-- n )
xis.end-tag (-- n )
xis.error (-- n )
xis.internal-dtd (-- n )
xis.proc-instr (-- n )
xis.public-dtd (-- n )
xis.start-tag (-- n )
xis.start-xml (-- n )
xis.system-dtd (-- n )
xis.text (-- n )
xos-write-cdata (c-addr u tos -- )
xos-write-comment (c-addr u tos -- )
xos-write-empty-element (c-addr1 u1 ... c-addr2n u2n n c-addr u tos -- )
xos-write-end-tag (c-addr u tos -- )
xos-write-internal-dtd (c-addr1 u1 c-addr2 u2 tos -- )
xos-write-proc-instr (c-addr1 u1 c-addr2n u2n n c-addr u tos -- )
xos-write-public-dtd (c-addr1 u1 c-addr2 u2 c-addr3 u3 c-addr4 u4 tos -- )
xos-write-raw-text (c-addr u tos -- )
xos-write-start-tag (c-addr1 u1 ... c-addr2n u2n n c-addr u tos -- )
xos-write-start-xml (c-addr1 u1 ... c-addr2n u2n n tos -- )
xos-write-system-dtd (c-addr1 u1 c-addr2 u2 c-addr3 u3 tos -- )
xos-write-text (c-addr u tos -- )
zif% (-- n )
zif+input-size! (u -- )
zif+input-size@ (-- u )
zif+output-size! (u -- )
zif+output-size@ (-- u )
zif-(free) (zif -- )
zif-close-file (zif -- ior )
zif-create ("<spaces>name" -- ; -- zif )
zif-dump (zif -- )
zif-free (zif -- )
zif-gzf@ (zif -- gzf )
zif-init (zif -- )
zif-new (-- zif )
zif-open-file (c-addr u zif -- ior )
zif-read-file (c-addr1 u1 zif -- u2 ior )
zif-read-header (zif -- ior )
}t (i*x j*r -- )