Link here

Forth v6 Function Summary

Summary of Forth language functions

This document provides an overview by way of subject-sorted lists of the functions (called "Words" in QED-Forth) in the Forth firmware library available in V6.x Forth for the PDQ Board and PDQ Board Lite controllers. QED-Forth is both a programming language and a real-time embedded operating system.

The firmware functions listed on this page are described in detail in their appropriate glossaries:

Using this page
You can click on the function names listed on this page to view their definitions in a popup box.

On this page you'll find a categorized list of all functions (i.e., words) in the v6.x kernel. Unless otherwise noted, their full definitions are found in the main glossary, Forth V6 Function Glossary.

For help in understanding the notation used in the function definitions in the glossaries, consult the description of stack symbols, abbreviations and naming conventions.

If you have been programming the controllers that used the v4.4x kernels and are now using this newer v6.x kernel to program the PDQ Board or PDQ Screen controllers, you might want to consult Forth V6 New Features for a list of differences between this kernel and prior versions.

A separate listing of functions that temporarily disable interrupts is available to assist you in planning the time-critical aspects of your application.

Software development in Forth uses the Codeblocks-based Mosaic IDE Plus Integrated Development Environment; this is the same IDE used for software development in C. While Forth programmers will not use the IDE's GNU C (GCC) compiler, the IDE provides a full-featured text editor and includes Mosaic Terminal for rapid Forth code downloads and interactive Forth debugging sessions with the 9S12 (HCS12) processor on the controller board.

 

Arrays

(See also the Matrices section.)

2ARRAY.FETCH BLANK.ARRAY PF.STACK.FRAME
2ARRAY.STORE COPY.ARRAY SWAP.ARRAYS
?ARRAY.SIZE DELETED ZERO.ARRAY
?DIMENSIONS DIM.CONSTANT.ARRAY: [0]
ARRAY.PF DIMENSIONED []
ARRAY: FILL.ARRAY
 

Assembler (HCS12/9S12 MCU)

The definitions for these words are found in the Forth V6 Assembler Glossary.

+LOOP, BGT EMUL LDAB ROLA
,+PC BHI EMULS LDD ROLB
,+S BHS END-CODE LDS ROR
,+X BITA END.CODE LDX RORA
,+Y BITB ENDIF, LDY RORB
,-PC BLE EORA LE RTC
,-S BLO EORB LEAS RTI
,-X BLS EQ LEAX RTS
,-Y BLT ETBL LEAY S,
,PC BMI EXG LO SBA
,PC+ BNE EXT LONG.AGAIN, SBCA
,PC- BPL FDIV LONG.BEGIN, SBCB
,PCR BRA GE LONG.ELSE, SEC
,S BRCLR GT LONG.ENDIF, SEI
,S+ BRN HI LONG.IF, SEV
,S- BRSET HS LONG.REPEAT, SEX
,X BSET IBEQ LONG.THEN, STAA
,X+ BSR IBNE LONG.UNTIL, STAB
,X- BVC IDIV LONG.WHILE, STD
,Y BVS IDIVS LS STOP
,Y+ CALL IF, LSL STS
,Y- CALL, IMM LSLA STX
-LOOP, CBA INC LSLB STY
>ASSM CC INCA LSLD SUBA
>FORTH CCR, INCB LSR SUBB
A, CLC IND,PC LSRA SUBD
A,PC CLI IND,S LSRB SWI
A,S CLR IND,X LSRD TAB
A,X CLRA IND,Y LT TAP
A,Y CLRB IND16,PC MAXA TBA
ABA CLV IND16,S MAXM TBEQ
ABX CMPA IND16,X MEM TBL
ABY CMPB IND16,Y MI TBNE
ADCA CODE IND5,PC MINA TFR
ADCB COM IND5,S MINM THEN,
ADDA COMA IND5,X MOVB TPA
ADDB COMB IND5,Y MOVW TST
ADDD CPD IND9,PC MUL TSTA
AGAIN, CPS IND9,S NE TSTB
ALWAYS CPX IND9,X NEG TSX
ANDA CPY IND9,Y NEGA TSY
ANDB CS INS NEGB TXS
ANDCC D, INX NEVER TYS
ANY.BITS.CLR D,PC INY NOP UNTIL,
ANY.BITS.SET D,S JMP ORAA VC
ASL D,X JSR ORAB VS
ASLA D,Y LBCC ORCC WAI
ASLB DAA LBCS PL WAV
ASLD DBEQ LBEQ PSHA WHILE,
ASR DBNE LBGE PSHB X,
ASRA DEC LBGT PSHC XCODE
ASRB DECA LBHI PSHD XGDX
ASSEMBLER DECB LBHS PSHX XGDY
B, DES LBLE PSHY Y,
B,PC DEX LBLO PULA [D,PC]
B,S DEY LBLS PULB [D,S]
B,X DIR LBLT PULC [D,X]
B,Y EDIV LBMI PULD [D,Y]
BCC EDIVS LBNE PULX [IND16,PC]
BCLR ELSE, LBPL PULY [IND16,S]
BCS EMACS LBRA REL [IND16,X]
BEGIN, EMAXD LBRN REPEAT, [IND16,Y]
BEQ EMAXM LBVC REV
BGE EMIND LBVS REVW
BGND EMINM LDAA ROL
 

