Version 0.23.0:

[changed]
- 'CLOSE #0' now returns an error, instead of closing all open file handles

[fixed]
- Bitfields were allowed to be passed to BYREF parameters
- #3153953: Faulty reoptimisation of constant optimizing in complex nested addition/subtraction expressions
- #3327533: Internal compiler error trying to parse non-integer bounds in array declarations
- C emitter: Erroneous '.0' being appended to double floating point literals like '1e-100'
- C emitter: Hidden UDT result parameters were emitted last rather than first in function declarations
- Fixed buggy PRINT USING floating-point scaling, now works more consistently across all platforms
- Built-in defines (__FILE__ & co) didn't use $ to prevent escaping
- time() crashed when the system time couldn't be retrieved
- Extra CR printed in -exx runtime error messages


Version 0.22.0:

[changed]
- "No newline at end of file" warning suppressed unless compiling with -w pedantic
- FIX(n)/INT(n) no longer affect the type/value of integer-type expressions
- __FB_UNIX__ and __FB_PCOS__ are no longer defined when false, allowing #IFDEF to work
- MID(s,n,0)=t statement was equivalent to MID(s,n)=t; now it more intuitively sets 0 chars (i.e. does nothing) like in QB
- Allow -1 to be used as array upper bound, at the cost of -2147483648 being disallowed

[added]
- Variadic macros: #define a(x, y...) f(x, y)
- __FB_BACKEND__ define, being defined to "gas" or "gcc" corresponding to -gen gas and -gen gcc respectively
- Support for user-defined operators EXP/LOG/SIN/ASIN/COS/ACOS/TAN/ATN

[fixed]
- #3052712: -pp was not emitting the last line of input if it didn't have an EOL marker
- inc/win/vfw.bi: Some vfw functions need to use cdecl instead of stdcall (weird API), also added #inclib "vfw32"
- SGN(const_longint) was leaving the upper 32 bits unchanged
- FRAC(n) was returning not 0 but n, for integer n
- FIX(n)/FRAC(n) were allowing the unchanged variable n to be passed by reference.
- SCREEN(x,y) and VIEW|WINDOW SCREEN weren't recognised in lang QB (it was necessary to use __SCREEN)
- rtlib allocated room for N user file numbers but only allowed N-1 to be used
- #3089481: -pp didn't distinguish \" escapes from "" sequences
- #3089424: type parameter error and missing types in commctrl.bi (thanks to vbmrupp)
- Multiple typedefs in the same line were not being accepted if each had its own type: 'type a as integer, b as integer'
- Could not typedef to a forward reference with multi-declaration syntax: 'type as Forward Foo'
- CONST's on PTR's weren't always preserved on typedefs to forward references
- Using typedefs and forward references, types with more than 8 PTR's could be created, this will now result in an error
- Forward references solving was faulty, e.g. a forward reference couldn't be solved with a function pointer or another forward reference
- #3076871: typeof() was not preserving the data type length when used on operation expressions
- C emitter: -g and -exx
- C emitter: circular UDT dependencies
- C emitter: SWAP on pointers
- C emitter: arrays/fixlen string declarations
- C emitter: addrof on functions and string literals in variable initializers
- C emitter: function pointers/string literals/array/fixlen string accesses
- C emitter: number literals
- C emitter: comparisons returned 1 and 0 instead of -1 and 0
- #2099245: mixing signed and unsigned operands (e.g. c1 + uv1) could result in the wrong result type if the first operand was a const
- Expressions containing constants that differed by "small" amounts (e.g. a*1e-20, a*1e-30) could be assumed to be equal in comparisons
- QB-compatible SCREEN modes now default to the same number of pages as QB instead of just 1 (e.g. SCREEN 7 now defaults to 8 pages)
- patch #3108334: GetKey in graphics modes shouldn't wait 20ms if there is a key already in the key buffer (thanks to TeeEmCee for patch)
- #3153953: Faulty reoptimisation on (i - (j+C1)*C2 + k)
- #1444576: WINDOWTITLE() does not persist
- va_first() not taking into account 4 byte parameter alignment
- ON ... GOTO with more than the supported number of target labels didn't cause an error
- Specifying 'stdcall' for procedures did not have an effect on DOS and Unix-like systems
- Symbol data types could be corrupted when unsolved forward references were used in procedure parameters, local variables and such
- #2973014: Compiler was crashing on function calls with certain number and kind of arguments
- va_first() now always returns an ANY PTR
- #3251750: Local UDT FOR..NEXT iterators could be constructed twice (for i as UDT = ...)
- STR$() in -lang qb didn't prepend ULONGINT's with a space when evaluated at runtime on non-Windows systems
- PROTECTED members could be accessed from outside the UDT's namespace
- inc/crt/stdint.bi: uint64_t wasn't unsigned
- inc/GL/glext.bi: GL{int|sizei}ptr[ARB] typedefs should be integers, not pointers


Version 0.21.1:

[changed]
- Removed the "v" and "b" from the version number in __FB_SIGNATURE__, following the release archive names

[fixed]
- #3034516: Remove trailing backslash from #macro line in inc/ode/odemath.bi
- gfxlib's x11 window didn't detect the mouse being outside the window sometimes because it checked only the mouse's y position. 
- Added some missing FB_UNLOCK()'s to the rtlib


Version 0.21.0:

[changed]
- BLOAD with 32-bpp BMP files now keeps alpha no matter what kind of header is used; fixes custom 32-bpp DRAW STRING fonts - thanks to Sisophon2001 for spotting this (DrV)
- #lang/$lang statements can now override the -lang command-line parameter (-forcelang has been added to allow overriding them) (counting_pine)
- Remove GNU extensions in install.sh (DrV)
- update FreeImage header to v3.11.0 and .def file for Win32 (jeffm)
- gfxlib internal: remove SCREEN_LOCKED flag since the check can be done using the "lock_count" counter instead (jeffm)
- remove unnecessary (and undocumented) command line options -nostdcall and -stdcall (DrV)
- lang qb: Allow DEF___ statements anywhere in code (counting_pine)
- RANDOMIZE (with no parameters) now uses a default seed that changes more than once a second (counting_pine)
- ImageCreate and internal screen allocation now aligns buffers to multiples of 16 to make working with SSE easier - thanks to 1000101. (yetifoot)
- COLOR now stores colors strictly in the format for the graphics screen's bit depth, so the default color can be relied upon when working on the screen, but not on images of a different bit depth (counting_pine)
- lang fb: Multi-line comments are now completely disallowed in single-line comments - thanks to VonGodric for help (counting_pine)
- DRAW now accepts numbers with multiple signs/whitespace prepended, and recognises relational distances from the x coordinate only, like in QBASIC (counting_pine)
- PRINT USING internals overhauled: it is now more reliable and behaves more like QBASIC with respect to parsing and printing (counting_pine)
- #2483518: Disregard letter suffixes on numbers in asm blocks, so things like "je 2f" can work (counting_pine)
- Updated examples to current FB, thanks to MOD for the patch (dkls)

[added]
- "-fpmode FAST|PRECISE" command line option (brybry)
- certain single-precision math approximations when using "-fpu SSE" and "-fpmode FAST" (brybry)
- automatic vectorization for floating-point numbers in "-fpu SSE" FPU mode (brybry)
- "-vec n" command line option to enable level n of vectorization (brybry)
- "__FB_FPU__" define whose value is the FPU mode ("x87"|"sse") (counting_pine)
- "__FB_FPMODE__" define whose value is the type of FPU precision ("precise"|"fast") (counting_pine)
- "__FB_VECTORIZE__" define whose value is the level of vectorization (brybry)
- FORMAT now supports the "n" character to unambiguously specify minutes, as in VB - e.g. 'format( now(), "nn:ss" )' (counting_pine)
- display objinfo configuration in -version (DrV)
- OpenBSD support started (DrV)
- Darwin support started (DrV)
- NetBSD support started (DrV)
- Multi-monitor support for Win32 GDI and OpenGL gfx drivers (DrV)
- FBC now reports the error codes in verbose mode if there are failures calling programs like the assembler or linker (counting_pine)
- Warning if an IF statement immediately follows a multi-line ELSE, due to potential confusion with 'ELSEIF' (counting_pine)
- Warning when using SHL/SHR if a constant shift value is greater than or equal to the number of bits in the type (counting_pine)
- -forcelang command-line parameter, to override #lang/$lang statements in code (replicates -lang's original behavior) (counting_pine)
- Ellipsis form in array declarations with initializers, ie "dim as integer array(0 to ...) = {1, 2, 3, 4}" (yetifoot)
- Naked functions - functions without prolog/epilog code, useful for writing small functions in asm (thanks yetifoot)
- More specific error message for FOR...NEXT variable mismatches, such as "FOR a ... NEXT b" (counting_pine)
- support for BYREF AS ZSTRING/BYREF AS WSTRING parameters (counting_pine)
- Warning when BYVAL AS STRING is used instead of BYREF AS ZSTRING (enable with "-w param") (counting_pine)
- lang qb: __SCREEN keyword for accessing FB's normal SCREEN syntax (counting_pine)
- PRINT USING now supports "&" for intelligent number formatting (counting_pine)
- PRINT USING: normal expressions allowed before USING (counting_pine)
- PRINT USING: support for SPC/TAB (counting_pine)
- VAL/VALINT/... now support "&..." for octal numbers, e.g. "&123" (counting_pine)
- Warning if the file doesn't have a newline at the end (counting_pine)
- Err may now be called as "Err()", like with a normal function (counting_pine)
- errors for several cases of division by constant zero (dkls)
- search 32-bit library paths in the linker scripts for Linux and FreeBSD (cha0s)
- preprocessor-only mode, activated by '-pp' command-line option (dkls)
- @<file> command-line option, to read command-line options from files (dkls)
- __FB_UNIX__/__FB_PCOS__ target type specific defines, thanks to segin for the patch
- C emitter backend (-gen gcc), experimental

[fixed]
- WIDTH was crashing when optional parameter was not specified (DrV)
- Initialize unix console cursor location to 1,1 if it is unknown (DrV)
- ImageConvertRow now aborts if given an invalid source bit depth (counting_pine)
- comparing [u]shorts with pointers was causing the compiler to crash (cha0s)
- quickly scrolling the mouse wheel was causing double click events in the x11 (linux) gfx driver (spotted by Sisophon2001) (DrV)
- FBC wasn't warning in some cases where a number literal was too big to fit in a ulongint (counting_pine)
- PCOPY, "SCREEN , a, v" in consoles weren't throwing an error if the page numbers were 1 more than the highest console page (counting_pine)
- lang qb: "SCREEN 0" was trying to set the visible page to 8 (counting_pine)
- #2057952 - lang qb: fixed floating-point type identification issues (counting_pine)
- #2068874 - objects of arrays with a destructor but no constructor were crashing due to missed NULL ptr checks (cha0s)
- #2085637 - define was not catching illegal symbol names (cha0s)
- Backslashes could escape End-of-line characters in string literals (counting_pine)
- Expressions with side-effects could be optimized away in some cases, e.g. cint(rnd) * 0 (counting_pine)
- WINDOW was swapping float coordinates using an int value (counting_pine)
- Faulty optimisation for "IF (a >= a | a <= a) THEN ..." (counting_pine)
- #2109564: POW and ATAN2 were not checking operand sizes in the SSE emitter - thanks Bryan S. for fix (jeffm)
- Fix Win32 DirectX gfx driver crashing when DirectX not working/available (DrV)
- Slightly improved expression/typename disambiguation in LEN/SIZEOF/TYPEOF (counting_pine)
- #2150255: SWAP with strings wasn't swapping the "allocated size" element in the descriptor, potentially leading to memory corruption - thanks to Mike Kennedy for discovering this (counting_pine)
- ANY PTR resolution was broken; if a function taking an ANY PTR had an overload taking another type (e.g. BYTE), the overload resolution would incorrectly report that the function call was ambiguous, if an ANY PTR was passed to the function. Now it chooses the ANY PTR candidate. (cha0s)
- #2169551: FB in Windows was using scientific notation to print or convert any numbers less than 0.1.  It will now only use it with numbers less than 0.0001 (counting_pine)
- #2210314: IIF within new[] was failing because trees with IIF were not cloned correctly (yetifoot)
- #2010551: included files names were being emitted in .stabs in upper case, causing problems in gdb under linux (yetifoot)
- "a mod &hffffffffu" could be mistaken for "a mod -1", and incorrectly optimised to 0 (counting_pine)
- #2210424 - PUT # was warning about pointers and var-len string fields when putting any UDT with a constructor (counting_pine)
- Faulty optimisation for "IF a op a THEN ...", where "op" is a non-comparison operator (counting_pine)
- #2225273 - Driver exit functions are called twice for GDI and DX driver.  Thanks to sisophon2001 for patch (counting_pine)
- "CASE IS rel_op expr" was allowing (but not properly handling) any token for rel_op.  Now, anything but a relational operator (=, >, <, <>, <=, >=) is rightly disallowed (counting_pine)
- Error messages were printed without a newline when compiling Unicode source (counting_pine)
- STRPTR/SADD were returning a reference that could be directly modified (e.g STRPTR(s) = 0), which wasn't safe (counting_pine)
- #2533376 - FBC could crash on new[count] if count wasn't an Integer (counting_pine)
- #2659332 - buggy implementation of warning message when GET/PUT was used for UDTs with pointer fields (thanks to dkls for patch); add slightly more helpful warning when just passing a pointer (counting_pine)
- SLEEP() was registered as a function when it should have been a sub (counting_pine)
- #2617069 InStrRev was skipping over some matches (counting_pine)
- In -g mode, .file/.stabs paths could be emitted with unescaped single backslashes - reported by KetilO (counting_pine)
- INSTR() could crash if the string to search for was too long (counting_pine)
- Patch #2471271: null-termination/memory management issues in WINPUT() - thanks to dkls for the patch (counting_pine)
- FB was "ghosting" parameter names in error messages, in cases where the parameter was unnamed, but a previous function header had a parameter with a name in the same position (counting_pine)
- #2038682: faulty optimisation - 16-bit ops on constants could result in constant values that weren't truncated to fit the result type (counting_pine)
- PRINT|WRITE #f could print to the wrong file number if it printed an expression that modified f (counting_pine)
- #2433409 - Bugs in graphics driver selection fallback.  Thanks to sisophon2001 for patch (counting_pine)
- Linux: fixed problems when switching graphics screens between full-screen and windowed.  Thanks to sisophon2001 for patch (counting_pine)
- SINGLE constants were being converted to string with double precision (counting_pine)
- #2806342 - symb can lose wstring literals - thanks to dkls for patch (counting_pine)
- #2102417 - Scope/Dtor problem if no new-line after "LOOP"-statement (counting_pine)
- Fixed incorrect pointer sizes being emitted in -fpu SSE code (brybry)
- #2082801 - errors when converting floating-point numbers to ulongint, or ulongint expressions to floating-point (counting_pine)
- Debug mode: emit correct stabs for global redim arrays - patch by SARG (counting_pine)
- #2914509 - INPUT was reading last char twice when reaching the 4096 char limit (dkls)
- #2776255 - not handling nested compounds in an EXTERN correctly caused bad name mangling (dkls)
- global destructors could be EXPORT'ed (dkls)
- 'dim a as string * expr = ""' wasn't working because of expression/varinit ambiguity (dkls)
- #2590116 - unix rtlib was repeatedly leaking its /dev/tty file handle (dkls)
- #2974397 - Dynamic arrays with any const qualifiers below the first level (aka [ptr ]*) would erroneously report duplicate definition (cha0s)
- The final slash stripping code in fbcGetLibPathList() was only working properly on systems using '\' as a path separator. (cha0s)
- Assignments to bitfields in globals were broken (dkls)


