Following on from the brief discussion of the speed of FORTH vs zzzip here, I have continued here in a new topic.

I have written a version of the zzzip speed test in FORTH. It does exactly the same thing - gets a screen memory pointer from EXOS and fills the screen with As, then Bs, ... Z. I have attached a file saved using EPFILEIO in case anyone wants to load it into IS-FORTH themselves. Or you can just type it in from the listing below. It is only the screen test part of the BASIC test.

To load it, save the attachment to your PC and in IS-FORTH type LOAD-BUFFERS. You should then be able to choose the file.

To type it in, in IS-FORTH type 1 EDIT and then type it in and press ESC when finished. To save it using EPFILEIO type SAVE-BUFFERS.

You don't need the comments between ( and ), but if you do have them you will want to use 80 column mode. To do this type 80 -TEXT before you type 1 EDIT. You will have to return to 40 column mode before you run it (with 40 -TEXT) because the video memory map is different in 80 column mode.

Either way once you have it in memory you then have to "compile" it with 1 LOAD. Then to run it type TEST4.

There is an odd problem that I have not bothered to get to the bottom of: it fills the first row of the screen and then starts on another row further down the screen, filling in the "gap" last. 

DECIMAL


: GET_SCREEN_MEM ( -- addr )
  0 0 3 102 SPFUNC          ( Special func Get Video Memory on chan 102 )
  0 <> ABORT" SPFUNC ERROR" ( EXOS error )
  SWAP DROP                 ( Do not need value returned in C )
;


VARIABLE INK


: TEST4
  102 #GRAPHICS             ( So PALETTE uses text chan )
  GREEN INK !
  GET_SCREEN_MEM            ( Screen ptr on stack throughout )
  91 65 DO                  ( Letters A to Z )
    DUP
    960 0 DO                ( One screenful )
      DUP J SWAP 255 S!     ( SPOKE letter { J }, assume seg is FF !  )
      1+                    ( Next screen pos )
    LOOP
    DROP
    25 INK +!               ( Next colour )
    0 0 0 0 0 0             ( Ready for PALETTE - unused colours )
    INK @ 0 PALETTE         ( Set new ink & background )
  LOOP
  DROP
;

For the comparision, there is the original BASIC code:
  410 CODE FINDMEM=HEX$("7d,6,3,f7,b,21,0,80,eb,b7,ed,52,c9")

 2040 LET SCREEN_MEM=REM(USR(FINDMEM,102),16384)
 2045 LET INK_COLOUR=GREEN
 2050 FOR CHAR=65 TO 90
 2060   FOR POSITION=0 TO 959
 2070     SPOKE 255,SCREEN_MEM+POSITION,CHAR
 2080   NEXT
 2082   LET INK_COLOUR=(INK_COLOUR+25) BAND 255
 2084   SET #102:PALETTE 0,INK_COLOUR
 2090 NEXT

It is running for about 6 minutes. The FORTH version is only about 10 seconds! Good demonstrate the speed difference between the two language! Impressive!
(And the FORTH have support for the EXOS Special Function call, no machine code needed for ask the video address.)

Just to demonstrate how rusty my memory is, I spent a long time finding out how to get the machine code part running using IS-FORTH's built-in assembler, only to then discover the built-in support for the EXOS Special Function Call! 

http://www.forth.com/starting-forth/index.html

It looks great for beginners! (I also like the cartoons )

I found something what I not understood
(Attachment Link)

If you put BINARY before : ABC ... it will work as expected.

BINARY
: ABC BINARY 11111111 DECIMAL . ;
DECIMAL

As you have it, 11111111 is being read as a big decimal number and then the bottom 16 bits are printed out as a signed decimal number.

It does not work as you expected because as ABC is compiled, FORTH is compiling a call to BINARY to happen at run time, not calling BINARY there and then (you could make it do that, but that discussion is probably best left for another day!)

FORTH can be quite confusing with execution time and compile time until you can get your brain around it! ":" is just an ordinary FORTH word that is executing, but as it is executing it is compiling another word...! It is worth persevering though because once you "get it" you will see a lot of power comes very simply, which is really the essence of FORTH and applications written in FORTH.

You have hit upon an example which is far simpler in FORTH than BASIC!

At the risk of confusing it, in your ABC example you could write it:

: ABC [ BINARY ] 11111111 [ DECIMAL ] . ;

which would then print 255. The [ DECIMAL ] part is only so we don't end up in binary at the command line.

[ turns compiling off so that BINARY is executed there and then rather than being compiled, and ] turns compiling on again! (If you are paying attention you might be wondering why [ and ] themselves are not compiled...the answer is that they are marked as "immediate" words, ie. they are executed even when in compiling mode. Any word can be marked as IMMEDIATE, and when they are executed in this way they can themselves compile something.)

 The [ DECIMAL ] part is only so we don't end up in binary at the command line.

But funny if it is happened
[ Guests cannot view attachments ]

The manual talking separately about the IS-FORTH and then the Enterprise specific FORTH things.
The IS-FORTH is released for other systems? Or it is planned for later but not happened because the collapse? The Videoton not interested about the FORTH?

How can Load/Save programs?
The description of the "NAME" not fully clear for me
Can you write some examples? (for Tape and Disk)