Optimized Stack Operations

[David Hayden]

I've been working for years on a system RPL implementation in C++. After getting sick of "stackrobatics" I implemented these two generalized stack manipulation commands. You might want to do something similar in your implementation. These can be used in place of multiple stack manipulations. You could also implement many of the existing stack manipulation routines using these, at a cost in compute time but a possible savings in space.

// New comand SHUFFLE. This shuffles up to 8
// levels of the stack. For example # 2314 SHUFFLE does
// ob4 ob3 ob2 ob1 -> ob2 ob3 ob1 ob4
// In other words, each hex digit specifies the old stack level that
// should go in that position. The "old" level is the level before
// the command executes (but after popping the arg).
// If a hex digit is zero it means "no change in this position."
// This means # 132 SHUFFLE is the same as UNROT
//
// Larger digits will specify larger (original) stack levels, so you
// can actually access up to level 15. E.g., # FFFF SHUFFLE will
// copy level 15 to levels 1-4.

The next command is REARRANGE. It's like SHUFFLE, but lets you add or remove levels from the stack at the same time:

# delta # shuffleSpec -> new stack
// Okay, there are commands and commands that manipulate the stack. Here
// is an efficient way to generalize it. Delta is the number of items
// to add to (delta>0) or remove from (delta<0) the stack.
// ShuffleSpec is a number that says how to shuffle the stack, similar
// to the SHUFFLE command. Note that the values in the spec refer to
// levels BEFORE the delta is applied.

// Example: 2DUP is the same as 2 # 2121 REARRANGE