We plan to to perform automatic inlining eventually, but for now you can perform inlining with
inline: ( "name" – inline:-sys ) gforth-experimental “inline-colon”
Start inline colon definition. The code between inline:
and ;inline has to compile (not perform) the code to be
inlined, but the resulting definition name is a colon
definition that performs the inlined code. Note that the
compiling code must have the stack effect ( -- ),
otherwise you will get an error when Gforth tries to create the
colon definition for name.
;inline ( inline:-sys – ) gforth-experimental “semi-inline”
end inline definition started with inline:
As an example, you can define an inlined word and use it with
inline: my2dup ( a b -- a b a b )
]] over over [[ ;inline
#1. my2dup d. d.
: foo my2dup ;
#1. foo d. d.
see foo
Inline words are related to macros (see Macros); the difference is
that a macro has immediate compilation semantics while an
inline:-defined word has default compilation semantics; this
means that you normally use a macro only inside a colon definition,
while you can use an inline: word also interpretively. But
that also means that you can do some things with macros that you
cannot do as an inline: word. E.g.,
\ Doesn't work: \ inline: endif ]] then [[ ;inline \ Instead, write a macro: : endif ]] then [[ ; immediate
Conversely, for words that would be fine as non-immediate colon
definitions, define them as non-immediate colon definitions or (if
utmost performance is required) as inline: words; don’t define
them as macros, because then you cannot properly use them
interpretively:
: another2dup ]] over over [[ ; immediate \ Doesn't work: \ #1. another2dup d. d.
You may wonder why you have to write compiling code between
inline: and ;inline. That’s because the implementation
of an inline word like my2dup above works similar to:
: compile-my2dup ( xt -- )
drop ]] over over [[ ;
: my2dup [ 0 compile-my2dup ] ;
' compile-my2dup set-optimizer
The DROP and 0 are there because compile-my2dup
is the implementation of compile, for my2dup, and
compile, expects an xt (see User-defined compile,).