www.jupiter-ace.co.uk

Exploring Forth by Owen Bishop

Granada Publishing 1984 - 176 pages. paperback.
ISBN 0 246 121882

  The Jupiter Ace is noted on page 4, where it talks about Forth words than are unique to the Ace which do not appear in other Forths on other micros such as the BEEP sound word.

Using the Jupiter Ace
  As far as the projects in this book are concerned, the Ace provides all the connections required. The edge connector on the Ace board has exactly the same connections as on the ZX81 or Spectrum, but on the Ace they are in a different order. The design for the Decoder board therefore needs amending slightly, or you can make a simple adaptor which brings each line to its correct position for plugging into a Decoder designed for the ZX computers.

  The main advantage of using the' Ace is that its language, FORTH, gives it very high operating speed. This makes it part- icularly suitable for the pulse-timing operations required by several of the interfaces in this book. Whereas a machine- code program is essential with the ZX computers, for a few of the projects the Ace operates fast enough when using FORTH. The FORTH language was, after all, designed to be used in controlling astronomical telescopes so it is to be expected that it should excel in controlling other kinds of interface too.

  The devices in this book have all been tested with the Ace and work as well on this machine as on the ZX Comptuers. There is one difference. On the Ace (or at the least on the model used during the writing of this book), unconnected lines usually read as 0, except for line D4 which reads as 1. Con sequently, with input to line DO only, the readings are 32

(0001 0000) or 33 (0001 0001) instead of the values found on the ZX computers. In practice it was found that the values on some of the unconnected data lines 'floated' occasionally, reading either as 1 or 0 at random. For this reason, it is pre- ferable to AND the data input with the value 0000 0001 to eliminated any values appearing on the unconnected lines.   The command required is:

31 IN 1 AND

where 31 is the address being read from. This sequence leaves 0 or 1 on the top of the stack, depending on the state of line D0.

Page 178. This page referes to programming the address decoder
Programming the Jupiter Ace

  The Ace has two words which allow it to interact with the decoder. For reading data from the decoder, or from inter- faces attached to the decoder, it has the word IN. Before IN is used, we place the address to be read from on the top of the stack. For example, to read from address 31 (Data Output 0), we use

31 IN

  This leaves the required data on the top of the stack. As explained on p. 10, it is safer to AND this to eliminate floating values on other data lines. To read line DO only, we use:

31 IN 1 AND

To read the bottom three lines DO to D2 we use:

31 IN 7 AND

To read all four data lines DO to D3 we use:

31 IN 15 AND

  To write to an interface we use the word OUT. This needs data to be present as second on stack and the address on top of stack. Thus to send data 12 to address 63 we type:

12 63 OUT

  Many of the interfaces work by simply addressing an Addressed Output, without actually sending data. Data of some sort is still required on the stack for use by OUT, so a convenient form of command is:

0 63 OUT

  The book is intended for people who can already program in BASIC, but would like to learn Forth. It teaches Forth by example and comparison. A common set of Forth words are used in the examples though out the book, but there are parts of the book that do not apply to the Ace. In chapter 11, "Versions of Forth", Steve Oakey gives a chapter by chapter notes on the different Forths that run on micros. see below for the Aces "work-around's" (pages 132, 133, 134, 135 ).

  This particular micro is neither fig-FORTH nor FORTH-79, so it does not fit this book too well in places. In particular, its input and output are not screen oriented, and therefore Chapter 8 (page 85 onwards) is not relevant to it. That in turn means that some of the later material cannot be easily run on the Jupiter, and you may run into memory-space problems with Chapter 10!

  While I am not a fan of the Jupiter Ace (says Steve Oakey), it does have some interesting features as well as some major differences from FORTH- 79. The following list (again separated into chapters) is not intended to be exhaustive, but highlights some of the main differences.

Chapter 2
  The Jupiter provides floating-point numbers as a standard facility. This feature introduces the operators F*, F+, F-, F/, F., FNE- GATE, INT (to convert a floating-point number to an integer) and UFLOAT (to convert back again).

