Overview

This is a simple indirect threaded Forth for the ARM Cortex M0/M3.
It can currently run on the
the Olimex STM32-P103 and the Olimexino STM32/LeafLabs Maple and supports
generic STM32F103 and STM32F030 boards. Other targets boards should be easy to
add. CoreForth consists of a small core written in ARM assembler, and
additional Forth words which are compiled on the host for the target using a
slightly modified version of
thumbulator.

CoreForth started based on
JonesForth,
but evolved to be closer to Forth-79. Some words and ideas were taken also
directly from CamelForth and the excellent
article series by
CamelForth’s author Brad Rodriguez.

The motivation behind CoreForth is to provide a simple platform to explore
Cortex M0/3 based development boards, not so much to be a fully fledged Forth
implementation (neither is ANS Forth compliance a goal), but there is nothing
preventing CoreForth to be taken into that direction.

CoreForth SE

CoreForth SE is a subroutine threaded
variant of CoreForth. It is under active development and allows easier debugging
and better performance.

Forth Implementation

CoreForth is an indirect threaded Forth. Register r7 is holding the instruction
pointer, register r6 is the return stack pointer, and the parameter stack is
handled via register sp (r13).

Four macros are used to define words within the assembler source:

• defcode: Define a word implemented in assembler. The code field pointer
  points to the words’ body.
• defword: Define a word implemented in indirected threaded code, each cell
  contains the code field pointer of the word to invoke. The code field
  pointer points to the DOCOL function
• defvar: Define a variable, the space is allocated at HERE from RAM.
• defconst: Define a constant

Board Dependent Code

The CoreForth source is split into two parts. The actual Forth implementation
under generic in CoreForth.s and a number of Forth source files, and the board
dependent code under e.g. olimexino-stm32. The board dependent code uses
.include to bring in the Forth kernel, this is neccessary in order to be able
to add new words to the board code due to the way the words are defined using
macros.

Building

CoreForth is written in GNU Assembler, and requires the ARM GCC cross
compiler as well as
thumbulator. The Makefile will
generate ELF and binary files, which can be flashed using e.g. OpenOCD. A good
overview of bare metal programming and qemu can be found on Franceso
Balduzzi’s
blog,
and using OpenOCD with hardware is explained in more detail on Johan
Simonsson’s pages.

CoreForth makes use of Forth words for the non-core functionality. The Forth
sources are compiled into binary form using thumbulator as a runtime
environment. The compiled assembler code and Forth sources are loaded into the
thumbulator memory. The Forth core executes the Forth sources, building the
target dictionary in memory as it processes the input data. At the end of the
compilation, the Forth core will dump itself plus the compiled dictionary into
one binary. For that purpose, thumbulator supports semihosting, including
console output.

This target compilation step is automated, adding new Forth sources for target
compilation is as simple as adding them as parameters to the thumbulator
invocation in the Makefile.

Previous Versions

The branch “1.0” contains the previous, qemu based version of CoreForth. That
branch is not actively maintained anymore, but can serve as an example for an
alternative cross compilation approach.