PFE 0.33.71

Homepage
SourceForge
Download
Documentation
-Overview
-The PFE Manual
old manual / (book)
-ChangeLog
-Authors
-License (LGPL)
-Wordsets / (book)
-Functions .. (book)
-Dp of ANS Forth
-The 4thTutor
-Forthprimer.pdf
- Old Wordsets
- Old Words List
Forth Links
* Forth Repository
* Taygeta Compilation
* TinyBoot FirmWare
* FiCL, Free Forth
* Research Vienna
* Research Bournemouth
* zForth WebRing
Other Links
* Tektronix/MPT
* Forth Org. (FIG)
* Forth Inc.
* MPE Ltd. Forths
* SF Win32Forth
* PD Win32Forth
* Neil Bawd

generated
(C) Guido U. Draheim
guidod@gmx.de

## TOOLS

> Programming-Tools (without ASSEMBLER)

`.S``( -- )``` => `"[ANS] FORTH"`

  print the stack content in vertical nice format. tries to show cell-stack and float-stack side-by-side,

  Depending on configuration, there are two parameter stacks: for integers and for floating point operations. If both stacks are empty, `.S` will display the message `<stacks empty>`.

  If only the floating point stack is empty, `.S` displays the integer stack items in one column, one item per line, both in hex and in decimal like this (the first item is topmost):

        12345 HEX 67890 .S
           	424080 [00067890]
                12345 [00003039] ok

  If both stacks ar not empty, => .S displays both stacks, in two columns, one item per line

        HEX 123456.78E90 ok
        DECIMAL 123456.78E90 .S
           	   291 [00000123]          1.234568E+95
           1164414608 [45678E90] ok

  Confusing example? Remember that floating point input only works when the `BASE` number is `DECIMAL`. The first number looks like a floating point but it is a goodhex double integer too - the number base is `HEX`. Thus it is accepted as a hex number. Second try with a decimal base will input the floating point number.

  If only the integer stack is empty, => .S shows two columns, but he first columns is called `<stack empty>`, and the second column is the floating point stack, topmost item first.

  primitive code = [p4_dot_s]

`DUMP``( addr len -- )``` => `"[ANS] FORTH"`

  show a hex-dump of the given area, if it's more than a screenful it will ask using => ?CR

  You can easily cause a segmentation fault of something like that by accessing memory that does not belong to the pfe-process.

  primitive code = [p4_dump]

`SEE``( "word" -- )``` => `"[ANS] FORTH"`

  decompile word - tries to show it in re-compilable form.

  `(SEE)` tries to display the word as a reasonable indented source text. If you defined your own control structures or use extended control-flow patterns, the indentation may be suboptimal.

        simulate:
          : SEE  [COMPILE] ' (SEE) ;

  primitive code = [p4_see]

`WORDS``( -- )``` => `"[ANS] FORTH"`

  uses CONTEXT and lists the words defined in that vocabulary. usually the vocabulary to list is named directly in before.

        example:
           FORTH WORDS  or  LOADED WORDS

  primitive code = [p4_words]

`AHEAD``( -- DP-mark ORIG-magic )``compile-only` => `"[ANS] FORTH"`

        simulate:
          : AHEAD  BRANCH MARK> (ORIG#) ;

  compiling word = [p4_new_ahead]

`BYE``( -- )``no-return` => `"[ANS] FORTH"`

  should quit the forth environment completly

  primitive code = [p4_bye]

`CS-PICK``( 2a 2b 2c ... n -- 2a 2b 2c ... 2a )``` => `"[ANS] FORTH"`

  pick a value in the compilation-stack - note that the compilation stack _can_ be seperate in some forth-implemenations. In PFE the parameter-stack is used in a double-cell fashion, so CS-PICK would 2PICK a DP-mark and a COMP-magic, see `PICK`

  primitive code = [p4_cs_pick]

`CS-ROLL``( 2a 2b 2c ... n -- 2b 2c ... 2a )``` => `"[ANS] FORTH"`

  roll a value in the compilation-stack - note that the compilation stack _can_ be seperate in some forth-implemenations. In PFE the parameter-stack is used in a double-cell fashion, so CS-ROLL would 2ROLL a DP-mark and a COMP-magic, see `ROLL`

  primitive code = [p4_cs_roll]

`FORGET``( "word" -- )``` => `"[ANS] FORTH"`

        simulate:
          : FORGET  [COMPILE] '  >NAME (FORGET) ; IMMEDIATE

  primitive code = [p4_forget]

`[ELSE]``( -- )``` => `"[ANS] FORTH"`

  eat up everything upto and including the next [THEN]. count nested [IF] ... [THEN] constructs. see `[IF]`

        this word provides a simple pre-compiler mechanism

  immediate code = [p4_bracket_else]

`[IF]``( flag -- )``` => `"[ANS] FORTH"`

  check the condition in the CS-STACK. If true let the following text flow into `INTERPRET` , otherwise eat up everything upto and including the next `[ELSE]` or `[THEN]` . In case of skipping, count nested [IF] ... [THEN] constructs.

        this word provides a simple pre-compiler mechanism

  immediate code = [p4_bracket_if]

`[THEN]``` => `"[ANS] FORTH"`

  (no description)

  immediate code = [p4_noop]

`?``( addr -- )``` => `"[ANS] FORTH"`

  Display the (integer) content of at address `addr`. This word is sensitive to `BASE`

        simulate:
          : ?  @ . ;

  primitive code = [p4_question]

`CODE``( "name" -- )``` => `"[ANS] FORTH"`

  call `ALSO` and add ASSEMBLER wordlist if available. Add PROC ENTER assembler snippet as needed for the architecture into the PFA. The CFA is setup (a) with the PFA adress in traditional ITC or (b) with an infoblock as for sbr-coded colon words.

  Remember that not all architectures are support and that the ASSEMBLER wordset is not compiled into pfe by default. Use always the corresponding `END-CODE` for each `CODE` start. The new word name is not smudged.

  primitive code = [p4_create_code]

`;CODE``( -- )``` => `"[ANS] FORTH"`

  Does end the latest word (being usually some DOES> part) and enters machine-level (in EXEC-mode).

  BE AWARE: The TOOLS-EXT will not provide an `END-CODE` or any other word in the `ASSEMBLER` wordlist which is required to start any useful assembler programming. After requiring ASSEMBLER-EXT you will see a second ";CODE" in the `EXTENSIONS` wordlist that will also provide an optimized execution than the result of this standard-forth implemenation.

  The Standard-Forth implementation will actually compile a derivate of `BRANCH` into the dictionary followed by `;`. The compiled word will not jump to the target adress (following the execution token) but it will call the target adress via the host C stack. The target machine level word (C domain) will just return here for being returned (Forth domain). Hence `END-CODE` may be a simple RET, comma!

  compiling word = [p4_semicolon_code]

`END-CODE``( "name" -- )``` => `"ASSEMBLER"`

  call `PREVIOUS` and add PROC LEAVE assembler snippet as needed for the architecture - usually includes bits to "return from subroutine". Remember that not all architectures are support and PFE usually does only do variants of call-threading with a separate loop for the inner interpreter that does "call into subroutine". Some forth implementations do "jump into routine" and the PROC LEAVE part would do "jump to next routine" also known as next-threading. The sbr-call-threading is usually similar to the native subroutine-coding of the host operating system. See `CODE`

  primitive code = [p4_end_code]