Version 1.01.0

[changed]
- On Linux/*BSD, the FB runtime will now delay using VT100 terminal escape sequences to query terminal window size and cursor position until the first use of a console I/O command (previously it was immediately done at startup, always, even if the FB program didn't use any of FB's console I/O commands)
- WITH ... END WITH blocks now have an implicit scope, like SELECT, DO ... LOOP, etc. Variables declared inside will no longer be visible outside.
- Identifier length limit increased from 64 to 128 (due to Windows API headers which contain at least one identifier with 68 chars)

[added]
- On Linux/*BSD, the FB runtime will now respect the __fb_enable_vt100_escapes global variable (also see examples/console/disable-vt100-escapes.bas). FB programs can set it to 0 (FALSE) in order to manually disable the use of hard-coded VT100-specific escape sequences by FB's console I/O commands. This can help getting FB programs to run on older terminals which don't accept these escape sequences. However, it may also cause FB's console I/O commands and functions to behave differently. For example, if the use of the escape sequence for querying cursor position is disabled, then the FB runtime will assume that the cursor starts out at position 1,1 even if that is not actually true.
- WITH compounds now also accept type<UDT>(...) and UDT(...) expressions
- Constant 0 integers can now be assigned to pointers no matter what integer type it is. Previously it didn't work with [U]LongInts on 32bit and [U]Longs on 64bit.
- Constant 0 pointers can now be assigned to any integer type. Previously this was only allowed with integer types matching the pointer size (32bit or 64bit).
- #757: It's now possible to do UDT().field instead of (UDT()).field (field accesses on anonymous UDTs with constructors)
- On 64bit, bitfields can now use the [U]LongInt type
- Bindings (new/updated, including 64bit support):
	Allegro 4.4.2 (allegro.bi)
	algif 1.3 (allegro/algif.bi)
	alpng 1.3 (allegro/alpng.bi)
	Allegro 5.0.10 (allegro5/allegro.bi, plus the addons such as allegro5/allegro_font.bi)
	CGUI 2.0.3
	CUnit 2.1-3
	fmod.bi for the old FMOD 3.75
	IUP 3.11.2
	libclang 3.5.0
	libcurl 7.39.0
	libffi 3.1
	libjit a8293e141b79c28734a3633a81a43f92f29fc2d7
	libpng 1.2.51, 1.4.13, 1.5.19, 1.6.14 (#define __LIBPNG_VERSION to 12/14/15/16 to select version, default = 16)
	libzip 0.11.2
	LLVM-C 3.5.0
	Lua 5.2.3
	ncurses 5.9
	PDCurses 3.4
	zlib 1.2.8
	crt/sys/types.bi now provides off_t on Windows, like MinGW.org and MinGW-w64

[fixed]
- 1.00.0 regression: DRAW x/y pen position was reset during X<address> subcommands, instead of being preserved and passed to/from the subcommands
- 1.00.0 regression: C backend: Bad code generated when taking the address of __FB_ARGV__, resulting in a gcc error.
- Linux/*BSD: FB programs run in the background (CTRL+Z + bg) could hang on exit due to the FB runtime triggering a SIGTTOU
- -gen gcc: Single-precision constants were being emitted with precision less than 24 bits
- 1.00.0 regression: When compiling on DOS, \ backslashes were passed to the linker as \\ causing it to fail opening the passed files
- An fixed-size array variable declared behind a dynamic array variable in the same statement (for example <DIM AS INTEGER a(), b(0 to 1)>) was accidentally made dynamic too
- 1.00.0 regression: "REDIM Foo.array()" created a new local array called "array" (ignoring the "Foo." namespace prefix) if Foo.array was an existing variable and not a declared-but-not-yet-defined EXTERN (or static member variable). This will trigger an error again now. In FB 0.90.1 the error was "duplicate definition". Now it will be "declaration outside the original namespace or class", to match the behaviour for non-array variables.
- Type-less (and dimension-less) REDIM was allowed to define EXTERN dynamic arrays, even though DIM is not allowed to be type-less for defining EXTERN variables
- 1.00.0 regression: Compiler crash after showing an error when defining a non-array EXTERN using an array declaration
- 1.00.0 regression: lhsint &= rhsint self-assignments, where the lhsint expression included a function call, didn't result in a "type mismatch" error anymore, even though the string result of the & concatenation operation couldn't be assigned back to the lhsint.
- Self-assignments will now be parsed correctly when the lhs is a call to a function with byref result and one argument, for example: f(0) += 1
- Partial fix for #740 (unsafe FB runtime signal handling code): Fixed a potential dead lock and unnecessary terminal size query in the Unix rtlib.
- 0.90.0 + 1.00.0 regressions: SELECT CASE [AS CONST], FOR, and WITH were broken if the given expression(s) contained temporary variables, for example a function call with dynamic string parameters where the passed arguments were string literals. The temporary strings or UDT objects were destructed too early, before even being initialized, causing undefined behaviour. Temporary dynamic strings were affected by the problem since FB 1.00.0. Temporary UDT objects were affected by the problem since FB 0.90.0.
- #522 (part 1): WITH destroyed temp vars before entering the block. Now they will be kept alive until END WITH (or any EXIT/RETURN/GOTO out of the WITH block).
- #522 (part 2): WITH produced bad code on Win32 when used on function call returning a small UDT (i.e. where the UDT is returned in registers)
- Win32 gfxlib2 did not process thread messages, causing problems with response to system hotkeys and potentially more
- Hiword() on 64bit didn't filter out the upper dword when given a 64bit value
- The compiler incorrectly added leading underscores to ASM symbols on Win64 and 64bit Cygwin. Leading underscores are only used by Win32, not by Win64 though.
- #744: False-positive "recursive define" error messages in some situations with multiple/consecutive/nested (but non-recursive) macro expansions in the same line
- #478: DRAW "Mx,y" was offsetting subpixel precision by 0.5, leading to rounding errors e.g. in "Pp,b"
- DRAW now draws U/E/R/F/D/G/L/H using line-drawing routines rather than pixel-by-pixel, resulting in steadier lines and much better speed
- DRAW was not unsetting the B/N qualifiers after 0-length directional commands, e.g. "R0", resulting in them being applied to the following command, e.g. DRAW "B U0D0L0R0 R10" would not draw "R10"
- Bad code was generated when initializing integer variables with a wstring-indexing expressions
- #723: LINE clipping now doesn't affect which (unclipped) pixels are plotted, eliminating rounding differences and correctly preserving the position of the style bits
- BLOAD now gives an error if it encounters a BMP file with an unknown header size
- BLOAD was misreading bitfields in BMP files with undocumented BITMAPV3HEADER format (56-byte headers)
- PRINT now disallows commas/newlines after SPC/TAB, instead of silently ignoring them
- 0.90.0 regression: Compiler crash during error recovery for expressions like 'type<UDT>().field' where initializer values are missing
- When passing a constant zero of some integer to an overloaded procedure, overloads with integer parameters will now be preferred over overloads with pointers (literal 0 can still be passed to pointer parameters in this case though, by casting it to the pointer type)
- Literal zeroes with [U]Byte or [U]Short type (or the 16bit Integer in -lang qb) can now be passed to pointer parameters of overloaded procedures (now it's possible to call Bsave() with 0 source buffer in -lang qb again -- it also was affected by this bug since FB 0.90)
- #760: RETURN and FUNCTION= couldn't be used together in byref functions returning an UDT with constructor. This check is now only applied to functions returning byval.
- #755: If no result is set in byref functions, the compiler will now show an error instead of a warning (because a byref function defaults to returning a null reference, most likely causing a crash at runtime)
- Better error message for function result assignments outside of the function (#754), and for illegal use of Exit Sub|Function|...
- #748: Static member variables in UDTs inside procedures or scope blocks were allowed without error message (but didn't and cannot fully work in this situation, like methods). The compiler will now show an error in this case.


Version 1.00.0 (former 0.91.0):

[changed]
- Platform naming conventions have changed for Linux/BSD due to 64bit/ARM support. dos/win32/xbox stay the same, win64 is added, and we use the <os>-<cpufamily> format for other systems (Linux/*BSD/Cygwin): linux-x86, linux-x86_64, linux-arm, etc. This affects the compiler's -target option, installation directory layout, release packages, compiler -v output, etc. but not any FB code.
- The normal (non-standalone) compiler now uses target-specific sub-directories in lib/freebasic/ again, for example lib/freebasic/linux-x86/, to allow libs for other targets to be installed into the same directory, for example lib/freebasic/linux-x86_64/, instead of having to use a separate directory like lib/freebasic-linux-x86_64/. Same goes for the FB makefile: the *.o files go into target-specific subdirs in src/{compiler,rtlib,gfxlib2}/obj/, to avoid trashing the source dirs with tons of separate obj-<target>/ subdirs.
- More predictable overload resolution for primitive types, preferring: the same dataclass >> a type that's at least as large >> the closest in size >> the same signedness >> the same kind >> the [U]INTEGER type
- Bin/Oct/Hex(x, digits) functions now prepend zeroes, even if it's more than the data type size, if needed to fill the result string up to the requested amount of digits
- Number literal suffixes are now followed more strictly. For example, a number with L suffix will now always be a 32bit LONG (previously it could be 32bit or 64bit, signed or unsigned, depending on the value), and the % integer suffix will always produce the FB dialect mode's default INTEGER type (INTEGER, or SHORT in -lang qb), but never a [U]LONGINT anymore.
- CONST isn't allowed/needed on constructors/destructors anymore, the non-CONST versions now work even with CONST objects. (A CONST constructor couldn't initialize the object, so it's not useful. And after a destructor runs, the object is "dead", so it doesn't matter whether the destructor modified it or not.)
- DOS rtlib no longer uses setlocale(), as FB-dos doesn't support Unicode anyways, and thus the setlocale() reference here only served to unnecessarily increase .exe size.
- #if expressions allow quirk function names to be used as literals again, so for example <#IF TYPEOF(x) = STRING> works again, instead of complaining about missing arguments in a call to the String() function.
- For dynamic arrays where the dimension count is known at the point of the declaration, fbc will now allocate array descriptors with room for only the amount of required dimensions. Descriptors with room for all of FB_MAXARRAYDIMS will only be used for dynamic arrays declared with '()' (unknown dimension count) now.
- The C++-compatible name mangling for procedures with BYDESC parameters has been adjusted to match the implementation of BYDESC parameters, and to support the new '(any[, ...])' syntax.
- #699: The default global New/New[]/Delete/Delete[] operators now simply use allocate()/deallocate() internally, instead of the functions from GCC's libsupc++. This avoids platform-dependant behaviour of the GCC functions (exception throwing, aborting) in case of allocation failure (instead, NULL will be returned as with allocate()).
- FB no longer uses libsupc++ (from GCC's libstdc++) by default
- The implicitly generated copy constructors and LET overloads will now have "BYREF AS CONST MyUdt" parameters (previously they didn't use CONST), to allow copying from CONST objects to work at least for the built-in data types or with nested UDTs. For backwards compatibility, if there is a user-defined "UDT.let(byref as UDT)" LET overload, FB will still add the non-const "UDT.constructor(byref as UDT)" copy-constructor. It's still the programmer's responsibility to write proper "byref as const UDT" versions of the copy-constructor or LET overload if the UDT needs deep-copying and CONST instances of the UDT are being used.
- Function pointer types that differ only in function result CONSTness will now be seen as different, as in C++. Function pointer types that differ only in BYVAL parameter CONSTness will now be seen as being the same, as in C++.
- Some internal data structures and fields ($fb_RTTI, $fb_Object, $base, $vptr) have been renamed from $foo to foo$ to prevent gdb/STABS debugging data confusion, because a leading $ has special meaning there.
- user32 is now linked in by default when compiling for Windows (and Cygwin) as it's sometimes needed by MinGW-w64's libmingwex

[added]
- 64bit support (currently x86_64 and aarch64, based on -gen gcc): INTEGER/POINTER = 64bit, LONG = 32bit DWORD. Compiler #define: __FB_64BIT__
- -arch 32|64 options to support easy switching between 32bit and 64bit, by selecting a default arch that supports 32/64 bits respectively.
- ARM support (currently armv6|armv7-a|aarch64) based on -gen gcc. Compiler #define: __FB_ARM__
- To support non-x86 Unix shared libraries, there will now be PIC (position-independent code) versions of the FB libs for such systems: fbrt0pic.o, libfbpic.a, etc. The compiler will automatically use them when making a non-x86 Unix shared library.
- -pic option for generating position-independent code for non-x86 Unix shared libraries (automatically enabled by -dll, but must be given manually when compiling code via -c or -lib, if it will later be linked into a shared library)
- fbc -v now prints out the target system and architecture
- BYVAL AS STRING is now working properly: it now has BYVAL semantics and no longer behaves like BYREF AS ZSTRING. Modifications made by the callee are not visible to the caller, as for other BYVAL parameters. (BYVAL AS STRING is implemented by copying the string argument into a temporary STRING, whose descriptor is then passed BYREF to the procedure)
- New syntax for declaring dynamic arrays with certain amount of dimensions (but no initial bounds): DIM array(ANY) AS INTEGER (1 dimension), DIM array(ANY, ANY) AS INTEGER (2 dimensions), etc. This allows for better compile-time checking of dynamic array parameters, and also allows the compiler to allocate smaller array descriptors which is especially useful for dynamic array fields.
- Dynamic array fields are now supported in UDTs (for example: array(ANY) AS INTEGER). Similar rules as for dynamic string fields apply: Just the array descriptor is included in the UDT, not the actual array data. The UDT will become a class, and is given an implicit constructor and destructor to initialize the array descriptor, or free the data it contains. This code will also automatically be added to user-defined constructors/destructors.
- REDIM now also accepts expressions to access dynamic arrays, instead of just plain identifiers, which is needed to redim dynamic array fields, or dynamic arrays that are static member variables. For example: REDIM (this.array)(0 to 1)
- Improved multiplication/division/modulus to bitwise shift/and optimizations to handle operations with 64bit and unsigned right hand operand better
- Updated header for libzip 0.11.1
- Indexing/member dereferencing operators ([], ->) can now be applied to VARPTR/PROCPTR/STRPTR/SADD() expressions (for example: print strptr(s)[1]), instead of requiring the address expression to be wrapped in parentheses first.
- FLT_MAX and DBL_MAX to crt/limits.bi
- operator [] overloading support, for example: type MyStringClass : declare operator []( index as integer ) byref as integer : ...
- warning message when mixing signed and unsigned operands in comparisons or integer divide/MOD/SHR operations, where the signedness could change the result
- crt/long.bi, which provides the CLONG and CULONG type aliases that always match C's long and unsigned long data types (for use when making FB bindings for C libraries that use C's long data type, because 64bit FB doesn't have a built-in type that matches 64bit C's long on all platforms)
- crt/longdouble.bi, which provides a CLONGDOUBLE type that (at least in size) matches C's long double type, for use by bindings.
- Adjusted CRT headers for 64bit support
- Updated CUnit 2.1-2 headers, with 64bit support
- #macro can now also be used to #define macros without a '()' macro parameter list
- #438: Checking of parameter initializer expressions: When a parameter has a different initializer in the procedure prototype and in the procedure body, a warning will be shown now. Previously, the compiler silently ignored the initializer from the body and always used the one from the prototype.
- Taking the address of an anonymous object created by constructor call is now allowed by the compiler: @UdtWithCtor( <ctor-params...> )  It already worked for anonymous objects of UDTs without constructor: @type<UdtWithoutCtor>( ... )
- crt/linux/syslog.bi header
- GFX statements now accept UDTs as target/source images, if the UDT has cast() AS ANY PTR (or other PTR types) operator overloads
- jpeglib example now works with both fb and fblite dialects
- Any function result may now be ignored at the call site (simply by not using the function result in any expression or assignment). Previously this was only allowed for functions returning integer types or pointers.
- Thread-safe version of the FB graphics library (libfbgfxmt), used automatically if FB's threading functions are used or fbc's -mt command line option is given, just like the thread-safe version of the FB runtime library (libfbmt).
- NEW/DELETE and NEW[]/DELETE[] can now be used with the dynamic STRING data type
- ThreadDetach() function in fbthread.bi: alternative to ThreadWait() that cleans up the thread handle but does not wait for the thread to finish.
- IsRedirected() function in fbio.bi, that can be used to check whether stdin or stdout is redirected to a file or not
- Dynamic array descriptors will now always be generated with the FBARRAY.data and FBARRAY.ptr pointer fields specialized for the array's original data type, improving the -g debug info
- Len() can now be overloaded as an operator for user-defined types
- Suspicious pointer assignment warnings will now be shown for constant declarations too
- CONST can now be used to declare UDT/string/procedure pointer constants, for example: CONST p AS MyUdt PTR = 0

[fixed]
- dlltool syntax error when building a DLL without any EXPORTs
- ImageDestroy() won't crash anymore if given a NULL pointer
- The compiler didn't check ALIAS names (if given in both DECLARE prototype and procedure body) for equality
- Compiler crash after showing error for "dim shared E as E" where E is an Enum declared inside an Extern block
- Compiler crash on Explicit Enum declared inside Extern block
- #if typeof() and #print typeof() will now take the full procedure pointer type including parameters, calling convention (if non-default), etc. into account, instead of just treating everything as "FUNCTION PTR".
- #669: Compiler crash instead of error message for Static member variables declared inside anonymous UDTs
- #675: SHARED variable initializers referencing a non-SHARED STATIC from the implicit main() scope triggered an internal compiler error (dangling pointer), instead of resulting in an error message.
- Various implicitly generated variables (such as FOR/WITH/SELECT CASE temp vars) won't appear in -g stabs output anymore
- #597: Illegal ASM generated for +,-,*,/ floating point operations when the right hand-side operand was a byte or ubyte variable enclosed in a cast to double or single
- #677: Casts changing only signedness on the rhs of a +,-,*,/ floating point operation could be ignored
- Using #undef (or Option NoKeyWord) on symbols which are already in use somewhere won't cause internal compiler errors anymore: The compiler will now simply forget the symbol's identifier, so it cannot be used from input code anymore, instead of fully deleting the symbol and possibly corrupting the compiler's internal data structures.
- #671: Arguments weren't always converted to the parameters' data type, causing gcc pointer mismatch warnings under -gen gcc
- #670: Functions returning a Byref result weren't allowed to return references to elements from array parameters
- Mid() statement didn't allow some string expressions as destination, such as <Mid( *StrPtr( s ), ... ) = ...>
- The UINT_MAX from crt/limits.bi was an INTEGER instead of UINTEGER
- #defines with invalid or missing identifiers were ignored instead of causing a compiler error
- #686: Statements with lots of identifier/keyword tokens (such as procedure pointer variable declarations with 10 parameters) could cause unexpected compiler behaviour, e.g. compiler errors even though the code was good.
- The compiler allowed integer arguments to be passed to BYREF AS Z/WSTRING parameters, treating them as pointers
- #603: Optional parameters for which no arguments were given could break overload resolution. Now, overload resolution will only search for matching overloads based on the given arguments.
- Overload resolution if no arguments were given will no longer prefer a parameter-less overload over one with only optional parameters. This is now an ambigious call error, as in C++, for consistency with overload resolution with one argument given between two overloads, both with the same first parameter, and one having a second optional parameter.
- #689: Bad code generated for GET #, , array(), , bytesread (bytesread variable not passed on to fb_FileGetArrayIOB(): the last argument was completely missing)
- The compiler allowed fixed-length z/w/string variables to be initialized with integers, leading to bad code generation or runtime crashes. Now only strings should be allowed.
- #691: 0.24 regression: The compiler didn't prevent linking .so's against themselves, causing an ld error
- 0.90.0 regression: When dragging a window on Win32 with the OpenGL gfxlib2 driver, it was resized to minimum size
- #663: For virtual methods, base.method() called the overriding method, instead of the base's own method
- The Is operator (RTTI) treated UDTs with the same identifier but from different namespaces as being equal
- RTTI/Vtables inside namespaces used GCC-incompatible name mangling
- #616: Assignments between pointers and floats are now disallowed, matching the behaviour for assignments between pointers and other incompatible data types
- fbc -g generated wrong stabs definitions for UDTs whose size had to be rounded up (tail padding), preventing gdb from properly showing the content of arrays of such UDTs
- #651: Multiple cases of bad ASM code generation for expressions involving LONGINTs, observable mostly when compiled under -exx due to the additional register spilling due to calls to pointer/bound checking functions (affected -gen gas only)
- inc/win/*.bi headers: PC* and LPC* typedefs were not marked as const ptrs
- -gen gas asm error when the rhs operand to SHL/SHR is a constant value greater than 255
- C backend: Won't generate #line 0 at the top of procedures under -g anymore
- C backend: Will now generate #lines for procedure headers under -g (improved debugging support under -gen gcc)
- #703: Compiler crash after recovering from "ElseIf behind Else" error
- The Win32 gfxlib2 will now use a (more) unique name for the window class it registers to create the graphics window, to prevent issues when using multiple gfxlib2 instances in parallel in the same process.
- Non-standalone fbc builds failed with a "not found" error when having to execute compiler tools repeatedly (i.e. when compiling multiple modules instead of just one), if the tools weren't present in the same directory tree as fbc, such that fbc had to rely on the PATH environment to find them, on systems where exec() won't search the PATH (i.e. DOS/Win32)
- crt/ctype.bi: The isascii() and toascii() CRT function declarations used wrong name mangling, and on Win32 the wrong calling convention too
- crt/bits/pthreadtypes.bi: Various type aliases (including pthread_t) and UDT fields were wrong (used a 64bit integer type instead of a 32bit type like the original C header, assuming a 32bit system)
- crt/win32/process.bi: spawnvpe()'s and _spawnvpe()'s last parameter type was wrong
- #434: win/winbase.bi's RtlFillMemory() declaration was wrong (it was just an alias for memset(), but actually it should be memset() with swapped fill/length parameters)
- crt/stddef.bi: Now uses signed 32bit wchar_t for Linux, to match glibc, instead of unsigned 32bit
- crt/stdint.bi: WCHAR_MIN/WCHAR_MAX/WINT_MIN/WINT_MAX declarations were incomplete
- Debugging help: For dynamic arrays, the compiler will now always name the array descriptor symbol after the original array name
- datetime.bi: DateDiff() was declared to return a 32bit integer while the rtlib actually returns a 64bit integer
- SELECT CASE AS CONST was ignoring the upper 32 bits of 64bit integer expressions in 32bit mode
- ICE (dangling pointer) with type initializer expressions, which is known to at least cause a compiler hang during error recovery
- #705: REDIM in a procedure marked with STATIC did not create a STATIC dynamic array (on heap, preserved to next call), but only a local dynamic array (on stack)
- STATIC declarations couldn't use variables for array bounds, but only compile-time constants
- STATIC declarations ignored OPTION DYNAMIC
- zlib example tried to modify a string literal, which would cause it to crash on Linux or with -gen gcc
- The compiler could sometimes ignore casts in address-of expressions, for example "@cuint( *integerptr )" returned an INTEGER PTR instead of a UINTEGER PTR
- #699: "New Integer[-1]" or similar uses of New[] with negative size, that will wrap around to a massively huge value because the size is treated as unsigned, caused the ASM backend to try to emit GiBs of MOV instructions (one for each 4 bytes...), seemingly causing the compiler to hang.
- #696: Bad code generated for temporary variable destruction (such as temporary strings from String IIf()) used as argument to built-in statements such as Open or Draw String when -e/ex/exx error checking was enabled
- On Linux/*BSD, shell(), exec(), run(), chain(), dylibload(), dylibunload() weren't thread-safe (due to Unix rtlib's console I/O handling)
- C backend: Nested anonymous structures could be emitted incorrectly, potentially causing them to be too small, which could easily result in buffer overflows on stack due to local variables of that struct type being smaller than expected
- filecopy() (for DOS/Linux/*BSD) can now handle large files (> 2 GiB)
- Using -asm att together with the ASM backend (-gen gas) now results in an error, because it only supports -asm intel
- Uninitialized variable accessed in format()
- =Any initializer on fields didn't cause an implicit constructor to be added as for other field initializers
- UByte/UShort versions of Bin/Hex/WBin/WHex( n, digits ) functions were missing
- Miscompilation of runtime library function calls for ImageCreate(), Mki() and ThreadCall, in modules except the first when compiling multiple modules in one invocation of fbc, if -lang qb was given on the fbc command line (not as #lang "qb" in the source).
- C backend: String literal emitting now also escapes characters that would otherwise form trigraphs
- big_int binding: Some function declarations were missing parameters; also added some missing functions
- 0.90.1 regression: PMAP was returning bad values for func values of 0 or 1.
- #701: fbc didn't escape \ as \\ in @files (response files) sometimes used when invoking ld
- Win32 fbc will now avoid hitting Win32 command line length limits when invoking ld with a long command line, by using "ld @file" (response files)
- #713: gfxlib2 crashed when closing and re-opening an X11 OpenGL graphics screen
- ThreadCall on Win32 couldn't be used with procedures declared inside Extern "Windows-MS" blocks
- CIRCLE did sometimes not fully update the screen immediately, causing the last scan line of the circle to remain invisible until the screen was updated some other way
- crt/linux/fnctl.bi: Broken declaration of open_ ALIAS "open"() (0.90.0 regression)
- Using Unicode characters in comments and compiling with -g could lead to junk bytes being emitted into the generated .asm/.c files
- #710: Operator Placement New[] ("new(address) DataType[N]") will no longer store a cookie containing the number of vector elements (N) in front of the allocated buffer, as done by normal New[]. The cookie is an implementation detail that the coder can't be expected to know, especially because it only applies to New[] when used with data type that has a destructor, so the buffer given to Placement New[] will likely be too small. Besides that, the cookie is only useful to Delete[], which however can only be used with New[], but not Placement New[] (no way to be sure that the given buffer even can be Delete[]'d).
- Bad code generated when using type<string>(...) in a string concatenation or as argument to a BYREF AS ANY parameter
- -fpu sse: Bad code generated for negation on Single function result returned through FPU stack
- -fpu sse: Bad code generated when calling sgn() on Single function result returned through FPU stack
- -fpu sse: Bad code generated when calling sqr() on Double function result returned through FPU stack
- -fpu sse and -vec 1|2: Various cases of bad code generation resulting in operand size mismatch errors
- fbc crashed after showing the error message when using -vec 1|2 without -fpu sse
- ASM backend: Sgn(LongInt) returned wrong values
- C backend: Extern "Windows-MS" is now supported, including DLL exports (stdcall procedures without @N suffix)
- #709: format() adds erroneous thousands delimiter, was affecting all number strings that were multiple of 3.
- #715: GFX statements (Get, Put, Line, Circle, ...) are now more strict about their target/source image parameters. Arrays are still accepted as in QB, but besides that, the argument must be some pointer expression now, that is expected to point to an FB.IMAGE buffer of the proper size. Previously non-pointer expressions were accepted but could cause bad code to be generated or could be silently miscompiled.
- #665: DRAW statement now accepts the same target image expressions as the rest of GFX statements (not just simple pointer variables or 'a.b' field accesses anymore)
- #687: DRAW statement now remembers the subpixel position between commands.
- #717: REDIM [PRESERVE] did not clear array elements with destructor but no constructor
- x->*field syntax wasn't working if operator -> was overloaded
- x[a][b] syntax wasn't working if operator [] was overloaded
- x[a].field syntax wasn't working if operator [] was overloaded
- Win32 ScreenInfo() reimplemented to report screen size more accurately (the old version returned incorrect values on Windows 8.1). Also, it will now report the size of the screen assigned to the program, rather than always the primary monitor.
- #assert inside #if 0 blocks caused a syntax error
- PP typeof()'s argument was not being macro-expanded properly (e.g. the x in <#if typeof(x) = ...>)
- Macro expansion right behind a PP typeof() wasn't working (e.g. the foo in <#if typeof(x) foo>)
- Crash (division by zero) when PRINTing onto tiny graphics screens (e.g. screenres 1, 1)
- pdflib.bi was missing #inclib "gdi32"
- Methods with CONST function results are no longer allowed to override virtual methods with non-CONST function results, and vice-versa (the return type must be the exact same, as for function pointers)
- CONST-member methods are no longer allowed to override non-CONST-member virtual methods, and vice-versa
- The compiler no longer crashes (SIGFPE) on constant expressions containing signed integer division overflows, e.g. -2147483648 \ -1, which triggers SIGFPE when calculated on x86. The compiler now inserts 0 (-2147483648 \ -1 = 2147483648 which doesn't fit into a 32bit signed integer, and in theory overflows to 0) and shows a warning. Note: FB programs doing such divisions at run-time (e.g. <dim a as integer = -2147483648, b as integer = -1 : print a \ b>) may still run into SIGFPE crashes; this change just affects the compiler itself, not the generated code.
- When calling a byref function through a function pointer, the result may now be ignored, just like with normal function calls, or when calling normal functions through function pointers.
- STRPTR() on a CONST STRING (DIM s AS CONST STRING) did not preserve CONSTness and allowed modifying the string
- win/objbase.bi: Wrong IsEqualGUID() declaration, producing wrong result value (subsequently, all aliases such as IsEqualIID() were wrong too)
- Fields were allowed to have type suffixes when declared using the "AS DataType a, b, c" syntax instead of "a AS DataType"
- When DIM'ing an EXTERN array, the DIM statement was allowed to have different lbound than the EXTERN
- Compiler crash during error recovery if a dynamic array declaration/REDIM contained '...' ellipsis upper bounds
- EOF() didn't work properly with files bigger than 4 GB
- #643: Typeless REDIM was accidentially being allowed, if the array's identifier matched that of a field visible through the implicit THIS reference, by re-using the field's data type, but still creating a new array. This will now trigger a compiler error just like other typeless REDIMs without a pre-existing array.
- Duplicate EXTERNs for dynamic arrays are now allowed, just like duplicate EXTERNs for normal or fixed-size array variables, which already were allowed before.
- EXTERN variables could be allocated via a static array variable declaration, this will now trigger an error.
- #648: Local (scoped) variable declarations (including REDIM) caused EXTERNs to be allocated, instead of shadowing them
- Local dynamic arrays can now be shadowed in nested scopes without compiler error
- More precise compile-time checks of dynamic array dimension counts
- -lang fblite/qb: EXTERN arrays are no longer allowed to have subcripts if OPTION DYNAMIC was in effect, because EXTERN dynamic arrays cannot have initial subscripts, just like COMMON arrays.
- #720: Some pointer assignments weren't working due to bogus CONSTness checking
- #582: Wrong code generated for bitfield self-BOPs or SWAPs sometimes under -exx or if the bitfield expression contained function calls (side-effects)
- When specifying an .o file name without extension but '.' in its path (for example: -o ../foo), fbc created temporary files by stripping everything from the .o path until that '.' and then appending the new extension, which often resulted in bad/unexpected file names (for example: ..foo.asm).
- Calling getkey() in one thread won't cause other threads' rtlib function calls to block until getkey() returns anymore
- #726: CONSTRUCTOR|DESTRUCTOR (module-level initialization/cleanup) was allowed to be specified on sub prototypes (although, it was ignored), method bodies (silently miscompiled due to the missing THIS argument), and PRIVATE/PROTECTED static member procedures. Now these cases are disallowed.
- #576: Array elements could be passed to array parameters in place of the array itself: <myfunction( myarray(index) )>. However, the array index was simply ignored. The array must be passed without index now: <myfunction( myarray() )>
- #722: Member operators NEW/DELETE/NEW[]/DELETE[] could be declared CONST/VIRTUAL/ABSTRACT despite being implicitly STATIC. This is now disallowed.
- C backend: main() will now be emitted with clang-compatible signature
- C/LLVM backends: Procedures using forward references in their signatures could be emitted with ANY PTRs in place of the forward references, while prototypes/calls could end up using the signature with resolved forward references, causing the generated C/LLVM code to have type conflicts.
- #719: Compiler crash when passing an upcasted class/UDT function result to a Byref parameter
- #698: sizeof() now allows string expressions (note: it returns sizeof(string), not the string length - len() should be used for that)
- #685: SETMOUSE had differing behaviour between platforms when x and y were not both present and within the window
- When RETURN'ing classes without copy-constructor from a function, or passing classes without copy-constructor to a Byval parameter, their Let operator overload was called, even though this is an object initialization, and not an assignment. (the object wasn't even initialized before the Let overload was called)
- Overload resolution didn't allow up-casting arguments when passing to a CONST parameter (e.g. BYREF AS CONST). This also prevented copy constructors with BYREF AS CONST parameter from being called, when the source object had to be up-casted.
- Copy-constructing or assigning an object from a CONST object didn't work with the implicitly generated copy-constructor or LET overload because they only had BYREF AS MyClass parameters which can't accept CONST objects (instead of calling the copy-constructor or LET overload, a shallow copy was done, which for example caused trouble if the UDT contained dynamic strings requiring a deep copy)
- C backend: A gcc warning was triggered when initializing a global variable with an @addressof expression, taking the address of another global.
- #614: When copying (copy-constructing or assigning) objects of classes extending OBJECT, the lhs' vptr could be overwritten incorrectly, causing the object to have a wrong run-time type.
- 0.90.0 regression: -g could produce bad stabs info when #includes were used (after closing an #include block, the wrong directive was used to return to the main file), preventing gdb from determining variable types sometimes
- -g will now produce correct stabs info for dynamic array descriptors
- 0.90.0 regression: Sometimes incorrect C++ mangling of procedures in nested namespaces
- 0.24.0 regression: SWAP called temporary variable destructors too early, even before calling constructors
- Temporary strings used during procedure calls could be freed too early (directly after the call, instead of being kept alive until the end of the statement), potentially leaving references to them (used with-in the same statement) dangling.
- #545: Overload resolution will now properly handle arguments with CONST qualifiers in their data type
- ASM backend -g debug info for dynamic array descriptors: The data type of the DATA & PTR pointer fields was wrong (they were emitted with an extra level of pointer indirection that shouldn't have been there). The DATA pointer field will also now have the array's original data type, while the PTR field is an ANY PTR (since it's the dynamic array's memory block, not necessarily the array data). The dimTB field will now be emitted as the array that it is (instead of as a sequence of manually generated fields).
- Any function pointers were allowed to be assigned to function pointers with varargs, as long as the signature outside the varargs part matched. On x86 this is technically ok for an assignment with types like "sub cdecl( byval as integer ) = sub cdecl( byval as integer, ... )", because the lhs can be called just like the rhs without passing any varargs. But this isn't allowed in C, and isn't necessarily safe on non-x86 platforms. Besides it also allowed BYREF or array (bydesc) parameters in place of the varargs, which breaks even on x86 (e.g. "sub cdecl( byval as integer, byref as integer ) = sub cdecl( byval as integer, ... )")
- Pointer assignments between pointers to different unsolved forward references will now trigger "suspicious" warnings because these forward references may be resolved to different types later. This matches the C++ mangling behaviour which also treats different unsolved forward references as different types.
- Destructors of UDTs with ABSTRACT/VIRTUAL methods will now reset the object's RTTI such that it matches the type whose destructor is running. This prevents virtual calls from a base class destructor into a derived class which has already been destructed, as in C++.
- The compiler refused to generate an implicit default-constructor and copy-constructor for UDTs derived from a simple plain-old-data base UDT (that itself didn't have any constructors)
- Bin/Oct/Hex() didn't accept pointers to CONST types
- Override signature compatibility checking was broken for methods using the Pascal calling convention
- C backend: Structures containing bitfields were sometimes not emitted correctly (wrong sizeof()), so for now they will be emitted as simple byte arrays. This is bad for -g debug info of course, but that can be fixed in the future when FB's bitfields have been made compatible to GCC's, and the C backend can emit them as-is, without having to worry about layout differences.
- #733: The -> operator couldn't be applied to parenthesized UDT expressions even if overloaded for that UDT
- On Win32, wrong code could be generated when returning complex structures from functions: Under -gen gas, they could be incorrectly returned in registers (if small enough), if they became complex only thanks to the addition of implicit members. Besides being ABI-incompatible to GCC/MSVC, this could also lead to missing destructor calls.
- C backend: stdcall functions returning non-trivial UDTs had the wrong @N stdcall suffix (the hidden result pointer parameter was calculated into it, but shouldn't be)
- 0.90.0 regression: Some cases of binary operations involving unsigned operands and constants could cause the compiler to show "implicit conversion" warnings due to internal transformations, for example: dim as uinteger a, b : print a - (b - 1)
- Bad code generated for temporary variable destruction in local array initializers: temporary strings or UDTs with destructors could be destroyed before first used
- #728: Buggy overload resolution for Byval As Const parameters
- LSET / RSET were aborting when the rhs was an empty var-len string
- #739: ASM backend: The compiler allocated unused stack space for dynamic arrays (besides the array descriptor), based on the array element data type size. This was not only a waste of memory, but could also lead to stack overflow crashes if the array element data type was very big.
- #736: Format() overflow when significand (after scaling to 19 digits) is 2^63 or greater
- Format() overflow on very small numbers, trying to scale them by excessively large powers of 10
- 0.24.0 regression: cgi-util.bi was missing
- Format() was adding an extra digit before the decimal point in scientific notation when rounding up to the next power of 10


Version 0.90.1:

[fixed]
- Potential internal errors in Unix rtlib during SIGWINCH signal handling, due to calls to non-async-signal-safe functions
- Any input on stdin could break the Unix rtlib's escape sequence communication with the terminal, e.g. typing very fast at an Input prompt
- #679: WINDOW width/height were losing precision on very small Single values
- Taking the address of a PEEK, [] indexing, or * dereferencing expression could ignore the PEEK/indexing/derefenced data type (e.g. "@peek( integer, myptr )" returned myptr's type instead of an INTEGER PTR, and "@string[index]" returned a ZSTRING PTR instead of an UBYTE PTR). This could also break WITH when used on a PEEK expression.
- C backend: Passing @proc (taking address of procedures) expressions to BYREF parameters caused bad C code to be generated
- Pointer arithmetic on procedure pointers is now disallowed. It is not meaningful, because procedures do not have a fixed size and are not arranged like array elements.
- 0.90.0 regression: A bug in array index parsing could cause the compiler to crash due to arrays being used without index, instead of showing an error message
- 0.90.0 regression: ON GOTO was broken due to the compiler generating bad jump tables for it
- 0.90.0 regression: Some Win32 API libs were missing (e.g. libstrmiids.dll.a)


Version 0.90.0 (former 0.25.0):

[changed]
- -c, -r and -pp options will now complement each-other when used together, instead of partially overwriting each-other and thus causing weird behaviour
- getkey()/inkey() under Linux X11 graphics mode will now return the FB extended keycode for DELETE (&h53FF or &hFF &h53) instead of ASCII DEL (&h7F), for consistency with console-mode and other platforms
- ScreenEvent() won't return extended keycodes anymore in the EVENT.ascii field under the Linux X11 graphics driver
- Removed compile-time errors for float division by constant zero; it will result in INF again, for consistency with the evaluation at run-time
- Overflows when converting constants to SINGLE/DOUBLE won't cause "math overflow" errors anymore
- Overflows in constant conversions to SINGLE will now trigger "overflow in constant conversion" warnings, like conversions to integer types do
- Constant conversions to DOUBLE are not checked for overflows anymore, since DOUBLE can hold all SINGLE/INTEGER/LONGINT values (although, with varying precision)
- Doing "udtvar.constructor( ... )" or "udtvar.destructor( )" won't automatically add a constructor/destructor anymore, but instead show an error
- The C backend now emits expressions in-line instead of using #defines, and also avoids many unnecessary casts, producing much nicer C code
- fbc now uses a custom COFF/ELF32 reader instead of libbfd for the objinfo feature
- fbc will now also read out compile-time information from libs passed as libfoo.a instead of -l foo or #inclib "foo"
- Linux fbc will now prefer linking with libtinfo over libncurses, if available (depending on the distro, ncurses may be present as one libncurses, or with separate libtinfo; but either way FB only needs the libtinfo part)
- ASM backend: Floating point constants are now emitted in form of their raw byte representation, for better precision than when using STR() to emit them as rounded floating point number literals
- crt/stdio.bi now declares rename() instead of rename_()
- Property methods using an explicit ALIAS now respect that alias and do not append __get__ or __set__ anymore
- #637: Assert[Warn]() messages go to stderr now, rather than to the FB screen (because that might be about to be closed)
- LBound/UBound( array, 0 ) now returns 1 and the dimension count, it is no longer the same as LBound/UBound( array, 1 )
- #if/#elseif expressions now recognize declared identifiers (for example a constant FOO will be expanded to its value, instead of being treated as a "FOO" string)
- Unary/binary operations won't return enums anymore; any enum operands will be converted to integer before the operation. (with math operations, the result can be any integer value, and the operand enum won't necessarily include a constant corresponding to that value. And also, if the operands are from different enums, the compiler wouldn't know which one to use as the result type)
- Unary/binary operations will now convert smaller operands to INTEGERs before the operation (note: thus, UBYTE becomes INTEGER now instead of UINTEGER, and also SHORT/USHORT operations will return an INTEGER now)
- -pp will now preserve #inclib, #libpath, #lang, $ meta commands, msbitfields #pragmas, and #undef (except on macros which, unlike other symbols, won't be preserved anyways), in order to allow the output file to be compiled just like the original
- -o in combination with -pp will now set the output file name for the preprocessed version of the associated input module
- SCREENRES is now a normal function instead of a quirk statement
- BSAVE now (by default) saves 32-bit .bmp files in 32-bit screen modes instead of 24-bit files

[added]
- VIRTUAL and ABSTRACT methods (including virtual destructors) in UDTs extending OBJECT, which can be overridden by methods in derived UDTs, provided the same method name and signature is used
- OVERRIDE attribute (method must override a virtual) on method declarations (compile-time check)
- STATIC member variables in UDTs
- BYREF function results:  function f( ) byref as integer
- '=>' can now be used for assignments, in place of '=', same as for initializers. This can be used to solve syntax ambiguities with '=', which sometimes may be interpreted as equality comparison operator while the programmer intended to do an assignment.
- LLVM backend (-gen llvm) that emits textual LLVM IR code and uses llc to compile it into ASM
- Updated headers for caca 0.99.beta18 (caca.bi = new API, caca0.bi = old API)
- Updated header for libzip 0.11
- Updated header for DevIL 1.7.8
- Fixed & updated header for PDCurses 3.4
- Updated GD graphics library header for the 2.1.0 development version
- Updated header for giflib 4.2.1 and 5.0.4 (version may be selected by defining __GIFLIB_VER__ to 4 or 5)
- Updated header for jpeglib 6.2, 7.0, 8.4 and 9.0 (version may be selected by defining __JPEGLIB_VER__ to one of 6,7,8,9)
- Updated header for libpng 1.5.14
- Updated header for Lua 5.2.2
- Updated header for IUP 3.7
- Updated headers for GTK+: GDK & GTK 3.4.4, glib 2.32.4, Cairo 1.12.2, Pango 1.30.1, ATK 2.4.0, Gdk-Pixbuf 2.26.1
- Updated header for libintl 0.18
- Updated header for ODE 0.11.1
- Updated header for SQLite 3.7.13
- Header for libxmp 4.0.4 (module audio decoder)
- Headers for CD 5.6 (Canvas Draw, 2D graphics) and IM 3.8 (image file handling) libraries
- Updated crt/linux/fcntl.bi header
- fbc -asm att|intel option (affects -gen gcc only)
- fbc -rr and -RR options for preserving the final .asm file (useful with -gen gcc where -r/-R preserve the .c file; same as -r/-R under -gen gas)
- fbc -print host|target option, to support shell scripts querying fbc for information that is useful to build systems etc.
- fbc -print x option (named after the fbc -x option), to display the output binary/library file name, as far as it's known based on other input, i.e. -dll, -lib, -m, and input files. For example, on Win32/DOS "fbc -m foo -print x" will give "foo.exe", while "fbc -print x" alone will only print ".exe" (this can be used to query the executable file extension)
- SELECT CASE won't use a temporary variable anymore if the given expression is just a plain variable access already
- SC_CLEAR constant for FB scancode &h4C (numpad 5, a.k.a. clear key) in fbgfx.bi
- SC_ALTGR constant (&h64) in fbgfx.bi, corresponding to the rtlib
- Constant overflow warnings for array boundaries, array/pointer/string indexing, CONST declarations, fixed-length string * N declarations, CASE expressions of a SELECT CASE AS CONST
- Huge variable on stack warning
- NAKED support for the C backend, using GCC inline asm
- ALIAS "" or LIB "" will now result in a compiler error
- fbc now recognizes --version and [-]-help command line options
- IIF now accepts strings and UDTs (yetifoot/dkl)
- win/initguid.bi win32 header
- -exx NULL pointer checks for procedure pointer calls
- CVD(longint), CVS(integer), CVL(single), CVLONGINT(double), for reinterpreting directly between floating-point and integer representations without using strings
- In procedure prototypes, identifiers of array parameters (as in "array() as type") can now be omitted (as in "() as type"), as for non-array parameters
- LBound/UBound() on fixed-size arrays with constant dimension argument (or none at all) will now be compile-time constants
- IIF now allows different types to be mixed, for example iif( condition, mybyte, myinteger ), the result type is the bigger type
- #if/#elseif now accept all kinds of constant expressions that would be accepted in other places (e.g. in PRINT or in constant declarations)
- preprocessor #assert statement
- INTEGER<n> / UINTEGER<n> / C[U]INT<n>, where n is 8/16/32/64, for allowing to choose integer types of a specific size
- CVI<n> / MKI<n>, where n is 16/32/64, to allow bit conversions of a specific size
- type<UDT>( ).field is now possible, as an alternative to (type<UDT>( )).field
- bpp parameter on BSAVE, to request a BMP bit depth
- TYPEOF() can now also be used directly on SUB|FUNCTION(...) function pointer types
- Mode parameter for Lcase()/Ucase() functions, that can be set to 1 to enable ASCII-only mode (e.g. LCASE("foo", 1)), which will be evaluated as compile-time constant if possible
- Improved multiplication/division/modulus to bitwise shift/and optimizations to handle operations with 64bit and unsigned right hand operand better

[fixed]
- libzip headers: zip_stat struct was unnecessarily named zip_stat_, breaking the libzip example
- QuickLZ 1.5.0 header & example
- "fbc libfoo.a" showed usage notes, instead of compiling like "fbc -l foo"
- GOTO jumping over the implicit wstring variable initialization of a SELECT CASE wstring into one of its CASE blocks will now show an error instead of only a warning
- GOTO jumping over the implicit variable initialization of a SELECT CASE (on anything except strings) into one of its CASE blocks will no longer show a false-positive "branch crossing ..." warning
- 'SELECT CASE str1 + str2' was broken and behaved like 'SELECT CASE str2'
- Inconsistent warning message on implicit number to ptr conversions
- Rename case-insensitive naming clashes in IUP3 header defines
- Compiler crash on UDT/enum comparisons (0.24 inheritance regression)
- win/dsound.bi - LPDSENUMCALLBACKW was missing the closing 'W' (thanks to VANYA for find/fix)
- #2131139: "SELECT CASE wstring" allowed integer expressions in "CASE"
- #3549349: The namespace prefix of constants on the left hand-side of assignments was being ignored by the parser, allowing the constant's identifier to match other symbols
- .o files are now linked in the exact order indicated by given .bas modules, .o files, .a files, or -a options on the fbc command line
- getkey() under X11 graphics mode on Linux didn't return proper extended key codes like in console-mode
- getkey() under DOS console-mode didn't encode extended key codes as a 2-byte code using &hFF, causing them to collide with normal key codes
- GooCanvas examples were #including gtk/goocanvas.bi instead of goocanvas.bi
- SQLite 3 header didn't compile due to missing forward declarations and a missing #include "crt/stdarg.bi"
- Potential X11 gfxlib2 driver crash on window maximization despite GFX_NO_SWITCH
- gfxlib2 X11 driver didn't recognize the numpad keys with numlock off
- Linux multikey() will now recognize the CLEAR key (both under linux and xterm terminals)
- gfxlib2 X11 driver returned &h4A instead of SC_MINUS (&h0C) for the "subtract" key on the numpad with numlock off, now it matches win32; the other "add/divide/multiply" keys are remapped this way aswell.
- On Win32 or DOS, __PATH__ could return the current working directory of the compiler instead of the source file's parent directory
- .stabs output could omit the source file's path, preventing gdb from finding the correct file
- Win32 cond*() functions won't crash anymore when given NULL arguments; Unix condwait() won't crash anymore when given NULL instead of a valid mutex pointer
- internal error in ThreadCall parser, potentially causing compiler crashes or miscompilation
- Warnings could still be shown even after the "Too many errors, exiting" message
- ASM backend: Unsigned integer multiplications did not preserve EDX in some cases due to buggy MUL code generation; now the simpler IMUL is used instead
- ASM/C backend: DOUBLEs being cast to SINGLE will now be truncated to SINGLE, as if an assignment to a SINGLE variable was made
- Multiple run-time library symbols have been removed from the global FB namespace: __main, mcount, _monstartup, rename, __divdi3, __udivdi3, __moddi3, __umoddi3, __fixunsdfdi
- Fixed-size arrays/UDTs > 2 GiB will now result in a compile-time error, instead of causing internal integer overflows
- SSE emitter: float2int conversions using movss/movlpd could generate illegal ASM
- ASM backend: A faulty optimization could cause array accesses to be mis-compiled
- More consistent optimization of (foo + constant1) * constant2 (using distribution)
- GOTO jumping over variable declarations of UDTs with non-default constructors only was not an error like in case of UDTs with default constructors
- EXIT FUNCTION in combination with RETURN with complex function result UDT was accepted, leaving the result UDT unconstructed
- Complex function result UDTs were not constructed if neither FUNCTION= nor RETURN were used
- No error was shown when complex function result UDTs were left unconstructed when using FUNCTION= because the UDT had no default constructor
- #3554189: "SWAP parent, child" was allowed (where child is an UDT derived from the parent UDT) even though "child = parent" assignments are not allowed
- #3544952: Static arrays of forward-referenced derived UDT pointers failed to compile
- #3538470: Expressions such as "(Type<MyUDT>( )).myfield" could crash the compiler or be miscompiled
- C backend: Local variables could shadow other variables from parent scopes or the toplevel namespace, or even in the same scope but above its DIM statement
- C backend: Bitfields were emitted as plain fields, making such structures unnecessarily big
- #3571432: LIB "" crashed the compiler
- ASM backend: -NaN float constants were emitted as +NaN
- C backend: Local UDT declarations were emitted in the scope they were first used, not where they were declared
- C backend: DATA statement declarations could be emitted in the wrong order, causing gcc errors
- C backend: Static variables with destructors were emitted as locals despite needing to be visible to destructor wrapper functions
- The C backend does no longer allow/disallow different cast()s than the ASM backend
- C backend: +/- INF/NaN float constants didn't work
- C backend: Using threadcreate() could cause duplicate function pointer typedefs errors
- EXPORT will now be ignored when compiling for non-win32 targets
- C backend: Dereferences on constants casted to pointer types (e.g. "*cptr(byte ptr, 0)") were not emitted correctly
- C backend: frac() returned x - int(x) instead of x - fix(x) (different for negative values)
- Expressions like "@*cast(integer ptr, 123)", i.e. taking the address of a dereferenced type-casted constant, were rejected or caused parsing inconsistencies
- FOR loops with ANY PTR counter used a zero step size or zero step size multiplier, instead of 1 as for BYTE PTR, generating an infinite loop
- FOR loops with FWDREF PTR counters were allowed, despite the incomplete type, causing zero step size to be used (as above)
- UDT methods (or other non-field members) declared in between bitfields interrupted bitfield packing
- C backend: FIELD = N with N > 1 didn't decrease field alignment in the C output
- "RANDOMIZE , 1" was not always using a random seed
- C backend: UDTs and functions with same names caused gcc errors
- BASS import library was using @N suffixes, even though bass.bi doesn't use them anymore
- ASM backend: Some operations could trash registers without preserving them, if there were no free registers available
- An irrelevant "missing parameter-less constructor" error could be shown when destructing an array of objects
- #626: Visibility checks for calls of NEW/DELETE operator overloads were missing
- #609: UDT initializers didn't work properly with derived UDTs
- Unions could cause bad UDT initializer behaviour in some cases
- For stdcall functions returning UDTs on stack, the hidden pointer parameter will no longer be calculated into the @N stdcall suffix, following GCC and MSVC.
- For functions returning UDTs on stack on Linux/DOS/*BSD targets, the callee now always pops the hidden pointer parameter, even when the function is cdecl, to follow the GCC ABI.
- On Linux and DOS targets, functions will not return UDTs in registers anymore, but always on stack, following the GCC ABI.
- ASM backend used dword reads to push bytes/words from memory, potentially causing buffer overruns
- ScreenInfo() crash under X11 gfxlib2 driver when RandR extension is unavailable
- DELETE and DELETE[] were allowed to be used on forward references
- C++ mangling of IMPORTed namespaced global variables (win32) was different from MinGW
- Casting floating-point to unsigned longint now works as expected for values over 2^63
- The wrong error message was shown for methods declared inside anonymous TYPE declarations
- Operators declared inside namespaces can now be implemented outside of the namespace, provided the namespace prefix is used, just like with normal procedures
- Constructors, destructors and properties can now be implemented outside of the namespace their parent UDT was originally declared in, provided the namespace prefix is used
- C backend: Nested anonymous structures/unions were not emitted, only their fields
- On Win32, functions returning structures containing only one CONST SINGLE or one CONST DOUBLE field returned them in EAX or EAX:EDX instead of ST(0)
- Let() = udtvar assignments and ThreadCall disallowed Union types already, but not yet Types with nested anonymous unions
- codepage-specific zstring to Unicode wstring conversions are now working, by default using the locale set when an FB program is started
- FOR now retains the signedness of the step value, so that negative steps may be used on unsigned counters of any size
- Visibility checks for copy constructor calls for BYVAL arguments were missing
- #591: READing further strings/wstrings after already having READ the last DATA statement caused a crash
- Intermediate .asm/.c files will now use the native EOL char, not always CRLF
- The C backend now supports objinfo, just like the ASM backend
- Buffer overrun in gfxlib2's X11 driver
- Preprocessor's macro parameter stringize operator # now produces an empty string ("") if the macro argument was empty, instead of producing nothing
- Make pointer subtraction perform signed integer division (instead of unsigned) and return a signed integer
- Static member procedures were allowed to be DECLAREd in UDT declarations nested inside procedures or scope blocks, even though procedures cannot be nested, and methods were already disallowed
- Constants with CONST bits were treated as INTEGER constants even if they were LONGINT or STRING
- Constants could not be declared as CONST STRING
- LBound/UBound( array, dimension ) with an out-of-bounds dimension argument (except for 0) will return 0 and -1 instead of crashing
- When DIM'ing an EXTERN array, the DIM statement must now have the same lbounds/ubounds as the previous EXTERN statement, otherwise a compiler error will be shown (previously, only the number of dimensions was checked)
- Duplicate EXTERN statements declaring the same array but with different lbounds/ubounds will now result in an error
- #print typeof() and error reports including data types will now include the "* N" for Z/WSTRING (as for "STRING * N") and display wstrings as "WSTRING" instead of UBYTE/USHORT/UINTEGER
- UDT SWAPs/assignments/LSets now include the structure's tail padding (if any) in the operation
- typeof() returned the wrong type for some expressions, for example function pointer calls, or iif()
- sizeof( *z/wstringptr ) returned 0 instead of sizeof( z/wstring )
- Temp vars for functions returning UDTs on stack won't be unnecessarily cleared anymore if the UDT has a constructor that's going to be called anyways
- #644: C backend: Local variables from unused PRIVATE procedures could be falsely emitted as globals
- Static variables from unused PRIVATE procedures could still be emitted even though the procedure was not
- Any temporary variables from parameter initializers were only allocated in the main() scope, instead of being duplicated into each scope context where the initializer expression was used
- -g STABS emitter did not explicitly emit the toplevel file name again after emitting #include file blocks, causing valgrind to get confused about following procedures' parent file
- va_first() on a BYVAL non-trivial UDT parameter (which is implicitly passed BYREF) could return the wrong pointer (it assumed BYVAL but implicitly it was BYREF)
- Compiler crash on some cases of nested type initializers
- Hidden temporary variables could be made STATIC in procedures marked STATIC (making all locals STATIC), leading to hidden bugs with multi-threading or recursion. Affected constructs: SELECT CASE, SELECT CASE AS CONST, WITH blocks, QB-style error handling, string concatenation, ON ... GOTO, FOR loops, temporary variables used by the ASM backend when spilling registers
- WINPUT() did not allow a # like INPUT() does, as in [W]INPUT( bytes, #filenum )
- Screen[Res] and ThreadCreate() no longer worked on Windows 9x since 0.24, because they called msvcrt's _beginthreadex() with the last parameter being NULL
- Placement "NEW(a)" didn't require the expression to be in parentheses, allowing "NEW (a) + b" etc.
- "new[expr] UDT" evaluated "expr" multiple times even if contained function calls, if the memory buffer was just being cleared (i.e. UDT had no default constructor and "{ ANY }" wasn't used)
- Bad code generation for new[]'s default constructor calling loop, when the new[] expression was duplicated, for example when it was part of a parameter initializer
- Bad code generation for wstring concatenation in a SELECT CASE expression, when it contained function calls
- Missing destructor calls for temporary variables in parameter initializer expressions
- Missing destructor calls for the temporary variable produced by type<UDT>( )
- type<UDT>() expressions could use an extra unused temporary variable
- Win32: Procedures declared inside EXTERN "Windows-MS" blocks were treated as having a different calling convention than STDCALL or EXTERN "Windows" procedures, even though they all use STDCALL (only Windows-MS won't add the @N suffix, but that does not matter for function pointers)
- #627: ICE instead of error message on array access without index (or ()'s) nested inside the index of another array access
- Bad conditional jumps when temporary variable destructors had to be called
- Double destructor calls for temporary variables from iif() condition expressions
- Temporary variables in the unreached expression in an IIF() or ANDALSO/ORELSE were always destructed, even if the code path that constructs them was not reached (either 2nd or 3rd operand of IIF(), 2nd operand of ANDALSO/ORELSE)
- When initializing an UDT parameter with any expression except for type(), an extra temporary copy was created everywhere the initializer was inserted
- type<const UDT>() was not parsed as constructor call if the UDT had constructors, but as plain UDT initializer instead, due to the CONST
- type() now also works with enums and function pointers (just for consistency, because it already worked with other built-in data types such as integers)
- BYREF AS ANY|forward-reference parameters are no longer allowed to have parameter initializers
- type() is no longer allowed as argument to BYREF AS ANY parameters
- Single-line IF statements were not opening a scope, exposing potentially uninitialised variables declared within to outside code, e.g. "IF 0 THEN DIM s AS STRING ENDIF:  PRINT s"
- win/commctrl.bi: NMPGSCROLL structure fixed
- Two temporary copies could be created when passing classes BYVAL
- UDT variables given in BYREF UDT parameter initializers could be copied to a temporary variable if a copy constructor was available, instead of being passed BYREF
- #630: C backend: EXTERN dynamic array descriptors were not emitted (if the EXTERN was not DIMed in that module)
- Destructors for temporary variables from deleted expressions were called, even though the variables were unused and never constructed (this affected e.g. the sizeof()/typeof() operand, or the instance expression in static member accesses)
- SELECT blocks will no longer allow other statements in between the SELECT header and the first CASE statement
- lang qb didn't allow DEF___ statements inside procedures/compounds despite the change in 0.21.0
- "CONST id AS" and "CONST AS" were allowed to be immediately followed by any statement, instead of triggering a compiler error
- The compiler allowed a single "ASM" token to appear at end-of-file (without newline following), without showing an "expected END ASM" error
- C backend: fbc always passed a "wrong" -mtune option to gcc, that didn't match what was given to fbc's -arch option
- The -exx CPU type check could look for invalid CPU families under any -arch option except 386/486/586/686
- The type checks for assignments involving *zstringptr or *wstringptr expressions could be buggy, for example causing "*zstringptr = float" assignments to be disallowed under the C backend
- #577: The compiler allowed assignments between string and *byteptr expressions, as if they were string and *zstringptr expressions
- #508: The internal allocate/callocate/reallocate declarations didn't use an unsigned parameter like the real malloc/calloc/realloc functions, causing type mismatches with the C backend
- #if typeof( myintegerpointer ) = "INTEGER PTR" will now work
- #if's expression evaluation could produce wrong results (or at least inconsistent with the rest of FB) on some edge cases, such as "(1/2) > .49" or "&hFFFFFFFFu > 0u" (both evaluated to FALSE while it should have been TRUE)
- String literal concatenation will now work properly in #if/#elseif expressions
- #661: -gen gcc will now invoke gcc with -m32 now, allowing it to work with multi-lib gcc that defaults to 64bit (usually on 64bit systems)
- #662: zstring ptrs were indexed as char* instead of ubyte*
- #641: Type casting of an expression to the same data type but with CONSTs added or removed was being ignored
- #647: Shared/static UDT vars with destructor (only) ignored variable initializers
- #621: Parsing & overloading checks for argument lists of PASCAL procedures/constructors was broken
- C backend: Backslashes in wstring literals were not escaped when emitting
- Binary operation result types are more consistent now, for example "integer + uinteger" will now return a uinteger, just like "uinteger + integer"
- Win32: When using a graphics window nearly as big as or bigger than the available screen space, the graphics window's size could be truncated by the system, for example causing GetMouse to return coordinates that didn't match the actual mouse position, at least under the DirectX driver. FB will now handle WM_GETMINMAXINFO to prevent the system from making the window smaller than requested.
- Anonymous type() couldn't be used in initializers for UDTs with constructors
- Comparison Operator overloads accepting two intrinsic-type parameters could be declared (but not used)
- #651: Operator overloading was overlooking matches where non-const expressions were passed to const parameters
- -pp could produce duplicate output in combination with parser restarts due to #lang mode changes
- C++ name mangling ignored CONST on return types of function pointers used as parameters in overloaded procedures
- -lang qb/fblite: "EXIT SUB/FUNCTION" above a "SELECT CASE string" tried to destroy an uninitialized string variable
- BSAVE was returning "file not found" errors on invalid arguments instead of "illegal function call" errors
- Sub calls were allowing the optional parentheses to start after the first argument, e.g. 'foo a, (b, c)'
- #668: Internal compiler error on lines such as "END SUB : SUB foo( )" (one procedure closed, and a new one opened, in the same line) when compiling with -g
- DOS COMMAND(0) was giving '/' for the path separator instead of '\'
- DOS CURDIR and COMMAND(0) return values had a lower-case drive letter
- EXEPATH() on all platforms was omitting the slash at the end of root paths, resulting in a relative or missing path (e.g. "X:\" -> "X:" or "/" -> "")
- Hang in exec()/chain() functions on Linux if the target executable isn't found (observed with musl libc)
- Minor scaling bug when using BSAVE to save 16-bit images to BMP, causing barely visible changes and the potential loss of the least significant green bit
- Potential crash (read-after-free) in gfxlib2 X11 OpenGL backend initialization


Version 0.24.0:

[changed]
- add a "special exception" to gfxlib2 license to allow linking into executables under more relaxed terms (the same as the rtlib)
- -target option now accepts system triplets (known from gcc/binutils)
- By default even the non-standalone fbc is now relocatable and relies on exepath()
- fbc no longer includes full ldscripts, a supplemental snippet (fbextra.x) is passed to the linker instead (except for the DOS/DJGPP version which still relies on a modified ldscript)
- __FB_UNIX__ and __FB_PCOS__ now work like the other target defines (check via #ifdef)
- All cross-compilation targets are now always enabled in the compiler
- -o now also affects .rc and .xpm input files (useful to change the file names of the temporary objects)
- -o must now clearly be specified in front or behind of the corresponding input file, for example: "fbc 1.bas 2.bas -o 1.o -o 2.o" no longer works, but "fbc -o 1.o 1.bas" is possible now
- -x used with -lib now sets the library file name
- "No newline at end of file" warning removed
- 'PALETTE index, r, g, b' now uses 8-bit precision on each color value
- The __FB_MIN_VERSION__() macro is no longer changed to ____FB_MIN_VERSION__() for -lang qb
- SWAP no longer accepts function calls
- ImageCreate() and Reset(streamno) now set the runtime error code, which can be retrieved with Err()
- Allow CONST STRING parameters in string.bi/datetime.bi functions
- wstring Input is now subject to the same 4096 characters length limit like the normal [z]string Input
- #3492598: FB-only overloaded operators now use Itanium C++ ABI-compatible name mangling
- The bitwise NOT operator is now mangled as bitwise not ('~' in C++) instead of logical negation ('!' in C++)
- The '= ANY' intializer on variables or fields will now prevent the default constructor call (if any), instead of generating a warning message, requiring the variable or field to be initialized with an explicit constructor call. It still won't affect destructor calls though.
- #3051592: crt/errno.bi now uses __errno_location() to access errno on Linux
- The NAKED keyword is now disallowed under -gen gcc because gcc doesn't support naked functions on x86
- DELETE on something that's not a pointer now always triggers an error, not just a warning
- The -target option is no longer case-sensitive
- Linux standalone fbc won't try to use tools from PATH anymore
- PRINT USING now prints Inf/Nan/Ind values in the same style as QB, e.g. "1.#INF"
- PRINT USING now disallows commas between expressions (they had the same effect as semi-colons)

[added]
- Single inheritance for classes: TYPE Child EXTENDS Parent
- BASE keyword for explicit base class access inside methods: BASE.member (as opposed to THIS.member)
- Runtime type information (RTTI) for classes extending other classes or the new builtin OBJECT class: IF variable IS SomeClass THEN ...
- THREADCALL keyword for starting functions in a new thread with parameters passed to them (requires libFFI)
- EVENT_MOUSE_HWHEEL for X11
- __DATE_ISO__ for returning the compile date in "yyyy-mm-dd" format
- fbc can now be built for installation into MinGW/DJGPP
- Support for windres instead of GoRC when installing into MinGW or cross-compiling from a non-win32 system
- The .def file generated when building a DLL is now preserved if -R was given
- 'fbc -static' option to tell the linker to link against static libraries if installed
- CONST may now be specified in front of the bodies of CONST methods, not just in the declaration, same as for STATIC
- "Real" Rnd() algorithm (activate via 'Randomize(, 5)') using Win32 Crypto APIs or Linux /dev/urandom
- New headers for many audio-related libraries (some experimental): libsndfile 1.0.X, libVLC 1.1.x, mpg123 library, MediaInfo, PortAudio, Flite 1.4, libmodplug 0.8.8.4
- New experimental X11 headers
- Updated headers for GNU gettext/libintl 0.17
- New algif and alpng headers for Allegro
- New header for the UUID library from e2fsprogs
- New headers for json-c
- New headers for the GNU dbm library
- acmStreamOpen() declaration to win/msacm.bi
- New header file: win/ddk/mmddk.bi
- New headers for compression and archive handling libraries: libzip 0.10, libbzip2 1.0.6, liblzma 5.0.2, zlib 1.2.6
- Updated headers for wx-c 0.9.2
- New headers for libjit 1.0.0 and libffi 3.0.10
- New headers for the Chipmunk 4.1.0 physics library
- Updated headers for CGUI 2.0.1
- New headers for IUP 3.5
- Updated header for SQLite3 3.7.8
- Updated headers for OpenAL 1.13 and ALUT 1.1.0
- Updated header for FreeImage 3.15.1
- Updated header for QuickLZ 1.50
- Updated header for PDcurses 3.4
- Updated header for libcaca 0.99 beta17
- Updated headers for OpenGL, including new freeglut headers
- Updated header for BASS 2.4
- Updated header for ODE 0.11.1
- Updated header for libcurl 7.24.0
- New header for SQLiteExtensions 3.6.23.1
- Updated headers for GTK+ 2.24 and 3.2.2, including gdk-pixbuf 2.25.0, gtkglext 1.2.0, ATK 1.33.6, Cairo 1.10.2, Pango 1.29.5, glib 2.31.4
- Updated header for Mini-XML 2.7 header update
- New header for ZeroMQ 2.1.10
- Updated header for cryptlib 3.4.1
- Wstrings are now allowed in Print Using
- Len(), Sizeof() and Typeof() can now be used on function calls and array accesses even if they have the same identifier as a type
- Same type/expression disambiguation for Peek/Poke as for Len/Sizeof/Typeof
- FIELD = N can now be used on nested anonymous TYPEs/UNIONs
- IIF()'s with constant conditions are now evaluated at compile-time
- Updated headers for PCRE library 8.31

[fixed]
- Subtracting pointers from numbers, e.g. (i-p) was being allowed, rearranging to (p-i)
- FBC should give an error if EOF reached while parsing code inside an #IF block
- Possible crashes in Date(), Now(), FileDateTime() if the system time couldn't be interpreted
- #3398498: VA_NEXT() intrinsic macro now works with types that aren't a multiple of 4 bytes
- #3404250: *.a input files being wrongly passed to ld as -l*.a
- Compiler crash on 'cast(T ptr, 0)->x'
- #2828675: UDT fields not having tail padding (ABI now changed to match GCC)
- #3422768: pp under -gen gcc complaining about va_arg/va_next tokens even if not used as the actual macros
- #2188864: Compiler crash on out of memory
- #3453953: GOTO/GOSUB allowed keywords as labels
- The #LANG metacommand was not allowed in disabled preprocessor blocks
- -gen gcc crash on 'if funcptr then ...'
- #3441855: SWAP allowed incompatible data types
- #3465650: Compiler crash after showing error for using array element as FOR loop iterator
- #3434928: Incomplete null op optimization breaking assumptions made for conditional jumps
- #3320650: gfx functions didn't accept CONST source images (DRAW STRING font, PUT/GET/POINT() source)
- False positive syntax errors after '#ifdef namespaceid' (and also #ifndef, #undef and #if defined())
- #3446210: SELECT CASE leaking its temporary (w)string if not reaching END SELECT (e.g. EXIT FUNCTION from inside a CASE block)
- Temporarily reset console during Unix dylibload() and dylibfree(), to properly restore terminal state at exit
- VAR initialized from a STRING * N variable created a STRING * 0 instead of a dynamic STRING
- -gen gcc: abs(longint) was just abs(integer)
- 'PALETTE index, r, g, b' wasn't behaving as expected on some obscure SCREEN modes
- Built-in macros are now working in -lang qb (__RGB(), __BIT(), __ASSERT(), ...)
- ERASE crashed on arrays of UDTs with constructor but no destructor
- Internal compiler error in cases like: '*(@cast(ubyte, byte_var_or_array_element) + 1)'
- SWAP allowed [z|w]strings marked as CONST
- #3215431: SWAP on byte/short array elements could generate bad code
- SWAP on bitfields now works with -gen gcc (caused internal compiler error), and won't use extra temp vars anymore
- 'SWAP a, b' could produce different results than 'SWAP b, a'
- SWAP on operands with different sizes could generate bad code
- #2824381: UDTs with methods inside module-level scope blocks caused compiler crash instead of error message
- EDI/ESI registers could be used without being preserved, when clearing local UDTs/strings/arrays > 16 bytes or copying UDTs > 16 bytes. The bug showed up when other parts of the function used EDI/ESI too (for example "plongint[indexvar] = longintvar").
- Procedure pointers could be dereferenced using the '*' operator
- #3476028: SWAP/LET() assignments allowed modification of string literals/constants
- SWAP on strings failed/produced bad results when strings had different lengths
- #3476021: SWAP didn't clear fixed-length string remainders
- GFX_SHAPED_WINDOW didn't work properly on some modern Linux systems (thanks Sisophon2001 for the fix)
- Wrong error message when calling non-const method on const UDT
- Shell() on Unix didn't return the proper shell exit code
- Memory leak and possible race condition in console Line Input function
- Infinite loop in Line Input on files opened with Encoding when reaching EOF without newline
- Bsave()'s length parameter wasn't unsigned like in the gfxlib
- Win32 ScreenControl GET_WINDOW_POS with minimized window could cause it to be locked up that way
- "array too big for stack" warning was shown for static arrays
- ScreenRes was truncating the screen's text width/height (columns/rows) to 0..255, causing incorrect Print'ing or even a division-by-zero crash during Print
- C backend: gcc warnings about pointer assignments from BOPs
- C backend: compiler crash on circular dependency between UDT and function pointer typedef
- Buffer overflow in wstring Input
- Input to dereferenced wstring ptr wasn't reading in anything
- #3510684: Array descriptors for arrays declared inside Extern blocks weren't always given an alias name, causing the mangled name for emitting to be wrong (under C++ mangling) or empty (under all other non-default manglings)
- #3496522: crt/sys/linux/types.bi contained wrong typedefs (int64_t being just integer etc.)
- Missing GET/PUT "UDT with var-len fields" warning when nested UDT fields had var-len fields
- GLUT/Windows headers compatibility issues
- win/commctrl.bi: TabCtrl_AdjustRect() and TabCtrl_SetImageList()
- win/winsock[2].bi: FD_CLR() macros were broken
- C backend: procedures using Pascal were treated as Cdecl
- C backend: Missing padding elements in multi-dimensional global array initializers
- C backend: didn't allow float-to-Long/Ulong casts
- C backend: float to uinteger conversions truncated to integer
- C backend: The 'as any ptr' overloads of bin/oct/hex didn't work unless the 'as integer' versions were used in the same module
- Wrong declarations of some the built-in wbin(), bin(), woct() overloads
- Buffer overflow in wbin()
- C backend: Pointer fields pointing to the parent UDT itself were always emitted as having a single PTR only, even if it was a PTR PTR etc.
- C backend: Taking address of module-level labels was broken (used by module-level error handling code)
- C backend: Wstring literals outside variable initializers were emitted assuming sizeof(wstring) = 2, causing buffer overflows on Linux (where sizeof(wstring) = 4)
- C backend: wchar type didn't match gcc's, breaking global fixed-length wstring initializers
- Unused bits (padding) in UDTs with bitfields could be left uninitialized by type initializers
- C backend #3421351: Wrong code for bitfield assignment when the target bitfield expression had nested field accesses
- #3509495: Delete[] on derived UDTs with destructors caused a compiler crash
- Overload resolution treated pointer arguments as uintegers, allowing them to match integer parameters
- Any Ptr arguments were seen as ambiguous even if there was a fully matching overload
- #3479361: Derived UDTs were allowed to access their base UDT's private fields
- Local arrays in methods didn't have access to private/protected destructors
- 'LET(fields...) = UDT' in methods didn't have access to private/protected fields
- Access to member constants wasn't always checking visibility
- ERASE and field declarations didn't check c/dtor visibility
- #3490779: -exx and -profile broke Naked procedures due to implicit RTL calls; now no more implicit code will be added (this change affects error handling/profiling calls for naked procedures, and member constructor/destructor calls in naked constructors/destructors)
- Compiler crash on naked constructors/destructors
- Early return from an UDT destructor prevented destruction of the UDT's fields
- #3489950: BASE() disabled implicit field construction and vtbl pointer setup in constructors
- #3479349: No error was shown when a constructor couldn't initialize the base UDT (i.e. when the base UDT didn't have a default constructor and there was no BASE() used either)
- #3479355: POD base UDTs weren't cleared by constructors
- #3474348: Multiple REDIMs on COMMON array were disallowed
- #3344224: Copy constructor, Let operator and destructor were added to UDTs having field initializers but no complex fields
- Implicit default and copy constructors (and also a Let overload and a destructor, if needed) will now be generated for derived UDTs which don't have either of them yet, if their base has a default constructor. If it has only non-default constructors, an error will be shown.
- Derived UDT constructors could implicitly use their base UDT's private default constructor
- #3372520, C backend: Buggy type initialization through pointers (i.e. NEW)
- #2855461: REDIM/ERASE on an array of UDT objects with non-parameterless default constructor was allowed, causing junk to be passed to the constructor parameters as the rtlib's REDIM implementation doesn't expect having to pass arguments
- ERASE could be used on an array of UDT objects with only non-default constructor
- EXTERN declarations of UDT variables with only non-default constructor caused an error
- Possible compiler crash when invoking variadic macro without specifying any argument text for the vararg ("...") parameter
- Macro arguments can now be completely empty (no space required anymore to get it to work)
- C backend: global constructor/destructor priorities were not emitted
- Win32: incorrect Inkey() values for Alt-7/Alt-8 (Thanks to DodgeRules for find/fix)
- Mismatched parentheses in various translated headers
- Concatenations could fail on some combinations of const/non-const and string/wstring operands
- Concatenations involving const strings could return const results, which could prevent them being passed to functions
- Some incorrect definitions/constants in commctrl.bi (thanks to VANYA for fix)
- The Unix rtlib initialization code could start waiting for a response from the terminal without ensuring to have sent the escape sequence first (missing fflush(stdout)), thus blocking on the stdin read until some other input arrived (e.g. pressing ENTER)


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)
