Node:Displaying characters and strings, Next:, Previous:String Formats, Up:Other I/O

Displaying characters and strings

This section starts with a glossary of Forth words and ends with a set of examples.

bl       -- c-char         core       ``b-l''
c-char is the character value for a space.
space       --         core       ``space''
Display one space.
spaces       u --         core       ``spaces''
Display n spaces.
emit       c --         core       ``emit''
Display the character associated with character value c.
toupper       c1 -- c2        gforth       ``toupper''
If c1 is a lower-case character (in the current locale), c2 is the equivalent upper-case character. All other characters are unchanged.
."       compilation 'ccc"' -- ; run-time --         core       ``dot-quote''
Compilation: Parse a string ccc delimited by a " (double quote). At run-time, display the string. Interpretation semantics for this word are undefined in ANS Forth. Gforth's interpretation semantics are to display the string. This is the simplest way to display a string from within a definition; see examples below.
.(       compilation&interpretation "ccc<paren>" --         core-ext       ``dot-paren''
Compilation and interpretation semantics: Parse a string ccc delimited by a ) (right parenthesis). Display the string. This is often used to display progress information during compilation; see examples below.
.\"       compilation 'ccc"' -- ; run-time --         gforth       ``dot-backslash-quote''

type       c-addr u --         core       ``type''
If u>0, display u characters from a string starting with the character stored at c-addr.
typewhite       addr n --         gforth       ``typewhite''
Like type, but white space is printed instead of the characters.
cr       --         core       ``c-r''
Output a newline (of the favourite kind of the host OS). Note that due to the way the Forth command line interpreter inserts newlines, the preferred way to use cr is at the start of a piece of text; e.g., cr ." hello, world".
at-xy       u1 u2 --         facility       ``at-x-y''
Position the cursor so that subsequent text output will take place at column u1, row u2 of the display. (column 0, row 0 is the top left-hand corner of the display).
page       --         facility       ``page''
Clear the display and set the cursor to the top left-hand corner.
S"       compilation 'ccc"' -- ; run-time -- c-addr u         core,file       ``s-quote''
Compilation: Parse a string ccc delimited by a " (double quote). At run-time, return the length, u, and the start address, c-addr of the string. Interpretation: parse the string as before, and return c-addr, u. Gforth allocates the string. The resulting memory leak is usually not a problem; the exception is if you create strings containing S" and evaluate them; then the leak is not bounded by the size of the interpreted files and you may want to free the strings. ANS Forth only guarantees one buffer of 80 characters, so in standard programs you should assume that the string lives only until the next s".
s\"       compilation 'ccc"' -- ; run-time -- c-addr u         gforth       ``s-backslash-quote''
Like S", but translates C-like \-escape-sequences into single characters. See \"-parse for details.
C"       compilation "ccc<quote>" -- ; run-time  -- c-addr         core-ext       ``c-quote''
Compilation: parse a string ccc delimited by a " (double quote). At run-time, return c-addr which specifies the counted string ccc. Interpretation semantics are undefined.
char       '<spaces>ccc' -- c         core       ``char''
Skip leading spaces. Parse the string ccc and return c, the display code representing the first character of ccc.
[Char]       compilation '<spaces>ccc' -- ; run-time -- c         core       ``bracket-char''
Compilation: skip leading spaces. Parse the string ccc. Run-time: return c, the display code representing the first character of ccc. Interpretation semantics for this word are undefined.

As an example, consider the following text, stored in a file test.fs:

.( text-1)
: my-word
  ." text-2" cr
  .( text-3)

." text-4"

: my-char
  [char] ALPHABET emit
  char emit

When you load this code into Gforth, the following output is generated:

include test.fs <RET> text-1text-3text-4 ok

Here are some examples of executing my-word and my-char:

my-word <RET> text-2
my-char fred <RET> Af ok
my-char jim <RET> Aj ok