FreeBasic Changelog

What's new in FreeBasic 1.10.1

Dec 28, 2023

changed:
rtlib: printf format specifier, use 'll' instead of 'I64' if building for ucrt or mingw-w64's stdio implementation (for newer gcc versions and c std)
gcc backend: use 'char' types for zstring instead of 'uint8' to avoid warnings in newer gcc 11+
release: update to build libffi 3.4.4 - this is needed to work with newer mingw-w64 based toolchains for gcc 11. and up
emscripten/fbc: in debug version of fbc (__FB_DEBUG__<>0) allow wchar conversion on win32 host to allow building and testing of the test-suite
github #421: fbc: win32/win64: pass '-fno-ident' to gcc to help prevent identification strings from accumulating in the final binary
updated bindings: PostgreSQL to 14.0
updated bindings: sqlite to 3.39.4
updated bindings: curl to 7.85.0
updated bindings: BASS to 2.4.17.0
added:
release: add recipes for building fbc distros using gcc-11.2 and gcc-12.2 Mingw-w64 project toolchains
release: add recipe for building fbc distros using winlibs-gcc-11.2/3/4 toolchain
fbc: '-fbgf' command line option to link against correct libfbgf variant, for platforms (emscripten) where it's not automatic due to missing objinfo support
basic-macros: better support for zstring and wstring conversion in evaluation of compile time arguments in __fb_query_symbol__, __fb_arg_etract__, __fb_iif__
added bindings: MariaDB 3.3.1
fied:
sf.net #982: Array descriptors emitted incorrectly in gcc backend
gas64: emit debug information for statics
gas64: handle #inf's and NaN's in float comparisons
unable to set opengl scaling to 1 after initial screen mode - previously: logic error in the driver code prevented the scaling from being set to 1
emscripten: fbc created faulty static libraries (it called ar instead of emar)
fbc: emscripten: wstring was broken because sizeof(wstring) was 2 rather than 4
emscripten: non-graphical programs will now run under node.js. Use - output.js to produce a .js rather than an .html
rtlib: emscripten: CURDIR and EEPATH always returned ""
emscripten/fbc: -sASYNCIFY wasn't passed to emcc at link-time as needed by recent Emscripten
sf.net #993: ignore (parse) single line comments for macros invoked with optional parentheses instead of passing as an argument to macro
sf.net #994: Bad handling of macro argument evaluation - reset file pointers to previous contet after evaluating arguments in __fb_query_symbol__, __fb_eval__, __fb_arg_etract__, __fb_iif__, and releasing leer contet
sf.net #996: fbc null pointer access testing defined(UDT.cast)

New in FreeBasic 1.10.0 (May 15, 2023)

