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 viceversa, 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; us e 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 wil l 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 an y 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 wil l 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 typi ng "fbc" on any dir the shell is currently at. If it was not possible to crea te the link, you may want to alter your PATH environmental variable to be abl e 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 wil l 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 wil l 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/Vist a 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 xter m. 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 breakpoin t 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" comma nd to change GDB to case-insensitive mode, pointer dereference will follow th e 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 help ers: - 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 i t 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 nullterminated (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 addressof (@), 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 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 '' same as *(foo + i) = bar

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 Test Test Test Test , 128 , 44, 44 ( )

et cetera. - Optional arguments can be initialized with expressions, not only constants . o Function overloading: DECLARE DECLARE DECLARE DECLARE SUB SUB SUB SUB Test Test Test Test OVERLOAD (a AS DOUBLE) (a AS SINGLE) (a AS INTEGER, b AS INTEGER = 1234) (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 seman tic 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=Lang QB 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 CUni t 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 inlin e 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/p ackages/gsl.htm - GTK+: http://www.gtk.org/ or http://gladewin32.sourceforge.net/modules/wfd ownloads/ - 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/j peg.htm - libPNG: http://www.libpng.org/pub/png/libpng.html or http://gnuwin32.sourc eforge.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.as p?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/zli b.htm EOF