
  FreeBASIC - A multi-platform 32-bit BASIC Compiler
  Copyright (C) 2004-2005 Andre Victor T. Vicentini (av1ctor@yahoo.com.br)


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:

    - Unpack the zip archive to any folder of your preference -- C:\ is a good
      idea if you are not going to use an IDE later. The directory structure
      as used inside the archive must be preserved.

    - Run the INSTALL.BAT file to generate the import libraries -- they are
      needed to call any function on DLL's and to create the executables.

    (Note: Do not install the Windows version over the old versions, unless the
     whole /lib/win32 directory is deleted first.)

  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/share/freebasic. A link to the compiler binary will be
      created at /usr/bin/fbc. If you don't have root priviledges, you can also
      install into a custom directory; run the install.sh script with no
      arguments for more info. Be warned though that installing with no root
      priviledges will prevent the script from installing a link to the binary
      into /usr/bin/fbc.
    
    (Note: to uninstall FreeBASIC, you can run "install.sh -u")

  o DOS:

    - Unpack the zip archive to any folder you want, but give preference to one
      with no white-spaces on 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 preview installation to fbc-win.exe or such, or
   it will be overwritten by the new one.)


Running:

  o Windows and DOS versions:

    - Open the DOS/Command-Prompt/Console 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\hello.bas", the hello.exe file will be created
      at the "examples" 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.

  o Linux version:

    - If the install.sh script was successfully executed with enough priviledges,
      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/hello.bas", the hello executable file will be
      created at the "examples" dir.


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 that 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).

    - If 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 an UTF-8 version - most modern
      distros come with support that and 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 been debugged using:
      "set args arg1 arg2 argn". You can also run GBD and pass the arguments directly
      to the application been 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 isn't 
      case insensitive).

    - 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.

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

    - Type "q" to quit.

    - Type "help" to see a list of commands, there are hundred 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; line numbers are supported; 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. All 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, etc

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

    - cgi-util and FastCGI: web development

    - DirectX and the Windows API - the most complete headers set between the BASIC
      compilers available, including support for the Unicode functions

    - 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 it,
      FreeBASIC compiles itself.), what makes it simple to be bootstrapped as it
      doesn't depend on non-portable tools.

  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 an
      text-editor that supports some 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 the conversion between Unicode to ASCII is be done
      automatically if necessary.
      
    - PRINT'ing to console is also supported (see Requirements), INPUT or LINE
      INPUT from console still not allowing wide-characters to be entered yet.

  o A large number of variable types available:

    - Integer: BYTE, UBYTE, SHORT, USHORT, INTEGER, UINTEGER, 
      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 User-defined Types (UDT'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 four dimensions can be used. For example,

      TYPE MyList
         ListData(0 TO MAXITEMS - 1) AS MyItem
      END TYPE

    - Function field types:

      TYPE MyType
         MyFunction AS FUNCTION (BYVAL 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

      DIM t AS mytype

      t.flag_0 = 1
      t.flag_1 = 0
      t.flag_2 = 1

      PRINT "All flags ON? ";
      IF ( t.flag_0 AND t.flag_1 AND t.flag_2 ) THEN
        PRINT "TRUE"
      ELSE
        PRINT "FALSE"
      END IF

  o Enumerations (ENUM's):

      ENUM MyEnum
         A
         B = 3
         C
      END ENUM

      DIM E AS MyEnum

      E = C

  o Arrays:

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

    - Unlimited number of array dimensions.

    - Any lower and upper boundaries.

    - 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(BYVAL ArgumentA AS INTEGER, BYVAL ArgumentB AS DOUBLE)
      DIM OtherPointer AS FUNCTION(BYVAL ArgumentA AS INTEGER)

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

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

    - Indexing:

      DIM foo AS INTEGER PTR

      foo = CALLOCATE( 10 * len( integer ) )

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

    - String Indexing:

      DIM text AS STRING

      text = "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

  o Optional function arguments (numeric and strings):

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

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

      et cetera.
      
  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)

  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

      DIM s AS sometype, b AS bar

      b.st.f = @b
      s.f = @b

      s.f->st.f->a = 1234

  o Escape characters inside literal strings:

    - Same as in C (except numbers are interpreted as decimal, not octal).
      Use the OPTION ESCAPE statement to turn this behavior on or off.

      OPTION ESCAPE
      PRINT "\"Hello from FreeBASIC!\""

  o Debugging support:

    - Full 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 A 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 (but 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, read the docs/keywords.txt file for a list of differences.

    - While FB is certainly the BASIC compiler that most resembles the Microsoft
      BASIC compilers for DOS, 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. (You can create them
      easily with UDT's and function pointers.)

  o FreeBASIC is most certainly not bug free, as with any other program.

    - The FreeBASIC project was started in September 2004, and was not/is not
      tested enough.


Possible Additions to Next Versions:

  o CLASS data structure (for object-oriented programming):

    - GUI code would be much easier to write.


Credits (in alphabetic order):

  o Angelo Mottola (a.mottola@libero.it) - Project Member:
    - Ported FreeBASIC to Linux; port maintainer.
    - Developer of GFXLib2.
    - Added profiling support.
    - Added build-in threads, dynlib support and I/O ports access support.
    - Made the rtlib thread-safe, besides many other runtime lib
      and compiler improvements.

  o Bryan Stoeberl (b_stoeberl@yahoo.com):
    - Translated the OpenGL Extensions header.
    - Wrote the glext example at the examples/GL dir.

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

  o Daniel R. Verkamp (i_am_drv@yahoo.com) - Project Member:
    - Ported FreeBASIC to DOS and Xbox; ports maintainer.
    - Translated the Allegro headers (W.I.P.).
    - Wrote the DLL and static library automation, plus resource scripts
      support on Windows.

  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 Edmond Leung (leung.edmond@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@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@swissonline.ch):
    - Translated the Win API sql/obdc headers (later replaced by the SWIG FB 
      wrapper version).

  o fsw (fsw.fb@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, besides the
      wx-c GUI examples (not included).

  o Garvan O'Keeffe (sisophon2001@yahoo.com):
    - Ported 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@univie.ac.at):
    - Translated the DISLIN header (later replaced by the SWIG FB wrapper version).

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

  o Randy Keeling (randy@keeling.com):
    - Wrote the GSL matrix test at the examples/GSL directory.

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

  o Mark Junker (mjscod@gmx.de) - Project Member:
    - 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.
    - Wrote the Windows installer scripts.
    - Many runtime library fixes and improvements.

  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 since version 0.11b).
    - Wrote the first file routines for the run-time library.

  o Nek (dave@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 Sterling Christensen (sterling@engineer.com):
    - Ex-project member, developer of the QB-like graphics library (later replaced by 
      GFXLib2 in 0.11b)

  o Steven Hidy (subxero@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.


  o Third-party tools included:
    - DOS version: DJGPP (http://www.delorie.com/)

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

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

  o The long integers (64-bit) division and modulo routines are from the GCC's
    libgcc2 sources.


Greetings:

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

  o Nexinarus: Organized the documentation (W.I.P.), found bugs and saved a bunch
    of kangaroos in the middle time.

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

  o Rel: Best beta tester ever, found loads of bugs.

  o Wildcard: Created the biggest FB forum and helped making FB known even before
    it was released.

  o Blitz: The first to see the compiler when it was just a toy (delete the
    sources!). Helped pointing me out the right paths to follow in order to
    generate better code. Helped finding bugs and wrote the first real apps.

  o Marzec: Loads of tests, besides giving many ideas.

  o Nek, na_th_an, Sj Zero, Z!re: Some serious beta testing - meaning: loads of
    bugs found.


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/

    - 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/

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

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

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

    - 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.php?name=Downloads

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

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

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

    - 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

    - 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/

    - 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
