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

## Double

> number + extensions

`2LITERAL``( x1 x2 -- )``immediate` => `"[ANS] FORTH"`

  compile a double-cell number to the current definition. When run, the doubele-cell is left on the stack for execution.

          ( -- x1 x2 )

  (in most configurations this word is statesmart and it will do nothing in interpret-mode. See `2LITERAL,` for a non-immediate variant)

  compiling word = [p4_two_literal]

`D+``( d1.ud1 d2.ud2 -- d3.ud3 )``` => `"[ANS] FORTH"`

  the double-cell sum operation ( `+` )

  primitive code = [p4_d_plus]

`D-``` => `"[ANS] FORTH"`

  (no description)

  primitive code = [p4_d_minus]

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

  freefield output for a double-cell number ( => . )

  primitive code = [p4_d_dot]

`D.R``( d1.d1 n -- )``` => `"[ANS] FORTH"`

  aligned output for a double-cell number ( => .R )

  primitive code = [p4_d_dot_r]

`D0<``( d1.d1 -- flag )``` => `"[ANS] FORTH"`

  the double-cell less-than-zero operation ( `0<` )

  primitive code = [p4_d_zero_less]

`D0=``( d1.d1 -- flag )``` => `"[ANS] FORTH"`

  the double-cell equal-to-zero operation ( `0=` )

  primitive code = [p4_d_zero_equals]

`D2*``( d1.d1 -- d1.d1' )``` => `"[ANS] FORTH"`

  the double-cell arithmetic shiftleft-by-1 operation ( `2*` )

  primitive code = [p4_d_two_star]

`D2/``( d1.d1 -- d1.d1' )``` => `"[ANS] FORTH"`

  the double-cell arithmetic shiftright-by-1 operation ( `2/` )

  primitive code = [p4_d_two_slash]

`D<``( d1.d1 d2.d2 -- flag )``` => `"[ANS] FORTH"`

  the double-cell is-less operation ( `<` )

  primitive code = [p4_d_less]

`D=``( d1.d1 d2.d2 -- flag )``` => `"[ANS] FORTH"`

  the double-cell is-equal operation ( `=` )

  primitive code = [p4_d_equals]

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

  result is the numeric equivalent of d. If the double number was greater than what could fit into a single cell number, the modulo cellsize will be left since the higher-significant bits are just `DROP`ed

  primitive code = [p4_d_to_s]

`DABS``( d1.d1 -- d1.d1' )``` => `"[ANS] FORTH"`

  the double-cell abs operation ( `ABS` )

  primitive code = [p4_d_abs]

`DMAX``( d1.d1 d2.d2 -- d1.d1|d2.d2 )``` => `"[ANS] FORTH"`

  the double-cell max operation ( `MAX` )

  primitive code = [p4_d_max]

`DMIN``( d1.d1 d2.d2 -- d1.d1|d2.d2 )``` => `"[ANS] FORTH"`

  the double-cell max operation ( `MIN` )

  primitive code = [p4_d_min]

`DNEGATE``( d1.d1 -- d1.d1' )``` => `"[ANS] FORTH"`

  the double-cell arithmetic negate operation ( `NEGATE` )

  primitive code = [p4_d_negate]

`M*/``( d1.d1 n1 +n2 -- d2.d2 )``` => `"[ANS] FORTH"`

  the double-cell multiply-divide operation using a triple-cell intermediate result for `*` ( `*\/` )

  primitive code = [p4_m_star_slash]

`M+``( d1.d1 n1 -- d2.d2 )``` => `"[ANS] FORTH"`

  the double-cell mixed-operand sum operation ( `+` / `D+` )

  primitive code = [p4_m_plus]