[ ] add a C backend
	[ ] address of labels (used by the error trapping) must be emitted with 2 "&"'s
	[ ] the forward typedefs can't have a temp name or the g++ mangling will be wrong
	[x] functions that return structs -- ABI-dependent, because the non-trivial UDT must be handled by FB
	[x] SWAP
	[x] UTF literal strings
	[x] debugging support
	[x] jump-tables (used in select as const)
	[x] unitialized static and global vars must be zeroed (gas does that automatically because .comm is used)
	[x] structs
	    [x] can't change type of functions that return structs in registers, they must be handled by GCC
	    [x] bitfields - note: ABI-dependent
	    [x] non exported or extern vars should have an suffix ($) to not clash with gcc symbols
	    	and to support structs with the same name
	    [x] method protos must be emitted
	    [x] handle forward references -- test the abstract (void *) ones
	    [x] handle function pointers
	    [x] emit only the used UDTs (hard to do, because func protos and other structs could set the flag)
	    Note: field access is stills done by pointers, what is ABI-dependent (ie: fails on x64)
	[x] the va_* macros/quirk-func must be passed to AST, each ABI has different way to access varargs
	    - they are incompatible with C (va_next() doesn't exist), so disable the va_* in -gen gcc mode
        [x] stdcall names shouldn't be mangled, but anything else should - at least
            the g++ mangling uses no special characters
	[x] how to handle VARINI###? pass it as a tree plus a callback?
	[x] DATA arrays must be emitted in the inverse order because the forward ref links
        [x] only accept inline asm in GCC format, pass as-is
	[x] how to acccess fields?
	  	foo.bar.baz would become:
	  	*((typeof(bar.baz) *)((char *)&foo + offsetof(foo, bar) + offsetof(bar, baz))
	  	but offsetof() is resolved at FBC compile-time, making the access ABI-dependent
	  	even if structs are fully emitted
	  	- (not so simple) solution: let the AST do it
        [x] function calls must be passed complete to IR, with params
	[x] can't use casting from fpoint to int type directly because C won't do rounding,
	    use inline functions instead (inline ASM if x86)
	[x] shared/module-level vars must be emitted before any proc
	[x] scopes must be preserved or local vars won't work
	[x] use GCC as a high-level assembler, no headers, nothing
	[x] linking should still be done by us
	[ ] if everything is solved, it would become much simpler to add a LLVM back-end as
	    it's essentially a high-level ASM with virtual-regs

[ ] CONST qualifier
    [x] ptr checking must be updated
    [x] must check assignment
    [x] must check overloading resolution and the proc dup check
    [x] CONST member procedures ( declare CONST function|sub proc()... )
    [ ] check consts with IIF

[ ] ctor/dtor
    - add 'function foo (...) as SomeObj = any', so #1682972 could be fixed AND when
      speed is important, the temporary result instance won't be cleared
    - ArrayClear will be used instead of a loop calling the dtors to destroy
      local non-dynamic arrays
      - callVarDtor will have to use astAddAfter then with scope blocks..

[ ] make cUdtMember process symbols as cIdentifier does or ambiguous access
    tests won't work
    - check if the new optimizations won't break when -ex or -exx are used

[ ] output member functions and static member data to the STABS TYPE/UDT info
    - operators must be handled as well
    - properties may need a __get/__set suffix

[ ] STATIC
    - add static data members, they must be initialized outside the TYPE|CLASS
    - allow all global operators to be declared as static methods so the private
      members could be accessed

[ ] operator overloading:
    - add 'operator []' (or string-ish classes won't allow 'direct' char access)
    - add support for functions returning references (reuse "BYREF") or the
      '->' operator will be useless for UDT's with copy-ctors or dtors
      as returning byval will make a deep copy
    - OPERATOR foo.() ( lb1, lb2, ..... ) AS TYPE -- array indexing, not functor

[ ] quirks:
    [ ] OPEN ... FOR is not checking for mode
    	- does QB allow that? CONS won't work without INPUT or OUTPUT
    [X] GET and PUT shouldn't allow strings when the number of items is passed
    [ ] -exx is giving suspicious ptr assignment when module/name are been restored inside ns'

[ ] add the -lang (qb|fb) cmd-line option:
    - "qb":
      [ ] RESUME is not working with array bounds and null ptr checks because the labels are not passed
          - that's the reason why QB needs a cmd-line option, every line executed needs a
            prev and post labels to be emitted to allow that to work
      [ ] SHARED at subs (non-shared vars at mod-level will have to be allocated
          statically, as before)
      [ ] STATIC shouldn't create/allocate arrays, just declare them as static
      [ ] ()'s around function arguments passed to byref params should make a copy of the
          argument
      [ ] events:
      	  - there should be a call to the event trapping function on EVERY line
      	    emitted (we can't use threads because DOS)
      	  - to the above work, a new cmd-line option must be added (as in QB)
      	  [ ] on key()
      	  [ ] on timer()
      	  [ ] on uevent
          - the other events are seldom, if ever, used..
      [ ] add "qb" mangling
          [x] symbols with same name but different sufixes than keywords
          [ ] arrays with same name as scalars (most spaghetti-code won't compile w/o this)
          [ ] labels with the same name as procs:
              declare sub foo \n foo: \n goto foo \n call foo
      [x] suffixes not optional in keywords (ie: it's always STR$, not STR)
      [x] data type remapping
      	  [x] INTEGER is 16-bit wide
      	  [x] LONG is 32-bit wide
          [x] CVI should take a short in -lang qb mode
      [x] move all variables to function-level, implicit or explict (see no SCOPE)
      [x] GOSUB and RETURN in subroutines (so RETURN can't be used as a shortcut to EXIT FUNCTION)
      	  - implement it using setjmp/longjmp later in the rtlib
      [x] periods in symbol names
      [x] numeric labels
      [x] params passed by reference by default
      [x] DEF### (ie: explicit types required)
      [x] implicit variables
      [x] suffixes % & ! # $
      [x] '$dynamic, '$static, '$include
      [x] LET
      [x] ON .. GOTO|GOSUB
      [x] ON ERROR, RESUME
      [x] OPTION's
      [x] DEFSNG by default
      [x] OPEN should be compatible with QB (ie: OPEN "DEVICE:"), the bloat doesn't
          matter in -lang qb mode, just implement a fb_OpenDev or so in the rtlib doing
          the parsing that will call any supported fb_hFileOpen###'s (COM, LPT, CONS, etc)
      [x] CALL: support undefined functions as in QB, all params BYREF as ANY
      [ ] DEF - neither a macro nor function will work.  The statements inside the DEF FN...
          need module level scope except for the parameters which shadow module level
          vars.  Would be like a module level GOSUB but callable from any scope, taking
          parameters and returning a value.  Very messy.  Also, it will make any symbol
          called Fn... invalid because it allows forward refs.

      [x] no SCOPE
      [x] no NAMESPACE
      [x] no CLASS (and exception handling)
      [x] no op and function overloading
      [x] no EXTERN (periods and suffixes screw mangling)
      [x] no multi-threading - not thread*, mutex*, cond*
      [x] no keyword not present in QB (prefixed with '__')

    - "fb" - the inverse of "qb", but show deprecated messages by now for:
      [ ] without ON ERROR, all stmts returning rt errors should be allowed to
          be used as functions too

[ ] data/function members:
    - add virtual (functions only)
      - the vtable must be compatible with G++ 3.x (ie: compatible with
        COM interfaces in Windows)

[ ] ParamArray, but with this syntax: foo(...) as bar
	- array must be built at compile-time and destroyed after the call
	- take care with objects..

[ ] PP:
    - add #pragma cmdline="-foo bar -baz"
	- painful to add
	- don't allow it if any line was parsed already
    - [macro expansion: won't work for inner macros
    - add varargs support, like foo(arg1, ...) ...
    - support default arguments?

[ ] SCOPE..END SCOPE:
    - can't optimize multiple MEM_CLEAR's if there's any branch to
      one of them
    - error handlers should be restored too (or not allowed at all)

[ ] disallow (in -lang qb mode):
	dim foo as foo
	.. and later ..
	const|dim|function|etc foo.bar

[ ] fbmain - explicit main function
    - must check if anything but the init/end labels were defined already inside
      the implicit main() or the mod-level constructor
    - must delete proto and all ast nodes
    - must create as CDECL but it doesn't have to be obligatory
    - must support RETURN or FUNCTION = to set the result
    - must check the params if passed byval and if they have the right types

[X] add the ... subscript when initializing array so
    "dim array(0 to ...) = {1, 2, 3, 4}" could be allowed

[ ] forward type defs used in byval parms of function ptr type defs shouldn't be an error
    - the prototype mangling must be updated when that occurs, but how to do that fast
      enough? the args would have to be linked to parent (the prototype), but updating
      the mangled alias on every argument can be slow..

[ ] add the wstring type:
    - fb_ConsoleInput() won't call fb_DevScrnInit_ReadWstr( ), so an input to a
      wstring won't work.. to not add more bloat, the compiler should have to
      call fb_ConsoleInput(there_is_any_wstr_argument), not so simple..
    - auto-convert literal strings to w- or z- on assignments, depending on the l-hand
      side type
    - fix the !!!FIXME!!!'s and write the !!!WRITEME!!!'s in the rtlib

[ ] swap of zstring's and var-len string's is not working?? or that's the behaviour..

[ ] passing a temporary string to a zstring ptr should not make yet-another temporary
    assignment in hStrParamToPtrArg(), just a pointer copy that later should be
    strDelete()'d

[ ] proc call:
    - add named parameters (foo := expr)
      - can be hard to be added because they don't have to come in order, params in
        prototypes don't require a name and because overloading
      - := must be a new token because the "foo bar : baz" ambiguity

*** *** *** *** ***
[ ] all functions returning STRING should actually return the FBSTRING
    object, but we can't code the it in g++, or in Linux we will need to
    link (and include) the stdc++ lib, that's over 2.5MB big, so it must
    be done in pure C, using the G++ ABI (ie: FBSTRING has a dtor, so it's
    never returned or passed by value):
    - compiler has to allocate the descriptor as it does now following the gcc ABI
    - any function in the run-time library returning strings will have to be
      modified (chicken-egg problem)
    - no more run-time allocation of temp descriptors (better with threads)
    - no more STR_LOCK's (ditto)
    - str_delete won't check for temp descriptors anymore

[ ] fixed-len strings compatible with QB:
    - no null-term, temporaries always created when passing to functions
    - probably will need their own assign and concat functions

[ ] "byval as string" arguments should make a temp copy (including descriptor)
    of the param passed:
    - must pass (?) the address of the temp descriptor, not the string data, what
      will break *all* functions assuming the latter - they would have to be
      declared as zstring ptr, what will need more changes in users' code, because
      the non-implicit pointer deref

*** *** *** *** ***
[ ] proc def:
    - when checking the prototype, the access modifiers must be checked too: PUBLIC, PRIVATE
    - to support params > 64k, "ret" can't be used

[ ] .stabn can't have args > 65535 (ie: line numbers)
    - only switching to DWARF2 (ie: too complex) would fix that, let GCC do it..

[ ] arrays will fail in quirk gfx funcs if multi-dimensional and have <> 0 lBounds

[ ] add "fix-len|w|z|string * expr" support to array args passed by descriptor

[ ] named field initializers: ( foo => bar, udt => ( 1, { 2, 3 }, 4 ) )
    - all fields initialized must be named as a special parser routine will have to be used,
      that will keep track of what wasn't initialized to fill 'em with 0's - static only,
      locals are already cleared

[ ] full debug support
    - add dynamic arrays - couldn't get GDB to use Fortran-like arrays
    - each overloaded function will show the locals of *ALL* functions

[X] AndAlso and OrElse, short-circuit versions of And and Or
    - pay attention to register spills if functions or complex expressions are
      used in left or right sides

[ ] inline functions
    - better than macros as they can be "turned off" when debugged
    - too hard to be added now due the register spills, IR must handle inter blocks and
      keep track of live vregs

[ ] classes
    - *MUST* follow the GCC 3.x ABI to make it easier to reuse C++ libs compiled by GCC
    - Java/Php5-ish syntax: CLASS INTERFACE EXTENDS IMPLEMENTS THROWS ABSTRACT
    - must support forward references for any kind of symbol, so classes can't be stored
      directly to AST
      - how to deal with "foo(expr)"? it could be an array or a function call..
      - keeping everything in a parser/token tree will allow templates to be added later
      - class shouldn't be emitted unless referenced
        - function bodies defined outside classes follow the private/public proc rules
    - single inheritance, plus interfaces
    - exceptions - with stack unwind support
    - pure virtual methods
    - down casting
    - some support for RTTI



