GfA Basic V2.0

GFA BASIC VERSION 2.0 AND THE GFA BASIC COMPILER
by Richard Karsmakers

Everybody  knows  that GfA Basic was the best  Basic  interpreter 
available  for the ST.  GfA Systemtechnik must have thought  that 
all  could be done better,  since they have launched the new  GfA 
Basic - GfA Basic version 2.0 - in November. It incorporates over 
thirty  new  commands  and comes with an extended  manual  of  35 
pages.  The  principles of GfA Basic haven't changed,  but  users 
have  to be aware of the fact that programs written in GfA  Basic 
V2.0  don't  nessecarely work on the  previous  versions!  Upward 
compatibiliy,  however, is said to be provided (I haven't had any 
problems   myself  with  running  'old'  programs  on   the   new 
interpreter).  Well,  what are the new commands? Here's a list of 
them:

*             Indirect giving-over of variables and arrays
!             Allows remarks behind a command in a line
==            Compare operator 'approximately equal'
BASEPAGE      Gives the address of the Basepage of GfA Basic
BITBLT        Raster-copy command
BGET          Reads from a data channel into memory
BMOVE         Quick moving of memory blocks
BPUT          Write memory to data channel
CLR           Clearing of variables (also specific variables)
CRSCOL/CSRLIN Gives the cursor position (column/line)
DEFNUM        Rounds off all numbers to a specified number of
               characters
EVEN          Checks if a variable is even
EXEC          Command to enable to execution of compiled/machine
               language programs
FALSE         Constant 0
FORM INPUT    Enables the changing of strings in a program
HIDEM         Hide the mouse cursor
HIMEM         Checks the address from which GfA Basic doesn't use
               memory anymore
INP?          Checks if a certain channel has a character
               available or not
MID$          This command now enables changing of strings
MONITOR       Calls  a  memory-resident  monitor  or   command-
               extension
ODD           Checks if a variable is odd
ON MENU BUTTON GOSUB
              Checks mouse clicks
OPTION BASE   This command is included for use with the compiler
OUT?          Checks of a specified channel allows sending of
               a character
RESERVE       Decrease or increase of memory that's used by BASIC
SGET          Gets the whole screen (32 Kb) in a string variable
SHOWM         Show the mouse pointer
SPUT          Puts the whole screen (32 Kb) from a string on the
               screen
TROFF/TRON    This doesn't need explaining
TRUE          Constant -1
TYPE          Allows you to check for the type of variable
               (integer, string, floating point, etc.)
VDIBASE       I don't get the meaning of this one (although I
               have the manual)
VOID          When a command is preceeded by this, it is per-
               formed but nothing is done with the result (this
               tends to save some time)
VSYNC         Synchronizes the vertical sync with screen building

That's all there is to know about the new GfA Basic version  2.0. 
If you want to order it in Holland, please contact Mark Software, 
Mat.  Marisstr.  76,  3314 TP,  Dordrecht. In Germany, you should 
contact  GfA Systemtechnik GmbH,  Heerdter  Sandberg  30,  D-4000 
Düsseldorf 11,  West Germany.  Tel. 0211-588011. The GfA compiler 
can  also  be  bought at these addresses  for  the  corresponding 
countries,  as well as at Commedia,  Eerste Looierdwarsstraat 12, 
1016 VM,  Amsterdam,  The Netherlands (Tel.  Holland 020-231740). 
Call for the latest prices!

Now  about the compiler.  Even though Christmas was a  very  busy 
time for the postman,  they still were able to deliver Commedia's 
reviewing sample just before Christmas,  so I was able to include 
this review in this issue of ST NEWS. Well, I think the GfA Basic 
compiler  significantly strengthens the position of GfA Basic  in 
the world of ST computer programming. You must understand that it 
has  an  immediate advantage over all other Basic  versions (even 
"Fast Basic",  that  we've tested but that's much  slower on  all 
aspects  than GfA Basic).  GfA Basic now is the first Basic  (and 
the best Basic ever seen anywhere on any computer by me) that has 
a generally available compiler. One big advantage of GfA Basic is 
that is a interpreter-rather than a compiler language.  When  you 
program in C, Modula 2 or Pascal, you'll always have to leave the 
compiler  after compiling after which you can test  the  program. 
Using GfA Basic you can design and test out your program  easily, 
after  which  you  can speed things up by  throwing  the  program 
through the Compiler.
There are a few bugs,  however. When your program works perfectly 
from  the  Interpreter,  it might encounter a  few  errors  after 
Compilation.   For  example,   the  MOD  command  isn't  compiled 
properly;  this makes a "Division by Zero" error occur. Also, the 
SETCOLOR c,r,g,b command doesn't work perfectly.  You can get rid 
of this error on a very easy way,  however,  by using the  second 
syntax  of  this command:  SETCOLOR  c,r*256+g*16+b  (the  number 
you'll get ranges from 0 to 1911).  No bother after that anymore. 
Frank  has had some trouble with the HIDEM  command,  that  isn't 
executed after compilation in certain cases.  I've never had  any 
problems with that uptil now,  but in other cases this might very 
well be a problem.

On  start-up,  you are welcomed by the GfA Compiler menu  screen. 
Firstly,  you can select whether a program should be stoppable or 
not.  Each time you build in a check for ALT+CTRL+SHIFT, it costs 
4  bytes so you'd better select "Nie" (never) for  space's  sake. 
The next option is "TRAPV".  You can select '+' or '-'.  When '+' 
is selected,  you'll get bombs on a TRAPV overflow error  (#107), 
otherwise  you will not get one.  Next,  there's a  selection  of 
"Bomben"  (Bombs).  If you select '+',  fatal errors are  caught, 
whereas  selecting '-' just causes bombs to appear on the  screen 
of  somethings  goes  terribly wrong.  Selecting  '+'  makes  the 
compiled  program  bigger,  since the compiler has  to  build  in 
routines to 'catch' bombs.
You  can  furtheron  select whether an error  that  occurs  in  a 
compiled  program  should be displayed as a number  or  as  text. 
Selecting "Zahl" (number) makes the compiled program smaller.
After  selection,  you simply select "Compiliere" (that's  German 
for   'to  compile')  and  you  simply  follow   the   computer's 
instructions.  After a while (a very short while,  I might  add), 
this  2-pass compiler has created a compact program that  can  be 
run  from  the desktop (so you can finally delete  your  run-only 
interpreter!).

Since  the  actual  GfA Basic Interpreter and  the  Compiler  put 
together  often  costs (much) less than  comparable  systems  for 
other languages,  I think it isn't hard to make a selection:  GfA 
Basic is it!  I now even think that Metacomco's new Basic will be 
a bit late, and it cannot be better than GfA Basic either!