C debugging functions

Detailed definitions for these words are found in Forth V6 Functions for C Debugging.

=CHAR CHAR* LONG =FLOAT DO[]
LONG* =INT FLOAT MAIN =LONG
FLOAT* MAIN2 C$>COUNTED$ FPtoString PrintFP
CALL.CFN INT CHAR INT*
 

Comparison operators

< 0= DMAX U< XU< <> 0>
DMIN U> XU> <= D< DRANGE UMAX
= D<> DU< UMIN > D= DU>
URANGE >= D> MAX X<> 0< D0<>
MIN X= 0<> D0= RANGE XRANGE
 

Constants (integer)

Integer constants (see also Floating point constants):

  -2     -1     0     0\0     1     2     3     4  
 

Control structures

+LOOP ENDIFTRUE IF RANGE.OF
AGAIN ENDOF IFTRUE RECURSE
BEGIN EXIT J REPEAT
CASE FOR LEAVE THEN
DO I LOOP UNLOOP
ELSE I' NEXT UNTIL
ENDCASE I- OF URANGE.OF
ENDIF I+ OTHERWISE WHILE
 

Debug, trace and benchmark functions

(BENCHMARK:) BENCHMARK: DUMP.REGISTERS
.HANDLES BREAK IS.TRACE.ACTION
.MAP BREAK.ALL SINGLE.STEP
.S DEBUG TRACE
.SEGMENTS DEFAULT.TRACE.ACTION
.TASKS DUMP
 

Definition

(See also Structures)

