PFE 0.33.70

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

CORE-Misc

Compatibility words

---

0<=( a -- flag )  => "FORTH"

 
  simulate    : 0<= 0> 0= ;
  

primitive code = [p4_zero_less_equal]

---

0>=( a -- flag )  => "FORTH"

 
  simulate    : 0>= 0< 0= ;
  

primitive code = [p4_zero_greater_equal]

---

<=( a b -- flag )  => "FORTH"

 
  simulate    : <= > 0= ;
  

primitive code = [p4_less_equal]

---

>=( a b -- flag )  => "FORTH"

 
  simulate    : >= < 0= ;
  

primitive code = [p4_greater_equal]

---

U<=( a b -- flag )  => "FORTH"

 
  simulate    : U<= U> 0= ;
  

primitive code = [p4_u_less_equal]

---

U>=( a b -- flag )  => "FORTH"

 
  simulate    : U>= U< 0= ;
  

primitive code = [p4_u_greater_equal]

---

UMIN( a b -- min )  => "FORTH"

see MIN , MAX and UMAX

primitive code = [p4_u_min]

---

UMAX( a b -- max )  => "FORTH"

see MAX

primitive code = [p4_u_max]

---

.VERSION( -- )  => "FORTH"

show the version of the current PFE system

  : .VERSION [ ENVIRONMENT ] FORTH-NAME TYPE FORTH-VERSION TYPE ;
  

primitive code = [p4_dot_version]

---

.CVERSION( -- )  => "FORTH"

show the compile date of the current PFE system

  : .CVERSION [ ENVIRONMENT ] FORTH-NAME TYPE FORTH-DATE TYPE ;
  

primitive code = [p4_dot_date]

---

LICENSE( -- )  => "FORTH"

show a lisence info - the basic PFE system is licensed under the terms of the LGPL (Lesser GNU Public License) - binary modules loaded into the system and hooking into the system may carry another LICENSE

  : LICENSE [ ENVIRONMENT ] FORTH-LICENSE TYPE ;
  

primitive code = [p4_license]

---

WARRANTY( -- )  => "FORTH"

show a warranty info - the basic PFE system is licensed under the terms of the LGPL (Lesser GNU Public License) - which exludes almost any liabilities whatsoever - however loadable binary modules may hook into the system and their functionality may have different WARRANTY infos.

primitive code = [p4_warranty]

---

STRING,( str len -- )  => "FORTH"

Store a string in data space as a counted string.

  : STRING, HERE  OVER 1+  ALLOT  PLACE ;
  

primitive code = [p4_string_comma]

---

PARSE,( "chars<">" -- )  => "FORTH"

Store a char-delimited string in data space as a counted string. As seen in Bawd's

  : ," [CHAR] " PARSE  STRING, ; IMMEDIATE

this implementation is much different from Bawd's

  : PARSE, PARSE STRING, ;
  

primitive code = [p4_parse_comma]

---

PARSE,"  => "FORTH"

(no description)

immediate code = [p4_parse_comma_quote]

---

DEFINED( "name" -- flag )  => "FORTH"

Search the dictionary for _name_. If _name_ is found, return TRUE; otherwise return FALSE. Immediate for use in definitions.

This word will actually return what FIND returns (the NFA). does check for the word using find (so it does not throw like ' ) and puts it on stack. As it is immediate it does work in compile-mode too, so it places its argument in the cs-stack then. This is most useful with a directly following [IF] clause, so that sth. like an [IFDEF] word can be simulated through [DEFINED] word [IF]

 
  : DEFINED BL WORD COUNT (FIND-NFA) ; 
  

primitive code = [p4_defined]

---

[DEFINED]( "name" -- flag )  => "FORTH"

Search the dictionary for _name_. If _name_ is found, return TRUE; otherwise return FALSE. Immediate for use in definitions.

[DEFINED] word ( -- nfa|0 ) immediate does check for the word using find (so it does not throw like ' ) and puts it on stack. As it is immediate it does work in compile-mode too, so it places its argument in the cs-stack then. This is most useful with a directly following [IF] clause, so that sth. like an [IFDEF] word can be simulated through [DEFINED] word [IF]

 
  : [DEFINED] BL WORD FIND NIP ; IMMEDIATE
  

immediate code = [p4_defined]

---

[UNDEFINED]( "name" -- flag )  => "FORTH"

Search the dictionary for _name_. If _name_ is found, return FALSE; otherwise return TRUE. Immediate for use in definitions.

see [DEFINED]

immediate code = [p4_undefined]

---

(MARKER)( str-ptr str-len -- )  => "FORTH"

create a named marker that you can use to FORGET , running the created word will reset the dict/order variables to the state at the creation of this name.

  : (MARKER) (CREATE) HERE , 
          GET-ORDER DUP , 0 DO ?DUP IF , THEN LOOP 0 , 
          ...
    DOES> DUP @ (FORGET) 
          ...
  ; 
  

primitive code = [p4_paren_marker]

---

ANEW( 'name' -- )  => "FORTH"

creates a MARKER if it doesn't exist, or forgets everything after it if it does. (it just gets executed).

Note: in PFE the ANEW will always work on the ENVIRONMENT-WORDLIST which has a reason: it is never quite sure whether the same DEFINITIONS wordlist is in the search ORDER that the original ANEW MARKER was defined in. Therefore, ANEW would be only safe on systems that do always stick to FORTH DEFINITIONS. Instead we will CREATE the ANEW MARKER in the ENVIRONMENT and use a simple SEARCH-WORDLIST on the ENVIRONMENT-WORDLIST upon re-run.

  \ old
  : ANEW BL WORD   DUP FIND NIP IF EXECUTE THEN   (MARKER) ;
  \ new
  : ANEW 
    PARSE-WORD  2DUP ENVIRONMENT-WORDLIST SEARCH-WORDLIST IF  EXECUTE  THEN 
    GET-CURRENT >R ENVIRONMENT-WORDLIST SET-CURRENT  (MARKER)  R> SET-CURRENT ;
  

primitive code = [p4_anew]