WRK DEFINITIONS
( A compound Forth word having a data area and a code area (called MAIN).
Data area typically holds strings and headless anonymous out-of-flow code
i.e. code that doesn't alter code flow in MAIN .
Program flow starts at MAIN .
)

\ VAL, ( a -- ) Headless value, holds a data reference and returns
\ xt of the value
\ {{ ( -- a ) Begins the compile of headless anonymous code
\ }} ( -- a ) IMMEDIATE ends headless anonymous code
\ []! ( x u a -- ) Store x in nth cell of array at address a
\ MAIN (a.k.a. VDOES) Vectors latest word to HERE
\ /FORGET ( xt -- ) Forget word of xt (non-parsing FORGET)

CREATE PARMBLK 16 CELLS ALLOT \ Array for holding upto 16 parameters
: [X0] PARMBLK @ COMPILE, ; IMMEDIATE
: [X1] PARMBLK CELL+ @ COMPILE, ; IMMEDIATE
CREATE BAR \ for testing, has current HERE
CREATE FOO \ the compound word
HERE ," Today's date is " VAL, PARMBLK !
HERE ," date" VAL, 1 PARMBLK []!
{{ [x1] /SYS }} VAL, 1 PARMBLK []!
MAIN
[X0] COUNT TYPE
[X1] CATCH THROW
;

CR FOO
Today's date is Вс окт 3 09:55:51 CDT 2021

WORDS
CURRENT and CONTEXT are WRK
FOO BAR [X1] [X0] PARMBLK
' FOO /FORGET \ remove FOO from dictionary
WORDS
CURRENT and CONTEXT are WRK
BAR [X1] [X0] PARMBLK
( When a compound word is forgotten, it's local data is reclaimed. )
BAR HERE - 0= TRUE assert-1 PASS

+echo
-fin-
ok
--
me

:) frogd
ELF32X86_64 Frog Version 1.0d

"wrk" job FORGET isn't unique

A compound Forth word has a data area, referred here as local data, and a code
area, called MAIN. The data area typically holds strings and reference code,
code that is compiled apart from the main code but is referenced by the main
code. Such reference code is headless, anonymous and not linked into the
dictionary.

Data references can be passed to MAIN via a parameter block where
parameters are execution tokens (XT) of values. Each parameter value
hold a data reference. The parameter values are compiled into the MAIN
code at appropriate points and each place a data reference on the
data stack when executed.

Program flow starts at MAIN.

In this arrangement referencing data and code by main code can perform
without exacting branching penalties.

Removal of a compound word from the dictionary by FORGET will also
reclaim the word's local data. No modification of FORGET should be
required.

\ VAL, ( a -- xt ) Headless value, holds data reference,
\ xt of the value is returned
\ {{ Begin compile of headless anonymous code
\ }} ( -- xt ) IMMEDIATE
\ End compile of headless anonymous code
\ []! ( x n a -- ) Store x in nth cell of array at address a
\ MAIN (a.k.a. VDOES) Vectors latest word to HERE

CREATE PARMBLK 16 CELLS ALLOT \ Array for holding up to 16 parameters
\ (Array size is whatever will do)
( A couple of words for compiling the first two parameters )
: [X0] PARMBLK @ COMPILE, ; IMMEDIATE
: [X1] PARMBLK CELL+ @ COMPILE, ; IMMEDIATE
CREATE BAR \ for testing, has current HERE

( A compound word )
CREATE FOO
HERE ," Today's date is " VAL, PARMBLK !
HERE ," date" VAL, 1 PARMBLK []!
{{ [x1] /SYS }} VAL, 1 PARMBLK []!
MAIN
[X0] COUNT TYPE \ print date text
[X1] CATCH THROW \ tell host to print the date
;

CR FOO
Today's date is Sun 03 Oct 2021 12:58:20 PM CDT

WORDS
CURRENT and CONTEXT are WRK
FOO BAR [X1] [X0] PARMBLK

