
  FreeBASIC - A multi-platform 32-bit BASIC Compiler
  Copyright (C) 2004-2011 The FreeBASIC development team.


License:

  This program is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
  Foundation; either version 2 of the License, or (at your option) any later 
  version.

  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  Place, Suite 330, Boston, MA 02111-1307 USA.


Installing:

  o Windows version:

    - Follow the installer instructions.  Don't forget to select which external 
      libraries to install; some are not selected by default.

  o Linux version:

    - Unpack the tar gzip archive to any folder.

    - Run "sudo ./install.sh -i" from that directory to install the binaries,
      libraries and include files into the system as root, at the default
      location of /usr/local.

    - Note: to uninstall FreeBASIC, you can run "install.sh -u"
      
  o Linux (standalone) version:

    - Unpack the tar gzip archive to any folder.

    - Run "sudo ./install-standalone.sh -i" from that directory to install 
      the binaries, libraries and include files into the system as root, at 
      the default location /usr/share/freebasic. A link to the compiler 
      binary will be created at /usr/bin/fbc. If you don't have root 
      privileges, you can also install into a custom directory; run the 
      install-standalone.sh script with no arguments for more info. Be warned 
      though that installing with no root privileges will prevent the script 
      from installing a link to the binary into /usr/bin/fbc.

    - Note: to uninstall FreeBASIC, you can run "install-standalone.sh -u"

  o DOS:

    - Unpack the zip archive to any folder you want, but give preference to one
      with no white-spaces in its name and not longer than 8 characters. The
      directory structure as used inside the archive must be preserved.


  (Note: if you are installing the DOS version over the Windows one or vice-
   versa, rename the fbc.exe file of the previous installation to fbc-win.exe or 
   such, or it will be overwritten by the new one.)


Running:

  o Windows version:

    - A desktop icon and start-menu links should be created by the installer; use
      them to open the console directly into the directory where FreeBASIC was 
      installed (or follow the DOS guide below if nothing works).
  
    - Type "fbc" (without quotes) to see a list of options. To compile the hello
      example type: "fbc examples\misc\hello.bas", the hello executable file will 
      be created at the "examples\misc" dir.
  
  o Linux version:

    - If the install.sh script was successfully executed with enough privileges,
      the compiler binary should have been copied to /usr/local/bin/fbc.
      This means that any user can invoke FreeBASIC by simply typing "fbc" on any
      dir the shell is currently at.

    - Type "fbc" (without quotes) to see a list of options. To compile the hello
      example type: "fbc examples/misc/hello.bas", the hello executable file will 
      be created at the "examples/misc" dir.

  o Linux (standalone) version:

    - If the install-standalone.sh script was successfully executed with enough 
      privileges, a link to the compiler binary should have been created at 
      /usr/bin/fbc. This means that any user can invoke FreeBASIC by simply typing 
      "fbc" on any dir the shell is currently at. If it was not possible to create 
      the link, you may want to alter your PATH environmental variable to be able 
      to invoke the compiler from any directory.

    - Type "fbc" (without quotes) to see a list of options. To compile the hello
      example type: "fbc examples/misc/hello.bas", the hello executable file will 
      be created at the "examples/misc" dir.

  o DOS version:

    - Open the Command Prompt if in Windows and change to the dir where the
      FreeBASIC archive was unpacked. For example, type "cd C:\FreeBASIC"
      (without quotes) and press Enter, if the archive was expanded to C:\.

    - Type "fbc" (without quotes) to see a list of options. To compile the hello
      example type: "fbc examples\misc\hello.bas", the hello executable file will 
      be created at the "examples\misc" dir.

    - You can also add the FreeBASIC dir to your PATH environment variable, so
      you will not have to switch to or type the FB's dir every time you want to
      compile your project's files.


