The GWBASIC to Liberty BASIC Survival Guide
-----------------------------------------------

Liberty BASIC is designed to be a lot like GWBASIC, but there are
differences.  Some of these differences are incompatibilities, and
some are enhancements.  Some things that are missing from this
evaluation copy of Liberty BASIC 0.9d are included in the
registered version.

Here you will find information about:

  PRINT                 File Handles
  INPUT                 INPUT$()
  Variable Names        Boolean Operators
  Variable Types        TIME$(), DATE$()
  Line Numbers          Random Numbers
  DIM                   READ, DATA, RESTORE
  ELSEIF...ENDIF


PRINT
---------------------------------------------------------------------

PRINT is -almost- the same.  The comma cannot be used as a formatter.
For example:

    print a, b, c

  is valid in GWBASIC, but not in Liberty BASIC

Also, PRINT USING isn't supported, but there is a using( function
instead.

  GWBASIC:        print using "The total is #####.##", ttl
  Liberty BASIC:  print "The total is "; using("####.##", ttl)

GWBASIC inserts spaces before and after numbers (called padding) when 
it prints them.  Liberty BASIC also does this, but this feature can 
be turned off if you prefer to do custom output formatting.  To turn 
it off, Pull down the Setup menu, and select Compatibility.  Then 
select the PRINT line to turn off BASIC's padding feature.  This will
remain in effect until you decide to change it.


INPUT
---------------------------------------------------------------------

GWBASIC permits this:

    input "Give me the next number"; n(x)

In Liberty BASIC, you must do this:

    input "Give me the next number"; n
    n(x) = n

GWBASIC automatically adds a question mark and an extra space onto the
end of the prompt (using above as example: Give me the next number? _).
Liberty BASIC lets you disable this if you prefer so you can do it your
own way.  For example:

    input "Give me the next number >"; n

  appears as:

    Give me the next number >_

To disable BASIC's automatic adding of the question mark, pull down
the Setup menu and select Compatibility.  Then select the INPUT line
to disable it.  This will remain in effect until you decide to change
it.





Variable Names
---------------------------------------------------------------------

Liberty BASIC accepts GWBASIC variable names.  But it also lets you
use upper and lower case letters.

  someTime   and   sometime 
  
  are considered different variables in Liberty BASIC.



Variable Types
---------------------------------------------------------------------

Liberty BASIC only supports two variable types, numeric and string.

The numeric variable holds either an integer or real value, and in
this case Liberty BASIC optimizes automatically.  If a real loses
its non-integer part through some calculation, then Liberty BASIC
converts it into an integer to speed up operations.  Integers can be
enormously large (see factorial.bas).  Reals are single precision.

The string variable holds a character string that can be as large as
available memory.



Line Numbers
---------------------------------------------------------------------

Liberty BASIC lets you use the conventional line numbers if you like.
You can also choose not to use them, and use descriptive branch labels
instead.  For example:

In GWBASIC:

  10 print "Let's loop!"
  20 x = x + 1
  30 print x
  40 if x < 10 then 20
  50 print "Done."
  60 end

In Liberty BASIC:

     print "Let's loop!"
  [mainLoop]
     x = x + 1
     print x
     if x < 10 then [mainLoop]
     print "Done."
     end

  You can see here that instead of jumping to line 20, as in the first
  example, we can instead jump to [mainLoop].  You can name your
  branch points and subroutines whatever you like.  They need to start
  and end with [ and ], respectively, and they can't have any spaces.

  Legal branch labels:

    [mainLoop]
    [loop1]
    [exceptionHandler]

  Illegal branch labels:

    [main loop]
    mainLoop



DIM
---------------------------------------------------------------------

The DIM statement can only dimension ONE array per statement, so 
instead of:

    dim a(20), b(20), c(20)

  do this:

    dim a(20) : dim b(20) : dim c(20)



ELSEIF...ENDIF
---------------------------------------------------------------------

Liberty BASIC supports IF...THEN...ELSE, but not the ELSEIF...ENDIF
combinations.



