Every word that plays with full qualified XTs is part of the compiler/
interpreter system. An XT may not only be an address of code in memory
but may point to additional informations. A word that plays with full
qualified XTs is not easy to target compile without to compile the
whole system of XTs (whatever this means for a specific system).

In the proposal there are only two words that need full qualified XTs:
DEFER@ and DEFER! .

I would suggest to introduce something like "lesser qualified XTs"
that are only to be used by the DEFER-words & friends, eg. a DXT. So
the stack diagrams would look like:

DEFER ( "name" -- ) CORE-EXT

IS CORE-EXT
Interpretation: ( dxt "name" -- )
Compilation: ( "name" -- )
Run-time: ( dxt -- )

DEFER@ ( xt -- dxt ) CORE-EXT

DEFER! ( dxt xt -- ) CORE-EXT

helmwo@gmail.com writes:

There are no full and lesser qualified XTs in Forth-94 and Forth200x,
there are only XTs, and they seem to correspond to what you call
lesser qualified XTs. You can only use an XT in EXECUTE, "COMPILE,",
and (with additional conditions) in >BODY, DEFER@, DEFER!. An
implementation of such an XT in a traditional-style system is the CFA,
and no name field or link field is necessary; that does not change
with X:deferred.

On Aug 17, 11:00 am, an...@mips.complang.tuwien.ac.at (Anton Ertl)
wrote:

I consider words using EXECUTE also as part of the compiler/
interpreter. I do not see much use of EXECUTE for normal programs if
they also could use DEFERs.
Well, the case that you can implement it in Forth-94 does not say
anythings about if it is a good design decision.

I want to explain a little more:
I do use defers a lot with nameless code. I do have some extensions
for it. So for example:
------------------
defer a defer b defer c

: runall a cr b cr c cr ;

On Aug 17, 5:00 pm, hel...@gmail.com wrote:

xt's and EXECUTE are the foundation of portable state machines ...
which are an important class of "normal" program.

helmwo@gmail.com wrote:

Ok, so you don't see much use of vectored execution arrays, state
machines, and thread-specific vectors in "normal programs", whatever
one of those might be!

Andrew.

helmwo@gmail.com writes:

It says that its implementation does not need any richer XTs than the
CORE wordset already needs.

BTW, it's also possible to implement EXECUTE with X:deferred:

On Aug 18, 11:03 am, an...@mips.complang.tuwien.ac.at (Anton Ertl)
wrote:

On Aug 18, 2:29 am, Bruce McFarling netscape.net> wrote:

Can you read? I wrote if a program also could use DEFERs.
HelFORTH 1.0 had code for state machines. But I did not use it much.

-Helmar

Op Sat, 18 Aug 2007 08:15:52 -0700 schreef helmwo@gmail.com:

Correction: In ISO Forth it's not guaranteed that you can tick a VARIABLE
or even a CONSTANT or (horror) a colon definition. Only words created with
CREATE can be ticked.
You must be referring to Figforth, Forth-97 and Forth-83. Not Forth-94!

On Aug 18, 11:18 am, hel...@gmail.com wrote:

I can read ... can you? Doing state machines using DEFER alone in the
absence of EXECUTE would be a kludgy work-around because EXECUTE was
not available.

This is probably the source for your limited view of the utility of
EXECUTE