CONSTANT 2CONSTANT FCONSTANT XCONSTANT XCONSTANT.REL
VARIABLE 2VARIABLE FVARIABLE XVARIABLE LOCALS{
EEVARIABLE EE2VARIABLE EEFVARIABLE EEXVARIABLE USER
INTEGER: DOUBLE: REAL: ADDR: XADDR:
REGISTER: X: R: ARRAY: MATRIX:
(CREATE) CREATE <DBUILDS <VBUILDS DOES>
REDEFINE XCREATE CODE RCODE XCODE
: ; NO.OP V.INSTANCE: D.INSTANCE:
 

Device drivers

(See also Serial I/O)

 

Analog to digital (ATD)

ATD.DIGITAL.INPUTS ATD.ON ATD.START.SAMPLE
ATD.MULTIPLE ATD.SAMPLE ATD0-7.RESULTS
ATD.OFF ATD.SINGLE ATD8-15.RESULTS
 

Digital I/O drivers

PORTAD0 PORTJ.DIRECTION PORTP.IN
PORTAD0.MODE PORTM PORTT
PORTAD1 PORTM.DIRECTION PORTT.DIRECTION
PORTAD1.MODE PORTP PORTT.IN
PORTJ PORTP.DIRECTION
 

I2C serial bus drivers

IIC.104KHZ.23PERCENT IIC.NUM.BYTES.TO.XMIT IIC.SEND.FRAME
IIC.10KHZ.13PERCENT IIC.RCV.BUF.FULL IIC.SEND.NEXT.FRAME
IIC.96KHZ.25PERCENT IIC.RCV.BUF.OFFSET IIC.TIMEOUT.ERROR
IIC.ARB.LOST.ERROR IIC.RCV.BUF.OVERFLOW IIC.XMIT.BUF.EMPTY
IIC.ERROR IIC.RCV.BUF.PTR IIC.XMIT.BUF.OFFSET
IIC.FREQUENCIES IIC.RCV.BUFFER IIC.XMIT.BUF.OVERFLOW
IIC.INIT IIC.RCV.BUF.SIZE IIC.XMIT.BUF.PTR
IIC.MASTER.RECEIVER IIC.RECEIVE IIC.XMIT.BUFFER
IIC.NAK.ERROR IIC.RECEIVE.FRAME IIC.XMIT.BUF.SIZE
IIC.NUM.BYTES.TO.RCV IIC.SEND
 

Pulse-width modulation (PWM)

PWM.ACTIVE.HIGH PWM.DISABLE.MULTIPLE PWM.SCALED.CLOCK
PWM.ACTIVE.LOW PWM.DUTY.READ PWM.SCALER
PWM.CENTER.ALIGN PWM.DUTY.WRITE PWM.SEPARATE
PWM.CLOCKA PWM.ENABLE PWM.SETUP
PWM.CLOCKB PWM.ENABLE.MULTIPLE PWM.UNSCALED.CLOCK
PWM.CONCATENATE PWM.LEFT.ALIGN PWM01
PWM.COUNTER.READ PWM.PERIOD.READ PWM23
PWM.COUNTER.WRITE PWM.PERIOD.WRITE PWM45
PWM.DISABLE PWM.PRESCALER PWM67
 

SPI drivers

INIT.IP.SPI SPI.FALLING.LEADING.EDGE SPI.RISING.LEADING.EDGE
INIT.SPI SPI.FALLING.TRAILING.EDGE SPI.RISING.TRAILING.EDGE
MASTER2 SPI.FREQUENCIES SPI.SAVE
SPI.CONFIG SPI.RESOURCE
SPI.EXCHANGE SPI.RESTORE
 

Timer-controlled I/O drivers

ECT.CLEAR.INTERRUPT.FLAG OC.SET.ACTION
ECT.FAST.CLEAR OC.TOGGLE.ACTION
ECT.INTERRUPT.DISABLE OC.TOGGLE.ON.OVERFLOW
ECT.INTERRUPT.ENABLE OC7.CLEARS.IT
ECT.PRESCALER OC7.DISCONNECT
ECT.STANDARD.CLEAR OC7.SETS.IT
HOLDING.REG.FORCE.LATCH OUTPUT.COMPARE
IC.1024.CYCLE.DELAY PULSE.A
IC.256.CYCLE.DELAY PULSE.A.EDGE
IC.512.CYCLE.DELAY PULSE.A.FALLING.EDGE
IC.DELAY.DISABLED PULSE.A.GATED.HIGH
IC.FIRST.POLARITY PULSE.A.GATED.LOW
IC.HOLDING.READ PULSE.A.OVERFLOW
IC.NO.OVERWRITE PULSE.A.RISING.EDGE
IC.NOISE.DELAY PULSE.A.SETUP
IC.OVERWRITE.OK PULSE.B
IC.PULSE.CONFIG PULSE.B.OVERFLOW
INPUT.CAPTURE PULSE.B.SETUP
MOD.COUNTER.LOAD PULSE.DISABLE
MOD.COUNTER.READ PULSE.ENABLE
MOD.COUNTER.SETUP PULSE.HOLDING.READ
MOD.COUNTER.UPDATE PULSE.REG.READ
MODULUS.UNDERFLOW PULSE.REG.WRITE
OC.ACTION TCNT.OVERFLOW
OC.CLEAR.ACTION TCNT.READ
OC.FORCE TRIGGER.EDGE
OC.IC.REG.READ TRIGGER.OFF
OC.NO.ACTION TRIGGER.ON.ANY.EDGE
OC.NO.TOGGLE.ON.OVERFLOW TRIGGER.ON.FALLING.EDGE
OC.REG.WRITE TRIGGER.ON.RISING.EDGE
 

Wildcard I/O drivers

FROM.IO IO.CHANGE.BITS SMART.IO.@
FROM.SMART.IO IO.CLEAR.BITS SMART.IO.C@
IO.! IO.F! SMART.IO.F@
IO.2! IO.F@ SMART.IO.X@
IO.2@ IO.SET.BITS TO.IO
IO.@ IO.X! TO.IO.REGISTER
IO.C! IO.X@
IO.C@ SMART.IO.2@
 

Dictionary

' CFA>PFA IMMEDIATE NP.NOBUMP
(CREATE) CHANGE.NFA.TYPE LAST.DP.PAGE NPAGE
(HERE) CONTEXT LAST.NP.PAGE ON.FORGET
, CURRENT LATEST PFA>NAME
?C.CALLABLE DEFINITIONS LIB2LIB.CFA.FOR PFA>NFA
?HAS.PFA DP LINK PRIVATE
?IMMEDIATE DP.NOBUMP LINK.HASH SMUDGE
ALLOT DPAGE MOVE.HEADERS SMUDGE:
ANEW FORGET NFA.FOR VALID.HASH
ASSEMBLER FORTH NFA>CFA VFORTH
BUILD.HASH.TABLE FUNCTION.TYPE NFA>L$ VOCABULARY
C, HAS.PFA NFA>LFA WIDTH
C.CALLABLE HASH.INDEX NFA>PFA WORDS
CFA.FOR HASH.INDEX>XADDR NFA>PROPERTIES
CFA>NAME HERE NHERE
CFA>NFA ID. NP
 

Floating point comparison

F< F= F0< F0= FMAX
F<> F> F0<> F0> FMIN
F<= F>= F0<= F0>=
 

Floating point constants

(For integer constants, see also Constants)

1/INFINITY 1/PI 360/2PI LOG10(2) SQRT(2)
-1/INFINITY 1/SQRT(2) INFINITY ONE TEN
1/LN(2) 1/TEN -INFINITY PI ZERO
1/LOG10(2) 2PI/360 LN(2) PI/2
 

Floating point math

See also Math (integer)

1/F F** FALOG2 FLOT FTAN
10^N F/ FASIN FNEGATE INT.FLOOR
>DEGREES F^N FATAN FP.ERROR INT.PART
>RADIANS F+ FCOS FP.POP OVERFLOW
DFIXX F2* FINT FP.PUSH RANDOM#
DFLOT F2/ FIXX FRANDOM RANDOM.GAUSSIAN
DINT FABS FLN FRTI UFIXX
DINT.FLOOR FACOS FLOG10 FSCALE UFLOT
F- FALN FLOG2 FSIN UNDERFLOW
F* FALOG10 FLOOR FSQRT
 

Floating point to string conversion

$>F FILL.FIELD FP&STRING.PUSH PrintFP
ASK.FNUMBER FIXED FP.DEFAULTS RIGHT.PLACES
F. FIXED. LEFT.PLACES SCIENTIFIC
F>$ FLOATING MANTISSA.PLACES SCIENTIFIC.
F>FIXED$ FLOATING. NEXT.NUMBER TRAILING.ZEROS
F>FLOATING$ FNUMBER NO.SPACES
F>SCIENTIFIC$ FP&STRING.POP NEXT.NUMBER
 

Heap

+CURRENT.HEAP CURRENT.HEAP HANDLE.PTR ROOM
+HEAP.HANDLE DEALLOCATED HEAP.PTR START.HEAP
+HEAP.PAGE DUP.HEAP.ITEM HEAP.STRUCTURE.PF TO.HEAP
.HANDLES FREE.HANDLE IS.HEAP TRANSFER.HEAP.ITEM
?HANDLE.SIZE FROM.HEAP RECOVER.HANDLE
ALLOCATED H.INSTANCE: RESIZE.HANDLE
 

Interpreter and compiler

#FIND ASCII POCKET
#TIB BACKTRACK QUERY
( CALL QUIT
(#FIND) CFA.FOR R:
(COMPILE.CALL) COMPILE RCODE
(COMPILE.REL.CALL) COMPILE.CALL RECURSE
(EXECUTE) COMPILE.LIB2LIB.CALL SMUDGE
(FIND) EVALUATE STATE
(FIND.LIB2LIB) EXECUTE TIB
(FIND.RELATIVE) FIND UNIQUE.MSG
// FIND.LIB2LIB WORD
2LITERAL FIND.RELATIVE WORD.IN.BUFFER
: IMMEDIATE X:
; INTERPRET [
>ASSM LIB2LIB.CFA.FOR [COMPILE]
>FORTH LITERAL \
>IN PARSE ]
?IMMEDIATE PARSE.BUFFER
 

Interrupts

ATD0.ID ECT5.ID PWM.SHUTDOWN.ID
ATD1.ID ECT6.ID RTI.ID
ATTACH ECT7.ID SCI0.ID
CLOCK.MONITOR.ID ENABLE.INTERRUPTS SCI1.ID
COP.ID IIC.ID SELF.CLOCK.ID
COUNTER.UNDERFLOW.ID IRQ.ID SPI0.ID
DISABLE.INTERRUPTS PLL.LOCK.ID SPI1.ID
ECT.OVERFLOW.ID PORTH.ID SPI2.ID
ECT0.ID PORTJ.ID SWI.ID
ECT1.ID PORTP.ID TRAP.ID
ECT2.ID PULSE.A.EDGE.ID XIRQ.ID
ECT3.ID PULSE.A.OVERFLOW.ID
ECT4.ID PULSE.B.OVERFLOW.ID

A separate listing of functions that temporarily disable interrupts is available to assist you in planning the time-critical aspects of your application.

 

Library management

#ENDSAVETO LIBRARY.IS.COMPILING
#SAVETO LOAD.APPLICATION
.SEGMENTS LOAD.LIBRARY
ADDR.SIZE LONG.SIZE
APPLICATION MAKE.HEADER
BUILD.APPLICATION MOVE.HEADERS
BUILD.LIBRARY MOVE.SEGMENT.TO.DEST.PAGE
BUILD.SEGMENTS OPEN.LAST.SEGMENT
BYTE.SIZE OPEN.SEGMENT
C.CALLABLE PAGE.SIZE
C.HEADERS: PARAMS(
CHAR.SIZE PRIVATE
COMPOSE.C.ASM.CODE PROTOTYPE:
COMPOSE.C.ASM.CODE.FOR LIBRARY
COMPOSE.C.HEADERS PUSH.FORTH.PARAMS
COMPOSE.C.HEADERS.FOR RELOCATE.ONLY:
COMPOSE.C.INSTALLER RELOCATE:
COMPOSE.C.INSTALLER.FOR REQUIRES.FIXED
COMPOSE.FLASH.INSTALLER REQUIRES.RELATIVE
COMPOSE.FORTH.INSTALLER RESTORE.SEGMENT.NAMES
COMPOSE.FORTH.INSTALLER.FOR SECTION$.XADDR
DATE/TIME: SECTION:
DUMP.KERNEL.S SEGMENT.ARRAY.ADDR
DUMP.SEGMENT SEGMENT.BUMP
DUMP.SEGMENT.FILE SEGMENT.PRESENT
DUMP.SEGMENT.FILE.FOR SHIFT.SEGMENT.PAGE
DUMP.SEGMENT.STREAM THIS.SEGMENT
DUMP.SEGMENTS THIS.SEGMENT.XBASE
EEPROTOTYPE: THIS.SEGMENT.XNFA
END.LOAD.SEGMENT TO.HERE
END.SEGMENT USER.SPECIFIED
FLOAT.SIZE VOID
FORTH.HEADERS: VOID.SIZE
IN.PLACE VPROTOTYPE:
INT.SIZE XADDR.SIZE
LAST.SEGMENT XCONSTANT.REL
 

Logical operators

AND COMPLEMENT NOT TRUE
BOOLEAN FALSE OR XOR
 

Math (integer)

See also Floating point math

* 2* ABS IXN- SCALE X1-X2>D
*/ 2+ D+ IXU+ SIGNED.D>S X1-X2>N
*/MOD 2- D- IXU- U*/MOD XALIGN
+ 2/ D>S LOG2 U/ XD+
- 2XN+ D>S? M* U/MOD XD-
/ 2XN- D2* M/MOD U>D XN+
/MOD 4+ D2/ MOD U2/ XN-
1+ 4- DABS NEGATE UD*S XU+
1- 4XN+ DNEGATE RANDOM UM* XU-
1XN+ 4XN- DSCALE RANDOM# UM/MOD |X1-X2|>U
1XN- 8XN+ IXN+ S>D UMOD
 

Matrices

(See also Arrays)

?DIM.MATRIX M. MATRIX.PF
?MATRIX.SIZE M.. MATRIX:
COPY.MATRIX M.PARTIAL PF.STACK.FRAME
DELETED M[] REDIMMED
DIM.CONSTANT.MATRIX: M[]! SWAP.MATRIX
DIMMED M[]@ ZERO.MATRIX
LOAD.MATRIX MATRIX [0]
 

Memory operators

@ ! ON OFF TO
(C!) (!) (2!) (F!) (X!)
C! ! 2! F! X!
(C@) (@) (2@) (F@) (X@)
C@ @ 2@ F@ X@
(EEC!) (EE!) (EE2!) (EEF!) (EEX!)
+! (+!) (+C!) +C! |2@|
|2!| |F@| |F!| |X@| |X!|
(CMOVE) CMOVE CMOVE.MANY CMOVE.IN.PAGE CMOVE.MANY.CHECK
(MOVE) MOVE MOVE.MANY MOVE.IN.PAGE ERASE
TO.EEPROM TO.FLASH TO.FLASH.MANY TO.XFLASH TO.MEMORY
(PAGE.LATCH) THIS.PAGE CALC.CHECKSUM CALC.CHECKSUM.MANY BLANK
LOAD.PAGE LOAD.PAGES STORE.PAGES FILL FILL.MANY
CLEAR.BITS SET.BITS CHANGE.BITS TOGGLE.BITS
, C, V, VC,
 

Memory map

(HERE) LAST.DP.PAGE UPOCKET
.MAP LAST.NP.PAGE UTIB
ALLOT NHERE VALLOT
COMMON.PAGE NP VHERE
DEFAULT.MAP RESTORE VP
DP RESTORE.ALL WE.ALL
EEALLOT SAVE WP.ALL
EEHERE SAVE.ALL WRITE.ENABLE
EEP UNSAVE.ALL WRITE.PROTECT
HERE UPAD
 

Multitasking and time-keeping

(STATUS) KILL SERIAL
.TASKS MAILBOX: SERIAL.ACCESS
?GET MICROSEC.DELAY SERIAL1.RESOURCE
?RECEIVE MSEC.TIMESLICE.PERIOD SERIAL2.RESOURCE
?SEND NEXT.TASK SET.WATCH
ACTIVATE PAUSE START.TIMESLICER
ALLOCATE.TASK: READ.ELAPSED.SECONDS STATUS
ASLEEP READ.ELAPSED.TIME STOP.TIMESLICER
AWAKE READ.WATCH TASK:
BUILD.STANDARD.TASK RECEIVE TASK'S.USER.VAR
BUILD.TASK RELEASE TIMESLICE.COUNT
COUNT.TO.MSEC RELEASE.AFTER.LINE UP
GET RELEASE.ALWAYS WAIT.TIL.MATCH
HALT RELEASE.NEVER WATCH.RESULTS
INIT.ELAPSED.TIME RESOURCE.VARIABLE:
INSTALL.MULTITASKER SEND
 

Numeric input & output

(See also Floating point to string conversion)

# CONVERT FP&STRING.PUSH PAD
#> D>R$ HEX SIGN
#S DECIMAL HEXD>R$ UD>R$
<# DIGIT HOLD
ASK.NUMBER FP&STRING.POP NEXT.NUMBER
BASE FP&STRING.POP NUMBER
 

Operating system

#USER.BYTES DUMP.AUTOSTARTS RESTORE.ALL
((ERROR)) ENABLE.BOOT.VECTORS RP!
(ABORT) INIT.VITAL.IRQS.ON.COLD SAVE
(ERROR) IS.PRIORITY.AUTOSTART SERIAL1.AT.STARTUP
(RP) LOAD.PAGE SERIAL2.AT.STARTUP
ABORT LOAD.PAGES SET.BOOT.VECTOR
ABORT" LOAD.PAGES.AT.STARTUP STANDARD.RESET
AUTOSTART: LONG.LINE.MSG STATUS.AT.STARTUP
CALC.CHECKSUM NO.AUTOSTART STORE.PAGES
CALC.CHECKSUM.MANY NO.STATUS.AT.STARTUP TALK.TO.MASTER
CHECKSTART.DISABLE NO.VITAL.IRQ.INIT TALK.TO.SLAVE
CHECKSTART.ENABLE OK UABORT
CLEAR.BOOT.VECTORS PRIORITY.AUTOSTART: UERROR
COLD QUIET UNSAVE.ALL
COLD.ON.RESET QUIET.COLD VERSION
CR.BEFORE.MSG R0 WARM
CUSTOM.ABORT REPORT.PAGES.LOADED WE.ALL
CUSTOM.ERROR RESTORE WP.ALL
DISABLE.BOOT.VECTORS RESTORE.SEGMENT.NAMES WRITE.ENABLE
IS.AUTOSTART SAVE.ALL WRITE.PROTECT
 

Serial I/O

(See also Floating point to string conversion)

#TIB DUMP.MANY.S2 RS485.INIT
$>F DUMP.S1 RS485.RECEIVE
. DUMP.S2 RS485.TRANSMIT
." EMIT RS485.TRANSMIT.DONE
.R EMIT1 SERIAL
>IN EMIT2 SERIAL.ACCESS
? ESC.HANDLER SERIAL1.AT.STARTUP
?KEY EXPECT SERIAL1.RESOURCE
?KEY1 HEX. SERIAL2.AT.STARTUP
?KEY2 HEXD. SERIAL2.RESOURCE
ASK.FNUMBER HEXD.R SPACE
ASK.NUMBER INPUT.STRING SPACES
BAUD KEY SPAN
BEEP KEY1 TAB.WIDTH
CFA>NAME KEY2 TYPE
CHARS/LINE LPARSE U.
COUNT.TYPE LTYPE U?KEY
CR NEXT.NUMBER UD.R
D. NEXT.WORD UEMIT
D.R PARSE UKEY
DIN PAUSE.ON.KEY USE.SERIAL1
DUMP QUERY USE.SERIAL2
DUMP.AUTOSTARTS QUIET WORD
DUMP.BINARY RECEIVE.BINARY XMIT.DISABLE
DUMP.INTEL RECEIVE.HEX
 

Stack operators

-2 -1 0 0\0 1 2 3 4
DROP 2DROP FDROP F2DROP XDROP X2DROP 3DROP 4DROP NDROP
DUP 2DUP FDUP F2DUP XDUP X2DUP 3DUP 4DUP
SWAP 2SWAP FSWAP XSWAP OVER 2OVER FOVER XOVER
ROT 2ROT FROT XROT OVER D.OVER.N F.OVER.N X.OVER.N
>R D>R F>R X>R PICK DPICK FPICK XPICK
R> DR> FR> XR> DUP>R 2DUP>R FDUP>R XDUP>R
R@ DR@ FR@ XR@ R>DROP DR>DROP FR>DROP XR>DROP
S0 SP! (SP) .S ROT -ROT ROLL -ROLL
?DUP NIP TUCK NDROP STACK.FRAME FRAME.DROP PF.STACK.FRAME ><
DEPTH NEEDED
 

String functions

(See also the numeric-input-output section)

" /STRING LCOUNT SKIP>
$COMPARE BL LPARSE -TRAILING
$MOVE CAT SCAN UPPER.CASE
," COUNT SKIP   ${      }$
 

Structures

STRUCTURE.BEGIN: STRUCTURE.END TYPE.OF: OR.TYPE.OF: TYPE.END
ALLOCATED DEALLOCATED H.INSTANCE: D.INSTANCE: V.INSTANCE:
ADDR-> BYTE-> INT-> DOUBLE-> XADDR-> REAL-> STRUCT->
ADDRS-> BYTES-> INTS-> DOUBLES-> XADDRS-> REALS-> STRUCTS->
STRING-> HNDL-> XHNDL-> PAGE-> MEMBER->
+CURRENT.HEAP +HEAP.HANDLE +HEAP.PAGE FIELD
HEAP.STRUCTURE.PF RESERVED SIZE.OF
 
This page is about: Forth Function Firmware Library of Words in QED-Forth, Forth Programming Language, QED-Forth Real-time Operating System (embedded RTOS) – An overview of the functions in the Forth firmware library for microcontroller-based single board computers using the 9S12 (HCS12) MCU. QED-Forth is both a programming language and an embedded RTOS (real-time operating system) with an interactive interpreter and compiler.
 
 
Navigation