8

In C, local variables exist inside of a function and contain the values like this:

void main(){
    int a = 5;
    int b = 9;
}

In the Gforth manual, they describe the local variables like this:

: swap { a b -- b a }
  b a ;
1 2 swap .s 2drop

but it seems like a function which is taking two arguments, a and b.

Another tutorial on the Forth language shows a variable like this:

variable a
3 a !    ( ! to store the value )

So, which one is correct?

Peter Mortensen
  • 30,738
  • 21
  • 105
  • 131
Tanzina Rahman Smita
  • 95
  • 3
  • Probably refresh your terminology. "Local variable" is well-defined in Forth; it's a variable which you declared in `{ ... }` which goes out of scope at the end of the definition. Your other example is not a local variable. – tripleee Apr 08 '22 at 10:46
  • Right. `variable` declares a _global_ variable. In standard Forth you can't even put a `variable` declaration inside a word definition, so there's not much room for confusion between the two. – Mark Reed Jun 21 '23 at 20:03

1 Answers1

10

In Forth, local variables are described by the following syntax (see also 13.6.2.2550 {:):

{: args [ | vals ] [ –– outs ] :}

where each of args, vals and outs represents space-delimited names (the parts in square brackets are optional). These names are interpreted as follows:

  • args names are for locals that are initialized from the data stack, with the top of the stack being assigned to the rightmost name in args;
  • vals names are for locals that are uninitialized;
  • outs names are ignored (they are for documentation purposes only, if any).

Gforth uses { ... } notation for locals as an alternative to the standard one.

So, swap can be defined as:

: swap {: a b :} b a ;

It takes two values from the stack into a and b local variables, and then puts them back on the stack in the reversed order.

An example of use an uninitialized local variable:

: exch ( x2 addr -- x1 ) {: a | x1 :}
  a @ to x1 a ! x1
;

The optional -- ... part is allowed to mimic a stack diagram, i.e., to unite the declaration of locals and the stack diagram for a word. For example:

: umin {: u2 u1 -- u2|u1 :} u2 u1 u< if u2 else u1 then ;

Without special optimizations, performance of local variables is slightly worse than of a little stack juggling.

ruvim
  • 7,151
  • 2
  • 27
  • 36
  • Re *"performance of local variables is slightly worse than of a little stack juggling"*: Can you quantify that? Do you have some measurements? What system was it tested on? – Peter Mortensen Jun 15 '22 at 11:34