[changed]:
gcc: '-funwind-tables' enabled on 64-bit targets for stack unwinding (adeyblue)
fbc: '--eh-frame-hdr' for linking on 64-bit nix targets for stack unwinding (adeyblue)
x86: arch 686 by default instead of 486 (SARG)
x86: arch 586 by default instead of 486 on DOS
asm backend: only with 686 arch, use of fcomi(p) to avoid slower instructions and also less code (SARG)
fbc: #DUMP <expr> and #ODUMP <expr> pragmas only available in debug version of fbc
inc/fbmath.bi renamed to inc/fbprng.bi
fbc: file I/O statements return "Expected file number expression" when checking for file number expression
fbc: [LINE] INPUT statements return "Expected ',' or ';'" error when checking for the comma or semi-colon separator
sf.net #953: fbc: improve compile time error messages for INPUT [#] statements
sf.net #953: fbc: improve compile time error messages for LINE INPUT [#] statements giving better positional information
sf.net #826: fbc: booleans are ranked against integer types to determine closest match in type resolution
sf.net #455: fbc: Allow &nnn... octal literals in source (like VALINT and friends)
fbc: automatically restart fbc/parser at first executable statement if required after preprocessor statements parsed
fbc: -forcelang overrides default lang, -lang, previous -forcelang, #lang, #cmdline "-lang", #cmdline "-forcelang"
fbc: allow gnu triplets for -target option even in standalone builds
gfxlib2: store alpha from source to destination when blending alpha primitives in MMX blender to match C blender
makefile: internal rename (TARGET_PRFEX => BUILD_PREFIX) and conditionally set the library and object directories (default is still based on TARGET)
fbc: dos: set DXE_LD_LIBRARY_PATH environment variable when calling DXE3GEN
release: target DOS gcc 9.3.0 and binutils 2.35.1 for next release
Unix GETMOUSE() under TERM=linux now requires libgpm 1.20.4 or higher (libgpm.so.2), instead of the older libgpm.so.1 versions. (for compatibility with modern Debian/Ubuntu versions, and probably other distros, since 2008)
gas64 : SGN type is INTEGER for whole numbers instead LONG
fbc: thiscall calling convention default for extern "c++" / win32 / x86 / non-static member procedures
fbc: disable byval cva_list returns on ARM targets
fbc: If a procedure definition has a declaration and the definition does not explicitly specify a calling convention, then the calling convention is implied by the declaration.
fbc: Improve handling of closing parenthesis in first argument of a procedure call for some expressions (sf.net # 468). If there is no leading parenthesis, then there should be no ambiguity that the procedure is being invoked without the parentheses
fbc: remove #pragma push( lookup108 ) to use symbol lookup method from fbc-1.08.x and earlier on unqualified symbol names - it was crutch for fb 1.09.0 to help with testing and transition to better lookups
fbc: passing byval constructor preference: prefer A.constructor( B ) instead of of B.operator CAST() as A + A.constructor() when passing UDT by value - this is to fix some inconsistencies in the rules when converting by construction one type to another
fbc: only up-cast initializers when needed. New behaviour is to try matching initializers without up-casting before matching with up-casting.
fbc: don't join operators separated by white space. Previously, '<' + '=', '<' + '>', '=' + '>', and '-' + '>' were joined together even if separated by whitespace.
fbc: don't skip whitespace between decimal point and digit. Previously, '.' + '0..9' floating point literals were allowed to be separated by whitespace.
gfxlib2: gfx_dos drivers initialize the internal dirty array based on scanline size
[added]:
gas/gas64: '.cif_sections' and '.cif_' directives for stack unwinding (adeyblue)
gas/gas64: '.seh_' directives for stack unwinding (adeyblue)
fbc: '-eunwind' command line option to enable stack unwind information, implied by '-e', '-ex', '-exx'
fbc: set bit value '__FB_ERR__' = &h200 if '-eunwind' is enabled
gas64 : stack overflow check (total of all local variables) at compile time --> warning - stack size for linux = 8MB, for Windows = default or defined by user (SARG)
gas64 : stack overflow check at run time if -exx is used - stack size for linux = 8MB, for Windows = default or defined by user (SARG)
fbc: debug pragma #LOOKUP <sym>
rtlib: DOS serial driver - add support for second PIC and IRQ 8 to 15
fbc allow '-target i386-pc-msdosdjgpp' and similar for cross compiling dos targets (even in stand alone)
rtlib: ./inc/fbc-int/system.bi - for fb_CpuDetect()
gfxlib2: ./inc/fbc-int/gfx.bi - to expose FB_GFXCTX structure and some typedefs from gfx lib (useful for some tests in the test-suite)
fbc: basic-macros: add __FB_IIF__( compare-expr, true-expr, false-expr ) macro
github #357: fbc: add '-buildprefix <name>' command line option to specify tool name prefix in both fbc standalone and normal set-ups. Overrides default 'target-' prefix on tool names in normal fbc set-up
fbgfx.bi: add scancode SC_CENTER=&h4C as alias for SC_CLEAR - used for NUMPAD 5 key
makefile: 'DISABLE_GAS64_DEBUG=1' makefile configuration option to disable debugging comments in gas64 asm files
gfxlib2: add FB.GET_SCANLINE_SIZE to fbgfx.bi and ScreenControl() to get current internal scan line size multiplier
gfxlib2: SCREENCONTROL: add getters for GL parameters - new GET_GL_* constants in fbgfx.bi
fbc: allow a TYPE or UNION to be declared inside another TYPE or UNION to allow declaration of nested named types. Support c++ name mangling parameters of named nested types. Support definition of variables declared in a named nested type.
Name mangling for c++ 'char' through BYTE/UBYTE parameters using the form "[unsigned] byte alias "char". Data type size is still 8 byte signed/unsigned from fbc side, but will be mangled as 'char'; neither signed nor unsigned for the c++ side.
Support 'SOURCE_DATE_EPOCH' environment variable for controlling the instrinsic __DATE__, __DATE_ISO__, __TIME__ macros. This in turn controls __FB_BUILD_DATE__ and __FB_BUILD_DATE_ISO__ macros when building the compiler. Report error message on malformed values.
fbc -nolib a,b,c command line option for selectively excluding specific libraries when linking (more fine-grained control than -nodeflibs, and not only for default libraries)
fbc will restart the parser when #cmdline "-mt" is used or usage of any threaded functions automatically enable -mt. This allows the compiler to parse the current module from the beginning and process any __FB_MT__ checks.
fbc: __fastcall support for gcc/gas 32-bit x86 - fbc passes first and second integer arguments in ECX and EDX registers respectively, caller cleans up stack.
fbc: __FB_QUERY_SYMBOL__( what, sym ) built-in macro for querying fbc symbol internals. Added fbc-int/symbol.bi.
add '-z retinflts' command line option for code generation. This option enables returning some structures (types) in floating point registers. This is a work-around for different handling of structs returned by value on different tool chains / targets.
fbgfx.bi: add private function fb.__pixels() to return a pointer to the image data (paul doe)
fbc: add command line option and warning '-w upcast' to warn when up-casting would discard initializers
fbc headers: add ./inc/fblimits.bi for minimum and maximum value constants - for example fb.MIN_VALUE_INTEGER and fb.MAX_VALUE_INTEGER
In normal build of fbc, try to automatically use gcc to query the search path for a std c++ library. This helps with dependency for tests/cpp and for some users that want to interop with c++
Add makefile option DISABLE_STDCXX_PATH to disable using gcc to search for some c++ library path
fbc: allow typename.member symbol checks for #ifdef / #ifndef / defined() where member can be a data field, static data field, nested type, constructor, destructor, property, operator (self-assignment, new, new[], delete, delete[], let, cast, for, step, next), or member procedure.
rtlib: dos: add "__fb_dos_no_dpmi_yield" variable to control calling "__dpmi_yield()" and prevent a crash under some dos extenders in dosbox
fbc: PROCPTR( UDT.member [, ANY|SUB|FUNCTION ...] ) to get a procedure pointer for type member procedures. If the member is abstract, then return 0 (null function pointer of the member procedure's call signature)
fbc: PROCPTR( UDT.member [, VIRTUAL ANY|SUB|FUNCTION ...] ) to get the zero based index in the virtual table. If there is no virtual table entry (or no virtual table at all) then return the special value of -1
[fixed]:
gas64: missing restoring of use of one virtual register on sqr for float (SARG)
gas64: variable of constant datatype not propagated when emitting uop (SARG)
llvm: add missing data type in datatype array (not tested)
sf.net #951: fbc: remove guessed type for cva_list (aka __builtin_va_list)
sf.net #952: fbc: CINT (and other conversion keywords) fails - don't allow inexact conversions or casts from UDT cast operators
sf.net #817: fbc: Type mismatch not detected when passing an array of UDT incompatible with the expected UDT
sf.net #953: fbc: no error generated on INPUT #h, "text" statements
sf.net #953: fbc: no error generated on LINE INPUT #h, "text" statements
sf.net #826: fbc: Weird overload resolution with booleans
sf.net #916: fbc: 'LINE INPUT [#1 | prompt,] variable [, maxchars]' requires length parameter for ZSTRING/WSTRING PTR variable
sf.net #916: fbc: Error on LINE INPUT [#1] if either missing or irrelevant max length argument
sf.net #892: fbc: Bug when default calling via a pointer to a 'Sub' defined with the only 'Any Ptr' optional parameter
github #403: fbc: The default value of the parameter was passed incorrectly when calling the pointer function (Skyfish) [optional parameter values are specified by the function pointer declaration]
sf.net #944: fbc: regression - local static arrays shouldn't have the array descriptor moved to global scope - partially revert #944 and add test
fbc: parser skips extra token on error recovery for #if/#ifndef/defined() statements
sf.net #455: fbc: Number lexing allows much bad input - a show a warning message "Expected digit" where '&o', '&h', '&b' has no digits following
gas64: initialize debug structure even if not emitting debug info to prevent errors due to setup changes by #cmdline inside the parser
fbc: don't allow '-lang' option to override '-forcelang' option on command line
github #199: Gfxlib Different Pixel Output Between C & MMX - change MMX Alpha blenders to match C blenders
github #368: Fix mangling involving toplevel CONST and abbreviations (dkl)
fbc: dos: invoke dxe3gen when cross compiling to dos - previously only executed on DOS host
fbc: dos: when invoking dxe3gen on cross compiler, don't write to ldopt.tmp, dxe3gen doesn't seem to be able to handle the ldopt.tmp argument
fbc: remove double path separator characters '/', '' when setting the fbc path prefix
rtlib: multikey was missing VK_NUMPAD5 and SC_CLEAR scancodes in the key table, causing NUMPAD-5 to be handled as escape in the windows D2D gfx driver
sf.net: #961: rtlib/gfxlib: COLOR() function returns LONG but should be ULONG
The DISABLE_GPM build option for the Unix rtlib now only disables GETMOUSE() for TERM=linux, which is the case that uses GPM, however GETMOUSE() for TERM=xterm now keeps working under DISABLE_GPM, since that case does not use GPM.
Unix rtlib: Multi-threaded use of shell()/exec()/dylibload()/dylibfree() can no longer cause input/output terminal configuration cleanup at program exit to fail
sf.net #965: fbc: Bad code generation in gcc backend for NOT PTR_EXPR - don't allow unary ops on pointers
Internal (unit tests): Stack corruption in mid() tests (regression from 1.07.0)
gfxlib2: LINE statement computing an incorrect line style pattern on any non-X86 (i.e. 64-bit, etc)
github #393: rtlib: OPEN fails when opening an encoded file for append. Check the BOM on existing files for INPUT/APPEND, write the BOM for new files for OUTPUT/APPEND.
sf.net #968: fbc: major changes how initializers are handled and pairing of a UDT's (internal) structure and the initializer list given by the user.
fbc: show an error on byref initializers that can't take address of. Previously this was checked by fbc debug assertion only.
sf.net #894: Can't initialise a UDT as copy of another if the first element is a UNION, fixed by sf.net #968
sf.net #922: Sometimes can't use extra backets inside TYPE UDT initialiser - now, don't allow optional parentheses when parsing type<UDT>(...) if left parenthesis is found
sf.net #824: Illegal destructor call after '#print typeof( f() )' when f() is a function returning an object by value
fbc: delete destructor calls of discarded expressions in IIF(), previously, unscoped dtors (to be called after the expression) and deleted dtors (to be never called) were being handled the same
gas backend: fix spill registers when all reused registers are within the same emit operation
github #404: gas64: fix stack size and alignment for GOSUB usage (SARG)
fbc: #macro definition parsing incorrectly handles single line comments ending with line continuation character and incorrectly joins the following line to the comment
fbc: add special handling for #inclib "fbgfx?" to fix incorrect linking to non-threaded gfx library. #include "fbgfx.bi" was causing the libfbgfx library to always be linked even when thread safe version was expected (causing deadlocks in user programs)
gfxlib2: fix dos keyboard handler so that left shift key will release in multikey() checks
sf.net #970: Illicit "error 202: Illegal member access, UDT.operator.cast" compiler error message - suppress bogus error message when checking procedure overloads for possible candidate
sf.net #811: *(ptr).field should give an error
sf.net #972: A local Type cannot access members of an inherited Type external to its scope but normally accessible
sf.net #834: Line continuation not handled during #if 0 skipping - fixed by ignoring line continuation characters and invalid directives - continue to preserve multiline comment parsing
fbc: internal: throw an error if __FB_EVAL__ would cause the parser to nest too deeply
fbc: improve code generation for structs returned by value and structs returned in registers - some structs where not handled correctly and had mismatched code generation when mixing modules with different fbc backends or linking again c libraries (e.g. gas+gcc or gas64+gcc) resulting in stack corruption or wrong values returned in structs
gas64: improve code generation for structs returned by value, fix optimization no 16, fix relocations for static / shared in shared libraries
fbgfx.bi: fix structures and declarations for #lang "qb" (paul doe)
gas64: fix structures passed by upcasting (SARG)
fbc: discard assignments and constructor calls in initializers that would write outside of the target when emitting initializer lists - previously, up-casted initializers were writing beyond the limits of the target and trashing memory
fix regression due to previous change on sf.net #917: optimization of 'm += s'. The optimization failed to consider 's = s + expr' where expr might contain 's'. In such a case, the optimization cannot be applied.
fbc: basic-macros: improve the handling of optional parens in function like macros by ending a macro argument list on the number of arguments expected (non-variadic macros only).
fbc: bad error recovery after overloaded operator [] caused compiler crash, for example if overloaded operator [] is found but can't be used due to mixing const and non-const types, or invalid members
fbc: improve error message 215 to indicate that only static members can be accessed from parameter intializers as well as static functions
fbc: #cmdline "-c ..." needs to restart parser since code generation is affected. The implicit main was being emitted even when '-c' was give in #cmdline and was working differently than when '-c' given on the actual command line.
fbc: extend lifetime of temporary variables in WITH TYPE(...) expressions to the END WITH statement
fbc: #cmdline "-r -rr -R -RR -o objfile ..." needs to restart the parser and handle changes in keeping the ASM file. In the case of '-o objfile' a major restart is needed since some initialization of filenames is done before parsing starts. By default the temporary ASM file was being kept even if #cmdline options indicate to keep it.
sf.net #569: gfxlib2: GetMouse/SetMouse scaling problem in QB modes Screen 2 & 8 - adjust GetMouse/SetMouse by internal scanline_size
fbc: fbc: fix bad error recovery on BYREF intializer. 'Dim Byref As UDT u = UDT()' would case compiler crash if UDT constructor argument optional

New in FreeBasic 1.09.0 (Jan 2, 2022)

New in FreeBasic 1.08.1 (Jul 9, 2021)

New in FreeBasic 1.08.0 (Jun 3, 2021)

changed:
array descriptor contains new 'flags' field. Careful, breaks binary compatibility plus chicken-egg problem to build fbc.
fbc '-version' reports build date in yyyy-mm-dd format (aka build date iso)
updated SQLite headers for binding to SQLite 3.34.0
updated BASS headers for binding to BASS 2.4.15
updated PostgreSQL headers for binding to PostgreSQL 12.0
updated curl headers for binding to curl 7.73.0
updated SDL1.2 bindings to SDL_gfx 2.0.26
updated SDL2 bindings to SDL2 2.0.14, SDL2_image 2.0.5, SDL2_mixer 2.0.4, SDL2_ttf 2.0.15
updated LLVM and Clang bindings to 5.0.0git-fb0acea
updated Chipmunk2D binding to 7.0.3
updated cryptlib binding to 3.4.5
updated DevIL binding to 1.8.0
updated fastcgi to fcgi-2.4.1-SNAP-0910052249 binding (no changes from fcgi-2.4.1-SNAP-031111212
updated libffi binding to 3.3 (used by threadcall)
updated libjit binding to 0.1.4
updated bzip2 binding to 1.0.8 (no change from 1.0.6)
refreshed ncurses-5.9 binding
refreshed mediainfo_0.7.77 binding
warning level for all warnings is increased by 1. Default warning level is 1. Previously, default warning level was 0 and some warnings had level of -1.
reverted changes due sf.net #893: invalid suffixes due to '-lang fb'
reverted changes due sf.net #832: Fix bug allowing QB style suffixes on all keywords, regardless of -lang
suffixes in '-lang fb' reverted to fbc-1.05.0 behaviours
sf.net #908: check visibility for overloaded operators FOR, NEXT, and STEP
sf.net #909, #832, #866 reverted error on suffix in lang fb dialect
sf.net #832: warn on suffixes for all built-in keywords.
'Suffix ignored' warning in -lang fb instead of errors
macros with parameters can now be invoked without using parentheses around the arguments using '#macro name ? (arg)' definition syntax
rtlib: internal fb_MemCopyClear() argument types changed to expect unsigned lengths (UINTEGER => size_t)
rtlib: internal changes to API: fb_ArrayErase(), fb_ArrayClear(), fb_ArrayClearObj()
rtlib: internal removal of unused / legacy functions: fb_ArrayRedim(), fb_ArrayRedimPresv()
rtlib: internal removal of unused / legacy functions: fb_ArraySetDesc(), temporay descriptor functions and structs
github #256: gfxlib2: enable frame buffer on linux-arm targets
gfxlib2: X11 driver - set the window title for both the frame window and the client window
rtlib: RANDOMIZE RND_REAL for real random number generator now fills a buffer (624 ulongs) and RND iterates the buffer
rtlib: refactor math_rnd.c internals for readability
fbcunit: update to version 1.0
sf.net #924: fbc: built-in for RGB() and RGBA() return ulong
gfxlib2: POINT returns ULONG
sf.net #927: PUT custom method expects function(ulong,ulong,any pr) as ulong callback function
fbc: double the minimum and default stacksize on 64-bit to 64Kb and 2048Kb respectively.
fbc: internal changes to optimize away unused call results
github #203: allow casts of addresses on static initializers
only write debug line information for statements and don't write comments / empty lines / directives for top level source code in assembly debug output
optimize byref 'm += s' string concatenations to fb_StrConcatByref() which will check for same string descriptor at run-time which can't be determined at compile time for byref parameters.
github #298: allow command line options passed to as, gcc, ld to be longer than 128 characters by using string types internally
sf.net #923: implicitly emit the deleting destructor for extern "c++" mangling for better g++ ABI compatibility
Add new gfxlib2 API's fb_GfxScreenInfo32() and fb_GfxScreenInfo64()
Change overload to SCREENINFO( byref as long = 0, byref as long = 0, byref as long = 0, byref as long = 0, byref as long = 0, byref as long = 0, byref as string = "" )
Add overload for SCREENINFO( byref as longint, byref as longint, byref as longint = 0, byref as longint = 0, byref as longint = 0, byref as longint = 0, byref as string = "" )
Add new gflib2 API's fb_GfxImageInfo32() and fb_GfxImageInfo64()
Change overload to IMAGEINFO( byval as const any ptr, byref as long = 0, byref as long = 0, byref as long = 0, byref as long = 0, byref as any ptr = 0, byref as longint = 0 ) as long
Add overload for IMAGEINFO( byval as const any ptr, byref as longint, byref as longint, byref as longint = 0, byref as longint = 0, byref as any ptr = 0, byref as longint = 0 ) as long
Add new gfxlib2 API's fb_GfxControl_i32() and fb_GfxControl_i64()
Change overload for SCREENCONTROL( byval as const long, byref as long = -2147483648, byref as long = -2147483648, byref as long = -2147483648, byref as long = -2147483648 )
Add overload for SCREENCONTROL( byval as const long, byref as longint, byref as longint = -2147483648, byref as longint = -2147483648, byref as longint = -2147483648 )
github #311: index argument in __FB_ARG_EXTRACT__( index, args... ) is evaluated as constant (Skyfish)
added:
extern "rtlib": respects the parent namespace, uses default fb calling convention and C style name mangling
array descriptor 'flags' field to track fixed length, fixed dimension, dimTb() size.
__FB_BUILD_DATE_ISO__ intrinsic define to return fbc build date in 'yyyy-mm-dd' format
__FB_BUILD_SHA1__ intrinsic define to return the compiler's source code commit sha-1, (if known)
'-print sha-1' to print the compiler's source code commit sha-1, (if known)
makefile: 'FBSHA1=1' makefile configuration option to determine the current repo commit sha-1 from git
makefile: 'FBSHA1=some-sha-1' makefile configuration option to explicit set the repo commit sha-1
makefile: '-d FBSHA1="some-sha-1"' compiler option to set the value of '__FB_BUILD_SHA1__' when building fbc
rtlib: inc/file.bi:FileFlush() function, usable for file, PIPE, CONS, and ERR streams opened for BINARY, RANDOM, OUTPUT, APPEND.
rtlib: inc/file.bi;FileSetEof() function, to adjust size of open file
sf.net feature request #293: allow len/sizeof/typeof for UDT members without expression
gfxlib: added Direct2D driver, preferred driver on newer systems. DirectX driver is still fallback for older systems (adeyblue)
fbc: add builtin function fb_MemMove() alias "memmove"
fbc: add builtin function fb_MemCopy() alias "memcpy" (was previously removed in an older version of fbc)
./inc/fbc-int/memory.bi - fbc API for low level memory operations allocate, callocate, reallocate, deallocate, clear, memcopy, memmove, copyclear
'-w suffix' or '-w pedantic' command line option enabled 'Suffix ignored' warning for built-in in string functions
__FB_UNIQUEID_PUSH__(), __FB_UNIQUEID__(), __FB_UNIQUEID_POP__(), __FB_ARG_LEFTOF__(), __FB_ARG_RIGHTOF__(), __FB_JOIN__() builtin macros
__FB_ARG_COUNT__() builtin macro
__thiscall keyword to specify the 'thiscall' calling convention (-gen gcc only)
__FB_QUOTE__(), __FB_UNQUOTE__(), __FB_EVAL__() builtin macros
rtlib: REDIM [PRESERVE] will generate run time error if attempting to resize static (fixed length) arrays.
gas64 emitter for x86_64 (SARG), added '-gen gas64' command line option to select
github #256: gfxlib2: add vga16_blitter for linux-arm targets to pack 2 pixels per byte and write to linear frame buffer
./inc/fbc-int/math.bi - fbc API for rnd, rnd32, randomize, expose some random number generator internals
./inc/fbmath.bi - add random number generators fb.rndfast32, fb.rndmsws32, fb.rndsquares32, fb.rndpcg32, fb.rndxoroshiro128
add THREADSELF in ./inc/fbthread.bi to return the thread id of the current thread (adeyblue)
makefile: add arm and aarch64 targets to the bootstrap package
release: add arm and aarch64 targets as an option to the contrib/release.build.sh script
emscripten port (WIP, v1ctor & angros47)
bindings to SoLoud audio library (soloud_c.bi: C API only)
bindings to raylib-3.0.0 library (raylib.bi and raymath.bi)
gas64: add debugging information for -g -gen gas64 for user code for FBdebugger only (SARG)
__FB_ARG_EXTRACT__( index, args... ) builtin macro (adeyblue)
__FB_X86__ intrinsic define on x86 and x86_64
added warning 'FOR counter variable is unable to exceed limit value' on constant end value for loops to help avoid infinite loops, e.g. for i as ubyte = 0 to 255
internal rtlib function fb_LEFTSELF( string, n ) to reduce the size of a string without reallocating the buffer
added GFX_SCREEN_EXIT = &h80000000l constant to fbgfx.bi - used with Screen 0 (closing any graphics window and preserving the console window content)
github #309: In macro/define's use '##_' to escape line continuation character '_' to allow multiple lines of macro expanded code to be combined into a single statement.(Skyfish)
fixed:
makefile: under MSYS2 (and friends), TARGET_ARCH is now identified from shell's default target architecture instead of shell's host architecture
sf.net #904; gcc backend: pass '-Wno-format' to prevent format string errors in gcc 9.x (enabled by default with -Wall)
sf.net #910: cast(string, variable) can cause fbc to segfault (infinite recursion), due to misplaced const & non-const casting
sf.net #898: fbc win gfxlib DirectX driver failed to initialize on 64-bit, due to incorrect construction of DIDATAFORMAT for keyboard device (macko17)
rtlib: potential buffer overflow in sys_getshortpath.c (macko17)
sf.net #404: len/sizeof type parsing eats namespace prefix (namespace prefix is now preserved)
sf.net #718: len/sizeof type parsing disambiguates between type and variable having same name
github #205: fix rtlib realloc memory leaks in 'redim preserve' and 'fb_hGetLocaleInfo' (adeyblue)
github #205: fix rtlib realloc memory leaks and malloc null ptrs in utf_conv.bi CharToUTF, 'WCharToUTF, UTFToChar, UTFToWChar, and related functions
github #205: fix rtlib potential malloc null ptr access in dev file read/write methods
default new, new[] operator (allocate) after #undef allocate caused compiler crash
default delete, delete[] operator (deallocate) after #undef deallocate caused compiler crash
windows GDI gfxlib driver now displays double scanline screen modes correctly (screen 2 & 8), rather than half screen (adeyblue)
sf.net #921: gfxlib: horizontal line drawing on 8-bit image was using wrong bpp
oGLfbGFX: opengl driver was leaking thread handle under 'screencontrol fb.SET_GL_2D_MODE, fb.OGL_2D_AUTO_SYNC'
oGLfbGFX: prevent opengl mode and scale from changing until next mode is set
sf.net #908: visibility / access rights of overload For/Next/Step operators not taken into account by for...next statement
sf.net #906: #error on line 2 not reported if immediately following #error on line 1
rtlib: ERASE - check for static (fixed length) plain, string, and object arrays passed to ERASE; clear only if array is static, and free memory if dynamic
rtlib: allow reading/writing data larger than 2GB with GET # / PUT # [WIP]
sf.net #882: error on REDIM udt.field(expr) if default constructor has no access
github #246: rtlib leaks thread local data, fixed by adding TLS destructors (adeyblue)
sf.net #918: pcopy (console) bug when copying large console buffers, windows only (adeyblue)
github #216: function getMouse() seems broken on Win10 when using the Console Mode (screen 0), fixed by turn off the QuickEdit console mode during GetMouse (adeyblue)
github #258: on windows directx and gdi drivers, only show window after initialisation is complete (adeyblue)
sf.net #925: CSIGN/CUNSG preserve size when converting pointers on 64-bit and implicit conversion of STEP value in FOR...NEXT statement
github #122: gfxlib2: linux GFX_NO_FRAME + GFX_OPENGL freezing at exit due to a dead lock between exit routines
sf.net #914: threadsafe RND() and RANDOMIZE() by adding a mutex
use the multi-byte & wide character functions wctombs() & mbtowcs() when converting between string and wstring (Skyfish)
sf.net #568: asm error assigning 16-bit constant to 32-bit var, invalid use of movsx instruction on immediate (short => long)
fbc: internal cThreadCallFunc() was using wrong function to get the procedures return type
fbc: read objinfo for elf format files on arm32 and arm64 (aarch64) to allow automatic options and linking of libraries
fbc: name mangling for cva_list name mangling with arm32 and arm64 (aarch64) targets
rtlib: FORMAT() should always use all the fix digits in exponential form, e.g. format(1234, "###e+#") = "123e+1"
github #92: FORMAT() should always have an exponent of 0 for zero.
sf.net #928: Wrong sign / type when printing BYTE values on arm/aarch64
various HANDLE_WM_*, FORWARD_WM_* macros in win/windowsx.bi were broken
gcc backend was trying to pass single types to double typed built-ins
gfxlib2: character data was incorrectly stored for values >= 128 causing incorrect values returned from SCREEN() function
LLVM backend: escape procedure names on win32 targets to avoid having llvm mangle the names also
sf.net #572: don't call vectorize operations for anything but gas+x86+sse backend / options
sf.net #572: gas+x86+SSE faulty optimisations with '-vec 2' for intra-expression vectorisation of horizontal add optimisation was generating bad AST resulting in bad assembly
gcc backend: inline asm for float to integer calculations was generating bad code with gcc optimizations due to x87 stack clobbered but not reported to gcc
gcc backend: fix GOSUB causing crash/exception on win64 - setjmp/longjmp failed on mingw-w64 64-bit and needed to be passed 2 parameters instead of 1
fix __FB_EVAL__() incorrectly reading past the end of the expression, and report errors in expressions
C backend: switch to .text section after writing the exports to the C file in the explicit asm block. gcc can move sections around with optimizations and there is a change between 7.x and 8.x that causes issue with where the directive section is located
sf.net #917: optimize 'm += s' string concatenations to fix the long compile times in the gcc backend (which makes heavy use of string building).
github #217: C backend, fix gcc array out of bounds warning when compiled with -O2 or higher optimizations and accessing non-zero lower bound fixed length string arrays
C backend: inline asm - don't add rsp/esp to the clobber list, it's deprecated in newer gcc versions and silently ignored in older versions
github #309: token pasting operator '##' allows pasting of single '_' characters
fbc: re-add __FB_GUI__ intrinsic define - the change was clobbered for a time during fbc 1.08.0 development after basic-macros were added

New in FreeBasic 1.07.3 (Apr 1, 2021)

New in FreeBasic 1.07.2 (Jan 1, 2021)

New in FreeBasic 1.07.1 (Sep 28, 2019)

New in FreeBasic 1.05.0 (Feb 1, 2016)

fixed:
0.90.0 regression: Self-op optimizations stopped handling some cases and should now work again, for example: optimizing A=A+1 => A+=1 where A is a Long, should give nice ASM code with -gen gas again
When Dim'ing an Extern variable, the Byref attribute was not checked - neither required nor disallowed - now the Dim must match the Extern with regards to Byref too.
Type(...) expressions couldn't be used at the begin of a statement (because the Type keyword was treated as begin of a Type declaration)
FileAttr() was still broken for 64bit - the result value was truncated to 32bit
1.04.0 regression: Under -gen gcc -asm att, support for gcc-style inline asm was broken
BYREF fixed-length strings (e.g. BYREF myParameter AS ZSTRING * 10) now trigger a compiler error since they are unsupported
print typeof() output now differentiates between ZSTRING and ZSTRING * N (ZSTRING without size is produced by dereferencing a ZSTRING PTR, or BYREF AS ZSTRING)
Context-specific keywords, e.g. graphics PUT modes, must now be given as keywords (e.g. PSET), string literals (e.g. "PSET") are no longer accepted.
Wstring-to-Zstring conversions didn't use the system's Unicode codepage conversion function, and only converted ASCII characters. Now it will try to convert the Unicode chars to codepage chars.
Compiler crash during error recovery when there was an error when parsing the argument expression for a BYREF AS ANY parameter
1.04.0 regression: Get# for WStrings was incorrectly changed to convert the loaded bytes to wstring characters, like Input# would do. Now it's changed back to just loading the raw bytes into the wstring, which is also how Get# works for other datatypes.
1.04.0 regression: Due to the Get# wstring breakage, the compiler failed to read source files encoded in UTF16LE with BOM on Windows
Eof() could incorrectly return TRUE too early on Windows, when reading a big text file with LF line endings, OPENed FOR INPUT (text mode)
Line's styled/pattern drawing support was broken on non-x86 systems

New in FreeBasic 1.04.0 (Oct 2, 2015)

Changed:
FileAttr() now returns an Integer instead of a Long, and now supports returning OS handles on 64bit
#750: The gfxlib is now cleaned-up by END (which also happens automatically at the end of the implicit main function), instead of the FB runtime's global destructor. This should fix the "hang on exit on Windows 10" issues. The reason is that the gfxlib clean-up needs to wait for the background thread to exit, which cannot safely be done in a global destructor on Windows, due to the loader lock. This means it is definitely not safe anymore to use FB graphics commands during global variable destructors or module-level destructors.
Windows API binding: The BOOLEAN typedef has been renamed to WINBOOLEAN due to the addition of built-in Boolean type to FB. You can #undef Boolean before #including windows.bi to get the Windows API BOOLEAN typedef again.
Many bindings now declare CTRUE (1) instead of TRUE (1), to avoid conflicting with the new built-in True (-1) keyword. You can #undef True before #including them to get their old TRUE (1) again.
On 64bit, but not -lang qb, integer number literals > 32bit now default to being Integers instead of LongInts, since 64bit Integers are the default type on 64bit. This only makes a difference for overload resolution and typeof(). No changes on 32bit or -lang qb.
#738: Operator overloading: The overload resolution is now a bit more permissive with regards to CONSTness; for example non-const UDT objects can be passed to Byref As Const UDT parameters, regardless of the other argument/parameter (if it's a binary operator). Previously this was disallowed (though only sometimes, due to a separate issue).
#756: Val() no longer recognizes 0x or 0X prefixes for hexadecimal values. &h or &H should be used instead. Previously it was only "supported" accidentally, and could produce wrong values (all d's turned into e's in the string before the conversion).
Added:
BOOLEAN data type (compatible to GCC C++). Logic operations involving boolean operands also return a boolean.
TRUE/FALSE built-in constants (programs may still declare them manually, but a warning will be shown)
CBOOL()
Boolean support for PRINT, INPUT, DATA, WRITE etc. Booleans are represented as "true"/"false" strings (case-insensitive).
DIM|VAR BYREF id AS datatype, for creating local references to other objects, similar to BYREF parameters
exepath() now works on FreeBSD, NetBSD, Darwin and Solaris
The FB gfxlib can now be built on OS X using XQuartz by passing ENABLE_XQUARTZ=1 to make
Redundant float constant declarations are now also allowed
Updated Mesa OpenGL binding to 10.6.4
Updated Windows API binding to MinGW-w64 4.0.4
Updated IUP binding to 3.15
Updated CD binding to 5.8.2
Updated FreeType binding to 2.6
Updated Lua binding to 5.3.1
Updated LLVM/clang bindings to 3.6.2
Updated some CRT/glibc bindings to glibc 2.22
Updated curl binding to 7.44.0
Updated libffi binding to 3.2.1
Updated libpng bindings to 1.5.23 and 1.6.18
Updated libzip binding to 1.0.1
New binding for libxcb 1.11
crt/limits.bi now declares FLT_MIN and DBL_MIN
Updated cgi-util binding to 2.2.1, with 64bit support
New binding for Chipmunk 7.0.1, with 64bit support
New binding for cryptlib (cl343_beta), with 64bit support
New binding for DevIL 1.7.8, with 64bit support
New disphelper binding
New binding for Expat 2.1.0, with 64bit support
New binding for FLite 2.0.0, with 64bit support
New binding for FreeImage 3.17.0, with 64bit support
New binding for GD 2.1.1, with 64bit support
New binding for GDBM 1.11, with 64bit support
New binding for GDSL 1.8, with 64bit support
New binding for gif_lib 4.2.3 and 5.1.1, with 64bit support
New binding for GMP 6.0.0, with 64bit support
New binding for GRX 2.4.9, with 64bit support
New binding for GSL 1.16, with 64bit support
New binding for IM 3.9.1, with 64bit support
Updated glib binding to 2.44.1
Updated GTK+ binding to 2.24.28 and 3.16.6
Updated ATK binding to 2.16.0
New binding for jpeglib 6b, 7, 8, 9a, with 64bit support
New binding for json-c 0.12, with 64bit support
New binding for libxml2 2.9.2 and libxslt 1.1.28, with 64bit support
New binding for liblzma from xz 5.2.1, with 64bit support
New binding for LZO 2.09, with 64bit support
New binding for MediaInfo 0.7.77, with 64bit support
New binding for libmodplug 0.8.8.5, with 64bit support
New binding for libmpg123 1.22.4, with 64bit support
New binding for Mini-XML 2.9, with 64bit support
New bindings for SQLite 2.8.17 and 3.8.11.1, with 64bit support
New bindings for PCRE 8.37 and PCRE2 10.20, with 64bit support
New binding for PostgreSQL 9.4.4, with 64bit support
New binding for libogg 1.3.2, with 64bit support
New binding for libvorbis 1.3.5, with 64bit support
New binding for Newton 3.13, with 64bit support
New binding for ODE 0.13.1, with 64bit support
New binding for PortAudio (pa_stable_v19_20140130), with 64bit support
New binding for libsndfile 1.0.25, with 64bit support
New binding for libuuid (e2fsprogs-libs-1.42.13), with 64bit support
New binding for libxmp 4.3.9, with 64bit support
New binding for ZeroMQ 4.1.3, with 64bit support
New binding for libVLC 2.2.1, with 64bit support
Select Case As Const maximum allowed Cases (jump table slots) increased from 4097 to 8192
Fixed:
False-positive "ambigious sizeof" warnings if the identifier could refer only to a type or procedure (in that case it should already be fairly clear that the type will be chosen, not the procedure, because sizeof() can't be applied to procedures at all), or if an expression such as "array(0)" is given to sizeof() (i.e. something that starts with an identifier but is followed by further tokens that clarify that it's not refering to a type)
Adjusted "ambigious sizeof" warning message for the case when it could refer to a forward reference or a variable
1.03.0 regression: Compiler crash during error recovery in case a CONST declaration was a duplicate definition
1.02.0 regression: zlib.bi couldn't be #included behind crt.bi due to the declarations for SEEK_SET & co
Typedefs allowed the data type or forward reference identifier to be omitted (e.g. "type T as")
Typedefs allowed forward references named after keywords, even though no such type alias or UDT can be declared (only quirk keywords are allowed as type names, not "core" keywords though)
#747: SPC(n) only allowed skipping into the next line, and truncated bigger values of n. Now it can skip multiple lines if n is big enough.
IUP binding: added various missing #inclibs
#782: C backend: inline ASM keywords were turned into references to previously declared FB variables/procedures/labels, if those were named after ASM keywords. Inline ASM keywords will now be left untouched (using the same heuristic, a list of ASM keywords, as used by the ASM backend).
__FB_ASM__ wasn't #defined for x86_64 even though the -asm option can be used on x86_64 too
C backend: UDTs using Field=N were emitted incorrectly (causing gcc errors), if they contained a field of type of another UDT that didn't use Field=N.
False-positive "ambigious sizeof" warnings if the identifier could refer to a type or variable of that type (in this case the size is obviously the same, and it doesn't matter which one is used)
C backend: Procedure pointers having a circular dependency on themselves could result in duplicate typedefs being emitted, causing gcc errors with older gcc versions.
rtlib & gfxlib compilation was broken on NetBSD, Darwin and Solaris (header & include-path issues)
On Darwin, linking with rtlib failed due to __fb_errmsg being discarded
Correctly implemented fb_hGetExeName for FreeBSD, NetBSD, Darwin and Solaris (needed by gfxlib2)
The FB makefile can now detect the OS when building on Solaris
fbc will now pass the proper parameters to "as" on OS X
1.02.0 regression: NULL was declared with pointer type in updated bindings (Windows API, SDL, etc.), and is now just an integer constant again, so it can be passed to things like WPARAM/LPARAM without triggering a compiler warning.
Open Com on Windows didn't invoke GetCommState() properly, meaning it could "randomly" fail. Also, the port was not always opened for exclusive access, even though MSDN says that is the only possibility.
1.03.0 regression: OpenAL binding: The ALboolean and ALCboolean typedefs were incorrectly expanded and translated as zstring in some places
format(now(), "ttttt") now works as expected under unix-like systems
-profile now works on win64; the compiler generated calls to "mcount" which doesn't exist on win64; it's named "_mcount" instead. (with MinGW-w64's libgmon at least)
1.02.0 regression: CHAR/WCHAR typedefs (and others) in the Windows API bindings were translated as zstring/wstring; they're now translated as byte/wchar_t again (and accordingly in some cases where fields/parameters use them as type and clearly don't want a zero-terminated string), to allow them to refer to a single char again.
1.01.0 regression: CGUI binding: InitCgui*() macros were all broken, not just InitCgui() (that was fixed before)
GdiPlus binding: Fixed GdipMeasureCharacterRanges() declaration (wrong parameter type)
RETURN in BYREF-result functions could erronously try to construct a result object, if the result UDT had constructor overloads taking a pointer
LLVM backend: Accesses to fixed-length strings now use the proper types
LLVM backend: Structs using FIELD=1 are now emitted as packed structs
Many bindings and especially the Windows API binding now use more proper Const/Type/Extern/Sub/Function declarations instead of #defines, allowing many identifiers (such as "LoadImage" which is also a Windows API function) to be used for custom functions in namespaces, even if the file #includes windows.bi or others.
1.02.0 regression: Windows API binding: COM interfaces in win/shlobj.bi were missing vtable entries
#761: crt/string.bi and win/shlwapi.bi can now be used together they use #undefs to override each-other (e.g. strcpy() vs StrCpy()), whichever is #included last wins.
Windows API binding: The NM_* constants from win/commctrl.bi are now adjusted to work on 64bit.
X11 binding: X11's boolean typedef was errornously translated as string type in some places it is now preserved, named "XBoolean", and translated as byte as intended.
GTK+ 2 binding: GtkCurve structure was translated incorrectly (i.e. wrong sizeof())
1.02.0 regression: Windows API binding: The LPRGLPVOID typedef and related ones were omitted from win/dplay.bi due to a translation bug
Windows API binding: win/GdiPlus.bi now uses the Gdiplus namespace and #inclib on 64bit too.
The @N stdcall suffix was calculated incorrectly (i.e. it was incompatible with gcc and MSVC) for procedures with Byval non-trivial UDT or Byval String parameters.
Static member variables using the parent UDT as their data type could be allocated incorrectly (not enough memory reserved, possible even zero memory), if they were declared above some or all fields (related to bug #649)
C backend: References to procedures and labels are now emitted as-is, instead of using gcc's inline asm place-holders with memory reference constraints (the latter only makes sense for variables, not functions/labels)
C backend: Inline ASM using labels (i.e. jumps) should now work, using gcc's "asm goto()" syntax
C backend: The register clobber lists produced for inline ASM are now adjusted to the target now x86_64 and ARM is supported (though ARM/AArch64 support is probably incomplete), no longer x86 only.
GET# didn't work with wstrings
Integer-only operations like AND, OR, \ and MOD converted non-integer operands to Integer, even if the other was a LongInt or UInteger. Now the conversion will use an integer type matching the integer operand (if any), to avoid truncating floating point values, and give more expected results.
ASM backend: Cross-compiling could give different results than native compilation with regards to the choice of whether to place string literals into .data or const (e.g. .rodata) sections
Compiling a Select Case As Const block containing a Case with a huge range of values such as won't cause the compiler to "hang" anymore
Select Case As Const: now triggers a compile-time error if a > b, instead of silently doing nothing
#784: C backend: String literals in inline ASM (containing double quotes, backslashes, etc.) were emitted into the .c code without escaping
#777: -lang qb: Suffixed identifiers on the left-hand side of assignments were resolved by prefering global variables instead of local ones. Now local ones take priority, as in other places (e.g. expressions) and as in QB.
#783: C backend: Run-time float-to-uint64 conversions truncated the value to int64
#745 part 1: PRINT comma-padding could wrap into the next line too early (if the padding would move the caret beyond column width-FB_TAB_WIDTH). This happened in both console and graphics modes.
#745 part 2: FB runtime cached the console/graphics window width but didn't update it when it got resized, this should now be fixed at least for the graphics window and Linux console window.
#743: 1.00.0 regression: len() used on UDT with overloaded cast() operators returned the result type and value of one of these cast operators, instead of the sizeof()
#738: Operator overloading: The overload resolution gave different results for b+a compared to a+b, if one argument/parameter differed only in CONSTness, and the other didn't.
#746: -lang qb's Open "Pipe:" wasn't working. Only Open "Pipe:" was accepted (but that's useless); anything else was treated as normal Open file command.
#414: ASM backend: Bad code generated for comparisons such as IF @globalvar = @stackvar THEN ...
C backend: Extern Import variables were not emitted and accessed correctly

New in FreeBasic 1.03.0 (Jul 14, 2015)

changed:
print now only prints the information, and then stops the compiler
non-standalone builds: -target no longer searches libs in lib/freebasic/, but rather in the normal lib/freebasic/ directory. I.e. the directory layout for native or cross compiling is the same, making packaging and distribution easier.
added:
IUP binding updated to 3.13
742: fbc can now use lib64/freebasic/... instead of lib/freebasic/ if built with ENABLE_LIB64=1
print fblibdir option
All the recently updated bindings now have copyright/license information
New libbzip2 binding (64bit-capable)
New libcaca binding (64bit-capable), libcaca-0.99.beta19
New BASS 2.4 & BASSMOD 2.0 bindings (64bit-capable)
New OpenAL (openal-soft-1.16.0) and freealut (1.1.0) bindings (64bit-capable)
New ASpell 0.60.6.1 binding (64bit-capable)
New libbfd binding (64bit-capable), supporting all binutils versions from 2.16 to 2.25
New CanvasDraw 5.8.1 binding (64bit-capable)
Updated CGUI binding to 2.0.4 (from CGUI project's CVS)
Redundant constant declarations (CONST A = 1 : CONST A = 1) are now allowed, just like redundant #defines
logic operation optimization: x 0 => x if x is a comparison operation already, and = 0 => , and NOT =>
ASM backend: slightly better code generation: Integer operand register will be re-used as Long result registers now (and vice-versa), which is ok since this is 32bit-only
len/sizeof/typeof will now warn if the given identifier is ambigious (i.e. if it could refer to both a type or a procedure/variable symbol), because currently the type will be preferred, which is typically unexpected, at least for len() on strings.
crt/longdouble.bi: ARM support
LLVM backend: global variable initializers
LLVM backend: fixed-size array variables/fields
fixed:
Windows API binding: win/ntddndis.bi and win/olectlid.bi headers were missing their content (and thus, the dependencies of ntddndis were missing too)
LLVM backend: local vars were emitted twice
LLVM backend: the signature emitted for calls will now use the same param dtypes as in the declaration, as required by LLVM
LLVM backend: self-BOPs, and the self negation UOP, weren't working
LLVM backend: field accesses, pointer derefs, global var accesses, with or without offsets, were mostly broken
LLVM backend: procedure pointers weren't implemented properly
1.00.0 regression: compiler crash on assignments with a dereferenced constant on the left side
1.00.0 regression: C backend: bad code for pointer array parameter accesses (resulting in gcc error reports)
Better error recovery after byref function result assignment type mismatch errors
1.01.0/1.02.0 regression: Various bindings: some macros using sizeof() were badly translated (doing sizeof((T)), which doesn't compile, instead of sizeof(T))
Various bindings: macros whose body is a scope block with just one statement are now translated as single-line statements, so that they can be used with single-line IF blocks
1.01.0 regression: CGUI binding: InitCgui() macro was broken
1.01.0 regression: GLib binding: G_N_ELEMENTS() macro was broken
Windows API binding: added #inclib "msimg32" to wingdi.bi, for using functions like GradientFill()
C backend: Bitfields in nested anonymous Types/Unions should no longer cause __fb_struct_size errors - fbc now uses the same work-around for them as for Types with bitfields at the toplevel, i.e. such Types are emitted as byte arrays, because fbc's/gcc's bitfield layout rules differ.
1.02.0 regression: Windows API binding: The select() function from winsock headers is now renamed to select_() again, as before
1.02.0 regression: Windows API binding: opensocket/selectsocket aliases for the socket_/select_ functions were missing
1.02.0 regression: Windows API binding: can be used with MinGW.org again, for the most part, although some individual functions still won't work as they use MinGW-w64-specific helper functions
Various bindings: Some trivial "inline" functions are now turned into macros; fixed some cases of missing information about renamed symbols (e.g. in SDL2 binding)
Some built-in functions with wstring parameters (e.g. Val(), Left(), Right()) accepted integers and pointers in place of the wstring (e.g. Val(0)). This triggers an error now.
772: Types with the same name but in different namespaces compared as equal in #if typeof(...) = typeof(...) checks and #print typeof(...) output, because the namespace prefix was not included in textual typeof()'s result string.
For dynamic array parameters with specified number of dimensions (e.g. instead of ), the number of dimensions in accesses and REDIMs is now checked at compile-time, like dynamic array variables
1.00.0 regression: Arrays declared with unknown dimensions ("()") could no longer be accessed with inconsistent dimension counts. This is now allowed again. If precise dimension count checking is wanted, the array should be declared using the "myArray(any, any, ...)" syntax.
1.02.0 regression: GL/glext.bi on Windows no longer automatically #included GL/gl.bi

New in FreeBasic 1.02.1 (Apr 27, 2015)

New in FreeBasic 1.02.0 (Apr 11, 2015)

changed:
Redims with explicit type will now redim existing dynamic array fields, if one of the same name exists, instead of creating a new local array. This makes Redims with explicit type match the behaviour of typeless Redims and Redims for global arrays.
Relaxed type checking for procedure pointers and virtual method overrides: Procedures with different signatures can now be treated equal if the signatures are compatible. For example: assignments between a function pointer returning an Integer and one returning a Long won't cause a "suspicious pointer assignment" warning on 32bit anymore.
asm intel is now the default for all targets/backends (i.e. the C backend no longer defaults to -asm att). This should make switching between backends less trouble-some, especially with regards to inline ASM.
The temporary .asm/.c files generated by fbc no longer contain time/date strings. This avoids unnecessary noise (the time/date is essentially always different) when comparing .asm/.c files (e.g. to detect changes in fbc's code generation).
added:
FB_ASM__ intrinsic #define on x86, defined to "intel" or "att" (corresponding to the -asm command line option -- useful for -gen gcc/llvm only)
fbc -showincludes option (shows #include tree) for debugging of #includes
Address-of followed by pointer-arithmetic on variables (expressions such as @x+N) will now be turned into offsetted variable accesses, resulting in better generated code
The results of type-casted function calls can now be ignored, even if it's a non-trivial cast
Covariant parameters and function results (feature request #289)
Type aliases for forward-reference type aliases (e.g. "type A as A_ : type B as A" -- previously it was only allowed to alias the forward reference directly: "type A as A_ : type B as A_")
761: crt/mem.bi for mem*() functions, separated from crt/string.bi, to allow them to be used together with windows.bi without running into conflicts between crt/string.bi and win/shlwapi.bi
crt/iconv.bi for using glibc's iconv on GNU/Linux
crt/regex.bi for using glibc's regex support on GNU/Linux
crt/pthread.bi for using glibc's pthread support on GNU/Linux
allegro5 binding: Win32-specific #inclibs supporting the lib naming convention used by Allegro5's Win32 builds
Bindings (new/updated, including 64bit support):
FastCGI 2.4.1-SNAP-0311112127
Windows API, based on MinGW-w64's headers; DDK not updated yet; for GdiPlus only the flat C API is updated, not the C++ part.
libpng 1.2.53, 1.4.16, 1.5.21, 1.6.16
X11, based on current X.org packages
SDL1: SDL 1.2.15, SDL_image 1.2.12, SDL_mixer 1.2.12, SDL_net 1.2.8, SDL_ttf 2.0.11, SDL_gfx 2.0.13
SDL2: SDL2 2.0.3, SDL2_image 2.0.0, SDL2_mixer 2.0.0, SDL2_net 2.0.0, SDL2_ttf 2.0.12, SDL2_gfx 1.0.1
GNU libiconv 1.14
fontconfig 2.11.1
Allegro 5.0.11
TRE 0.8.0 as tre/tre.bi and tre/regex.bi. For backwards-compatibility, the "plain" regex.bi still exists, but now just redirects to tre/regex.bi.
OpenGL, based on Mesa-3D 10.5.1 (GL/mesa/*) and MinGW-w64 3.3.0 (GL/windows/*). GL/gl.bi & co use the Windows OpenGL binding on Win32/Win64, and the Mesa binding elsewhere.
GLUT 3.7
GLFW 2.7.9 (GL/glfw.bi), 3.1.1 (GLFW/glfw3.bi)
freeglut 3.0.0
Cairo 1.14.2
FreeType 2.5.5
GLib 2.42.2
Pango 1.36.8
ATK 2.14.0
gdk-pixbuf 2.30.8
GTK+ 2.24.27, 3.14.10
GtkGLExt 1.2.0
The FB makefile now supports "make bootstrap-dist" and "make bootstrap" commands. The former allows packaging the FB sources together with precompiled fbc sources, and the latter allows building FB using those precompiled fbc sources, which is useful on systems that don't have a working fbc yet.
fixed:
Potential bad code generation for dynamic array field copying
C backend: Naked functions could end up in the .data section instead of .text
Returning a dereferenced constant (such as field>) caused a compiler crash
1.00.0 regression: Bad code generation for dynamic array descriptor initialization (and potentially other cases)
1.00.0 regression: . member access was allowed on [] pointer indexing expressions even if the type was not an UDT, but a UDT ptr
Some unsafe pointer assignments between ANY PTRs and non-ANY PTRs with different PTR indirection levels didn't trigger a "suspicious pointer assignment" warning (e.g. ANY PTR PTR = BYTE PTR)
On 64bit, all number literals with '&' suffix (LONG type) triggered a "too big" warning, even if their value was not really too big.
765: insufficient precision on FLT_MAX / DBL_MAX constants in crt/limits.bi
gfxlib could crash on exit, if Screen[Res] was used in a global/module constructor
768: View [Screen] did not clip the given viewport coordinates to the screen properly, if x1/y1 were negative
0.90.0 regression: Potential compiler crash with -fpu sse -fpmode fast if the program used sin/cos and contained certain global float constants (such as pi/2)
1.00.0 regression: Potential dead-lock in thread-safe runtime library when using file or console I/O functions from multiple threads
binding: allegro5: Fixed compilation on win32/win64
Compiler directory layout: The non-standalone (Linux-style) DOS build now uses include/freebas/ and lib/freebas/ if running on DOS, instead of when compiling for DOS. This allows cross-compiling from Linux (or others) to DOS to work again: If on Linux, fbc -target dos will now use the normal include/freebasic/ and lib/freebasic/ directories of the Linux compiler, instead of requiring the 8.3-compatible directories.
Extern variables were allowed to have mismatching fixed-length string lengths in declaration and definition
0.90.0 regression: In -lang qb, using __offsetof() caused a compiler error
lang qb's __offsetof() won't truncate the offset to 16 bit anymore
Unix rtlib: division-by-zero crash on console I/O commands such as Input, if the terminal size couldn't be queried
Unix rtlib: memory leak in X11 keyboard input handling initialization
rtlib/gfxlib2: memory leaks of internal thread-specific data (gfxlib's TLS data when using the thread-safe (mt) FB runtime, and all TLS data of the main thread when using the normal (non-mt) FB runtime)
rtlib: When using Open Scrn, there could be a dangling pointer bug in the internal screen file handle

New in FreeBasic 1.01.0 (Dec 29, 2014)

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

New in FreeBasic 1.00.0 (Sep 19, 2014)

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 - 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-/ 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 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( ) It already worked for anonymous objects of UDTs without constructor: @type( ... )
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
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(...) 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 )
Macro expansion right behind a PP typeof() wasn't working (e.g. the foo in )
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. ) 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: . However, the array index was simply ignored. The array must be passed without index now:
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

New in FreeBasic 0.90.1 (Jul 18, 2013)

New in FreeBasic 0.90.0 (Jun 24, 2013)

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 / UINTEGER / C[U]INT, where n is 8/16/32/64, for allowing to choose integer types of a specific size
CVI / MKI, where n is 16/32/64, to allow bit conversions of a specific size
type( ).field is now possible, as an alternative to (type( )).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
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( )).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( )
type() 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() 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

New in FreeBasic 0.24.0 (Aug 25, 2012)

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)

New in FreeBasic 0.23.0 (Sep 7, 2011)

New in FreeBasic 0.22.0 (May 18, 2011)

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

New in FreeBasic 0.21.1 (May 18, 2011)

New in FreeBasic 0.21.0 (May 18, 2011)

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

New in FreeBasic 0.20.0b (Jan 23, 2009)

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)

New in FreeBasic 0.18.3b (Jan 5, 2008)

Changed: lang qb: INTEGER (%) and LONG (&) are now, respectively, 16- and 32-bit wide
Changed: lang qb: default numeric literals are now assumed to be INTEGER or SINGLE
Changed: lang qb: symbols with the same name as keywords are now allowed: dim left as integer: const dim$ = "" etc
Changed: lang qb: all data types and functions/keywords not present in QuickBASIC were removed
Changed: allow "3.6e-08f" notation (type specification is accepted after 'e')
Changed: ang qb: SLEEP(n) expects seconds
Changed: ang qb: INKEY$ returns CHR$(0) as the extended character
Changed: PUT ALPHA with alpha paramter = 0 does nothing
Changed: update OpenAL (0.0.8) and alut (1.1.0) headers
Changed: update OpenAL and alut .def files for Win32
Changed: update ODE (0.9) header and import library (Win32), removed examples/libraries/ode
Changed: CONDWAIT now takes a second parameter, a mutex, and now operates identically to pthread_cond_wait
Changed: INSTR( s1, ANY s2) returns 0 if s1="" or s2="" as per documentation
Added: CONST qualifiers
Added: CONST member procedures
Added: lang qb: STICK(n) and STRIG(n) functions
Added: RESET(0|1) procedure to reset stdio handles after redirection
Added: headers for ogg and vorbis
Added: error when NEXT var does not match FOR var
Added: "-w next" warning when variable is specified after NEXT
Added: borderless opengl windows on linux
Added: allow GFX_NO_FRAME in Win32 OpenGL gfxlib driver
Added: added the VK_A-VK_Z and VK_0-VK_9 scancodes in winuser.bi
Added: #1816871 - sizeof() is now usable in asm blocks
Added: INSTR( wstring, ANY wstring ) was missing from the rtlib
Added: rtlib implementation of INSTRREV - (W.I.P.)
Added: First version of COM/serial support for DOS, W.I.P.
Fixed: self ops defined as global needed to throw an error
Fixed: GOTO, GOSUB and RETURN were accepting invalid labels
Fixed: SCREENLOCK/SCREENUNLOCK is now properly handled by the DOS gfxlib
Fixed: DOS console SETMOUSE was not scaling the coordinates
Fixed: parameter type mismatches weren't being caught with bydesc parameters
Fixed: more robust solution for solving deadlock on app close if screenlock is called with no screenunlock
Fixed: close window fixes in examples
Fixed: mouse_init for linux tty was failing
Fixed: #1815503 - do nothing if radius