FORGET FOO \ remove FOO from dictionary
WORDS
CURRENT and CONTEXT are WRK
BAR [X1] [X0] PARMBLK
( local data also reclaimed )
BAR HERE - 0= TRUE space assert -1 PASS

-fin-
ok
--
me

On Sunday, October 3, 2021 at 1:05:36 PM UTC-5, S Jack wrote:
> :) frogd
> ( A compound word )
> CREATE FOO
> HERE ," Today's date is " VAL, PARMBLK !
> HERE ," date" VAL, 1 PARMBLK []!
> {{ [x1] /SYS }} VAL, 1 PARMBLK []!
> MAIN
> [X0] COUNT TYPE \ print date text
> [X1] CATCH THROW \ tell host to print the date
> ;
>
A cosmetic change, using PASS in place of PARMBLK to reduce clutter.
Note by doing so parameter order and duplication (none here) comes into play.

( A compound word )
CREATE FOO
HERE ," date" VAL,
PASS {{ [ COMPILE, ] /SYS }} VAL,
HERE ," Today's date is " VAL,
PASS PASS MAIN
[ COMPILE, ] COUNT TYPE \ print date text
[ COMPILE, ] EXECUTE \ tell host to print the date
;

CR FOO
Today's date is Tue 05 Oct 2021 10:37:25 AM CDT
--
me

On Tuesday, October 5, 2021 at 10:53:34 AM UTC-5, S Jack wrote:

Compound word vs. Data quotation

CREATE FOO ( s -- )
HERE >R 6 ALLOT CSI R SMV "33m" R S+ R> val,
HERE >R 4 ALLOT CSI R SMV "m" R S+ R> val,
2 PARMS MAIN
[P1] WA SWA S+
[P0] SWA S+
SWA COUNT DUMP
SWA COUNT ADUMP
SWA CR TELL ;
cr "Compound word example" foo

