Re: I found a FORTH stack optimzer, but could use a better version.

"Jenny Brien" <jennybrien@[EMAIL PROTECTED]
> wrote in message
news:ab815318-9e67-4709-a479-a5fdae1bd429@[EMAIL PROTECTED]
> I'm interested in the minimal set needed to implement the normal Forth
> stack operators.

Then these might be of use which use rstack:

:DUP >R R@[EMAIL PROTECTED]
 R>;
:SWAP >R A! R> A@[EMAIL PROTECTED]
 >R DUP R> SWAP;
:ROT >R SWAP R> SWAP;
:-ROT SWAP >R SWAP >R
:NIP >R DROP R>
:TUCK >R R@[EMAIL PROTECTED]
 SWAP R>;

These don't use rstack, but use simple words:

:NIP SWAP DROP;
:TUCK SWAP OVER;

Maybe these also, if you have native implementations for TUCK or NIP:

:SWAP >R TUCK DROP;
:SWAP OVER >R NIP R>;
:OVER SWAP TUCK;
:TUCK DUP -ROT;

Except for use of A!  and A@[EMAIL PROTECTED]
 , most of those can be found using this:
http://black.cs.bgu.ac.il/forth-opt

> Since I shall need an rstack anyway, I think adding
that to Chapman's quarks might be a reasonable compromise.

....

> To recap:  The top two stack items are in registers T and N, the rest
> on the hardware stack
>
> The Quarks:
>
> DIP   T=N
>       DRIP  N=T
>       TUCK  push a copy of T
>       TAKE  pop to T
>       NUP   push a copy of N
>       NIP   pop to N
>

Let's call the top of the physical stack Z for use below, but those are
now
in terms of Z...

       TUCK  push a copy of T to Z
       TAKE  pop Z to T
       NUP   push a copy of N to Z
       NIP   pop Z to N

> To which add:
>
> T>R    push a copy of T to the rstack
>       R>T    pop rstack to T
> N>R    push a copy of N to the rstack
>       R>N    pop rstack to N
>

I agree that an additional word(s), in terms of FORTH, needs to be added
at
least to implement ROT, perhaps for other operations unreviewed...e.g.,
ROLL.  But, I'm not sure about the ones you just proposed.

>   : ROT  >R SWAP R> SWAP ; translates to the quarks
>
> T>R DIP NIP  NUP DRIP TAKE  NUP DRIP R>T  NUP DRIP TAKE
>
> Simplification:
>
> DIP NIP NUP DRIP = DIP
>       DIP TAKE  = TAKE
>       DRIP R>T  NUP DRIP TAKE = R>N
>
> leaving  R>T TAKE NUP R>N
>

Wouldn't it be easier to add a tem****ary register or variable since that's
what >R and R> effectively do?  E.g., something like A! and A@[EMAIL PROTECTED]
 attribute
to
MachineFORTH?  SWAP is then:

:SWAP >R A! R> A@[EMAIL PROTECTED]
 A! and A@[EMAIL PROTECTED]
 need to be adjusted for the placement of two stack items
from
the physical stack into registers.  I.e., we need A2! and A2@[EMAIL PROTECTED]
 which store
and fetch Z, the top of the physical stack, into A.  Then ROT becomes:

:ROT  A2! NUP DRIP A2@[EMAIL PROTECTED]
 TAKE;

The only further optimization I see is to create another word which does
T=A
directly, i.e., "combine" A2@[EMAIL PROTECTED]
 and TAKE:

:ROT  A2! NUP DRIP A2T;

All four should still be 1:1 for x86 and (hopefully) pairable on x86...

Okay, so you prefer rstack to A, then we'll need to use one of your words
above, R>T, to replace A2T.  And, define one like NIP or TAKE but pops Z
to
the R stack, e.g., Z>R:

:ROT  Z>R NUP DRIP R>T;


Rod Pemberton