Version 0.20.0 Beta:

[changed]
- the "-r" compiler switch will now prevent FBC compiling/linking the asm, unless overridden by "-c".  Its old behavior is now given by "-R" (counting_pine)
- update FreeImage header to v3.10 and .def files for Win32 (cha0s)
- x11 gfx driver: let the window manager pick the window position (DrV)
- '&' string concatenation will not pad positive numbers, even in lang qb (counting_pine)
- removed runtime check for dialect in BLOAD/IMAGECREATE/GET so they will respect the dialect where used even if main module is compiled under a different dialect.  qb/fblite uses old header and fb uses new-header. (jeffm)
- lang qb can now use all the OPTIONs fblite can, e.g. OPTION STATIC|BYVAL|... (counting_pine)
- CVD / CVS may no longer be constant, since binary equivalence cannot be guaranteed at compile-time (counting_pine)
- binary operator overload resolution logic: Now an operator is only eligible if at least one side of the expression matches the candidate's parameter list exactly, without implicit coercion/casting. (cha0s)
- the default aspect ratio for CIRCLE is now 1.0 in SCREENRES modes (counting_pine)
- CIRCLE should get its size from just the horizontal scale of the WINDOW/VIEW viewport - its ratio should be unaffected (counting_pine)
- DIR may now accept a byref [u]integer for out_attrib (byval integer ptrs are still allowed) (counting_pine)
- SCREENLOCK/SCREENUNLOCK now keep a reference count internally to allow them to be used inside functions without unlocking a global lock (DrV)
- linux: only specify linker script path for standalone builds (fixes lib path problems on x86-64) (DrV)
- removed mini.bi, example, and wrapper (jeffm)
- BLOAD now supports 15, 16, and 32-bpp BMP files, alpha in 32-bpp BMP files (BITMAPV4/V5HEADER only), arbitrary BI_BITFIELDS bitfields, and OS/2 BMP files (DrV)

[added]
- #lang directive and $lang metacommand to set compiler dialect from source code (jeffm)
- IMAGEINFO function, for retrieving useful information about FB gfx buffers (counting_pine)
- warning message when string literals aren't closed with a quote (counting_pine)
- C emitter: GOSUB and ON GOSUB using setjmp/longjmp (jeffm)
- "-z gosub-setjmp" command line switch will select setjmp/longjmp implementation even if the backend is ASM (jeffm)
- fblite, qb: OPTION GOSUB, OPTION NOGOSUB to enable/disable GOSUB support. State can be checked with the intrinsic define __FB_OPTION_GOSUB__ (jeffm)
- #1899251 (feature request) - RETURN without GOSUB runtime error check for both ASM and setjmp/longjump implementations of GOSUB (jeffm)
- ANDALSO and ORELSE operators (yetifoot)
- "-R", "-C" switches, to tell FBC to retain the asm and object files (if written), respectively (counting_pine)
- SSE/SSE2 instructions in x86 emitter for floating point math (Bryan Stoeberl)
- "-fpu FPU|SSE" command line switch (Bryan Stoeberl)
- OPTION("FPU|SSE") to specify proc return method (Bryan Stoeberl)
- CPU check for SSE applications (Bryan Stoeberl)
- #1515157 (feature request) - GET# returns number of bytes read in 5th byref parameter (jeffm)
- improved error messages for GET#/PUT# - warn if passing a pointer as source/destination, error if elements is given on string or array (jeffm)

[fixed]
- wstring VAL*s were accepting invalid characters in hex/oct/bin numbers (counting_pine)
- PCOPY wouldn't copy graphics screens higher than the max console page (counting_pine)
- VAL on non-win32 platforms was only accepting 'e' (not 'd') as an exponent specifier (counting_pine)
- VAL* was saturating instead of overflowing large numbers in some cases (counting_pine)
- wstring VAL was truncating hex/oct/bin numbers to 32 bits (counting_pine)
- constant ASC expressions were returning signed integers instead of uintegers (counting_pine)
- STR should pad numbers if and only if it is called from a lang qb module, even in multi-module programs (counting_pine)
- #1933706 - !"\a" was not working correctly (yetifoot)
- #1914051 - Some unhandled escape sequences were being allowed through (yetifoot)
- #1861363 - gfxlib win32 gdi driver was using the alpha_remover_blitter on depths < 32 bits (jeffm)
- #1931922 - lang qb: prototypes for overloaded procdefs were not being added correctly (jeffm)
- lang qb/fblite was allowing dups of unsuffixed variables having different types (jeffm)
- lang qb: LEN() was allowing UDT's and typedef's (jeffm)
- GET/PUT were discounting padding at the end of UDTs (counting_pine)
- escaped strings in unicode sources were crashing the compiler (counting_pine)
- WRITE wouldn't append a comma or newline to empty strings (counting_pine)
- serial driver on linux wasn't handling device names correctly (jeffm)
- #1957281 - PALETTE in Screen 12 should work like in Screen 13 (counting_pine)
- string literals in #defines couldn't contain double-quotes (counting_pine)
- Three-digit decimal escape sequences would swallow the next character if it was decimal as well (counting_pine)
- #1914051 - !"\x..", !"\X.." escape sequences weren't working properly (counting_pine)
- #1961732 - LSET wasn't accepting dereferenced vars for the destination (counting_pine)
- RSET was allowing constants to be modified (counting_pine)
- CPTR() will generate a warning if casting to anything but pointer, integer, or enum and will generate a pedantic warning when casting to anything but pointer (jeffm)
- #2004439 - LSET/RSET was not deleting temporary string descriptors for the destination (jeffm)
- #1914763 - LINE INPUT to a WSTRING variable on an ascii text file was failing if last line of file had no end of line character (jeffm)
- #1979795 - GETMOUSE in Win32 GFX driver was not clearing the status of the XBUTTON's correctly (jeffm)
- #2016487 - inc/win/vfw.bi - Changed "Delete" to "Delete__" and ported the remaining IC* AVI* and MCI* defines (jeffm)
- "TYPE FOO : AS INTEGER BAR : END TYPE" wasn't allowed because a bitfield value was expected to follow "BAR : " (counting_pine)
- Casting ops that called a function (e.g. CSNG("..."), CLNG/CVL ) weren't necessarily returning the exact desired type (counting_pine)
- #1872418 - Win32 GFX updater thread was calling rtlib string conversion unsafely in the non-threaded version of the rtlib (jeffm)
- internal: lang qb/fblite - error recovery for duplicate defs could cause a out of bounds array access in symbGetDefType because the temporary name begins with '.' (jeffm)
- #2038666 - lang qb: variables with the same name as a keyword must have a suffix (jeffm)


Version 0.18.6 Beta:

[fixed]
- re-fixed gfxlib win32 driver calling driver exit routines twice - previous fix was incorrect (jeffm)
- #1999505 - refresh rate after two screenres is always 60 Hz - should be fixed by above, see r5029 (jeffm)
- #1996802 - 2 x screen + screelist = crash - should be fixed by above, see r5029 (jeffm)
- #1968601 - Screenres Fullscreen/Windowed Bug - should be fixed by above, see r5029 (jeffm)


Version 0.18.5 Beta:

[changed]
- fbc when installed to a configured --prefix now uses target directories (jeffm)
- added the --enable-standalone configure switch.  If building for current dos/win32 or to use fbc from inside the development tree, this switch must be used (jeffm)

[added]
- install-standalone.sh for installing the standalone version (jeffm)

[fixed]
- gfxlib win32 driver was calling driver exit routines twice (jeffm)
- included files weren't normalizing slashes before being cached (cha0s)
- install.sh should use "=" for string comparison instead of "==" (jeffm)


Version 0.18.4 Beta:

[changed]
- lang qb: keywords, data types, functions or macros not present in QB can now used by prefixing them with "__" (ie: "dim foo as __byte __ptr") (v1c)
- lang qb: DATA should be allowed inside compound-statements (v1c)
- lang qb: MKI/CVI/CINT now return 16-bit sized results (counting_pine)
- lang qb: PRINT now appends a space when printing numbers (counting_pine)
- lang qb: "IF...THEN REM ...", "IF...THEN : ..." are now single-line statements (counting_pine)
- when finding binutils, fbc checks environment variables, then ./bin/<target>, then (on Linux only) if the sub-program was not found, fbc will invoke the system default (jeffm)
- bug #1881320 - global operators defined within type body have to be disallowed until the feature is properly implemented (cha0s)
- Linux/BSD file structure is now a lot more unix-friendly (cha0s)
- INPUT no longer delimits with space/tab for strings (counting_pine)
- ignore const correctness when passing to varargs, they aren't type safe anyway (jeffm)

[added]
- INSTRREV - feature request #1244607 (jeffm)
- 'ENUM foo EXPLICIT' to allow the enum elements not to be imported to the current namespace (syntax suggested by Pritchard) (v1c)
- CRT function: declare function mkstemp( byval template_ as zstring ptr ) as integer (cha0s)
- SWAP now supports one or more bitfield variables (cha0s)
- placement new: see wiki for details on syntax and usage (cha0s)
- explicit ctor/dtor calling (WIP) (cha0s)
- Statements can now be written directly after multi-line ELSE/ELSEIFs, like in QB (counting_pine)
- fb.GFX_HIGH_PRIORITY flag for SCREEN/SCREENRES (jeffm)
- fb.GET_HIGH_PRIORITY option for SCREENCONTROL (jeffm)
- split bfd.bi by version and add support for binutils 2.18 (DrV)

[fixed]
- lang qb: SLEEP with no arguments not handled correctly in gfx modes (jeffm)
- lang qb: LINE -(x,y) was not being allowed due to parser changes (jeffm)
- lang qb: Allow file.bi and datetime.bi headers (jeffm)
- lang qb: Integer literals outside the range [-32768..32767] were being stored as 16-bit integers (counting_pine)
- lang qb: OPEN not handling COM/LPT device names correctly (jeffm)
- lang qb: #1905669 - DIM'ed variables not initialized at start of procedure (jeffm)
- OPEN COM protocol parser was not handling default parameters (jeffm)
- BLOAD could not use old-style image header when loading BMPs (counting_pine)
- VAR was disregarding the extended type information (like const qualifiers), found by stylin
- variables with const qualifier shouldn't have been accepting ANY as an initializer (cha0s)
- FBC was crashing on invalid data types (e.g. INPUT 1) (counting_pine)
- VALLNG was accepting invalid characters in hex/oct/bin numbers (counting_pine)
- VAL now allows longint-sized hex/bin/oct numbers (counting_pine)
- Many cases of badly-handled numbers in INPUT (counting_pine)
- Faulty logic in optimizing signed integer division by powers of two greater than 1 (counting_pine)
- initialization of a UDT should not invoke its LET operator if no casting is needed (jeffm)
- const qualified data types were not being allowed with null ptr checks (jeffm)
- str was trying to fold const qualified variables (counting_pine)
- INPUT was incorrectly parsing floating-point numbers with the 'd' exponent specifier on non-win32 platforms (jeffm)
- SCREENGLPROC returns NULL (instead of a linker error) if OpenGL support was not compiled in to the gfxlib (jeffm)
- #1877440 - g++ name mangling for const qualifiers (jeffm)
- #1877439 - const qualifier overloading with byref (jeffm)
- #1872532 - fix null pointer access when parsing parameters and allow OVERLOAD in member proc declarations for consistency (jeffm)
- #1876286 - constructor should not take byval arg of parent type as only parameter (jeffm)
- #1891840 - Internal name mangling for function ptrs causing collision (jeffm)
- #1890675 - dereferencing bogus casted expressions would cause a crash (cha0s)
- #1891408 - forward references weren't taking the symbol-to-be-patched's const info into account when backpatching (cha0s)
- #1892194 - gfxlib2 had screen 12 with a 256 color palette, instead of 16 (cha0s)
- assignment of bitfields wasn't ensuring that the assignment wouldn't trash the parent variable, if a number too big was assigned (cha0s)
- #1901102 - operator NEW wasn't working correctly when used directly in the body of a type (not in an explicit constructor) ex: type foo: as integer ptr a = new integer: end type (cha0s)
- #1901924 - INPUTting large numbers to a floating-point were incorrectly allowing integer overflow before being casted to the floating-point type (cha0s)
- #1900852 - bitfields used in variable initializers weren't handled properly (cha0s)
- #1900586 - GET #/PUT # not returning errors for mismatched record lengths with RANDOM mode files or negative record numbers (jeffm)
- #1825178 - reverted: gfxlib (win32 gdi/directx drivers) creates its windows with default thread priority like in 0.17 (jeffm)
- #1865673 - symbols defined inside namespaces that had already been imported were throwing a duplicate definition (cha0s)
- #1905284 - bitfield accessing wasn't always working when the optimizer would remove the field node (cha0s)
- #1890693 - array and UDT initializers in TYPE's (jeffm)
- #1905725 - wrong integer division code when used with implicit/explicit pointers plus constants (v1c)
- #1906004 - fb_PageSet() was testing page requests against console limits, even in gfx mode (cha0s)
- #1909925 - const qualifier with EXTERN should not have been expecting an initializer (jeffm)
- #1919630 - fbc wasn't handling UNC paths on windows (jeffm)


Version 0.18.3 Beta:

