On 21 Aug 2006 16:04:53 -0700, "Alex McDonald"
btopenworld.com> wrote:

It's the function of a standard to encourage people to use the
same names for the same function, but it is not the purpose to
stop new facilities being added to implementations.

Common practice is to use { ... }. Is changing a name in common use
because we need new glasses or bigger monitors good enough reason
for change?

Mark Carter wrote:

How about:

: (create) CREATE ; IMMEDIATE

When CREATE is executed during compilation of makeit, it'll do the
look-ahead and construct foo.

But I find that pretty limiting, because makeit always makes the same
name, not things that are then individually useful. How were you
planning to use this?

By the way, in FORTH, Inc. products we have a word called (create) which
does the work of constructing the dictionary entry. It's used by most
defining words.

Cheers,
Elizabeth

Elizabeth D Rather wrote:

I actually came up with that - but there's a snag - it's created when
the compiler compiles, rather than at run-time.

Mark Carter wrote:

Elizabeth D Rather wrote:

Good idea. I'll use that. I'll probably try to implement things in a way
like (without worrying about specifics):
3 well-group: testcond d101 tp d103
so that they can be read with something as simple as the statement
testcond read-group

I've had a quick read on chapter 11 of the Forth books - the one that
has LEAVE, POSTPONE, [ , etc. in it. It'll probably take me a few more
iterations before I'm more convinced I know what I'm doing.

It'd be nice to see how some Forth words (BEGIN, WHILE, UNTIL, IF, etc.)
could be implemented in Forth,

Many thanks for your response.

On Wed, 02 Aug 2006 21:42:38 +0100, Mark Carter privacy.net>
wrote:

The factor we use is called $CREATE ( addr len -- ). It avoids the
look-ahead problem and can be used inside CREATE itself. Most Forths
have an equivalent, but the name of the word has not been
standardised. Using it, your word would look like:

: makeit \ --
\ Creates a one cell variable called FOO.
s" foo" $create 1 cell allot ;

You will find that your code is *much* easier to maintain and
read if you *always* put in a stack comment and a short description
of the word.

Stephen

Stephen Pelc wrote:

win32forth doesn't appear to have it - I've searched the whole of its
dictionary.

Mark Carter wrote:

You might try

look CREATE
or
see CREATE

Maybe you'll get a decompiled version, or a look at the source code.

You might be able to see a word that does the same thing. Or maybe it
won't be quite the same thing.

There are various trade-offs to using the deep details of your
compiler. You might get simpler code. You get locked into your
particular Forth compiler. It gets harder for anybody else to maintain
your code.

J Thomas wrote:

J Thomas wrote:

In Win32Forth you have;