1B 5B 33 33 6D 43 6F 6D 70 6F 75 6E 64 20 77 6F 72 64 20 65 78 61
6D 70 6C 65 1B 5B 6D
•1B[33mCompound word example•1B[m
Compound word example

: BAR ( s -- )
[, HERE >R 6 ALLOT CSI R SMV "32m" R S+ R> val, P0! ,]
[P0] WA SWA S+
[, HERE >R 4 ALLOT CSI R SMV "m" R S+ R> val, P0! ,]
[P0] SWA S+
SWA COUNT DUMP
SWA COUNT ADUMP
SWA CR TELL ;
cr "Data quotation example" bar

1B 5B 33 32 6D 44 61 74 61 20 71 75 6F 74 61 74 69 6F 6E 20 65 78
61 6D 70 6C 65 1B 5B 6D
•1B[32mData quotation example•1B[m
Data quotation example

-fin-

Notes:
i. WA ( s -- ) Place string s in buffer SWA
i. SWA ( -- a) Working string buffer, 256 bytes
i. SMV ( s a --) Move string s to address a
i. S+ ( s1 s2 --) Append string s1 to string s2
i. VAL, ( x -- xt) Headless value, holds x returns value xt
i. P0! ( x -- ) Store x in parameter block 1st cell
i. PARMS ( xn..x1 n -- ) Store n parms in parameter block
i. [Pn] Compile nth parameter
i. DUMP ( a u --) Dump u bytes as hex values starting at address a
i. ADUMP ( a u --) Dump u bytes as characters starting at address a
Non-printables are shown as hex values preceded by
big dot (value 149 in KOI8R codepage)
i. Tell ( s -- ) Print string s (same as "count type")
ok
--
me

On Sunday, October 10, 2021 at 6:53:18 PM UTC-5, S Jack wrote:
> On Tuesday, October 5, 2021 at 10:53:34 AM UTC-5, S Jack wrote:
>
> Compound word vs. Data quotation
>
> Notes:
> me

Notes: addendum
i. CSI ( -- s) String, Control Sequence Introducer, ESC [
--
me

Data quotation

Hid HERE and VAL, in data quotation [, ... ,]
In data quotation parameter P0 holds HERE of the beginning data.
After data quotation P0 holds xt of headless value that
holds HERE of the beginning data. The headless value is compiled
after the data quotation.

27 CONSTANT ESC \ escape character

: STRING_ADD_PREFIX ( s -- s' )
"WA SWA S+" EVALUATE ; IMMEDIATE

: STRING_ADD_POSTFIX ( s -- s' )
"SWA S+" EVALUATE ; IMMEDIATE

: RETURN_STRING ( -- s )
"SWA" EVALUATE ; IMMEDIATE

\ Data quotation example1
\ Add data prefix and postfix to string
\ Output string is in work buffer SWA
: STRING_MAKE_GREEN ( s -- s' )
[, ," x[32m" ESC P0 CHAR+ C! ,] STRING_ADD_PREFIX
[, ," x[m" ESC P0 CHAR+ C! ,] STRING_ADD_POSTFIX
RETURN_STRING ;

"Hello World!" STRING_MAKE_GREEN
DUP SPACE TELL Hello World!
COUNT 2DUP
DUMP
1B 5B 33 32 6D 48 65 6C 6C 6F 20 57 6F 72 6C 64 21 1B 5B 6D
ADUMP
•1B[32mHello World!•1B[m

\ Example 2
: STRING_MAKE_BROWN ( s -- s' )
[, '"[33m*** " HOLDS ESC HOLD' /S, ,] STRING_ADD_PREFIX
[, '"[m" HOLDS ESC HOLD " ***" HOLDS' /S, ,] STRING_ADD_POSTFIX
RETURN_STRING ;

"Good-bye" STRING_MAKE_BROWN
space tell *** Good-bye ***

-fin-

Notes:
i. s Notation of counted string with byte count
i. P0 ( -- x ) First parameter (in parameter block)
i. P0! ( x -- ) Store x as first parameter
i. [P0] Compile first parameter
i. VAL, ( x -- xt) Compiles headless value, holds x returns value xt
i. [, Start data quotation, P0 is HERE at data beginning
i. ,] ( -- a) End data quotation, Retrun address a of data block
i. SWA ( -- a) String variable, 256 bytes
i. WA ( s -- ) Move string s to string variable SWA
i. ," ( ccc<"> -- s) Parse to double-quote and return string s
i. SMV ( s a --) Move string s to address a
i. S+ ( s1 s2 --) Append string s1 to string s2
i. DUMP ( a u --) Dump u byte hex values starting at address a
i. ADUMP ( a u --) Dump u byte characters starting at address a
Non-printables are shown as hex values preceeded by
big dot (value 149 in KOI8R codepage)
i. Tell ( s -- ) Print string s (same as "count type")
i. /S, ( d -- ) Compile pictured string (no numeric conversions)
ok
--
me

Compound word vs. Data quotation

CREATE SBROWN ( s -- s')
[- "x[33m" S, ESC R CHAR+ C! -]
[- "x[m" S, ESC R CHAR+ C! -]
2 PARMS MAIN
[P1] STRING_ADD_PREFIX
[P0] STRING_ADD_SUFFIX
RETURN_STRING ;

"Compound word example" SBROWN count adump
•1B[33mCompound word example•1B[m

: SGREEN ( s -- s' )
[, "x[32m" S, ESC R CHAR+ C! ,] STRING_ADD_PREFIX
[, "x[m" S, ESC R CHAR+ C! ,] STRING_ADD_SUFFIX
RETURN_STRING ;

"Data quotation example" SGREEN count adump
•1B[32mData quotation example•1B[m

-fin-
--
me

Standard data compare non-quotation vs. quotation

Data non-quotation

27 CONSTANT ESC
\ Standard data example
: FOO ( s -- s' )
AHEAD
[ HERE >R S" x[32m" STRING_COMPILE ESC R@ CHAR+ C! R> -ROT ]
THEN LITERAL STRING_ADD_PREFIX
AHEAD
[ HERE >R S" x[m" STRING_COMPILE ESC R@ CHAR+ C! R> -ROT ]
THEN LITERAL STRING_ADD_SUFFIX
: STRING_ADD_PREFIX "wa swa s+" eval ; IMM
RETURN_STRING

;

S" Hello World!" FOO ADUMP
•1B[32mHello World!•1B[m

Standard data compare non-quotation vs. quotation

Data non-quotation

Standard data compare non-quotation vs. quotation

Data non-quotation

27 CONSTANT ESC
\ Standard data example
: FOO ( s -- s' )
AHEAD
[ HERE >R DATA_GREEN_ATTRIBUTE R> -ROT ] ? missing data

' eval see
EVAL
134532404 COUNT
134532408 GEVAL
134532412 ;S ok
' geval see

GEVAL
134532356 SIB
134532360 >R
134532364 >R
134532368 2R
134532372 CMOVE
134532376 2R>
134532380 (EVAL)
134532384 ;S ok
' (eval) see
' fi aka then
Standard data compare non-quotation vs. quotation

Data non-quotation

27 CONSTANT ESC
\ Standard data example
: FOO ( s -- s' )
AHEAD
[ HERE >R DATA_GREEN_ATTRIBUTE R> -ROT ]
THEN LITERAL STRING_ADD_PREFIX
AHEAD
[ HERE >R S" x[m" STRING_COMPILE ESC R@ CHAR+ C! R> -ROT ]
THEN LITERAL STRING_ADD_SUFFIX
THEN LITERAL STRING_ADD_PREFIX
RETURN_STRING
;

Standard data compare non-quotation vs. quotation

Data non-quotation

27 CONSTANT ESC
\ Standard data example
: FOO ( s -- s' )
AHEAD
[ HERE >R DATA_GREEN_ATTRIBUTE R> -ROT ]
THEN LITERAL STRING_ADD_PREFIX
AHEAD
[ HERE >R DATA_ATTRIBUTE_OFF R> -ROT ]
THEN LITERAL STRING_ADD_SUFFIX
RETURN_STRING
;

S" Hello World!" FOO ADUMP
•1B[32mHello World!•1B[m

Data quotation

\ Data quotation example
: BAR ( s -- s' )
[, DATA_GREEN_ATTRIBUTE ,] STRING_ADD_PREFIX
[, DATA_ATTRIBUTE_OFF ,] STRING_ADD_SUFFIX
RETURN_STRING
;

S" Hello World!" BAR ADUMP
•1B[32mHello World!•1B[m

-fin-
--
me

Standard data compare non-quotation vs. quotation

Data non-quotation

27 CONSTANT ESC
\ Standard data example
: FOO ( s -- s' )
AHEAD
[ HERE >R DATA_GREEN_ATTRIBUTE R> -ROT ]
THEN LITERAL STRING_ADD_PREFIX
AHEAD
[ HERE >R DATA_ATTRIBUTE_OFF R> -ROT ]
THEN LITERAL STRING_ADD_SUFFIX
RETURN_STRING
;

S" Hello World!" FOO ADUMP
•1B[32mHello World!•1B[m

Data quotation

\ Data quotation example
: BAR ( s -- s' )
[, DATA_GREEN_ATTRIBUTE ,] STRING_ADD_PREFIX
[, DATA_ATTRIBUTE_OFF ,] STRING_ADD_SUFFIX
RETURN_STRING
;

S" Hello World!" BAR ADUMP
•1B[32mHello World!•1B[m

-fin-
--
me

On 2021-10-13 17:28, S Jack wrote:
> Standard data compare non-quotation vs. quotation
>
> Data non-quotation
>
> 27 CONSTANT ESC
> \ Standard data example
> : FOO ( s -- s' )
> AHEAD
> [ HERE >R DATA_GREEN_ATTRIBUTE R> -ROT ]
> THEN LITERAL STRING_ADD_PREFIX
> AHEAD
> [ HERE >R DATA_ATTRIBUTE_OFF R> -ROT ]
> THEN LITERAL STRING_ADD_SUFFIX
> RETURN_STRING
> ;
>
> S" Hello World!" FOO ADUMP
> •1B[32mHello World!•1B[m
>
>
> Data quotation
>
>
> \ Data quotation example
> : BAR ( s -- s' )
> [, DATA_GREEN_ATTRIBUTE ,] STRING_ADD_PREFIX
> [, DATA_ATTRIBUTE_OFF ,] STRING_ADD_SUFFIX
> RETURN_STRING
> ;
>
> S" Hello World!" BAR ADUMP
> •1B[32mHello World!•1B[m
>

In both cases, an interface is not separated from its implementation.
That don't look great. What problem it solves?

--
Ruvim

On Wednesday, October 13, 2021 at 5:16:18 PM UTC-5, Ruvim wrote:

> In both cases, an interface is not separated from its implementation.

True in the first case, the -ROT assumes AHEAD puts two values on
control-stack. But a system could do this and provide the user with
a word where this is hidden.
Don't see interface problem in second case; not much shows.

> That don't look great. What problem it solves?

Solves no problem that I'm aware of. More of a matter of style and
alternatives.

The second case has two advantages over the first. First, it's abstracted,
so a system with Anton's data sections could put the compiled data there
and other systems could just compile the data in the word that uses it.
The second advantage, but only where the data is being compiled in the
word, is that the Literal is replaced by a headless Value (no second
branch penalty).

I may be the only one but I like the structured style:
: FOO
[, data1 ,] word1
[, data2 ,] word2
...
[, dataN ,] wordN
;

A reminder, data is compiled character string which characters are
values maybe with some mixture of text. 'S"' which is text only could
not be used by itself to provide the data. What goes between "[," and
",]" are words to compile the data. "]," provides the following word
with a reference to the beginning of the compiled data.
--
me

:) cat job
[#] demo_ipc -- IPC demo
--.
347 LOAD \ PARMS
cr
h1 IPC demo
cr
cr
h2 Pipe to Bash EXPR for REGEX operation
cr
CREATE EXPR
[[ %'expr "% S, ]] \ P2, Prefix string constant
[[ %" : "% S, ]] \ P1, Middle string constant
[[ %"'% S, ]] \ P0, Suffix string constant
3 PARMS MAIN
IPC:H 0= IF IPC:OPEN FI
[P2] WA \ place Prefix in SWA buffer
SWA S+ \ append topic string
[P1] SWA S+ \ append Middle
SWA S+ \ append REGEX string
[P0] SWA S+ \ append Suffix
SWA IPC:WRITE \ write to IPC channel
PAD 80 IPC:READL \ read ipc line
;

MARKER myJob \ Mark beginning of job memory
:[ IPC:SRC 2@ TYPE ]: IS IPC:READL \ IPC response action
".*\(X.*Y\).*" \ REGEX expression
"Old magic XYZZY still works" \ topic string
cr EXPR \ apply REGEX to topic string
cr
cr .( Sent: ) SWA TELL \ view what was sent
myJob \ release job memory
cr
cr done
cr
( Notes:
i. [[...]] ( -- xt ) headless value with reference to enclosed data
i. :[...]: ( -- xt ) anonymous and headless word
) --.
[#] //
:) job=job
:) GO=$job frogd
ELF32X86_64 Frog Version 1.0d

getgo ok
go
IPC demo

Pipe to Bash EXPR for REGEX operation

XYZZY

Sent: 'expr "Old magic XYZZY still works" : ".*\(X.*Y\).*"'

-fin-
ok
bye :)
--
me