Requirements:

  o Windows version:

    - The FreeBASIC compiler (fbc.exe) and the executables generated by it need
      at least Windows 95 to run -- it was not tested in Windows 3.x with the
      Win32 system installed yet.

    - The msvcrt.dll (the Microsoft's C runtime library) must be present (note:
      it didn't use to come with Windows 95, but it's installed by many 
      applications and can be also downloaded at:
      http://support.microsoft.com/default.aspx?scid=kb;en-us;259403 ).

    - The gfx routines will use DirectX 5.0 or later if found on the host system,
      otherwise they'll fall back on standard Win32 GDI which will work on any
      Windows system.
      
    - Unicode wide-strings (WSTRING's) only work in Windows NT/2000/XP/2003/Vista 
      or above. Applications that depend on wide-strings will run in Windows 98/Me, 
      but no input/output will work if the character set isn't latin-based, 
      because those platforms don't support Unicode strings. Windows 95 has most 
      Unicode API functions missing, applications using wide-strings won't even 
      be loaded by this specific OS.

  o Linux version:

    - The FreeBASIC compiler (fbc) and the executable generated by it depend on
      libc, libm, libpthread and libdl. These are all standard Linux libraries
      and should be available by default on all modern distros.

    - When using the gfx routines, the dependencies will increase. FreeBASIC gfx
      programs will also need libX11, libXext, libXpm, libXrender and libXrandr
      to be installed on the host system to be executed. This is usually not a
      problem as long as there's a recent X11 server installed in the system
      (at least XFree86 4.3.0 or any X.org version).

    - While having a working X11 installation is enough to run FreeBASIC gfx 
      programs, it may be not enough to compile them; you may need to install 
      the X11 development libraries from your Linux packages repository.

    - Unicode wide-strings (WSTRING's) with non-ascii character sets can only be 
      displayed in console if the locale is set to a UTF-8 version - most modern
      distros support that, but char sets other than latin may work only in xterm.

  o DOS version:

    - A DPMI (DOS Protected-Mode Interface) server must be present to run
      fbc.exe and any executable generated by it. When running in raw DOS (ie:
      not a Windows 3x/9x/NT/XP/etc command-prompt), the CWSDPMI server
      (http://clio.rice.edu/cwsdpmi/csdpmi5b.zip) must be on your PATH
      environment variable (note: FreeDOS comes with it already installed).

    - Unicode isn't supported in DOS, WSTRING will be the same as ZSTRING, 
      character sets other than latin aren't supported.

Debugging:

  o The debugger is in the bin\win32 or bin\dos directories (the GDB.EXE file), 
    for the Windows and DOS versions respectively. It usually comes already 
    installed in most Linux distros.

    (Note: all commands should be typed without quotes and then [return] must be 
     pressed.)

    - Compile the sources using the -g cmd-line option to add debugging support.

    - Load it in GDB using: "gdb myapplicationname.exe".

    - Set the arguments to the application being debugged using:
      "set args arg1 arg2 argn". You can also run GDB and pass the arguments 
      directly to the application being debugged: 
      "gdb --args myapp.exe arg1 arg2 arg3".

    - If the executable isn't in the same directory of the source files where it
      was compiled, type: "dir path/to/my/application/sources".

    - Place a breakpoint in the first line using: "b main". To place a breakpoint
      in a function called "abc" use: "b ABC" (note: all in uppercase, GDB is 
      case sensitive by default, but you can use the "set language pascal" command
      to change GDB to case-insensitive mode, pointer dereference will follow the
      pascal syntax then).

    - Type "r" to start the application.

    - Type "n" to step over function calls. Keep pressing [return] to skip
      to the next line.

    - Type "s" to step into function calls. Same as above.

    - Type "c" to continue execution until the next breakpoint.

    - Use "print ABC" to show the contents of the variable called "abc". GDB
      supports pointer/pointer field dereferencing, indexing and arithmetics
      too, so "print *MYPOINTER" will also work. (note: undeclared variables 
      or the ones with suffixes like % & ! # $ can't be printed).

    - Use "disp ABC" to display the contents of a variable called "abc".

    - Use "watch ABC" to stop each time a variable called "abc" is changed.

    - To reference variables declared inside name spaces, use the C++
      scope resolution operator (::), enclosing them in single quotes. For 
      example, to show the value of a variable called "abc" that was defined 
      in a name space called "foo", use: "print 'FOO::ABC'".

    - Use "r" again to restart the application when finished.

    - Type "q" to quit.

    - Type "help" to see a list of commands, there are hundreds of others.


Most Important Features:

  o BASIC Compatibility:

    - FreeBASIC is not a "new" BASIC language. It is not required of you to
      learn anything new if you are familiar with any Microsoft-BASIC variant.

    - FreeBASIC is case-insensitive; scalar variables don't need to be
      dimensioned and suffix can be used (in -lang qb or fblite only); line 
      numbers are supported (ditto); a main() function is not required; most of 
      the graphic and console statements and functions found in MS-QuickBASIC 
      were implemented, et cetera.

  o Clean Syntax:

    - Only a small number of keywords have been added. Many functions are
      implemented as libraries, so for the most part, there are no new intrinsic
      routines, and therefore there is a low chance of having name duplication
      with old code. If you want to show a message box in Windows, simply do:

      #include "windows.bi"
      MessageBox NULL, "Text", "Title", MB_ICONASTERISK

      (note: MessageBox is case-insensitive, it can be MESSAGEBOX if you want)

  o Most of the known C libraries and API's can be used without wrappers or helpers:

    - GTK+ 2.0: cross-platform GUI Toolkit (over 1MB of headers, including
      support for Glade, libart and glGtk)

    - libxml and libxslt: defacto standard XML and XSL libraries

    - GSL - GNU Scientific library: complex numbers, vectors and matrices, FFT,
      linear algebra, statistics, sorting, differential equations, and a dozen
      other sub-libraries with mathematical routines

    - GMP - GNU Multiple Precision Arithmetic Library: known as the fastest 
      bignum library

    - SDL - Simple DirectMedia Layer: multimedia library for audio, user input,
      3D and 2D gfx (including the sub-libraries such as SDL_Net, SDL_TTF, etc)

    - OpenGL: portable library for developing interactive 2D and 3D graphics 
      games and applications (including support for frameworks such as GLUT and 
      GLFW, plus the GL Extensions)

    - Allegro: game programming library (graphics, sounds, player input, etc)

    - GD, DevIL, FreeImage, GRX and other graphic-related libraries

    - OpenAL, Fmod, BASS: 2D and 3D sound systems, with support for mod, mp3, 
      ogg, midi, etc

    - ODE and Newton - dynamics engines: rigid body dynamics simulation

    - cgi-util and FastCGI: web development

    - Windows API - the most complete headers set among the BASIC
      compilers available, including support for the Unicode functions and
      the GDI+ library

    - DirectX - Direct3D, DirectDraw, DirectSound, DirectMusic, DirectInput, 
                DirectPlay and DirectShow, with interfaces up to version 9

    - DispHelper - COM IDispatch interfaces made easy

    - more to come...

  o Multi-platform:

    - FreeBASIC currently runs on 32-bit Windows, Linux, and MS-DOS and also
      creates applications for the Xbox console. More platforms to come.

    - The run-time library was written with portability in mind. All third-party
      tools used exist on most operating systems already as they are from the
      GNU binutils. The compiler is written in 100% FreeBASIC code (that's right,
      FreeBASIC compiles itself.), which makes it simple to be bootstrapped as it
      doesn't depend on non-portable tools.

  o Multi-threading:

     - The run-time library comes in single- and multi-threaded versions, so the
       mutexes/locks are only used if the MT version is selected.

     - The MT version is automatically selected when thread functions like 
       ThreadCreate are used. It can also be selected manually, passing the 
       -mt option when compiling.

  o Unicode support:

    - Besides ASCII files with Unicode escape sequences (\u), FreeBASIC can 
      parse UTF-8, UTF-16LE, UTF-16BE, UTF-32LE and UTF-32BE source (.bas) or 
      header (.bi) files, they can freely mixed with other sources/headers in 
      the same project (also with other ASCII files).

    - Literal strings can be typed in the original non-latin alphabet, just use 
      a text-editor that supports one of the Unicode formats listed above.
      
    - The WSTRING type holds wide-characters, all string functions (like LEFT, 
      TRIM, etc) will work with wide-strings too.

    - OPEN was extended to support the ENCODING "format" option, files in UTF-8, 
      UTF-16LE and UTF-32LE can be read (using INPUT # or LINE INPUT #) and 
      written (using PRINT # or WRITE #) when opened in INPUT, OUTPUT 
      and APPEND modes, all of the conversion between Unicode to ASCII is done
      automatically if necessary.
      
    - PRINT'ing to console is also supported (see Requirements), INPUT or LINE
      INPUT from console doesn't allow wide-characters to be entered yet.

  o Name spaces:
    - Recursive (up to 64 levels):

      NAMESPACE outer
        DIM foo        
        NAMESPACE inner
          DIM bar          
        END NAMESPACE
      END NAMESPACE

      outer.inner.bar = outer.foo + 1

    - Can be imported (including into other name spaces):

      USING outer

      inner.bar = foo + 1

    - Imported name spaces go out of scope if used inside compound statements or 
      routines:

      NAMESPACE ns1.ns2.ns3  '' multi-nesting 
        DIM foo = 1
      END NAMESPACE

    - Symbols are mangled following the GCC 3.x ABI, allowing C++ global 
      functions and variables defined inside name spaces to be accessed directly:

      // compile with G++ 3.x or above
      namespace cpp {
        int sum( int a, int b ) { return a + b; }
      }

      EXTERN "c++"
        NAMESPACE cpp
          DECLARE FUNCTION sum ( a AS INTEGER, _
                                 b AS INTEGER ) AS INTEGER
        END NAMESPACE
      END EXTERN

      PRINT cpp.sum( 1, 2 )

  o A large number of variable types available:

    - Integer: BYTE, UBYTE, SHORT, USHORT, INTEGER, UINTEGER, 
      LONG and ULONG (same size as a POINTER), LONGINT and ULONGINT (64-bit) 

    - Floating-point: SINGLE and DOUBLE.

    - String: fixed (STRING *), variable-length (STRING) or null-
      terminated (ZSTRING), up to 2GB long.

    - Unicode Strings (WSTRING): like ZSTRING, but with support for wide 
      characters. Use the Windows unicode API functions directly, etc.

  o Structures (TYPE's and UNION's):

    - Unlimited nesting.

    - BASIC's TYPE statement is supported, along with the new UNION statement
      (including nameless nested UNION's).

      TYPE MyType
         A AS SHORT
         B AS INTEGER
         C AS LONG
         D AS OtherUDT
         UNION
            E AS DOUBLE
            F AS SINGLE
            G AS OtherUDT
         END UNION
         H AS BYTE
      END TYPE

      Or,

      UNION MyUnion
         A AS INTEGER
         B AS LONGINT
         C AS DOUBLE
      END UNION

    - Array fields utilizing up to eight dimensions can be used. For example,

      TYPE MyList
         ListData(0 TO MAXITEMS - 1) AS MyItem
      END TYPE
      
      (Note: Dynamic arrays are currently not allowed in TYPE's.)
      
    - Function pointer field types:

      TYPE MyType
         MyFunction AS FUNCTION (ArgumentA AS INTEGER) AS INTEGER
      END TYPE

    - Bit fields:

      TYPE mytype
          flag_0 : 1 AS INTEGER
          flag_1 : 1 AS INTEGER
          flag_2 : 1 AS INTEGER
      END TYPE

    - Private, Protected or Public access modes:

      TYPE mytype
       PUBLIC:
          field1 AS INTEGER
       PRIVATE:
          field2 AS INTEGER
      END TYPE

  o Enumerations (ENUM's):

      ENUM MyEnum
         A
         B = 3
         C
      END ENUM

  o Const Qualifier Type Safety:

    - For variables and arrays of any allowable data type

      DIM variable AS CONST datatype CONST PTR = initializer

    - Procedure parameters and return values

      FUNCTION foo( BYREF arg AS CONST bar ) AS CONST baz

    - Const-methods in User Defined Types (TYPE or CLASS):

      TYPE foo
        ...
        DECLARE CONST SUB bar()
      END TYPE

  o Constructors and Destructors in User Defined Types (TYPE or CLASS):
  
    - Constructors can be overloaded and take default parameters
    
    - Constructor chaining is supported (as in Java):
    
      CONSTRUCTOR foo( bar AS INTEGER )
      	this.bar = bar
      END CONSTRUCTOR

      CONSTRUCTOR foo( )
      	CONSTRUCTOR( 1234 )
      END CONSTRUCTOR
    
    - Global and local static instances also allow constructors and/or 
      destructors

    - The NEW and DELETE operator are supported (including the vector versions):
      
      DIM f AS foo PTR = NEW foo( 1234 )
      PRINT f->some_field
      DELETE f

  o Methods in User Defined Types (TYPE or CLASS):

      TYPE foo
      	bar AS INTEGER
      	DECLARE SUB printMe ( ) 
      	DECLARE STATIC SUB printThis ( BYREF f AS foo )
      END TYPE
      
      SUB foo.printMe ( ) 
        PRINT bar
      END SUB

      SUB foo.printThis ( BYREF f AS foo )
        PRINT f.bar
      END SUB
  
  o Operator Overloading in User Defined Types (TYPE, ENUM or CLASS):
  
    - All binary operators can be overloaded, but the relational ones
    
    - Operators to self (op=) can be handled separated for better performance
    
    - Most unary operators can be overloaded (casting included), plus address-
      of (@), pointer dereference (*) and UDT member pointer dereference (->)
      
    - The assignment operator can also be overloaded
    
    - Operators can be global or member functions:
    
      TYPE foo
      	bar AS INTEGER
      	DECLARE OPERATOR CAST ( ) AS STRING	
      	DECLARE CONSTRUCTOR ( bar AS INTEGER )
      END TYPE
      
      CONSTRUCTOR foo ( bar AS INTEGER )
      	this.bar = bar
      END CONSTRUCTOR
      
      OPERATOR foo.CAST ( ) AS STRING
      	RETURN STR( this.bar )
      END OPERATOR 
      
      OPERATOR + ( BYREF lhs AS FOO, BYREF rhs AS FOO ) AS FOO
      	RETURN FOO( lhs.bar + rhs.bar )
      END OPERATOR

  o Properties in User Defined Types (TYPE or CLASS):
  
    - Set (the "value" parameter can be overloaded):
      
      PROPERTY foo.bar( value AS INTEGER )
      	this._bar = value
      END PROPERTY

    - Get:
          
      PROPERTY foo.bar AS INTEGER
      	return this._bar
      END PROPERTY
      
    - Indexed (the "index" parameter can be overloaded also):

      PROPERTY foo.bar( index AS INTEGER, value AS INTEGER )
      	this._array(index) = value
      END PROPERTY

      PROPERTY foo.bar( index AS INTEGER ) AS INTEGER
      	return this._array(index)
      END PROPERTY
    
  o Arrays:

    - Dynamic and static arrays are supported, up to 2 GB in size.

    - Up to eight dimensions, including arrays with unknown dimensions.

    - Any lower and upper boundaries, including negative values.

    - REDIM PRESERVE statement is supported to resize any dynamic array and
      keep its contents intact.

  o Pointers:

    - Pointers to any of the data types listed above, including UDT's and arrays.

    - Uses the same syntax as C. For example,

      TYPE Node
         PreviousNode AS Node POINTER
         NextNode     AS Node POINTER
      END TYPE

      DIM CurrentNode AS Node POINTER
      CurrentNode->NextNode->PreviousNode = NULL

      DIM A AS SHORT POINTER, B AS SHORT POINTER, C AS SHORT POINTER POINTER
      *A = *B \ **C

    - Unlimited indirection levels (e.g., pointer to pointer to ...)

    - Function pointers:

      DIM MyPointer AS SUB(ArgumentA AS INTEGER, ArgumentB AS DOUBLE)
      DIM OtherPointer AS FUNCTION(ArgumentA AS INTEGER)

      MyPointer = @RealSub '' or PROCPTR(RealSub)
      MyPointer(1, 2)

      SUB RealSub(ArgumentA AS INTEGER, ArgumentB AS DOUBLE)
         Result = ArgumentA * ArgumentB
      END SUB

    - Indexing:

      DIM foo AS INTEGER PTR = CALLOCATE( 10 * len( integer ) )

      FOR i = 0 to 9
        foo[i] = bar            '' same as *(foo + i) = bar
      NEXT

    - String Indexing:

      DIM text AS STRING = "BAR"
      print text[0]             '' output will be 66 = ASC("B")

    - Function dereferencing:

      value = somefunc( )->somefuncptr( )->somefield

    - Type Casting:

      CPTR(BYTE PTR, intptr) += 1

      CPTR(myudt1 PTR, @udt2)->foo = *CPTR(INTEGER PTR, bar)

  o Variable initializers for static, module-level or local variables, arrays
    and UDT's:

      DIM foo( 0 to 3 ) AS INTEGER = { 1, 2, 3, 4 }

      STATIC bar( 0 to 1, 0 to 1 ) AS ZSTRING * 10 => { { "abc", "def" }, _
                                                        { "ghi", "jkl" } }

      DIM mytype as MYTYPE = ( "a", 1, 2.0 )

      DIM mytypearray(0 to 1) as MYTYPE = { ( "a", 1, 2.0 ), ( "b", 3, 4.0 ) }

      DIM localvar AS INTEGER = a + b * d
      
    - Void initializer to not clear the local symbols and speed up 
        allocation:
      
        DIM localvar AS DOUBLE = ANY
        
        DIM localarray(0 to 9) AS INTEGER = ANY

  o Optional function arguments (numeric, strings or UDT's):

      DECLARE SUB Test(a AS DOUBLE = 12.345, b AS BYTE = 255, _
                       s AS STRING = "abc")

      Test
      Test , 128
      Test ,
      Test 44,
      Test 44
      Test ( )

      et cetera.
      
    - Optional arguments can be initialized with expressions, not only constants.
      
  o Function overloading:
  
    DECLARE SUB Test OVERLOAD (a AS DOUBLE)
    DECLARE SUB Test (a AS SINGLE)
    DECLARE SUB Test (a AS INTEGER, b AS INTEGER = 1234)
    DECLARE SUB Test (a AS BYTE, b AS SHORT)

  o Inline Assembly:

    - Intel syntax.

    - Reference variables directly by name; no "trick code" needed.

  o Preprocessor:

    - Same syntax as in C (including #DEFINE's with arguments):

      #DEFINE SOMEDEF 1234
      #DEFINE OTHERDEF 5678
      #IFDEF SOMEDEF
      #   IF NOT DEFINED(OTHERDEF)
      #      DEFINE OTHERDEF SOMEDEF
      #   ELSE
      #      IF OTHERDEF <> SOMEDEF
      #         UNDEF OTHERDEF
      #         DEFINE OTHERDEF SOMEDEF
      #      ENDIF
      #   ENDIF
      #ELSE
      #   DEFINE OTHERDEF 5678
      #ENDIF
      #PRINT OTHERDEF

      #DEFINE bar(x,y) ((x) * (y))
      #DEFINE foo(x,y) bar(x-y,y-x)
      a = foo(b, c)
      
    - MACRO...ENDMACRO construct, to simplify multi-line #DEFINE's
      
      #MACRO WhileHoldingKey(code)
        DO
          SLEEP 1
        LOOP WHILE MULTIKEY(code)
      #ENDMACRO

  o Typedefs:

    - Supporting forward referencing as in C:

      TYPE foo AS bar

      TYPE sometype
           f   AS foo PTR
      END TYPE

      TYPE bar
           st  AS sometype
           a   AS INTEGER
      END TYPE

  o Escape characters inside literal strings:

    - Same as in C (except numbers are interpreted as decimal, not octal).
    
    - Use the ! prefix with the literal strings to escape them

      PRINT !"\"Hello from FreeBASIC!\""

  o Debugging support:

    - Full source-level debugging support with GDB (the GNU debugger) or 
      Insight (the GDB GUI frontend)

    - Array bounds checking (only enabled by the -exx command-line option)

    - Null pointers checking (same as above)

  o Create OBJ's, LIB's, DLL's, and console or GUI EXE's:

    - You are in no way locked to an IDE or editor of any kind.

    - You can create static and dynamic libraries adding just one command-line
      option (-lib or -dll).

  o Non-fatal error handling:

    - The FreeBASIC parser won't quit unless n# (default:10) syntax and/or semantic 
      errors happened, making it easier to port sources from different languages 
      and to work with large projects.

  o As a 32-bit application:

    - FreeBASIC can compile source code files up to 2 GB long.

    - The number of symbols (variables, constants, et cetera) is only limited
      by the total memory available during compile time. (You can, for example,
      include OpenGL, Gtk/SDL, BASS, simultaneously in your source code.)

  o Optimized code generation:

    - While FreeBASIC is not an optimizing compiler, it does many kinds of
      general optimizations to generate the fastest possible code on x86 CPU's,
      not losing to other BASIC alternatives, including the commercial ones.

  o Completely free:

    - All third-party tools are also free. No piece of abandoned or copyrighted
      software is used (except GoRC on Win32). The assembler, linker, archiver, and
      other command-line applications come from the GNU binutil programming 
      tools.


What FreeBASIC Isn't:

  o FreeBASIC is not a QuickBASIC clone, neither an emulator.

    - DEF SEG, PEEK and POKE to absolute 16-bit memory locations and many
      old and deprecated statements that are seldom used today were not
      implemented, please see http://www.freebasic.net/wiki/wikka.php?wakka=LangQB
      for a list of differences.

    - While FB is certainly the BASIC compiler that most resembles the Microsoft
      BASIC compilers for DOS (when using the -lang qb option), don't expect to 
      compile old source-codes filled with unsupported statements or external 
      libraries, that won't work.

  o FreeBASIC is not a Visual Basic alternative.

    - There are no events, or any GUI wrapper of any kind.

  o FreeBASIC is most certainly not bug free.

    - The FreeBASIC project was started in September 2004, and was/is not
      tested enough. There are no alpha/beta closed testing groups, so the final
      users are also testers. Regression tests are always added when a bug
      is fixed.


Credits (in alphabetic order):

  Project members:

  o Andre Victor T. Vicentini (av1ctor[at]yahoo.com.br):
    - Project creator. 
    - Main compiler developer.

  o Angelo Mottola (a.mottola[at]libero.it):
    - Ported FreeBASIC to Linux.
    - Developer of GFXLib2.
    - Added built-in threads, dynlib support and I/O ports access support.
    - Made the rtlib thread-safe, besides many other runtime lib
      and compiler improvements.

  o Daniel R. Verkamp (i_am_drv[at]yahoo.com):
    - Ported FreeBASIC to DOS and Xbox; ports maintainer.
    - Translated the Allegro headers (later replaced by the SWIG FB wrapper 
      version).
    - Wrote the DLL and static library automation, plus resource scripts
      support on Windows.
    - Developed the VB-compatible file routines in the extended runtime library.

  o Jeff Marshall (coder[at]execulink.com):
    - Improved and fixed the printer support in all platforms.
    - Added compiler tests and improved the document translator.
    - Helped in adding the fblite dialect.
    - Miscellaneous fixes and improvements.

  o Mark Junker (mjscod[at]gmx.de):
    - Added support for file systems like SCR, LPTx, COM, etc.
    - Added printer support.
    - Developer of the FB runtime-lib extended (libfbx).
    - Added the automated runtime-lib and compiler tests (later replaced by CUnit unit testing).
    - Wrote the Windows installer scripts.
    - Many runtime library fixes and improvements.

  o Matthew Fearnley (counting.pine[at]virgin.net)
    - Helped in adding the fblite dialect.
    - Miscellaneous fixes and improvements.

  o Ruben Rodriguez (rubentbstk[at]gmail.com):
    - Many compiler improvements and bug fixes.
    - Corrected the errors in English in readme.txt and migrating.txt, plus
      the messages in compiler/error.bas.
    - Added the __PATH__ intrinsic define, and made OFFSETOF() work inside inline
      asm blocks.

  o Simon Nash
    - Implemented the AndAlso/OrElse short-circuit operators. 
    - Many compiler improvements and bug fixes. 


  Contributors:

  o Abdullah Ali (voodooattack[at]hotmail.com):
    - Fixed and finished the Windows NT DDK headers at the inc/win/ddk dir,
      translated by the SWIG FB wrapper. 
    - Wrote the Windows NT DDK test at the examples/Windows/ddk/driver dir.
    - Added DLL hot-linking support to the Windows port (disabled at the moment).

  o Bryan Stoeberl (b_stoeberl[at]yahoo.com):
    - Translated the OpenGL Extensions header (later replaced by the SWIG 
      FB wrapper version).
    - Wrote the glext example at the examples/GL dir.
    - Added SSE/SSE2 code generation for floating point math.

  o Claudio Tinivella (tinycla[at]yahoo.it):
    - Translated from C all the Gtk tutorials at the examples/Gtk/Tutorials dir.

  o Chris Davies (c.g.davies[at]gmail.com):
    - Translated the OpenAL headers (later replaced by the SWIG FB wrapper 
      version).
    - Wrote the OpenAL demonstration in the examples/sound directory.

  o Dumbledore
    - Ported the wx-c headers (later replaced by the SWIG FB wrapper version).
    - Wrote the wx demonstration in the examples/wx-c dir.

  o dr0p (dr0p[at]perfectbg.com):
    - Fixed the PostgreSQL headers translated by the SWIG FB wrapper.
    - Wrote the postgresql_test.bas example at the examples/DB dir.
  
  o Edmond Leung (leung.edmond[at]gmail.com):
    - Translated the SDL headers, including SDL_mixer and SDL_image (later 
      replaced by the SWIG FB wrapper version).
    - Wrote/ported many of the examples in the examples/SDL dir.

  o Eric Lope (vic_viperph[at]yahoo.com):
    - Translated the OpenGL and GLU headers (later replaced by the SWIG FB 
      wrapper version).
    - Wrote the rel-* graphics demonstrations in the examples/gfx directory.
    - Wrote the examples/GL/fbgfx_texture.bas OpenGL example.

  o Florent Heyworth (florent.heyworth[at]swissonline.ch):
    - Translated the Win API sql/obdc headers (later replaced by the SWIG FB 
      wrapper version).

  o fsw (fsw.fb[at]comcast.net):
    - Translated most of the Windows API headers (later replaced by the SWIG FB 
      wrapper version).
    - Wrote the glade_gui demo at the examples/Gtk directory, in addition to the
      wx-c GUI examples (not included).

  o Garvan O'Keeffe (sisophon2001[at]yahoo.com):
    - Translated most of the NeHe's OpenGL lessons at the examples/GL/NeHe dir.
    - Wrote the PDFlib demonstration, at examples/pdflib

  o Hans L. Nemeschkal (Hans.Leo.Nemeschkal[at]univie.ac.at):
    - Translated the DISLIN header (later replaced by the SWIG FB wrapper 
      version).

  o Jofers (spam[at]betterwebber.com):
    - Wrote the examples in the examples/freetype directory.

  o Jose Manuel Postigo (postigo[at]uma.es):
    - Added support for serial devices in Linux.

  o Laanan Fisher (laananfisher[at]gmail.com):
    - Re-implemented the compiler test suite (at the /tests directory), using 
      unit testing (CUnit).

  o Matthias Faust (matthias_faust[at]web.de):
    - Translated the SDL_ttf header (later replaced by the SWIG FB wrapper 
      version).
    - Wrote the SDL_ttf demonstration.

  o Marzec:
    - Wrote the SDL_bassgl, SDL_opengl, and SDL_key tests in the SDL directory.
    - Translated the first SDL headers (replaced by new ones in version 0.11b).
    - Wrote the first file routines for the run-time library, later replaced.

  o Nek (dave[at]nodtveidt.net):
    - Translated the Windows API headers, integrating parts of fsw's work (later 
      replaced by the SWIG FB wrapper version).

  o plasma:
    - Translated the FMOD and BASS headers.
    - Wrote the fmod.bas test in the examples/sound directory.

  o Randy Keeling (randy[at]keeling.com):
    - Wrote the GSL matrix test at the examples/GSL directory.
    
  o Sterling Christensen (sterling[at]engineer.com):
    - Ex-project member, developer of the QB-like graphics library (later 
      replaced by GFXLib2 in 0.11b)

  o Steven Hidy (subxero[at]phatcode.net):
    - Rewrote this readme file, correcting v1ctor's mistakes (also re-edited by
      KrisKhaos for version 0.12).

  o zydon:
    - Wrote many of the examples in the examples/Windows/gui directory.


  Third-party tools included:
    
  o All platforms:
    - GNU binutils (http://www.gnu.org/software/binutils/)
    
  o DOS version: 
    - DJGPP (http://www.delorie.com/)

  o Windows version: 
    - Mingw (http://www.mingw.org/)
    - GoRC (http://www.godevtool.com/)

  o Xbox version: 
    - OpenXDK (http://www.openxdk.org/)


Greetings:

  o Plasma: freebasic.net domain register and since mar/2005 hosts the main site
    too, many thanks to him.

  o VonGodric: author of the first FreeBASIC IDE: FBIDE (download it here:
    http://www.hot.ee/fbide/ ).

  o Everybody that helped writing the documentation (and in special to Nexinarus 
    that started it), more details at 
    http://www.freebasic.net/wiki/wikka.php?wakka=ContributorList

  o All users that reported bugs, requested features and as such helped 
    improving the compiler, language and run-time library somehow.


Links:

  o Official site: http://www.freebasic.net/ or
                   http://fbc.sourceforge.net/ or
                   http://www.sourceforge.net/projects/fbc

  o IRC channel: irc://irc.freenode.net/freeBASIC

  o External libraries:

    - Allegro: http://www.talula.demon.co.uk/allegro/

    - BASS and BASSMod: http://www.un4seen.com/

    - BIG_INT: http://chat.finalcombat.com/valyala/big_int/

    - cgi-util: http://www.newbreedsoftware.com/cgi-util/

    - cryptlib: http://www.cs.auckland.ac.nz/~pgut001/cryptlib/

    - CUnit: http://cunit.sourceforge.net/

    - Curl: http://curl.haxx.se/

    - DevIL: http://openil.sourceforge.net/

    - DISLIN: http://www.linmpi.mpg.de/dislin/
    
    - DispHelper: http://disphelper.sourceforge.net/

    - Expat: http://expat.sourceforge.net/

    - FastCGI: http://www.fastcgi.com/

    - fmod: http://www.fmod.org/

    - FreeImage: http://freeimage.sourceforge.net/

    - FreeType: http://www.freetype.org/

    - GD: http://www.boutell.com/gd/ or http://gnuwin32.sourceforge.net/packages/gd.htm

    - GDSL: http://www.nongnu.org/gdsl/
    
    - GIFLIB: http://sourceforge.net/projects/libungif/

    - GLFW: http://glfw.sourceforge.net/

    - GLUT: http://www.xmission.com/~nate/glut.html

    - GMP: http://www.swox.com/gmp/

    - GNU ASpell: http://aspell.net/

    - GRX: http://grx.gnu.de/

    - GSL: http://www.gnu.org/software/gsl/ or http://gnuwin32.sourceforge.net/packages/gsl.htm

    - GTK+: http://www.gtk.org/ or http://gladewin32.sourceforge.net/modules/wfdownloads/

    - IUP: http://luaforge.net/projects/iup

    - JAPI: http://www.japi.de/

    - libcaca: http://sam.zoy.org/libcaca/

    - libJPEG: http://www.ijg.org/ or http://gnuwin32.sourceforge.net/packages/jpeg.htm

    - libPNG: http://www.libpng.org/pub/png/libpng.html or http://gnuwin32.sourceforge.net/packages/libpng.htm

    - LibXML: http://xmlsoft.org/

    - Lua: http://www.lua.org/

    - Mini-XML: http://www.easysw.com/~mike/mxml/

    - MySQL: http://dev.mysql.com/

    - Newton: http://www.physicsengine.com/

    - ODE: http://ode.org/

    - OpenAL: http://www.openal.org/ or http://developer.creative.com/landing.asp?cat=1&sbcat=31&top=38

    - OpenGL: http://www.opengl.org/

    - PCRE: http://www.pcre.org/
    
    - PDCurses: http://pdcurses.sourceforge.net/

    - PDFlib: http://www.pdflib.com/ or http://gnuwin32.sourceforge.net/packages/pdflib.htm
    
    - PostgreSQL: http://www.postgresql.org/

    - SDL: http://www.libsdl.org/ (look under Libraries for SDL_net, SDL_image, SDL_ttf, etc)

    - SDL_gfx: http://www.ferzkopp.net/~aschiffler/Software/SDL_gfx-2.0/
    
    - SpiderMonkey: http://www.mozilla.org/js/spidermonkey/

    - SQLite: http://www.sqlite.org/

    - TinyPTC: http://sourceforge.net/projects/tinyptc/

    - TRE (Regular Expressions): http://laurikari.net/tre/

    - wx-c: http://wxnet.sourceforge.net/

    - Zlib: http://www.zlib.net/ or http://gnuwin32.sourceforge.net/packages/zlib.htm


EOF