Chapter 3
  FORGET (page 29) is augmented by the word REDEFINE, which allows a new definition to overwrite an old one. This avoids a build- up of RAM that contains old (usually incorrect) versions of words.

Chapter 4
  NOT (page 35) and > (page 34) are not present; see pages 128 and 130 respectively for suitable definitions.

  R@ is not provided, but I is a suitable alternative name. If you do not wish to have to remember this for all the following examples, put in the definition

: R@ I ;

  +LOOP is the fig-FORTH version. See the comments on page 128 and the text on page 45 for how it works.

Chapter 6
  There are some major differences here, as EXPECT is not provided on the Jupiter. All its input is done using WORD (together with some supplementary words it provides), but some of the subsequent exercises use EXPECT and are more difficult to do without it. You can simulate EXPECT by including the following definitions:

 : WAIT 1500 0 DO LOOP ;
 : KEY WAIT BEGIN INKEY ?DUP UNTIL 
 WAIT ;
 : EXPECT
   0 DO
     KEY DUP EMIT 
     DUP ASCII ~ =
     IF DROP LEAVE
     ELSE OVER C! 1+ 
     THEN
    LOOP
   0 SWAP C!
 ;

  This version of EXPECT uses the ~ to end the input instead of a carriage return; if you wish to revert to the standard CR character, replace `ASCII ~' with `13'. (The WAIT instructions are absolutely essential to debounce the keyboard!) KEY is not present either, but the above definition works quite happily.
  NUMBER is provided, but is slightly different from the version assumed in this book: the top-of-stack entry is an integer that indicates whether the number below it is an integer or a floating-point number. Wherever the word NUMBER appears in the examples, you should write NUMBER DROP.
 Of the double-length operators in Table 6.1, D-, D/, D*, D= and DU< are absent (none of them are used in this book). The double- length stack operators have only the 2DUP missing. Only the

standard */ and */MOD mixed-length operators are provided (page 59).
  Of Tables 6.4 and 6.5, only the DMIN, DMAX, 2* and 2/ operators are missing. Only the 2* is used much in later chapters, and it may be worth entering its definition from page 131.
  As with the Dragon, HEX and DECIMAL are present, but OCTAL is not. I suggest you play with these two and check the use of OCTAL after you have learned how to define it for yourself (in Chapter 7).

Chapter 7
  You should not enter Figure 7.1a as a word, as ASCII is already provided on the Jupiter Ace and the definition in the figure will not work (see the Chapter 9 section below for more details).
  The comments regarding VARIABLES also apply to the Jupiter. While the Jupiter does not provide the C VARIABLE mentioned on page 65, it does use them; BASE is a one-byte variable, for instance, though in most other FORTHs it is a two-byte variable.
  CMOVE (page 76) is not provided. One definition of it is

: CMOVE 0 DO OVER I + C@ OVER I + C! LOOP 
DROP DROP ;

Chapter 8
The Jupiter does not use screens for input, and therefore much of Chapter 8 (pages 85 onwards) is not relevant.
Chapter 9
  The section on complex data structures (page 96) and subsequent examples need to be slightly different. For the defining words that include a DOES> in them, the definition must start with DEFINER rather than a colon. So Figure 9.8 would appear as

 DEFINER CONSTANT CREATE , DOES> @ ;

instead of as given in the text.
  Compilation/execution (page 98) gives rise to problems as well, as the Jupiter does not have STATE or [COMPILE]. This does not affect the examples given here, but you will not be able to test

the version of ASCII given in Figure 7.1a, nor will you be able to develop such words yourself. Recursion (page 103) is made very easy: the Jupiter allows a word to refer to itself even if the definition is incomplete. Figure 9.14 therefore becomes

: FACTORIAL
DUP 0= IF DROP I ELSE DUP 1- FACTORIAL * THEN
;

The first of the examples (Figures 10.1 to 10.10) will not run on the Jupiter because of the differences in input methods.