File Handles
---------------------------------------------------------------------

GWBASIC lets you use only numbers as file handles.  Liberty BASIC lets
you use numbers, and it lets you use letters also.

  open "autoexec.bat" for input as #1 ' GWBASIC

  open "autoexec.bat" for input as #autoexec  ' Liberty BASIC

Now here's the catch.  Whenever you reference the file handle, you
MUST use have a # in front of it.

  if eof(1) > 0 then 10020 ' GWBASIC

  if eof(#autoexec) > 0 then [reachedEnd]  ' Liberty BASIC

Additionally:

  print # 1, "buffers = 30"  ' this works fine in GWBASIC
         ^--------this extra space not allowed in Liberty BASIC



INPUT$()
---------------------------------------------------------------------

  In GWBASIC, there are two uses for INPUT$().
  1) To fetch x number of characters from a sequential file
  2) To fetch x number of characters from the keyboard

    a$ = input$(1, 10) 'Fetch 10 characters from file handle 1
    a$ = input$(1) 'Fetch 1 character from the keyboard

  In Liberty BASIC, there are also two uses for INPUT$().
  1) To fetch x number of characters from a sequential file
  2) To fetch only 1 character from the keyboard

    a$ = input$(#1, 10) 'Fetch 10 characters from file handle #1
    a$ = input$(1) 'Fetch a single character from the keyboard


Boolean Operations
---------------------------------------------------------------------

Liberty BASIC supports AND & OR, much like GWBASIC.  These are
typically used in IF...THEN statements like so:

  if x < limit and userAbort = 0 then [mainLoop]

  if (c$ >= "A" and c$ <= "Z") or (c$ >= "a" and c$ <= "z") then [inRange]

However, bitwise ANDing and ORing aren't supported.  If numbers are 
ANDed or ORed, then a Zero is always a Boolean False, and any 
Non-Zero is always a Boolean True, and 0 and 1 are the only possible  
return values.  Consider:

  print 1 and 1         ' produces 1
  print 1 and 0         ' produces 0
  print 1 or 0          ' produces 1
  print 0 or 23         ' produces 1
  print -5 and 0        ' produces 1

GWBASIC supports bitwise operations such as:

  print 8 or 16         ' produces 24
  print 7 and 15        ' produces 7

Liberty BASIC doesn't support this format.



TIME$(), DATE$()
---------------------------------------------------------------------

In GWBASIC you get the time or date by using the special variables
time$ and date$.  For example:

  print time$           'this produces the current time
  print date$           'this produces the current date

In Liberty BASIC it looks like this:

  print time$()         'this produces the current time
  print date$()         'this produces the current date



Random Numbers
---------------------------------------------------------------------

In Liberty BASIC, random numbers between 0 and 1 are generated with
the expression RND(1).  GWBASIC will produce the same result with 
that expression.  Apparently GWBASIC also lets you substitute just
RND, and it assumes the (1) part in this case.  Both of these lines
produce the same result in GWBASIC.

  x = int(rnd(1)*10)+1  ' this format works with both BASICs
  x = int(rnd*10)+1     ' this format doesn't

The second line is not permitted in Liberty BASIC.  It will always
equal 1, because rnd will be parsed as a numeric variable, and will
equal zero, unless it is assigned some other value.


READ, DATA, RESTORE
--------------------------------------------------------------------

In Liberty BASIC, only non array variables may be listed in a
READ statement.  In GWBASIC arrays may be used as arguments.

For example this works in GWBASIC but not in Liberty BASIC:

   for x = 1 to 10
        read a$(x)
   next x
   data "Fred", "Eddie", "Sue", "Tina", "Ellen"
   data "Tim", "Kim", "Allen", "Neil", "Cathy"

Do this instead with Liberty BASIC:

   for x = 1 to 10
        read n$
        a$(x) = n$
   next x
   data "Fred", "Eddie", "Sue", "Tina", "Ellen"
   data "Tim", "Kim", "Allen", "Neil", "Cathy"