[changed]
- lang qb: INTEGER (%) and LONG (&) are now, respectively, 16- and 32-bit wide (v1c)
- lang qb: default numeric literals are now assumed to be INTEGER or SINGLE (v1c)
- lang qb: symbols with the same name as keywords are now allowed: dim left as integer: const dim$ = "" etc (v1c)
- lang qb: all data types and functions/keywords not present in QuickBASIC were removed (v1c)
- allow "3.6e-08f" notation (type specification is accepted after 'e') (cha0s)
- lang qb: SLEEP(n) expects seconds (feature request #1718012) (jeffm)
- lang qb: INKEY$ returns CHR$(0) as the extended character (feature request #1718012) (jeffm)
- PUT ALPHA with alpha paramter = 0 does nothing (DrV)
- update OpenAL (0.0.8) and alut (1.1.0) headers (DrV)
- update OpenAL and alut .def files for Win32 (DrV)
- update ODE (0.9) header and import library (Win32), removed examples/libraries/ode (jeffm)
- CONDWAIT now takes a second parameter, a mutex, and now operates identically to pthread_cond_wait (DrV)
- INSTR( s1, ANY s2) returns 0 if s1="" or s2="" as per documentation (jeffm)

[added]
- CONST qualifiers - feature request #1480621 (v1c and cha0s)
- CONST member procedures (cha0s)
- lang qb: STICK(n) and STRIG(n) functions (jeffm)
- RESET(0|1) procedure to reset stdio handles after redirection (jeffm)
- headers for ogg and vorbis (yetifoot)
- error when NEXT var does not match FOR var (jeffm)
- "-w next" warning when variable is specified after NEXT (jeffm)
- borderless opengl windows on linux (yetifoot)
- allow GFX_NO_FRAME in Win32 OpenGL gfxlib driver (DrV)
- added the VK_A-VK_Z and VK_0-VK_9 scancodes in winuser.bi (yetifoot)
- #1816871 - sizeof() is now usable in asm blocks (yetifoot)
- INSTR( wstring, ANY wstring ) was missing from the rtlib (jeffm)
- rtlib implementation of INSTRREV - (W.I.P.) feature request #1244607 (jeffm)
- First version of COM/serial support for DOS, W.I.P. (jeffm)

[fixed]
- self ops defined as global needed to throw an error - bug #1480621 (cha0s)
- GOTO, GOSUB and RETURN were accepting invalid labels (v1c)
- SCREENLOCK/SCREENUNLOCK is now properly handled by the DOS gfxlib (DrV)
- DOS console SETMOUSE was not scaling the coordinates (DrV)
- parameter type mismatches weren't being caught with bydesc parameters (cha0s)
- more robust solution for solving deadlock on app close if screenlock is called with no screenunlock (cha0s)
- close window fixes in examples (yetifoot)
- mouse_init for linux tty was failing (yetifoot)
- #1815503 - do nothing if radius <= 0 in CIRCLE (yetifoot)
- the stabs information now contains the datatype of the 'data' and 'ptr' fields in dynamic array descriptors (cha0s)
- #1813104 - scancodes for SC_LWIN(&h5b), SC_RWIN(&h5c), SC_MENU(&h5d), are now same in both gfx/console modes and on all platforms (jeffm)
- "TYPE ID AS SUB() AS DATATYPE" was being seen as a function. Syntax check added (jeffm)
- #1856569 - BSAVE to BMP was calculating scan line padding incorectly for 8, 15, and 16 bit depths (jeffm)
- #1825178 - fbgfx/win32 changes thread priority to normal if the gfx window is minimized or inactive, partial fix (jeffm)


Version 0.18.2 Beta:

[changed]
- TYPE's now have default 4 byte field alignment on dos/linux, was 8 byte. (yetifoot)
- fix zstring constructor in libvariant patch by voodooattack (tracker #1750468) (DrV)
- extend 16-bit colors returned from screen function in gfx mode to full 32-bit colors patch by counting_pine (tracker #1726579) (DrV)
- fixes for COLOR function in gfx mode (DrV)
- Return just the foreground color for full-color modes, since both colors can't fit in one 32-bit integer (DrV)
- Upsample 16-bit colors to 32-bit, with opacity, for compatibility with other gfx functions. patch by counting_pine (tracker #1726580) (DrV)
- updated ode headers copyright notice (jeffm)
- examples directory reorganized putting all external library examples in ./examples/libraries/ (v1c)
- replaced "dynamic" with "var-len" terminology in the compiler error messages (jeffm)
- BYTE replaced by UBYTE in the windows headers (v1c)
- fb_ctors/fb_dtors sections removed from *.x linker scripts as they are no longer used (v1c)
- libfb_ctor.c removed, replaced by fbrt0.c (v1c)
- don't use fbrt0.o if the cmm-line option "-nodeflibs" was given (jeffm)
- SCREEN now follows the QB syntax in -lang qb (v1c)
- RND is now 100% compatible with QB in -lang qb mode (patch written by counting_pine)
- ERASE is now compatible with QB, that is when ERASE is called on a variable-length array, the bounds information is reset in addition to the data being destroyed (cha0s)

[added]
- support for multiple assignments: 'LET( foo, bar, ... ) = UDT_expression' (v1c)
- the "windows-ms" mangling support to EXTERN .. END EXTERN, so MS-ish DLL's can be created and used without editing the .def files (v1c)
- the configure script for the compiler now accepts --enable-crosscomp-(target) to choose -target support on all platforms when building fbc (DrV)
- cursor support for INPUT/LINE INPUT in GFX modes (v1c)
- 'PCOPY [srcPg] [, dstPg]' and 'SCREEN [, activePg] [, visiblePg]' for non-graphic, console, screen 0 mode - for DOS and Windows only (v1c)
- SCREEN() (without parameters) will return the current screen pages as: (activePg or (visiblePg shl 8)) (v1c)
- GNU ASpell-0.50 header and import library (jeffm)
- install.sh will copy fbc.1.gz to /usr/share/man/man1/

[fixed]
- #1785162 - math overflows weren't being checked if the floating point #s were the same type (cha0s)
- this was allowed; redim foo( 1 ) as integer: dim as integer bar: dim as integer foo(bar) ''... (cha0s)
- casting overloaded operators were not being checked when initializing variables with incompatible types (v1c)
- #1777001 - array parameters were not being checked for duplicates when DIMming local variable-length arrays (cha0s)
- #1745849 - pascal calling convention was emitting bad asm - regression test added (jeffm)
- #1785469 - was missing extern "c" block in crt/math.bi (DrV)
- #1799517 - VAL() was evaluating out-of-bound characters impromperly in non-base 10 numbers. (cha0s)
- #1790722 - INPUT wasn't prompting with a '?' if no prompt string was given (cha0s)
- REDIM was instantiating objects, even when the array type was a pointer (cha0s)
- bug #1780306 - temporary variables + GOSUB in -lang qb (v1c)
- variables with same names could be redeclared in -lang qb inside compound statements (v1c)
- bug #1738490 - COMMON can't be used with UDT's that have a ctor/dtor (what includes var-len string fields) (v1c)
- bug #1682972a - functions returning UDT's through a hidden 1st arg pointer weren't first initializing the UDT (cha0s)
- bug #1682972b - UDTs with operator let weren't initializing the destination variable first, so if operator let didn't do anything, the variable remained uninitialized (cha0s)
- bug #1720013 - UDTs with operator LET were being allowed to take a byval arg with the same type as the UDT, causing infinite recursion at execution (cha0s)
- bug #1745685 - rtlib functions whose addresses were taken weren't getting their callbacks called, leading to potential linker errors (cha0s)
- bug #1772809 - ERASE wasn't reconstructing fixed-length object arrays after destroying them (cha0s)
- bug #1684966 - temporaries' dtor flushing needs to be delayed when updating typeini nodes (cha0s)
- *cast(zstring ptr, @some_var) = "hello" wasn't working... (cha0s)


Version 0.18.1 Beta:

[changed]
- the default calling convention of variables has changed in -lang FB. UDT's (including strings) will default to BYREF, all else will default to BYVAL (cha0s)
- TYPEs with default constructor/destructors or methods had to be allowed on the module level. This affects you if you define a TYPE inside a function with any functions inside the TYPE, or any child objects that have constructors or destructors. This includes elements 'as string', since they need constructors and destructors to initialize and clean up memory (cha0s)
- ODE 0.8 headers, import library, and examples, thanks D.J.Peters, (jeffm)

[added]
- configure option for --disable-objinfo to allow building and using fbc with a broader range of binutils (jeffm)
- A third parameter to ThreadCreate, you can specify the size of the thread's stack, in bytes (cha0s)
- inc/image_compat.bi, to abstract some of the issues between new/old image formats (cha0s)

[fixed]
- #1735413 - UDT initialization would fail if the initialization expression was surrounded in parenthesis, due to the udt = (elm, elm) syntax. it will now fallback to check if the first expression encountered matches the udt type, if so, it will attempt a ctor call/assign. (cha0s)
- #1734192 - UDT initialization with unions should have been checking the first union element against the given expresssion. (cha0s)
- Mangling params taking FB arrays wasn't unique from params as the array's datatype. Recompile any libraries/linked objects taking arrays as parameters.
- ThreadCreate was accepting literally "any" pointer at its first parameter. Added a mechanism for building function pointer symbols (to check against, say the first arg passed to ThreadCreate) at the rtl symbol initializer. (cha0s)
- #1713886 - symbols in FOR had the temp bit stripped out to make scope jumping work, but it can be added in later, otherwise the branch checker will get confused (cha0s)
- #1696229(part one!) - constant symbols in TYPEs could be modified with disastrous results. (cha0s)


Version 0.18.0 Beta:

[changed]
- include file and import library for libcurl 7.15.4 (jeffm)
- #1723533 - MK* had to be reverted, it will not evaluate constant numeric expressions to constant literal expressions anymore (it will behave like it used to), because of the NULL-terminated nature of literal strings, sorry (CV* still evaluates to constants(arguably much more important ;)) (cha0s)
- the overload resolution wasn't normalizing the total sum of its matching args (cha0s)
- gfxlib creates its windows with THREAD_PRIORITY_ABOVE_NORMAL again, without it was jerky (cha0s)

[added]
- include file and import library for LZO 2.02 (DrV)
- literal conversion overflow warnings (cha0s)
- SETMOUSE now has a 4th parameter, clip, which allows restricting the mouse pointer to the graphics window; GETMOUSE now has a 5th parameter, clip, to retrieve the current mouse clipping status
  IMPORTANT: this is a binary incompatible change - you must recompile any code that uses SETMOUSE or GETMOUSE (DrV)
- a vararg procedure can now be defined in a TYPE, it has to be unique (cha0s)
- a second STEP in PUT, see the wiki for details (cha0s)

[fixed]
- the #include once and #pragma once PP directives weren't fully solving the paths of their include files (cha0s)
- overloaded property resolution was failing (cha0s)
- nehe/data/font.tga was missing half the characters (jeffm)
- #1716570 - bit positions of bitfields shouldn't advance in a UNION (jeffm)
- PUT would crash with a null pointer for a source (cha0s)
- TYPEOF would crash when handling an array with an index expression (cha0s)
- #1696394 - default colors for GFX primitives were being set using the wrong target bpp (jeffm)
- #1711210 - there was a deadlock when an app ended when the screen was locked (cha0s)
- #1726019 - converting a constant floating-point to an unsigned integer was incorrect (cha0s)
- #1680718 - local variables were being allowed with static and shared initializers (jeffm)
- the 'elements' arg on get/put wasn't being checked for validity, causing internal width multiplication to fail on all but numeric types(cha0s)
- "as ANY" as being allowed on TYPE members(cha0s)
- bogus field accesses should have been creating a fake symbol (cha0s)
- gfxlib wasn't waiting long enough when preventing a potential deadlock, causing deinitialization to fail (and crappy graphics consequences) (cha0s)


Version 0.17 Beta:

[changed]
- see the migrating.txt file for the list of changes because the new -lang command-line option (v1c)
- #undef can't remove symbols defined inside namespaces anymore, to allow namespace redefinition to work (v1c)
- calling "SCREEN 0" now causes an 80x25 text mode to be set and cleared by default (lillo)
- the pre-processor keywords aren't reserved words anymore (v1c)
- because the above change, $inclib and $libpath were removed, use #inclib and #libpath instead (v1c)
- OpenGL option flags to SCREEN (GFX_STENCIL_BUFFER and GFX_ACCUMULATION_BUFFER from fbgfx.bi) have changed their value
  to make room for new common flags at smaller digits (lillo)
- the CUSTOM PUT mode now accepts one more parameter to be passed to the blender function, which now must have the form:
  function blender(byval src as uinteger, byval dest as uinteger, byval param as any ptr) as uinteger
- GETJOYSTICK now supports up to 8 axis and on win32 returns POV as axis 7 and 8. (jeffm)
- main GFX window on win32 captures mouse input to allow out of window mouse button releases (jeffm)
- the arguments passed to overloaded functions that contain enum parameters must be enum's too, no auto-coercion will
  be done from integer/floating-point, to support operator overloading (v1c)
- the STATIC attribute when used in the left-side of function declarations was removed, it will only accepted at the right-side, as in QB, to allow STATIC to be used with class methods later (v1v)
- symbols declared inside namespaces using keyword names (like INPUT, PRINT, etc) are now allowed (v1c)
- even with an explicit alias, symbols will be mangled if declared inside a namespace (v1c)
- thread*, cond* and mutex* ids are now "any ptr", not integers, to allow easy and safe migration to 64-bit platforms in future (v1c)
- string fields in UDT's are now pseudo-objects, with that change, UDT's containing those fields can only be initialized if a 
  constructor is explicitly defined (v1c)
- pointers to z|wtrings can't be passed byval to string params directly anymore, dereference them first (v1c)
- pointers to byte|ubyte arrays can't be passed byval to string params directly anymore, use type casting (v1c)
- offsetof() can now be used inside inline asm blocks - the patch was sent by cha0s (v1c)
- all file functions can now use 64-bit offsets (DrV)
- the GET/PUT image buffers now support an extended header which takes the first 32 bytes of a buffer. GET and IMAGECREATE
  create images with this new header, while all primitives support both this and the old-style 4 bytes header (lillo)
- thanks to the new GET/PUT header, pixel data now starts at offset 32 and pixel rows are paragraph-aligned (the pitch of
  a row will always be a multiple of 16 bytes)
- the Lua headers were replaced by machine-translated ones, some function/macro names were changed by the Lua authors since the last version;
  also, the luauxlib.bi header was renamed to lauxlib.bi to match the original C one (v1c)
- SetDate and SetTime now return an error when they fail (DrV)
- internal profiler removed, profiling is now done externally using GPROF (jeffm)
- -lang qb now skips UDT alignment by default (cha0s)
- DATA can't be declared inside procs anymore (as in QB) (v1c)
- there are no more limits in the number of arguments and files that can be passed in the command-line (v1c)
- EXEC in dos and linux now parses arguments like in windows and with no hardcoded limits on the allowable number of arguments (jeffm)
- LOCATE will now accept a full 5 args to be compatible with QB, however the final 2 args have no effect (cha0s)
- STR will now pad positive numbers with a single space, as in QB, but ONLY if -lang qb is used (cha0s)
- ACOS(), ASIN(), LOG(), EXP(), SGN() and FIX() are now inlined (v1c)
- OPEN now is more compatible with QB, the file/device is parsed at runtime (cha0s)
- MK* and CV* will now evaluate constant expressions at compile-time (cha0s)
- TYPE() now supports intrinsic types, as well as UDT's. (cha0s)
- Addition, subtraction, multiplication, and both types of division can now be done at the preprocessor (cha0s)
- THREADCREATE and thread procedures now take ANY PTR parameters instead of INTEGER (DrV)

[added]
- the -lang command-line option, to allow language compatibility without keeping FB from progress, see the migrating.txt file (v1c)
- operator overloading in UDT's (TYPE's and ENUM's) (W.I.P.) (v1c)
- constructor and destructor support in UDT's (TYPE's) (v1c)
- method support in UDT's (TYPE's) (v1c)
- properties in UDT's (TYPE's) (v1c)
- #macro .. #endmacro, to better support multi-line pre-processor defines (v1c)
- TYPE's, UNION's, ENUM's and typedefs can now be declared inside functions and scope blocks (v1c)
- auto-scanning for libraries and object files when linking, the #inclib's and #libpath's are now stored in the object files ala in VC++ (v1c)
- FileCopy, FileAttr, and FileLen VB-compatability functions (DrV)
- the __FB_DEBUG__ define, that is set to TRUE (-1) if in debug mode (if the -g option was used), FALSE (0) otherwise (v1c)
- field access can now be used with PEEK, like in: PEEK( some_type, some_int ).some_field (v1c)
- the #line number [, "filename"] pre-processor directive, works as in C (v1c)
- the GFX_NO_FRAME flag to SCREEN, to create a frameless window (lillo)
- the GFX_SHAPED_WINDOW flag to SCREEN, to create a custom shaped window. Produces the same as frameless window, but drawing
  transparent pixels causes the corresponding portion of the window to be transparent too (lillo)
- the __FB_ERR__ define, set to 1, 3, 7, if one of the -e, -ex or -exx cmd-line options was passed, respectively (v1c)
- Win32 GDI gfxlib driver now supports fullscreen (lillo)
- the ADD drawing mode to PUT and DRAW STRING, allowing additive blending; works in hi/truecolor modes only (lillo)
- namespace nesting, as in .net: namespace foo.bar.baz : end namespace (v1c)
- the FileDateTime function to the extended run-time library (it returns a serial, not a string like in VB) (v1c)
- CUnit (unit testing framework) headers, static library and examples (v1c)
- linear VESA gfx driver for DOS (DrV)
- support for typedefs in fixed-len string declarations (v1c)
- the __FILE_NQ__ and __FUNCTION_NQ__ intrinsic defines, same as __FILE__ and __FUNCTION__, but without double-quotes (v1c)
- ISDATE function in rtlibx (jeffm)
- serial device support in Linux, written by Jose Manuel Postigo (v1c)
- the __PATH__ intrinsic define, that returns the __FILE__'s path - the patch was sent by cha0s (v1c)
- byval structs returned in registers can now be passed byref to other functions (v1c)
- all gfx primitives can now respect the alpha channel; just init the screen with the new GFX_ALPHA_PRIMITIVES flag (&h20) (lillo)
- the SCREENEVENT function, to retrieve system events. Notifications include mouse and keyboard activity, window focus changes, and more. See
  new example in examples/gfx/fbgfx_events.bas for more info. fbgfx.bi has been updated with the EVENT structure and known event IDs (lillo)
- the GDI+ headers, import library and examples (v1c)
- the SCREENCONTROL function, to set/get internal gfxlib states. See fbgfx.bi for a list of accepted parameters (lillo)
- Gfxlib now supports window positioning; just call "SCREENCONTROL SET_WINDOW_POS, x, y" (use GET_WINDOW_POS to retrieve current position) (lillo)
- Module CONSTRUCTOR/DESTRUCTOR support priority attributes 101-65535 (jeffm)
- the GFX_MULTISAMPLE flag to SCREEN, to enable fullscreen antialiasing while in OpenGL mode via the ARB_multisample extension (lillo)
- the GFX_ALWAYS_ON_TOP flag to SCREEN, to let the program window stay always on top (lillo)
- FOR [var] AS [type] = 0 to ... variable dimensioning within FOR statements (cha0s)
- UDT's can now return a boolean result, if operator cast() was overloaded (cha0s)
- BLOAD and BSAVE can now accept an additional optional final parameter: a pointer to an array of 256 integers to hold the image palette if any (lillo)
- FOR now supports UDT's as counter variables, if operator let, +=, and global <=, >= are overloaded with operators taking numeric rhs. (cha0s)
- the PRIVATE and PUBLIC attributes for members/methods of TYPE's (cha0s)
- the JNI (Java Native Interface) header, import library and example (v1c)
- the cairo (Multi-platform 2D graphics library) headers, import library and example (v1c)
- all Gfxlib drawing functions can now successfully work on buffers using a depth different than the current one (lillo)
- using PUT to draw an 8bpp sprite on top of a 32bpp one with ALPHA drawing mode will cause the source to be set as the dest alpha channel (lillo)
- the FRAC() inline function, that returns the fractional part of a floating-point number (v1c)
- the VAR keyword, which allows type inferrence from initializers (think DIM without AS) ex: var foo = "hello", bar = 2.4 (cha0s)
- multiple EXIT and CONTINUE levels support (EXIT FOR, FOR or CONTINUE DO, DO, DO, etc) (v1c)
- the __FB_BUILD_DATE__, __FB_BUILD_TIME__, and __FB_BUILD_SIGNATURE__ intrinsic defines, see wiki for details. (cha0s)
- DyLibSymbol is now overloaded; it can take a short as the second arg, to specify the proc's ordinal. Patch by voodooattack
- the TYPEOF() compiler intrinsic, which substitues the type of the variable given in it's place, "dim as typeof(foo) bar"... see 
  http://www.freebasic.net/wiki/wikka.php?wakka=KeyPgTypeof for details (cha0s)
- the win32 DirectX gfx driver will now go fullscreen on the nearest monitor when the user presses Alt-Enter/maximize (DrV)

[fixed]
- premature optimization in bitfields when converting to a signed integer type (v1c)
- the case of the aliases of extern dynamic arrays was not been preserved (v1c)
- moving mouse out of program window and back onto it used to reset mouse buttons status as reported by GETMOUSE (lillo)
- while drawing arcs with CIRCLE, the bottom line of the affected display pixels could not have been updated occasionally (lillo)
- linux framebuffer device gfx driver now successfully restores original gfx mode on exit (lillo)
- removed spurious keypresses reported in INKEY$ when switching terminals while in framebuffer gfx mode (lillo)
- when mangling parameter-less C++ functions, the void (v) type was missing (v1c)
- implicit variables with the same name as UDT's were not been allowed (v1c)
- namespace symbols were been allowed in expressions (v1c)
- PRINT for wstrings was not using wide-chars when padding or printing a new-line (v1c)
- when PRINTing wstrings to a redirected output in Win32, the wide-string was only partially printed (v1c)
- namespaces when redefined were not updating the imported (USING) list used in other namespaces (v1c)
- arrays with more than 2 dimensions couldn't be initialized (v1c)
- DIR() under Linux was not working correctly (lillo)
- Exiting from a gfx program now does not cause console clearing anymore under Linux (lillo)
- literal wide-string arguments passed to byref var-len string parameters were not creating a temporary string descriptor (v1c)
- comparing a NULL string pointer to an empty string was not returning equal (v1c)
- static/global variables not accessed outside the asm block wouldn't not be emitted (v1c)
- the "= any" initializer was not working with UDT's - they were always cleared (v1c)
- the string concat operator (&) had a different precedence order than in VB (v1c)
- names of non-shared COMMON variables were not been preserved (v1c)
- field arrays of function pointers were not correctly parsed (v1c)
- #define's parameters weren't checked for duplicated definitions (v1c)
- concatenating a wstring literal and a var-len string variable was causing an ICE (v1c)
- when the FORMAT()'s string has no exponent part, the fraction shouldn't be scaled up (v1c)
- CIRCLE had precision problems when deailing with large coordinates and radius values (lillo)
- debugging info for local static variables that were never referenced was been emitted (v1c)
- functions with forward types parameters were been incorrectly mangled (v1c)
- SWAP with bitfields was been allowed (v1c)
- mangling of symbols declared inside nested namespaces (v1c)
- string indexing was being allowed with functions (v1c)
- file size calculation in text-mode, EOF() should always work in text-mode now (v1c)
- empty literal strings couldn't be used with stringize'd macro params (v1c)
- DOS ISR and gfxlib were calling the DPMI memory locking service incorrectly (DrV)
- BLOAD/BSAVE did not support automatic path separator conversion for cross-platform compatibility (lillo)
- the function type was being checked before the overloading resolution, causing overloaded SUB's and FUNCTION's when mixed to fail (v1c)
- SUB pointers returned by functions couldn't be directly dereferenced (v1c)
- quirk string functions were refusing invalid types without reporting the errors (v1c)
- RETURN could be used in functions without returning any expression (v1c)
- lvalue op= rhs had side-effects if functions were present in lvalue (v1c)
- (*udtptr).field wasn't allowed (v1c)
- pointers were being allowed as array indexes (v1c)
- Linux X11 gfx driver kept the program window hidden when starting in fullscreen mode (lillo)
- 'DRAW "X" & @cmd' did reset coordinates before executing cmd to the starting position before running the whole DRAW statement (lillo)
- padding of UDT's was incorrect if only byte and/or short fields were present (v1c)
- High-intensity background colors are now enabled in Linux console, but only inside an xterm (lillo)
- Console was still cleared when exiting a gfx mode on certain terminals under Linux (lillo)
- Serial driver on windows was not setting DTR high when opening the device (jeffm)
- Serial driver on windows was ignoring RB/TB buffer size parameters (jeffm)
- DOS gfxlib always failed when no mouse was detected (DrV)
- Win32 GDI driver did not use a custom palette in fullscreen mode, and was giving approximated colors (lillo)
- static arrays with lower bounds <> 0 would fail when passed as index-less arguments to quirk gfx statements (cha0s)
- fb_GfxGet was using the array descriptor's 'ptr' field to assert the validity of the data, instead of the 'data' field (cha0s)
- arrays with lbounds <> 0 passed as args or dynamic would fail in quirk gfx functions (cha0s)
- there is no more special color value to flag default color in COLOR and gfx primitives, resulting in no more "hole" in supported colors range (lillo)
- DirectDraw surface restoring was bugged, resulting in crashes if another DirectX-based program entered fullscreen (lillo)
- KILL was always returning 0 (DrV)
- DIR on DOS now only returns files/directories with the attributes specified (DrV)
- the BIT, BITSET, BITRESET macros now use TYPEOF() to determine the variable type when accessing. (cha0s)
- the quotes of literal strings were not being preserved when used inside #IF expressions (v1c)
- symbols were case-sensitive when compared inside #IF expressions (v1c)
- ulongints were being improperly seen as pointers since the bottom 32-bits were 0 and they were only being checked as the native integer type(thanks counting_pine) (cha0s)
- ulongints would qualify as pointers if they were completely 0, a check had to be added for native pointer width equivalence.(cha0s)
- palette would access invalid memory if the index given was >= maximum palette indices. (cha0s)
- CVS, CVD weren't using floats internally, CVLONGINT wasn't using a longint internally (cha0s)


Version 0.16 Beta:

[changed]
- IMPORTANT: the NOT unary operator behavior in conditional statements is now fully compatible with QB/VB (ie: always
  bitwise, never logical), see the migrating.txt file for more details (v1c)
- IMPORTANT: every compound statement (IF, FOR, etc) will now open a new scope block, see the migrating.txt file (v1c)
- any non-SHARED, COMMON or EXTERN variable and array declared in the module-level (ie, outside any function) will be
  allocated on stack now (that was changed to allow non-constant expressions to be used with variable initializers in
  the module-level), to declare static symbols, see the next item (v1c)
- STATIC can now be used in the module-level too (v1c)
- local arrays with unknown dimensions (ie: DIM array()) can now be declared inside functions too (v1c)
- floating-point literal numbers in scientific notation without an integer and fractional part cannot be written as
  ".E###" anymore, they must be changed to "0.E###" due ambiguities with macro substituions and .'s been used in WITH
  and (later) to access objects' member fields (v1c)
- internal symbols mangling, if using DLL's that contain exported variables or overloaded functions and that were
  compiled by older versions, rebuilt the DLL's also (v1c)
- when aborting because run-time errors, the name of the module that caused the error will be printed too (v1c)
- runtime error checking removed from getmouse() and getjoystick() (v1c)
- the size of argument-less #defines and macro expansion texts can be now up to 2GB (v1c)
- parentheses ()'s aren't anymore optional with arg-less macros, to allow them to be passed as parameters to other macros (v1c)
- GOSUB and ON expr GOSUB cannot be used inside SUB's/FUNCTION's anymore (GOTO will be always allowed), RETURN without
  expression can now be used as a shortcut to EXIT SUB|FUNCTION (v1c)
- UDT parameters (TYPE's) can now be optional too (v1c)
- any complex expression can be used in optional parameters, not constants only (v1c)
- duplicated definitions of type aliases with exactly the same target types are now allowed (v1c)
- the OpenGL extensions header was replaced by a machine translated one (v1c)
- UDT's (TYPE's and UNION's) can have the same name as keywords (v1c)
- Dir()'s "attribute" parameter by default shouldn't include directories, hidden or system files (v1c)
- INPUT will now accept floating-point numbers loaded to integer types, rounding them as in QB (v1c)
- maximum number of array dimensions changed to 8 to speed up allocation of arrays with unknown dimensions (v1c)
- more restrict pointer resolution in overloaded functions (v1c)
- the Allegro headers were replaced by machine translated ones, END_OF_MAIN() must be used now in Linux (v1c)
- bad compound statements are better handled now, new-lines won't be ignored anymore neither multiple error
  messages will be shown (v1c)
- for CONST's with explicit types, no inference will be done, the r-side values will be converted instead (v1c)
- the GLFW include file was retranslated using the latest C header (v1c)
- PRINT in Linux won't convert characters over 127 to UTF-8, allowing UTF-8 string to be printed too (v1c)

[added]
- name spaces blocks (NAMESPACE ID ... END NAMESPACE), that can be nested, imported, etc (v1c)
- extern blocks (EXTERN "MANGLING_SPEC" LIB "LIB_NAME" ... END EXTERN), to better support libraries written in
  different languages than BASIC or C (C++ for example) (v1c)
- anonymous UDT's that can be passed as parameters or used in assignments, like:
  "foo TYPE(1,2)" where foo was declared as "foo([mode] p as bar)" (v1c)
- TYPE<symbol>(...) to allow anonymous UDT's to be passed to overloaded functions (v1c)
- non-fatal error handling, the parser won't exit unless #-errors happened, making it easier to port
  sources from different languages to FB and to work with large projects (v1c)
- the -maxerr command-line option, to define after how many errors the parser should stop (v1c)
- the "= any" variable initializer, that tells the compiler to not clear the local symbol (v1c)
- support for the optional "digits" argument in HEX(), OCT() and BIN() (and their wide-char versions) (v1c)
- the -include command-line option, to pre-include headers in every source file (.bas) that will be compiled (v1c)
- Linux framebuffer console gfx driver (lillo)
- warning message when allocating implicitly a variable inside an expression (v1c)
- DRAW STRING statement, to draw text in gfx mode at pixel perfect positions; supports default as well as custom fonts (lillo)
- the curses.bi header compatible with ncurses (v1c)
- over 30 Gtk tutorials translated from C by Claudio Tinivella (v1c)
- AVI-capture missing symbols to the vfw.bi Windows API header (v1c)
- new prototypes to the Newton header (v1c)
- better duplicated definition check when implicitly allocating variables whose names contain periods, inside functions that return UDT's (v1c)
- libPNG import library and include file (v1c)
- libJPEG import library and include file (v1c)
- gif_lib import library and include file (v1c)
- ImageConvertRow, to convert between different color depths (v1c)
- import library and include file for the Curl library (v1c)
- an optional out_attrib parameter to Dir(), that returns the attributes of the file matched (v1c)
- the __FB_OPTION_EXPLICIT__, __FB_OPTION_ESCAPE__, __FB_OPTION_DYNAMIC__, __FB_OPTION_PRIVATE__, __FB_OPTION_BYVAL__ defines,
  that are set to TRUE (-1) if the respective OPTION was used, FALSE (0) otherwise (v1c)
- DirectPlay headers from the DirectX SDK (v1c)
- DirectMusic headers from the DirectX SDK (v1c)
- DirectShow headers from the DirectX SDK (v1c)
- the ZSTRING and WSTRING types without PTR's can now be used in TYPE aliases (v1c)
- the $ prefix for literal strings, to not process escape sequencies when Option Escape is been used (v1c)
- literal strings can be concatenated just by grouping them, without using + or & (v1c)
- EXIT SELECT, to exit CASE blocks without resorting to GOTO's (v1c)
- the __FB_OUT_EXE__, __FB_OUT_DLL__, __FB_OUT_LIB__, __FB_OUT_OBJ__ defines, that are set to TRUE (-1) depending on the
  output format (Executable, Shared library, Static library or Object file) select when compiling (v1c)
- overloaded unsigned versions (ubyte, ushort, uinteger and ulongint) of INPUT (v1c)
- CONST AS SymbolType foo, bar, ... (v1c)
- ENUM's can now be used in explicitly typed CONST's (v1c)
- ENUM elements can now be referenced as: enumid.elmentid (v1c)
- spidermonkey (a JavaScript embedded interpreter) headers and import library (v1c)
- multi-line comments: /' this is a comment '/ (v1c)
- the erfn and ermn to retrieve respectively the function and module name when a runtime error occur (v1c)

[fixed]
- INPUT from console when it's been redirected (v1c)
- "any ptr"'s weren't been taken as "byte ptr"'s when pointer arithmetics were used (v1c)
- using the -exx option with too complex expressions in src files with too many functions would generate bad code (v1c)
- PUT ALPHA had a problem with sprites having an odd width (lillo)
- if the size of the destine string was unknown when assigning an ASCII to a WSTRING string, nothing would be copied (v1c)
- bitfields couldn't be used in SELECT CASE (v1c)
- address of null pointers couldn't be taken if sources were compiled with null-pointer checking on (-exx) (v1c)
- SETDATE string to integer conversion was incorrect, making it always fail (DrV)
- the default type in PEEK and POKE should be unsigned byte, not signed (v1c)
- shifting 64-bit integer operands by constants above 32 were generating wrong code (v1c)
- doing integer-only operations like \ mixing 64-bit integers and floating-point operands would generate bad code (v1c)
- suffixes (%, #, etc) were not been preserved in argument-less #defines (v1c)
- NOT couldn't be used in pre-processor directives if ()'s were present (v1c)
- w- and z-strings were been allowed in IIF() (v1c)
- GFX PUT's CUSTOM callback couldn't be a pointer (v1c)
- INPUT in Win32 was not printing the message to console (v1c)
- resource files were not been passed inside quotes to GoRC (v1c)
- __FILE__ couldn't be used in anything but Linux if it had a path and OPTION ESCAPE was on due the \'s (v1c)
- anonymous UDT's (TYPE(...)) couldn't be used when setting function results (v1c)
- assignment of different UDT types were been allowed (v1c)
- power-of-2 MOD to AND optimizations can't be done in signed types without checks at runtime (v1c)
- field dereference couldn't be used with CAST( ... ptr, ... ) (v1c)
- INPUT$(n) was crashing when reading from console (v1c)
- PAINT was crashing if using a buffer as target with a height bigger than the screen mode used (v1c)
- debugging UDT fields wasn't been possible, all offsets were passed as 0 to GDB (v1c)
- spilling byte registers would cause wrong code to be emitted in some cases (v1c)
- profiling functions were been called inside destructors (v1c)
- another PRINT USING fixes (v1c)
- LINE INPUT # had a memory leak (v1c)
- precision when converting doubles to strings was one digit too low causing problem with 64-bit int consts assigned to floats (v1c)
- default drawing scale for DRAW statement is now as in QB 4.5; also fixed relative M command parsing (lillo)
- calling void function pointers in expressions was been allowed (v1c)
- passing GFX_NO_SWITCH to SCREEN resulted in a program freeze when using the DirectX gfx driver (lillo)
- styled box drawing was mistakenly not implemented (lillo)
- DRAW and WINDOWTITLE crashed the application if called with an empty string variable (lillo)
- specifying a border color to VIEW in gfx mode had no effect (lillo)
- MID statement (not the function) for wide-strings was not passing the size of the destine string (v1c)
- wide-string indexing was not multiplying the index expression by sizeof( wchar ) (v1c)
- bitfields declared inside unions had wrong offsets (v1c)
- INKEY did not report extended ascii characters under Linux X11 gfx mode (lillo)
- overflow could happen if assigning an asc string to a too small fixed-len wide string (v1c)
- PAINT crashed when used against target buffers smaller than the screen (lillo)
- FORMAT: infinite loop when rounding; too big (over 2^63) or too small numbers weren't converted correctly (v1c)
- PRINTing wide-strings in Linux with characters above 127 was given incorrect results (v1c)
- text-mode's (SCREEN 0) width wasn't been restored when SCREEN was previously in a GFX mode, causing problems with PRINT (v1c)
- the number of arguments passed to macros wasn't been checked (v1c)
- enum's were not been allowed in CAST( DataType PTR, ... ) (v1c)
- external libraries were not been passed to LD when linking shared libraries in Linux (v1c)
- "end if" was missing in ASSERT and ASSERTWARN, they couldn't be used before statement separators :'s (v1c)
- converting unsigned constants to strings at compile-time was returning the numbers in signed form (v1c)
- type aliases to themselves were case sensitive, causing forward symbols to be created if cases were different (v1c)
- descriptors of local dynamic arrays with unknown dimensions weren't been reseted (v1c)
- non-pointer arguments were been coerced when passed to pointer parameters (v1c)
- changing string constants was been allowed (v1c)
- WRITE was outputing floating-point numbers around quotes (v1c)
- non-decimal 64-bit literal constants were been sign-extended from 32-bit if below 2^32 (v1c)
- bit-fields accessed inside private functions would cause errors (v1c)
- the level of indirection of UDT params was not been take into account when creating mangled names for function pointers (v1c)
- stack was been wrongly poped in some cases of DIV and MOD of integers (v1c)
- resolution of overloaded function pointer arguments were not working (v1c)
- byte and short var-args were not been converted to integers (v1c)
- fixed-len string arguments passed to var-length string parameters were not been updated correctly (v1c)


Version 0.15 Beta:

[changed]
- IMPORTANT: all the Windows API headers (under inc/win) were re-translated using the h2bi
  tool, the old sources are NOT compatible with those headers because the new ones use the
  C-like standard (pointers instead of BYREF arguments, etc). If you really want to still
  using the old headers, remove the inc/win dir and copy the old one over it - the old
  headers won't be anymore updated though (v1c)
- alignament and padding of UDT's (TYPE's and UNION's) now fully follow the GCC 3.x ABI,
  if DLL's were compiled with older versions and UDT's are passed by argument or returned
  from functions, recompile the libraries if clients will be compiled with this version
- LOCATE/CLS/WIDTH/SCREEN are now window-local (left/top of window = 1/1) on Win32 (mjs)
- VAL64 function renamed to VALLNG as longint's can be wider than 64 bits in future ports (v1c)
- WITH can now accept dereferenced pointers as argument and the depth became unlimited (v1c)
- Linux version can now be installed in any directory (lillo)
- DATA can now be used inside functions too (mjs)
- duplicated EXTERN's are now accepted if they have the same type (v1c)
- the depth of nested anonymous inner TYPE's and UNION's is now unlimited (v1c)
- the function names won't be anymore preserved if only LIB is used, an ALIAS must be present now (v1c)
- IF THEN followed by a statement separator (':') will be seen as a multi-line IF now, so END IF is obligatory (v1c)
- non-shared or public variables declared on module-level (outside any proc) will be now show as LOCAL in GDB/Insight (v1c)
- level of indirection checking when assigning or passing pointers (v1c)
- All DOS console I/O now depends on BIOS or direct memory access (mjs)
- libfb_gfx_data.c is now created from the "original" data files (mjs)
- speed-up of DOS console output due to direct memory accesses (mjs)
- The "CLOSE WINDOW" key code is now changed to ALT+F4 (mjs)
- all SDL headers were exchanged by machine translated ones (v1c)
- the BASS and BASSMOD headers were exchanged by machine translated ones (v1c)

[added]
- the WSTRING type, for unicode strings - like ZSTRING's, they can't be variable-length (v1c)
- UTF-8, UTF-16LE, UTF-16BE, UTF-32LE and UTF-32BE support for source and headers files
  (they can be freely mixed, also with ASCII files) (v1c)
- OPEN CONS, OPEN LPT, OPEN ERR, OPEN PIPE (OPEN "PIPE:" won't work), OPEN SCRN (mjs)
- the ENCODING "fmt" option to OPEN, when mode is INPUT, OUTPUT or APPEND, the "fmt" can be:
  "utf-8", "utf-16", "utf-32" or "ascii" (v1c)
- LPRINT support (mjs)
- LPOS(n) (mjs)
- include files for the DirectX library: DInput, DSound, DDraw, D3D, D3DX, D3DRM, D3D9 and D3DX9 (v1c)
- the missing macros in the Gtk headers (v1c)
- VIEW PRINT() now returns the top and bottom row (mjs)
- all WIDTH variations (with #filenum, LPRINT, and device$) (mjs)
- VALUINT and VALULNG, unsigned versions of VALINT and VALLNG, respectively (v1c)
- IN/OUT/WAIT now work for real ports I/O; a runtime error is triggered if unable to access a port.
  VGA ports are still emulated if in gfx mode (lillo)
- new null gfx driver: pass -1 as flags parameter to SCREEN to work with gfx without visual feedback.
  Useful to produce gfx to be embedded in OS dependent contexts (GDI, Gtk, etc.) (lillo)
- PUT now supports specifying a sub area of the source buffer to be drawn. Use the new syntax:
  PUT [dest,] [STEP](x,y), source [,(x1,y1)-(x2,y2)] [,mode [,(alpha|blender)]] (lillo)
- INSTR([n,] s$, ANY p$) (mjs)
- RTRIM$(s$[, ANY p$]) and RTRIM$(s$, p$) (mjs)
- LTRIM$(s$[, ANY p$]) and LTRIM$(s$, p$) (mjs)
- TRIM$(s$[, ANY p$]) and TRIM$(s$, p$) (mjs)
- compile-time check for math overflow in literal numbers when assigned or passed as parameter (v1c)
- compiler is now much more strict at reporting implicit numeric conversions (lillo)
- programs compiled with -e will check if the host CPU is at least the one specified in -arch (lillo)
- FB extension library, the list of functions includes:
  DATESERIAL, DATEVALUE, YEAR, MONTH, DAY, WEEKDAY, TIMESERIAL, TIMEVALUE, HOUR, MINUTE,
  SECOND, NOW, MONTHNAME, WEEKDAYNAME, DATEADD, DATEPART, DATEDIFF,
  FORMAT (mjs)
- the & operator, allowing to concatenate strings, automatically converting types to string if needed (lillo)
- basic CYGWIN port (mjs)
- the SCOPE .. END SCOPE compound statement, to create inner symbol scopes in main-module or inside functions or macros (v1c)
- the __FB_MAIN__ define, set when the main-module is been parsed (could also be used to unit-test libraries) (v1c)
- you can OR the &h4 value (GFX_NO_SWITCH constant from fbgfx.bi) to the forth SCREEN parameter (flags) to prevent
  user from switching fullscreen/windowed via maximize button or ALT-Enter (lillo)
- OPEN COM for Win32 (mjs)
- QB-compatible POS(n) is now allowed too (mjs)
- SQLite static library for DOS (DrV)
- stack size (-t) parameter for DOS (DrV)
- CLS 2, VIEW PRINT, LINE INPUT and SCREEN(y,x,colorflag) are now supported in graphics mode (mjs)
- ALT+NumKeys works in Win32 console mode (mjs)
- "CLOSE WINDOW" key code (ALT+F4) now works in Win32 console too (mjs)
- "deep sleep" (i.e. sleep that cannot be interrupted by key press, use with SLEEP msecs, 1 (mjs)
- parameters passed by descriptor to overloaded functions are now supported (v1c)
- support for SCREEN 1, 2, 9, 10, 11, and 12 for DOS (mjs)
- support for printing to GDI printers on Win32 (mjs)
- C### (CINT, CDBL, etc) can now be used with strings, as in VB (v1c)
- include file and import-lib for the FreeType2 library (v1c)
- WSTR() to convert any standard type (including ASCII strings) to wide-strings (the wstring type) (v1c)
- WSTRING() function, same as STRING() but returns a wstring (v1c)
- WCHR() function, same as CHR(), but returns a wstring (v1c)
- WHEX(), WOCT() and WBIN() function same as HEX(), OCT() and BIN() respectivelly, but return wstrings (v1c)
- WSPACE() function, same as SPACE(), but returns a wstring (v1c)
- WINPUT() function, same as INPUT(), but returns a wstring (v1c)
- support for multiple typedef declarations and the inverse notation "TYPE AS DataType (Symbol ',')+" (v1c)
- source-level debugging support for inline assembly blocks (v1c)
- the CAST() intrinsic function: "CAST( DataType, Expression )" (v1c)
- include file and import-lib for the Expat XML-parsing library (v1c)
- include file for the DISLIN library (v1c)
- DOS VESA gfxlib driver (DrV)

[fixed]
- main modules with periods (.) in their names would generate executables w/o the file extensions (v1c)
- "? " was never printer for LINE INPUT ""; a$ (mjs)
- INPUT$(n) doesn't wait for a complete line any more (mjs)
- WIDTH on Win32 returned a bad mix of Window/Screen buffer values (mjs)
- the PAD problem for PRINT (mjs)
- array fields were not been checked for wrong number of dimensions (v1c)
- ##arg## was not working if white-spaces were around the macro argument (v1c)
- the VALINT and VAL64 functions were saturating unsigned integers in DOS and Linux, making the compiler
  for those versions to process wrongly unsigned integer literals above 2^31 (v1c)
- comparing a null zstring to null var-len string would not return equal (v1c)
- WIDTH in gfx mode was returning the width/height in pixels instead of character cells (lillo)
- INSTR can now handle strings with NULs - using a Boyer-Moore implementation (mjs)
- apps using the multithreaded rtlib under Linux were crashing on exit (lillo)
- module names were not been checked causing errors if invalid symbol characters were used (v1c)
- unsigned short multiplications would leave the stack unpoped if a specific register wasn't free (v1c)
- packed local non-static arrays of UDT's of sizes 3, 5 or 9 would generate bad indexes when referenced (v1c)
- console programs running in vanilla Linux console were ignoring break condition (CTRL-C) (lillo)
- INPUT in plain Linux console mode was entering infinite loop if certain keys were pressed (lillo)
- BLOAD did not load 32bit BMP files correctly (lillo)
- TIMER was returning ticks since the application started in DOS (v1c)
- INCLUDE for files INCLUDEd from a non-standard path (mjs)
- storing a longint (64-bit) to a integer was causing a stack fault in the compiler (v1c)
- assigning UDT's returned from functions to arrays was generating invalid code, depending on the UDT type (v1c)
- profiling multithreaded apps caused a crash on program exit (lillo)
- GETMOUSE now works in combination with INKEY$ on Win32 (mjs)
- string's dead-lock when using the thread-safe version of the runtime library (v1c)
- now the Linux console routines use termcap for output for wider terminals compatibility (lillo)
- comparing strings would give wrong results if characters above 127 were present (v1c)
- UDT results were been allowed to be passed by reference to functions (v1c)
- address of overloaded functions can now be taken correctly (v1c)
- wrong overload type could be returned if pointers to UDT's were used as parameters and arguments (v1c)
- PASCAL functions couldn't be overloaded (v1c)
- Fixed the TAB and SPC when used with OPEN "CON" and files (mjs)
- the precision was one digit too wide when PRINT'ing single's and double's, causing some artifacts (v1c)
- Calling an overloaded function with 0 arguments (mjs)
- Hopefully fixed all output issues on Win32 (mjs)
- LOCATE will now throw an error if it gets invalid arguments(mjs)
- byref args with optional values were reusing the temp var in the case of strings and floating-point types (v1c)
- SIGSEGV happened when GETJOYSTICK was used in CONSOLE mode (mjs)
- Everything that depends on VIEW PRINT on DOS (mjs)
- MULTIKEY now recognizes enhanced scan codes on DOS (mjs)
- Completely fixed key handling in Win32 gfx mode (mjs)
- WRITE with empty strings must result in a "" (mjs)
- Win32: Don't reflect key status changes when application is not active (mjs)
- Non-Win32: non-decimal signed integer constants were been saturated when over &h80000000 (mjs)
- QB has a different order of precedence for the logical operators OR and AND (v1c)
- ambiguity with colon ':' used after anonymous inner UDT's (v1c)
- var-initializing of non-local data was not taking the number of array elements into account, causing wrong alignments (v1c)
- CLS 1 (does nothing) and CLS 2 (clears view port only) now work as expeced in CONSOLE mode (mjs)
- VIEW PRINT is now always reset when SCREEN or WIDTH are called (mjs)
- ambiguity check for overloaded functions with optional arguments not in the end of list (v1c)
- udt's passed by value were been pushed in the inverse order to stack (v1c)
- too big constants (above 1GB) could be missed by Select As Const (v1c)
- declarations for INP (without error check) and OUT (returns INT instead of VOID) are now correct (mjs)
- Original timer ISR is now called at the rate of 0x10000 (mjs)
- suffixed byval string args would be missed when looked up if a global suffixed string with the same name existed (v1c)
- GET and PUT for graphics now support field arrays too (v1c)
- a division of a signed integer by a power of 2 constant would give a wrong result if the left-operand was negative (v1c)
- exponent handling (including when too big to fit) in PRINT USING (v1c)
- the subtraction of two pointer operands was not been divided by the operands' length (v1c)


Version 0.14 Beta:

[changed]
- IMPORTANT: to fully support pointer type-casting, now every time a pointer is updated, the expression will be
  multiplied by the pointer type, as done in C, so if you had: "dim p as integer ptr:" "p += len( integer )", now it
  must be changed to "p += 1"
- to make BYVAL AS STRING arguments more safe, as they are allowed in FB functions since version 0.13, if not
  passing pointers or numeric values such as NULL or 0, the BYVAL modifier will have to be used now (v1c)
- _main will be always the entry-point from now, to be more compatible with statically linked C libraries and
  to remove the DOS and Xbox temporary object creation "hack". Because of that, if compiling and not linking
  objects files, the -m command-line option must be used to tell the compiler which module will be the main
  one (v1c)
- the DllMain function is not needed anymore in the Windows version, just declare the exports and remove the
  DllMain function, it won't be ever called (v1c)
- the module-level code of non-main modules will now be always executed (before the main module), no REDIM's or
  such will be missed as it used to happen in QB. Implicit module initialization can be done now as in Pascal,
  just add any code to the module-level scope (ie: outside any function) (v1c)
- the array descriptors had to be modified, if you have any DLL's compiled with old versions, please recompile
  them with this new version if passing arrays by descriptor to functions (v1c)
- the intrinsic functions SIN, COS, TAN, ATN, SQR, INT and ATAN2 are now implemented as inline and will be
  evaluated at compile-time when constants are used as parameters (v1c)
- macro text will be expanded on comments emited when the -g command-line option is used (v1c)
- multiple strings concatenation such as "a = b + c + d + ..." will be converted to
  "a = b: a += c: a += d: ...", giving a speed up, because no temporary dynamic strings will be used (v1c)
- speeded up PUT routine when using PSET/PRESET/AND/OR/XOR drawing mode (lillo)
- the compiler is now a bit easier to be cross-compiled using the Win32 version (v1c)
- SCREENINFO does not return a pointer to an internal structure anymore, and if called before a gfx mode has
  been set, it returns infos on the desktop resolution/depth. See gfxlib.txt for more info (lillo)
- COLOR will now return the current/last color attributes as: (forecolor or (backcolor shl 16)) (v1c)
- WIDTH will now return the current/last dimensions as: (width or (height shl 16)) (v1c)
- LOCATE will now return the current/last cursor state as: (x or (y shl 8) or (visible shl 16)) (lillo)
- ENUM's are now much more restrict, warnings will be shown if they are passed or assigned to other types than
  integers, but now it's possible to overload functions where the enum argument is the main one (v1c)
- curdir$ now returns path with backslashes instead of slashes (mjs)
- OPTION's will now be used too in the context of the file that included a header if it changed the default OPTION's (v1c)
- chr$(0) can now be output with PRINT too (mjs)
- Printing PAD's now works exactly the same as on QB(X) with console/file/redirected console (mjs)
- MULTIKEY, GETMOUSE and SETMOUSE will now also work in plain console text mode (lillo)
- user defined type (UDT) assignaments are now done with inline code (v1c)
- the Windows version of FBC can now compile and link DOS, Linux and Xbox applications if the proper cross-compiling
  versions of the GNU binutils are available and if all the libraries needed are installed (v1c)
- #UNDEF will now work with any symbol kind, not defines only (v1c)

[added]
- function overloading, the return type is not taken into account, only the arguments (as in Java) (v1c)
- pointer type-casting: CPTR( DataType, Expression ), as in: "*cptr(byte ptr, somePointer) = 255"
- functions can now return structures (user defined types) too, only external functions could before (v1c)
- full debug support using GDB (the GNU debugger) or Insight (GDB's GUI frontent), only dynamic arrays can't
  be watched at the moment, everything else works, including var-len strings and UDT's (v1c)
- array bounds checking when the -exx (extra error checking) cmd-line option is used (v1c)
- null pointers checking, same as for array bounds checking (v1c)
- alpha blending support for PUT; pass ALPHA as drawing mode. Only works if in 32bit color depth (lillo)
- uniform alpha blending support for PUT: pass ALPHA,value to specify an unique alpha with which to blend sprite with
  background. Works in 15, 16, 24 and 32bit color depth (lillo)
- custom blenders for PUT: pass mode CUSTOM,blender, where blender is a pointer to a function of the form
  "function blender ( byval src as uinteger, byval dest as uinteger ) as uinteger". This will be called for each pixel
  and must return the new blended pixel to be drawn (lillo)
- RGBA() built-in macro, works like RGB() but allows to specify an alpha value (lillo)
- CVSHORT(), CVLONGINT(), MKSHORT$() and MKLONGINT$() (v1c)
- byte, short and longint overloaded versions of HEX$, OCT$ and BIN$ (v1c)
- GETJOYSTICK function in gfxlib to get the full state of an attached joystick (lillo)
- FUNCTION can now be used inside inline assembly blocks to set the function's result (v1c)
- error message when macro text is too long (v1c)
- support for 16 background colors if in text mode under Xterm in Linux (lillo)
- added BMP saving capabilities to BSAVE, due to popular demand (lillo)
- warning message for suspicious pointer assignaments (v1c)
- include file and import lib for the CGUI library (v1c)
- many NeHe OpenGL lessons, ported by sisophon2001 (v1c)
- IMAGECREATE and IMAGEDESTROY built-in function to create and destroy gfx image buffers (lillo)
- PALETTE [USING] now supports the new PALETTE GET [USING] construct to get current palette color(s), so you can
  do "PALETTE GET index, r, g, b" or "PALETTE GET USING pal" instead of using the old INP/OUT tricks (lillo)
- added SCREENSYNC to wait for vertical blank, so you can use it instead of the old WAIT &h3DA,8 trick (lillo)
- added SCREENLIST to fetch available screen modes (lillo)
- added DYLIBFREE to unload a dynamic link library previously loaded at runtime by DYLIBLOAD (lillo)
- labels already defined can now be referenced in inline ASM (v1c)
- #DEFINE macros can now be empty too, as the argument-less ones used to (v1c)
- '##'s can be used now to delimit macro arguments as in C: #define makefuncname(name) func_##name## (v1c)
- the '#' prefix can now be used in macros when the text representation of a macro argument is wanted (v1c)
- ASSERT built-in macro, works like in C (it's only enabled when the module is compiled with debugging support (-g)) (v1c)
- Allow to compile the "linux" version with CYGWIN (non-functional yet) (mjs)
- signals and some exceptions like seg. violation and div by 0 can now be handled by users in standard ON ERROR handlers
  if compiling with error checking on (using the -e or -ex cmd-line options) (v1c)
- version macros __FB_VER_MAJOR__, __FB_VER_MINOR__, __FB_VER_PATCH__, __FB_MIN_VERSION__ (mjs)
- graphical PUT will now fail and report a runtime error if an image GETed while in a mode with a certain depth is
  attempted to be drawn in a mode with a different color depth (lillo)
- private functions will only be emitted if referenced (v1c)
- constructor and destructor functions - constructors will be executed *after* fb_Init (mjs)
- -map <filename> to create a map file (mjs)
- the ERL function - returns the line number where the runtime error happened, as in QB (v1c)
- include file and import library for GMP (multi-precision lib) (v1c)
- include file and import library for FastCGI (v1c)
- the OFFSETOF macro, to return the offset of an UDT field: ofs = offsetof(myudt, somefield) (v1c)

[fixed]
- EQV can't be optimized when used in compound stmts, because the NOT opcode doesn't update any flags on x86 (v1c)
- INPUT$() for console was reading a char less, causing INPUT$(1) to fail (v1c)
- PRINT USING ^^ should be used to set the number of exponent digits (v1c)
- more thread-safetiness checks in platform dependent rtlib routines (lillo)
- SHELL in Linux was not restoring console state before calling sub-process, resulting in bad keyboard I/O (lillo)
- @'s used on DATA stmts were storing the names, not the addresses of var's or proc's (v1c)
- DRAW had a parsing problem when directed towards an offscreen GET/PUT buffer (lillo)
- parameters passed explicitly using BYVAL weren't been checked with byval string arguments (v1c)
- PUT was accepting literal values, what will fail because the way BYREF AS ANY args pass numeric values (v1c)
- complex pointer expressions would not be parsed if used as parameters to functions (v1c)
- SWAP wasn't working with type fields (v1c)
- Mouse wheel position was reset to 0 under Win32 when window was put out of focus (lillo)
- non-numeric variables were been allowed in CHR$() (v1c)
- the unary operator "+" was been allowed with string operands (v1c)
- intrinsic string functions when used with "zstring *" arguments would operate on the full strings, not only until
  the null-terminators (v1c)
- ENUM elements separated by commas would update the values twice (v1c)
- Text mode colors now behave correctly under Eterm in Linux (lillo)
- PRINT'ing nothing followed by commas "PRINT," would not print the padding correctly (v1c)
- escape sequences were not being converted when used within var initializers (v1c)
- MMX inline asm wasn't compiling as GAS didn't understand it even if .arch i686 was used (lillo)
- WIDTH in gfx mode was crashing if either one of width or height was not specified (lillo)
- STEP clause applied to PSET was not forcing coordinates to be relative to last gfx cursor position (lillo)
- function profiler rewritten to fix recursive functions profiling (lillo)
- swapping fixed-len and z-strings would not swap or set the null-terminators (v1c)
- wrong code could be generated when 64-bit integers (longint's) were used in complex expressions (v1c)
- field arrays of UDT's are now padded to follow the GCC 3.x ABI (v1c)
- using gfx primitives inside a screenlock/screenunlock pair will not hang programs anymore (lillo)
- BLOADing a 2 or 16 colors BMP was giving screwed images (lillo)
- ON expr GOSUB would crash because the jump-table was not skipped as with GOTO (v1c)
- strptr(lit string) when used to initialize static or module-level variables would generate an exception (v1c)
- byval string params were not passed correctly to byref as any arguments when the byval clause was used (v1c)
- wrong number of dimensions in a static array would generate an exception (v1c)
- LINE INPUT was allowing any data type as argument, not strings only (v1c)
- VIEW in gfx mode was not filling the area if a fill color was specified, and border color had problems if in
  truecolor mode (lillo)
- using CLS in Linux console was forcing screen clear on program exit (lillo)
- passing by desc arguments to GFX function w/o explicit indexes given would crash the compiler (v1c)
- dereference of void types was been allowed (v1c)
- a field referencing the parent UDT would put the compiler into an infinite loop (lillo)
- ASM inline in the RT lib would not generate what was expected in GCC 4.x, as it's more restrict than 3.x (v1c)
- EOF didn't work with INPUT files on DOS (DJGPP, GCC 4.0) (mjs)
- The _get_cs(), _get_ds(), _get_ss() implementations didn't work (mjs)
- curdir$ didn't work for DOS and might have caused SIGSEGV on Linux (mjs)
- the ANY type was been allowed in DIM/REDIM (v1c)
- redimension of array fields was not resulting in a compile-time error (v1c)
- include files are now searched for in current dir, then the source file dir, then the system include dirs (lillo)
- chr$(0) will not be evaluated at compile-time, to circumvent the null-terminator limitation with strings (mjs)
- MID$()= (assigning MID) didn't release temporary strings (1x src and 3x dst) (mjs)
- Win32 OpenGL driver had problems with fullscreen modes on some machines (lillo)
- made all Win32 gfx drivers more vsync friendly (lillo)
- now using SetDIBitsToDevice instead of StretchDIBits in GDI gfx driver, solving some drawing problems (lillo)
- the 8bit TRANS mode MMX PUT routine produced wrong results (lillo)
- PRESET did not behave as it was supposed to (lillo)
- overloaded functions could not use the function name to assign results (v1c)
- local undefined labels were silently ignored (v1c)
- BLOADing a BMP with 16 or less colors was changing the whole 256 colors palette if in 8bit mode (lillo)
- __LINE__ now returns a number instead of a string (mjs)
- VIEW cleared the screen with a bad color if called without arguments, instead of just resetting the view (lillo)
- coordinates translation with PMAP was giving back bad results (lillo)
- thread-safetiness fixes to DIR$ (lillo)
- "#define foo bar" now works too, where "bar" is a macro (v1c)


Version 0.13 Beta:

[changed]
- arrays and pointers will be optimized for shorthand when possible (before, only vars were), ie:
  "foo(a+b-c) = foo(a+b-c) * expr" will become "foo(a+b-c) *= expr" when code is generated (v1c)
- RETURN can now be used as a shortcut to function result set + EXIT FUNCTION (as in C); with this modification,
  the LABEL's (if used) must have been defined already, no forward references are allowed anymore (v1c)
- ASC now has an optional parameter to retrieve a char at a specific position as in "c = asc( "abc", 2 )" (v1c)
- CHR$ now accepts multiple arguments as in "s = chr$( 65, 66, 67, 68 )" (v1c)
- COMMAND$ can now return just a specific argument as in "argv3 = command$(3)" (v1c)
- PEEK and POKE now accept STRING and UDT's as data type (v1c)
- literal string expressions can now be used with CONST's (v1c)
- glut include file, header completed with help of the SWIG FB wrapper (v1c)
- SCREENCOPY now copies only the page area set by most recent VIEW call, or whole screen if no viewport is set (lillo)
- fixed-length strings can now by referenced using the "$" suffix, as in QB (v1c)
- #ifdef and #ifndef will find any kind of symbol, not #define's only as before (v1c)
- WITH can now be used recursively (v1c)
- local variables are now aligned to dword boundary to be more compatible with some C API's (v1c)
- TIMER now uses the Win32 high resolution timer when available (lillo)
- DOS port now detects if STDOUT is not the terminal and uses printf() if so, so shell I/O redirection works now (DrV)
- more clear error messages when scalars variables are been accessed as arrays and vice-versa (v1c)
- the string argument in SHELL and DIR$ is optional now, as in QB (v1c)
- #DEFINE won't report an error if declaring again a symbol with exactly the same text - won't work with macros (v1c)
- #UNDEF won't report an error if un-defining an non-existent symbol (v1c)
- FB__* built-in #defines are now named __FB_*__, please update your code if you used them! (lillo)
- New built-in dynamic #defines: __FILE__, __FUNCTION__, __LINE__, __DATE__ and __TIME__ (lillo)
- in Win32, the import libraries are now created from .def files when the install.bat is executed by the user (v1c)
- type-less REDIM's will check for already allocated arrays, as in VB (v1c)
- internally replaced the use of the Xxf86vidmode extension with the Xrandr extension to toggle fullscreen gfx mode
  under Linux. This works much better and is more compatible with more recent distros, but it makes FB gfx programs
  to require at least XFree86 4.3.0 or any version of Xorg to run. (lillo)

[added]
- runtime library is now split into a thread-unsafe and a thread-safe versions. Former is used when compiling singlethreaded
  applications to avoid unnecessary locking, latter is used when compiling multithreaded apps. The compiler detects if the
  app in multithreaded if it makes use of THREADCREATE; to force linking with the thread-safe lib in any case, use the -mt
  commandline option (lillo)
- long integer (64-bit) data types (signed and unsigned), all operations done inline but for division and modulo (v1c)
- typedefs with forward referencing support, as in C (but the syntax is "TYPE Name AS SymbolType") (v1c)
- the ZSTRING type, null-terminated strings with fixed-length but that can be dereferenced and returned by functions (v1c)
- variable-initializers, as in "DIM foo AS INTEGER = 123", "DIM bar(2) AS DOUBLE => { 1, 2, 3 }", etc (v1c)
- field-dereference on function's returning pointers to UDT's as in "foo(arg1)->bar(arg2)->a.b.c" (v1c)
- bitfields, same syntax as in C: "foo : 4 as integer", "bar : 1 as integer", etc (v1c)
- on compile error, the line where error occured is shown with a "^" under offending token. Disable with -noerrline (lillo)
- inline string indexing as in "char = somestring[idx]" (V1c)
- variable-arguments, as in C: "sub foo(byval bar as integer, ...)" (v1c)
- va_first(), va_arg() and va_next() intrinsic macros, to access variable-arguments in FB functions (v1c)
- include file and import lib for the GTK+ 2 library (v1c)
- include file and import lib for the libxml2 library (v1c)
- include file and import lib for the libxslt library (v1c)
- include file and import lib for the GSL library (v1c)
- include file and import lib for the SQLite library (v1c)
- include file and import lib for the MySQL client library (v1c)
- include file and import lib for the DevIL library (v1c)
- include file and import lib for the gd library (v1c)
- include file and import lib for the zlib library (v1c
- include file and import lib for the PDFlib Lite library (v1c)
- include file and import lib for the ODE library (v1c)
- include file and import lib for the Newton library (v1c)
- include file and import lib for the cryptlib library (v1c)
- include file and static lib for the GRX library (v1c)
- include file and static lib for the BIG_INT library (v1c)
- include file and static lib for the cgi-util library (v1c)
- include file and static lib for the Mini-XML library (v1c)
- include file and static lib for the GDSL library (v1c)
- include file and static lib for the GLFW library (v1c)
- include file and static lib for the PDCurses library (v1c)
- PALETTE can now be called with 4 parameters, specifying new color red/green/blue components directly (lillo)
- ENUM's can now be nameless (v1c)
- CUBYTE, CUSHORT and CUINT, same as CBYTE, CSHORT and CINT, but work with unsigned types (v1c)
- DYLIBLOAD and DYLIBSYMBOL intrinsic functions to manage dynamic libraries at runtime (lillo)
- nameless inner TYPE's on UNION's (v1c)
- strings passed by value to FB functions, ie: "sub foo(byval bar as string)" -- note: they are not copied to stack,
  they are just a zstring with unknown size (v1c)
- gfxlib internal data (default fonts and palettes) is now compressed in the EXE and decompressed on the fly using a tiny LZW codec,
  resulting in 5K smaller EXEs. Access to internal data without calling SCREEN first will return garbage (lillo)
- inline asm now supports complete IA32 instruction set (lillo)
- unsigned versions for STR$() (v1c)
- the val64() intrinsic function, to convert a string to a longint (v1c)
- the valint() intrinsic function, to convert a string to an integer (VAL() returns a DOUBLE) (v1c)
- the SIZEOF() intrinsic function, to return the size of any data type (v1c)
- SCREEN/SCREENRES now accept an additional optional parameter allowing to request a specific refresh rate (lillo)
- optional sub/function parameters can now be strings as well, as in: "declare sub test(arg as string = "default")" (lillo)
- "FUNCTION =" can now be used to store to current function's result, as in PB (v1c)
- function's can return UDT's now, but only for prototypes of C libs (compiled by GCC 3.x only), not internally yet (v1c)
- TYPE and UNION fields can now be declared as "AS sometype a, b, c, d(123)" too (v1c)
- ENUM items can now be separated by commas too, as in "a, b, c = 2, d" (v1c)
- the PIPE: file type to OPEN, for read or write access, as in: "OPEN "PIPE:dir *.*" for input as #1" (v1c)
- the ugly ON ERROR GOTO 0 (v1c)
- OPEN, CLOSE, GET# and PUT# can be used as functions now, so errors can be checked w/o handlers (v1c)
- argument-less #define's can now be declared and referenced using optional ()'s (v1c)
- #ERROR metacommand to interrupt compiling with user defined errors (lillo)
- include file and static lib for the libcaca library (DrV)
- include file and import lib for the wx-c library (DrV)
- profiling: use the -profile commandline option to enable function profiling code generation. Running a profiled
  program will generate the profile.txt file on exit, containing timing results for all function calls (lillo)
- algebraic identities optimizations at ast (lillo)
- include file for the OpenGL extensions, ported by Bryan Stoeberl (v1c)

[fixed]
- IMPORTANT: fixed a bug with horizontal/vertical styled LINE drawing; this means the GfxPrint routine as was reported
  in gfxlib.txt of 0.12 does not work as expected with gfxlib 0.13; if your program used it, it's time to update its
  code from the new gfxlib.txt (lillo)
- CVS() was being done as CVD() (v1c)
- SELECT CASE and other compound statements were accepting UDT's w/o any fields given (v1c)
- line-continuation with _ when anything but white-spaces were used after it (v1c)
- dyn arrays of function pointers can now be redimensioned, as the symbol name is being mangled now (v1c)
- MID$ with len = 0 should return an empty string (v1c)
- WINDOW statement was inverting y coordinate (lillo)
- LINE INPUT was limited to 1024 bytes (v1c)
- bug with INP/OUT emulation for palette handling (lillo)
- LEN() was not working when string concatenation was used (v1c)
- STRPTR()/SADD() were not checking for constants (v1c)
- char 255 was seen as -1 as byte's (not ubyte's) were used by lex, making lexSkipLine fail when that char was used inside a comment (v1c)
- unsigned versions for READ were missing (v1c)
- field arrays starting at offset 0 with a lbound <> 0 would cause an access to the wrong fields, 'cause a bug at parser3 (v1c)
- escape seqs generated by chr$ when evaluated at compile-time would fail if an octagonal escape was needed and other numbers followed (v1c)
- some fixes to the way gfx coordinates are transformed when WINDOW is active (lillo)
- #if <number> conditional compilation was not skipping code block if number was 0 (lillo)
- using -x with libs would include the lib itself into the compilation as listFiles was called before processOptions at fbc (v1c)
- programs using SCREENRES failed to compile when runtime error checking was enabled (lillo)
- GET now triggers an illegal function call runtime error if image is partly offscreen (lillo)
- PUT used to crash if sprites with null width/height were passed (lillo)
- comma wasn't been skipped when quoted strings were read by INPUT (v1c)
- strings and UDT's were being allowed in boolean tests when no relational operators were used (v1c)
- different parameter types were being allowed with by descriptor arguments (v1c)
- double locking on Linux was causing SETMOUSE/GETMOUSE to hang programs (lillo)
- conversion to/from fpoint to byte vars could be wrong if too complex operations were used (v1c)
- literal values passed as parameter were not been converted at compile-time, generating bad code is some cases (v1c)
- CLS in gfx mode now clears viewport only if previously set via VIEW (lillo)
- BEEP rtlib routine for DOS was missing (DrV)
- BYREF AS ANY arguments when variables weren't passed would create a temp vars with the VOID type (v1c)
- SCREEN function rtlib routine for DOS was missing (DrV)
- SETDATE/SETTIME support under Linux was missing (lillo)
- size of identifiers and literals as being checked inside comments (v1c)
- LSET should accept UDT's too (v1c)
- SCREENCOPY gave corrupted image display if called after a primitive targeted against a user buffer (lillo)
- some minor issues when BLOADing BMPs (lillo)
- floating-point to unsigned integer could saturate values above 2 ^ 31 due the x86 FISTP nature (v1c)
- unsigned integer constants were being saturated, due the problem above (v1c)
- include/lib paths now accept both "/" and "\" as path separators on all platforms (lillo)
- PRINT in gfx mode now detects CR+LF as an unique new line (lillo)
- Enabled maximize button on X11 windows under Linux, switching to fullscreen like under Win32 (lillo)


Version 0.12 Beta:

[changed]
- IMPORTANT: now to declare functions on DLL's that will be exported, the EXPORT clause must be used, as global
  functions won't be automatically exported anymore, because that would make it hard to write DLL's with
  multiple modules where not all global functions should be exported (v1ctor)
- IMPORTANT: the format of the internal string descriptor was modified to speed up concatenation of large strings,
  so you MUST recompile all the old code, don't reuse object files compiled with older versions (below v0.12b) and
  rebuild DLL's created in FB if they return or process STRING's passed to/from client EXE's (v1c)
- Linux port does not use ncurses anymore, but its own internal lowlevel routines for console access.
  Apart from no ncurses dependency, this means faster console output (also under X11), no screen clearing
  at programs startup and proper colors support under X11. Compatibility issues may rise though, so
  feedback is welcome (lillo)
- PEEKS, PEEKI, POKES, POKEI keywords removed, use now the new syntax as "PEEK( data type, expression )" or
  "POKE data ype, expression, expression" to peek/poke different data types than BYTE, that's the default one (v1c)
- many Allegro's globals like al_screen, al_rgb had the "al_" prefix removed, they are now as the originals (v1c)
- Gfx GET and PUT now support both arrays and generic pointers as data holders (lillo)
- white-spaces are now preserved for ASM blocks and #DEFINE's (v1c)
- Linux port install script will now warn users if not run with root priviledges (lillo)
- the range of console-mode background colors is now 0 to 15 in DOS and Windows, 'cause Nex wanted that :) (v1c)
- generated EXEs size can now be up to 5-6K smaller than before (lillo)
- empty statements like ":foo=1::bar=2:" are now accepted, "if foo then:bar:else:foo" will work too (v1c)
- DIM|REDIM array w/o explicit dimensions is not allowed anymore inside procs, as the descriptor size is unknown (v1c)
- RGB is now an intrinsic macro, not a function (so no UDT's called RGB are allowed anymore) (v1c)
- symbols can now start with an underscore as in "_1234 = 1234" (v1c)
- local labels can now have the same name in different procs (v1c)

[added]
- resource files support on Windows, just add the .rc's or .res' to the list, they will be automatically
  compiled -- the Windows C headers were also added, so complex scripts (ie: dialogs and menus) can be
  used too (DrV)
- XPM icon resource files support on Linux. As with Windows resource, just pass the .xpm file to
  the commandline and the executable will sport a fb_program_icon symbol holding the XPM data.
  If using gfxlib, this is automatically used to set the window icon (lillo)
- built-in multiplatform threading functions (lillo)
- "operator =" shorthand, as in "a += b * c" (v1ctor)
- SELECT CASE AS CONST statement, only integer constants are allowed and a jump table is generated making the it much
  faster than an ordinary SELECT when more than 4 CASE's have to be checked (v1c)
- #DEFINE's with arguments (macros) as in "#DEFINE foo(a,b) ((a)*(b))" (v1c)
- "CONS:" and "ERR:" special file names, to open the console for i/o access and the std error for output (v1c)
- compile-time evaluation for the CHR$ and ASC intrinsic routines (v1c)
- SCREENINFO gfx function to get informations on current gfx mode (lillo)
- SCREENRES gfx statement to set custom resolution modes (lillo)
- SETMOUSE gfx statement to set mouse position and cursor visibility (lillo)
- Win32 GDI internal gfx driver for systems where DirectX is not installed (lillo)
- OpenGL internal gfx driver for both Win32 and Linux (lillo)
- possibility to select default internal gfx driver to be used via FBGFX environmental variable (lillo)
- the OpenAL headers, ported by Chris Davies (v1c)
- include file and static library for TRE (a POSIX regular expressions lib) (v1c)
- the ASM statement can be used on a single line as in "ASM mov eax, 1234" (v1c)
- SCREEN() function, working as in QB (lillo)
- gfxlib now internally uses MMX routines to update the screen if supported (lillo)
- "OPTION NOKEYWORD", to remove intrinsic routines/statements (v1c)
- "DIM|REDIM|STATIC|COMMON AS SymbolType" for multiple declarations like "DIM AS INTEGER a, b, c(10)" (v1c)
- all gfx primitives now accept as optional first parameter a target buffer where drawing will take place (lillo)
- BLOAD now supports loading BMP files (lillo)
- IFF(), conditional IF, to be used with numeric types only as in: "a = IIF( b > c, -1, 0)" (v1c)
- LOWORD, HIWORD, LOBYTE and HIBYTE intrinsic macros (v1c)
- BIT, BITSET and BITRESET intrinsic macros (v1c)
- nameless arguments on function prototypes as in "BYVAL AS INTEGER" (v1c)
- END IF to end the single line IF's to make porting of complex C macros easier to be done (v1c)
- the winsock 1.1 include file and import library (v1c)

[fixed]
- ACCESS clause was not being checked with OPEN (v1c)
- BINARY and RANDOM modes should try opening the file as write- or read-only when no access was given (v1c)
- local labels not found weren't being reported (v1c)
- LEN() now accepts PTR's when used with ENUM's and UDT's (v1c)
- ERASE should accept multiple arguments (v1c)
- DATA should not be allowed inside procs (v1c)
- invalid types in CASE statements were not been reported (v1c)
- byref UDT arguments with array fields would be wrongly accessed because an error at parser3 (v1c)
- length of array fields on UDT's was wrong, as the elements weren't taken into account by the symb mod (v1c)
- "blurry window" gfx bug in Win32 DirectX windowed mode (lillo)
- Waiting for vertical retrace via WAIT under Win32 was waiting twice the time as needed (lillo)
- DRAW had precision bugs that caused malformed shapes to be drawn (lillo)
- bad negative coordinates transformations was affecting all gfx primitives (lillo)
- SCREENPTR was always returning the pointer to the visible page memory instead of the working page (lillo)
- palette handling via INP/OUT emulation was producing bad colors (Sterling)
- various fixes to the X11 internal gfx driver: was not working if the X server was running in 24bpp mode, mouse
  cursor was not hidden in fullscreen mode, mouse and keyboard were still working even if the app had not got
  focus, had memory leaks if executed on a remote X server (lillo)
- using gfx primitives on a non-visible working page was still causing screen updates (lillo)
- BSAVE was not expecting commas as parameters separator (lillo)
- Linux port had precision problems with the TIMER function (lillo)
- PSET gfx primitive was not respecting default color (lillo)
- SGN() for floating-point numbers was converting the source to integer at the AST module (v1c)
- #DEFINE's can now contain forward references to other #DEFINE's (v1c)
- CIRCLE used wrong color for lines when drawing arcs with negative start/end angles (lillo)
- Calling SCREENLOCK/SCREENUNLOCK when framebuffer is already locked/unlocked does not hang program anymore (lillo)
- ON...GOTO and ON...GOSUB now work as expected (v1c)
- only empty ()'s should be allowed with COMMON (v1c)
- all quirk routines now check for invalid parameters (v1c)
- REDIM now checks for run-time errors (out-of-mem) (v1c)
- INPUT quirks: comma separates all items, white-spaces won't separate strings, etc (v1c)
- PRINT and WRITE shouldn't allow UDT's as parameter, same with INPUT (v1c)
- COMMON arrays wouldn't be redimensioned when a REDIM was used (v1c)
- integer division and modulo could gen bad code if pointers or indexes were used with EAX as the index reg (v1c)
- base for non base-0 arrays with more than 2 dimensions was being wrongly calculated (v1c)
- d! = cbyte( d! ) would gen bad code at EMIT if the SI or DI registers were used as source (v1c)
- #define's would be checked inside $include and $inclib if ' was used as delimiter (v1c)


Version 0.11 Beta:

[changed]
- the internal GFX library is now the former alternative one written by lillo, many thanks to Sterling
  for making the first version, he started working on it even before FB was released -- if you prefer to
  continue using it, the sources still on CVS at sf.net (src/gfxlib), just build the library and rewrite
  the libfbgfx.a file at \lib, it contains no PAINT or DRAW, nor low-res screen modes, but everything
  else stills functional - the SCREEN arguments are different, pay attention
- new OpenGL header translated by Rel to work better with pointers, there are no more BYREF arguments,
  use @ or varptr() to get the address of variables and arrays when the argument is a BYVAL ... PTR (v1c)
- fmod and BASS headers: all BYREF arguments changed to BYVAL ... PTR to work better with pointers (v1c)
- new SDL headers translated by Edmond Leung, no changes needed on user's code (v1c)
- fixed-len strings on arrays can now be passed as parameter to functions (v1c)
- array fields can now be passed by descriptor, as in "array(idx).arrayfield()" (v1c)
- #DEFINE now supports complex definitions like "any ptr" at right-side rule (v1c)
- pointers to pointers *MUST* now be declared as "ptr ptr ...", multiple dereferencing are only allowed on those (v1c)
- -w cmm-line option changed to -nostd (v1c)
- ERASE now accepts non-dynamic arrays and fills them with 0's (v1c)
- the crt dll on Win32 is now msvcrt.dll instead of crtdll.dll, to be able to statically link to libs
  compiled with VC 5/6 and Mingw (crtdll is not supported by M$ anymore), you can use the new -nostdlibs
  option to set a different lib (like crtdll) if you really need that -- ie: plain vanilla Windows 95/osr2
  doesn't come with msvcrt.dll installed (it can be found at M$'s site) (v1c)

[added]
- include file and import lib for the GLU library (thanks Rel for sending it) (v1c)
- include file and import lib for the FreeImage library (thanks Eric) (v1c)
- include file and import lib for the SDL_gfx 2.0 library (v1c)
- include file and static lib for the Lua (teh C-like scripting language) library (v1c)
- escape chars (\) on string literals, use "OPTION ESCAPE" to enable -- they won't be parsed within $include $inclib (v1c)
- GOTO on single-line IF's w/o THEN (v1c)
- EXTERN keyword, to declare external/global variables (not the same as COMMON) (v1c)
- EXPORT keyword, to declare exported functions on executables (not in DLL's) (v1c)
- STRPTR keyword, works like SADD, but name makes more sense (as for VARPTR, PROCPTR) (v1c)
- WITH..END WITH compound statement -- won't work with field dereference "->" (v1c)
- warning messages when passing a scalar type to a function argument that expects a pointer (v1c)
- -w cmm-line option to change the min level of warning messages shown (v1c)
- ONCE keyword to be used with $INCLUDE or #INCLUDE as in: '$include once: "includethisfileonlyonce.bi" (v1c)
- UDT arguments now can be declared and passed by value too (v1c)
- -nodeflibs cmm-line option, so no standard libraries are automatically linked (v1c)
- "*([@]variable +|- expression)" and "*@variable" support (v1c)
- pointer indexing support, as in "myptr[idx]" (v1c)

[fixed]
- COMMON arrays shared between different sources had different descriptor names (v1c)
- the UDT size returned for UDT vars when using LEN() was the real-one, w/o padding (v1c)
- LEN() can now handle arrays with no indexes given, as in QB (v1c)
- by ref arguments now accept different data types when expressions are passed (v1c)
- when an include file was not found, the executable would still built (v1c)
- the --dllname cmm-line option to dlltool.exe should not contain the path (v1c)
- udtptr.field was being accepted as valid -- it must to be udtptr->field (v1c)
- PRINT/WRITE both have much more precision now when printing floating-point numbers (v1c)
- #ELSEIF were not skipping to #ENDIF if and #IF or other #ELSEIF had already being true (v1c)
- SHARED with DIM|REDIM was being allowed inside procs (v1c)
- STATIC was was being allowed outside procs (v1c)
- indexes as "byte|short var + constant expr" could gen bad code, as var wasn't been converted to int (v1c)
- loading an ubyte to a signed one storing a sbyte to an unsigned one would make a convertion at emit (v1c)
- "DIM a as myudt, a.b as sometype" won't be allowed anymore (v1c)
- Pre-processor would fail if comparing numbers using relational operators others than = and <> (v1c)


Version 0.10 Beta:

[changed]
- some param declarations on include files were changed, don't use the old ones with this version (v1ctor)
- arrays can't no more be accessed w/o indexes (even at (0)) (v1c)
- DirectDraw include file (ddraw.bi) completed by Drv (v1c)
- GFX lib is much more modular now, executables generated are much smaller (Sterling)
- default char set on Linux is now IBM codepage 437 (same as in DOS) (lillo)
- the SDL lib is added automatically when the intrinsic GFX routines are used (v1c)
- winmm.bi renamed to mmsystem.bi to match the original C version (v1c)

[added]
- RESUME and RESUME NEXT error handling intrinsic functions (v1c)
- DIR$ intrinsic function, both for Windows and Linux (lillo)
- REALLOCATE intrinsic function (same as C's realloc) (v1c)
- SETDATE and SETTIME statements, thanks DrV for sending the patches (v1c)
- PUT# and GET# now can write/read full arrays as in VB (v1c)
- power (^) operator optimization: "var ^ 2" becomes "var * var" (v1c)
- MOD operator optimization: "var MOD power of 2 constant" becomes "var AND constant-1" (v1c)
- winmm import library that was missing (v1c)

[fixed]
- QB GFX library runs fine now, it was a makefile fault (headers changed but files didn't get rebuilt) (v1c)
- SDL and OpenGL include files are more cross-platform now (thanks Danilo) (v1c)
- alignament of UDT fields wasn't correct when they were an UDT too (v1c)
- fixed-len strings were being allowed in function arguments and results (v1c)
- reported names of not found include files still wrong (v1c)
- PRINT with no args on Linux was causing a segment-fault (lillo)
- NAME was declared as RENAME (v1c)
- function arguments with same name as the function itself were being accepted (v1c)
- PRINT USING was not doing any output if there was no chars at end of the format string (v1c)
- illegal unary/binary/convertion operations were been silently ignored (v1c)
- mytypeptr->myfieldarray(expr) is now working again (v1c)
- ON ERROR was accepting GOSUB too (v1c)
- functions with optional arguments called as parameter could try taking args from the caller function (v1c)
- CLOSE now accepts multiple files (v1c)
- COMMAND$ on Windows when the executable path had white-spaces was returning part of it (v1c)
- fpoint regs were been spilled in the wrong order when procs were called within complex expressions (v1c)
- when making a DLL the path was not being stripped, creating bad exclude symbols (v1c)
- making a static library was not saving the built lib to the source path (v1c)
- rtlib arg len calc was wrong and affected CDECL function calls when byval strings were passed (v1c)


Version 0.09 Beta:

[changed]
- FBC's command-line options are now case-sensitive, -b is NOT the same as -B anymore, pay attention (v1ctor)
- all Windows-only include files were moved to the inc\win path, fix your sources please (v1c)
- calling function pointers no more needs a * at beginning, () must now be used, even if proc has no args (v1c)
- pre-processor is now at Lex's level, so it can be used inside TYPE, UNION and ENUM blocks too (v1c)
- LOCATE now accepts a 3rd optional argument to turn cursor on and off (lillo)
- max length of literal strings was too short, 1024 chars now (also an error msg is shown if too big) (v1c)

[added]
- QB-ish GFX library (not fully functional yet, palette is buggy), all credits to Sterling for the hard work (v1c)
- DLL and static library automation, thanks to DrV for sending the patches (v1c)
- support for creating shared libraries on Linux (lillo)
- #ELSEIF pre-processor statement (lillo)
- pre-defined #defines: FB__VERSION, FB__SIGNATURE, FB__WIN32, FB__LINUX (lillo)
- double-quotes on literal-strings, as in: text = "quote=""": print text (will print: quote=") (v1c)
- more complete Windows API include files, thanks to Nek and fws for the hard work (v1c)
- dereferenced byte pointers can now be assigned to fixed and var-len strings and vice-versa (v1c)
- function calls can now be dereferenced, ie: sometype = *somefuncreturningapointer(somearg) (v1c)
- ALLOCATE and DEALLOCATE intrinsic functions, to dynamic allocate memory (as malloc/free) (v1c)
- CLEAR intrinsic function, to fill a memory block with some value (as memset) (v1c)

[fixed]
- rtlib routines still had stdcall alias (with @'s) when -w option was used (v1c)
- "."'s were being checked inside an $include directive when using apostrophes instead of quotes (v1c)
- #DEFINE's were case-sensitive and quotes weren't being preserved (v1c)
- defines passed by cmm-line were being ignored if no value was explicitly given (v1c)
- PRINT couldn't print more than 80x25 chars at time (WRITE stills limited tho) (v1c)
- TRIM$ was eating one char more (v1c)
- undefined UDT elements when accessed w/o OPTION EXPLICIT were being declarated as new variables (v1c)
- ACCESS clause on OPEN was expecting an expression, correct is READ|WRITE|READ WRITE (v1c)
- "imm op short var" was allocating the wrong register type, due an integer imm optimization at AST (v1c)
- ptr params passed byref to functions were being converted, as IR wasn't treating POINTER dtypes as UINT (v1c)
- "dim var as sometype: goto|gosub var" was being accepted (v1c)
- when an include file was not found, the compiler context was not being restored (v1c)


Version 0.08 Beta:

[added]
- pre-processor: #DEFINE ID, #UNDEF ID, #IFDEF ID, #IFNDEF ID, #IF Expression, #ELSE, #ENDIF, #PRINT (v1ctor)
- -d cmd-line option, to add compile-time pre-processor define's (v1c)
- -w cmd-line option, to treat stdcall calling convention as cdecl even on Win32 (v1c)
- NOSTDCALL define to rtlib, also all __stdcall references are now FBCALL (v1c)

[fixed]
- comparing a fpoint operand against an int operand would not load the int to the FPU stack due the comp&branch opt (v1c)
- debugging symbols were being stripped even when the -g option were used (v1c)
- sdlvideo.bi: pitch field from SDL_Surface struct redeclared as ushort - it was uinteger before (v1c)
- sdlvideo.bi: SDL_Rect fields were integer's instead of short's (v1c)
- sdlevent.bi: SDL_MouseMotionEvent, yrel was declared as unsigned (v1c)


Version 0.07 Beta:

[changed]
- DIM now can be used with non-constant indexes, what will create a dynamic array (v1ctor)

[added]
- DIM array(), dynamic arrays with unknown dimensions as in VBDOS/VB (v1c)

[fixed]
- RTRIM$ would fail with fixed-len strings as fb_StrAssign was not padding them with nulls (v1c)
- DATE$ was allocating 2 chars less than needed (v1c)
- EXIT was not checking if was inside a compound stmt or a proc, an access violation would happen (v1c)
- vars explicity declared with full type weren't be found when used with a prefix of same type (v1c)
- emit was pushing words to stack and cleaning 4 bytes when converting to/from fpoint vars to/from short vars (v1c)
- ERASE was accepting any kind of vars, including scalars and non-dynamic arrays (v1c)
- const relop expr would gen bad code (dst as immediate value) (v1c)
- functions should never be allowed to return structs (v1c)
- INPUT statement for console was generating an infinite loop at AST if no prompt string was passed (v1c)
- sdlmouse.bi: SDL_WarpMouse was named as SDL_WrapMouse (v1c)


Version 0.06 Beta:

[added]
- STATIC declared before SUB or FUNCTION like in VBDOS/VB (v1ctor)
- another quirk: ELSE and ELSEIF with statements in the same line (v1c)
- "IF expr THEN linenumber", GOTO ugly stuff (v1c)
- byte and floating-point vars can now be freely mixed (v1c)
- ALIAS declaration on SUB's or FUNCTION's (prototypes already had that) (v1c)
- FRE function (v1c)

[fixed]
- assumption that GAS would convert IDX*3 to IDX*2+IDX like MASM/TASM/NASM do (v1c)
- passing non-existent arrays by descriptor would cause an access violation (v1c)
- RND should never return 1.0 (v1c)
- too few array dimensions (limited to 16 now) (v1c)
- DATE$ was wrong, libc's localtime() returns current year less 1900 (v1c)
- FOR was accepting UDT fields as counter (v1c)
- file names with spaces, now quotes are added when passing them to AS and LD (v1c)
- when path contains spaces, EXEC, RUN and CHAIN will use a short one (v1c)


Version 0.05 Beta:

[added]
-  NEXT with multiple identifiers (NEXT a, b, ...), as many old sources seem to have that (v1ctor)

[fixed]
- PRINT and WRITE stmts were accepting expressions separated by white-spaces (BC also allows that) (v1c)
- quirks with LINE INPUT and INPUT for console, message is optional (try parsing that using a LR..) (v1c)
- and another one with CLOSE, file number is also optional and that way it works as RESET (v1c)
- CSRLIN was declared as CSRLINE (v1c)


Version 0.04 Beta:

[changed]
- fpu initialization is done at rtlib now, for better portability (v1c)

[added]
- LOCAL keyword to be used with ON ERROR statments, when inside sub-routines (v1c)
- "ERR = expr" statement, for setting the error number (the ERR function already existed) (v1c)

[fixed]
- SDL prototype for UnlockSurface, the alias was wrong (v1ctor)
- SDL include files: all BYREF args were changed to BYVAL ... PTR, for better consistency (v1c)
- line continuation char "_" was being processed inside comments and $include's file names (v1c)
- entry point name wasn't checking for "-" chars, that are valid on file names, but invalid on symbol names (v1c)
- using RESTORE w/o a label before any DATA statement would create the wrong default label (v1c)
- loading larger vars to byte ones with SI/DI was wrong as the source type was not being remapped at EMIT (v1c)


Version 0.03 Beta:

[fixed]
- entry point name was wrong when the source file had slashes in the name, and not back-slashes (v1ctor)
- IR was renaming the compare ops when operands hadn't the same class, 'cause a x86 FPU opt. done at AST (v1c)


Version 0.02 Beta:

[fixed]
- IR module was not freeing regs of the same classes while making int convertions and reusing them (v1ctor)
- optargs.bas wasn't working, it was being used just as a prototype, shouldn't be there (v1c)
- argument-less function pointers: parser wasn't accepting them when ()'s were used (v1c)
- right$ was reversing the result (v1c)
