Words

#args ( -- n )

#bits/byte ( -- n )

#bits/cell ( -- n )

#bits/char ( -- n )

+" ( "ccc<quote>" -- )

+field ( structure-sys n "<spaces>name" -- structure-sys ; addr1 -- addr2 )

+stt ( c-addr u -- )

+\" ( "ccc<quote>" -- )

,\" ( "ccc<quote>" -- )

0! ( a-addr -- )

0>= ( n - f )

0e+0 ( F: -- r )

1+! ( a-addr -- )

1-! ( a-addr -- )

1e+0 ( F: -- r )

2e+0 ( F: -- r )

3drop ( x1 x2 x3 -- )

3dup ( x1 x2 x3 -- x1 x2 x3 x1 x2 x3 )

4drop ( x1 x2 x3 x4 -- )

4dup ( x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2 x3 x4 )

<= ( n n - f )

<=> ( n1 n2 -- n )

<l@ ( l-addr -- n )

<l@ ( l-addr -- n )

<w@ ( w-addr -- n )

<w@ ( w-addr -- n )

>= ( n n - f )

>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-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 )

arg@ ( n -- c-addr u )

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-execute? ( i*x xt bar -- j*x flag )

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-execute? ( i*x xt car -- j*x flag )

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-execute? ( i*x xt chs -- j*x flag )

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 -- )

d<> ( d d - f )

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-execute? ( i*x xt dcl -- j*x flag )

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 -- )

dcl-sort ( xt 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-execute? ( i*x xt dnl -- j*x flag )

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-sort ( xt 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 -- = Write the weekday: 0..6, 0 )

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-execute? ( i*x xt hct -- j*x flag )

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-execute? ( i*x xt hnt -- j*x flag )

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>" -- )

jis% ( -- n )

jis+remove-read-parameters ( i*x n -- )

jis-(free) ( jis -- )

jis-create ( "<spaces>name" -- ; -- jis )

jis-dump ( jis -- )

jis-free ( jis -- )

jis-init ( jis -- )

jis-new ( -- jis )

jis-read ( jis -- i*x n )

jis-set-reader ( x xt jis -- )

jis-set-string ( c-addr u jis -- )

jis.boolean ( -- n )

jis.done ( -- n )

jis.double ( -- n )

jis.end-array ( -- n )

jis.end-object ( -- n )

jis.error ( -- n )

jis.float ( -- n )

jis.name ( -- n )

jis.null ( -- n )

jis.number ( -- n )

jis.start-array ( -- n )

jis.start-object ( -- n )

jis.string ( -- n )

jos% ( -- n )

jos-(free) ( tos -- )

jos-create ( "<spaces>name" -- ; -- jos )

jos-dump ( jos -- )

jos-free ( jos -- )

jos-init ( jos -- )

jos-new ( -- jos )

jos-write-boolean ( flag jos -- )

jos-write-double ( d jos -- )

jos-write-end-array ( jos -- )

jos-write-end-object ( jos -- )

jos-write-float ( r jos -- )

jos-write-name ( c-addr u jos -- )

jos-write-nil ( jos -- )

jos-write-number ( n jos -- )

jos-write-start-array ( jos -- )

jos-write-start-object ( jos -- )

jos-write-string ( c-addr u jos -- )

l! ( n l-addr -- )

l+! ( l l-addr -- )

l+! ( l l-addr -- )

l, ( x -- )

l, ( x -- )

l@ ( l-addr -- n )

l@! ( l1 l-addr -- l2 )

l@! ( l1 l-addr -- l2 )

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 )

lfield: ( structure-sys "<spaces>name" -- structure-sys ; addr1 -- addr2 )

lfields: ( structure-sys n "<spaces>name" -- structure-sys ; addr1 -- addr2 )

llroll ( l1 u2 -- l3 )

llroll ( l1 u2 -- l3 )

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-flush ( flag -- )

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 )

lrroll ( l1 u2 -- l3 )

lrroll ( l1 u2 -- l3 )

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 = State type char, data )

nfs.class ( -- n = State type class, data )

nfs.lparen ( -- n = State type left paren, data )

nfs.match ( -- n )

nfs.rparen ( -- n = State type right paren, data )

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 -- = Generate a random number with a beta distribution with alpha r1 [>0] and beta r2 [>0], alpha*beta = mean, alpha*beta^2 )

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 -- = Generate a random number with a gamma distribution with alpha r1 [>0] and beta r2 [>0], alpha*beta = mean, alpha*beta^2 )

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 )

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-execute? ( i*x xt scl -- j*x flag )

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 -- )

scl-sort ( xt 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 )

sgn ( n1 - n2 )

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-sort ( xt 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-execute? ( i*x xt str -- j*x flag )

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 )

str^move ( str2 str1 -- Move str2 in str1 )

s\" ( "ccc<quote>" -- c-addr u )

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-float ( jis -- false | r 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-fixed-point ( r 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+get-cursor ( -- u1 u2 )

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+reset-scroll-region ( -- )

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{ ( -- )

u<= ( u u - f )

u<> ( u u - f )

u>l ( u -- l )

u>l ( u -- l )

ud. ( ud -- )

w! ( n w-addr -- )

w, ( x -- )

w@ ( w-addr -- u )

warning" ( "ccc<quote>" -- )

wfield: ( structure-sys "<spaces>name" -- structure-sys ; addr1 -- addr2 )

wfields: ( structure-sys n "<spaces>name" -- structure-sys ; addr1 -- addr2 )

xis% ( -- n )

xis+dump-read-parameters ( i*x n -- )

xis+remove-read-parameters ( i*x 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 -- )

Generated by fsdocgen 0.1.0