TO IMPLEMENT ============ RST --- - footnotes; prefix :i: whitespace before :i:, _reference, `reference`__ __ anonymous: www.nimrod.org Bugs ---- - BUG: sigmatch for ``len`` matches the open array too often... *sigh* - BUG: for j in 0 .. a.len + b.len - 1: nil where a and b are open arrays does not compile - BUG: ["sh", "-c", someProcWithOpenArray(openArr)] produces wrong C code - BUG: bootstrapping does not work with Borland C - BUG: addr/deref does not work when interpreting - BUG: Check that pure procs only consist of asm statements (and comments) - BUG: tlastmod returns wrong results on BSD (Linux, MacOS X: works) - BUG: the parser allows empty statements/object case branches - BUG: when optmizing cgen.c with Visual C++, GCC, LLVM (O3), it breaks. - BUG: ``-cc:bcc`` command line option does not error - BUG: symbol files still do not work High priority ------------- - documentation: var types, ``[]`` overloading, ``cast`` and type convertions, ``if`` expresssions, (anonymous) procs - implement two-phase lookup for generics (this is hard...): This is useful for macros too! Alternative: Explicit early name binding. Both is hard to implement - implement closures for the C code generator - get rid of ``nkHiddenStdConv`` in several places: this mechanism caused more bugs than it ever solved! Library ------- - xml, html, url, cgi, fastcgi: implement from scratch - unicode library - socket library (does SDL for us?) - osproc for Windows - bignums - python Low priority ------------ - use `` notation for identifier concatenation? - Visual C++: emit ``default: __assume(0);`` for optimization - ``nkTempAsgn``-node as optimization - macros: ``typecheck`` pragma; this is really a good idea! This allows transformations based on types! - make callconv a set - partial generic instantation is missing - commas are not optional any longer as this may lead to bugs (which?) - get code generation for C++ exception handling right! - find a way for easy constructors and destructors; though constructors are flawed... destructors are not, however! - multiple dispatch Changelog ========= - pasparse: comments after begin end; are not longer part of the nkStmtList node - BUGFIX in ccgexprs.genSetLengthSeq - adapted ast.pas for nil sons - case records: type information generation is now complete - enums: size depends on the number of values - fixType pass in semantic checking altered - implicit conversion from pointer to other pointer type disallowed - $ifdef implemented for Pascal parser - fixed bug in types.pas concerning computation of set size (div rounds down!) - fixed a bug in `sameFile` in ``nos.pas`` - BUGFIX: Conversion from string to cstring - implemented field checks for case records - fixed code generation for sets of size 8 - eliminated recursion in the ropes module; this increases efficiency a lot and fixes the huge stack usage - fixed a bug in the exception handling; stack tracing - bugfix: mRepr was forgotten in semfold; we could evaluate this at compile time! - BUGFIX: repr from seq[string] - implemented the `release` switch in the config file - change in extccomp.pas to provide `getCompileCFileCmd`. This is used by the cgen module to include the used command. Thus a change in the C compiler switches triggers a recompilation. - BUGFIX: returning from within a ``try`` context now works, thus we get a proper stack trace again! - eliminated `skipAbstract` - disallowed ``var var T`` - implemented checks for object conversions - renamed ``appRopeFormat`` to ``appf`` and ``ropeFormat`` to ``ropef`` - field names are not mangled any longer if the containing record/object type is ``importc``'ed or ``exportc``'ed - the engine now supports up to 254 node kinds; this is needed for future enhancements - changed assignable handling - implemented better compile-time range checking and conv-transformation - object checks now work for ptr/ref - math and time library for the ECMAScript target - BUGFIX for long standing bug in semantic checking of asm statements - BUGFIX for long standing bug in reraiseException - removed r'c': it is pointless - cleaned up the AST - reworked tuple handling - implemented type converters - evaluation + macros - made nkConv and nkCast format consistent - syms are not copied any longer when importing them as this does not quite work for the code generators - semantic checking now does lots of checks to prevent crashing with illegal syntax trees caused by buggy macros - ``$`` is now magical - ccg: name mangling generates shorter names - r.a rewritten to r^.a if necessary (same for arrays); this should eliminate some bugs and the C code generator already depends on it - fixed bugs in transf concerning inlining of iterators; tgeneric now works! - fixed enum symbol bug: enum symbols are not overloadable! - conversion transformation is now done in the semantic pass - conversion transformation is now done in the transf pass again - object conversions now may be addressable - removed addr(TClosure) hack in instgen module - fixed type description bugs in ccgtypes; should now be correct - added ``passl`` and ``passc`` pragmas and used it in the ``math`` module - changed handling of ZCT in the GC - added an optimization for arrays in forAllChildrenAux - fixed a bug in sigmatch; formal may be nil! - fixed a bug in the C code generator concerning the ``$`` operator - many commands of the debugger are now named as in GDB - fixed the GC: gctest now works again - fixed typedesc generation in the C code generator once again - BUGFIX: chckObj needs nil check if pointers are converted - BUGFIX: In lookup.pas: n.ident was accessed even though invalid - BUGFIX: loc.s was not initialized for temporaries - BUGFIX: index checking was not performed for openarr[const] and sequence[const] - now no "intelligent" reuse of temporaries is done any longer; this should avoid subtle bugs that may have been in the code generator - BUGFIX: int64 literals for the Pascal parser; this fixes the bug in the generation of ``types.nim`` - Finally long standing bug in mOrd of ccgexprs has been fixed! - BUGFIX: sonsLen is not attempted always in ``lsub`` and ``gsub`` - BUGFIX: This code yielded invalid Nimrod code:: s := qualifiedLookup(c, n, true); // check for ambiguity if s <> nil then result := semSym(c, n, s, flags) else // THE COMMENT HERE IS INVALID! result := semFieldAccess(c, n, flags); - bootstrapping now writes a diff.log file for easier debugging; first line is ignored in the diff computation - ``volatile`` removed in ``excpt.nim`` to avoid VCC warnings - changed ``genAddr`` in ``ccgexprs`` module - BUGFIX: sameFile for ``os`` module under Windows was not working - BUGFIX: importing ``system`` as a module now generates a proper error - BUGFIX: ``ze`` built-in needs to be done differently - CHANGE: Do not include clock time in the executable! Otherwise bootstrapping check does not work. - fixed the RstParser; initialization back to zero is not done in loop; documentation generator now also work in the Nimrod version - BUGFIX: ``semExpr`` replaced by ``semExprWithType`` in semstmts - finally got tuples and objects right - BUGFIX: typo in sigmatch: tySet branch - BUGFIX: enums with 256 elements do not fit into a byte, because otherwise overflow detection does not work! - 2008/8/14 first bootstrap with new tuple semantics - BUGFIX in repr; gctest now works again - tuned the GC - BUGFIX the scanner now accepts 64 bit integer literals - BUGFIX: ``getApplicationFilename`` on Mac OS X fixed; installation on Mac OS X should work now - BUGFIX: reversed order of ``fixAbstractType`` and ``analyseIfAddressTakenInCall`` again, because codegen otherwise screws up - removed tfAssignable; this does not belong to a type! - ccgutils: merge types with the same ID in the code generators - ccgtypes: tySet now unsigned - fixed arith.nim overflow handling - implemented NIM_CONST for the C code generator, because it always made problems with picky compilers like PCC - some fixes for Pelles C - BUGFIX: do not remove nkConv even if no range check is needed! - BUGFIX: genRangeCheck needs to cast! - BUGFIX: code generation for mInc, mDec, mChr - BUGFIX: spaces in the C compiler's path are finally possible - new strtabs module - new parseopt module used for parsing of command line - got rid of NU and NI in ``nimbase.h``; now the code generator deals with it appropriately - parseopt, hashes, strtabs and parsecfg in the Standard library - introduced splitting for long entries in TOC - implemented profiling support - removed cfilecache switch (-f does the same) - implemented acyclic pragma (even for the Pascal parser) - implemented thread local variables - improved cycle detection in types module - huge optimization of GC - added ``c`` and ``cc`` short commands - zlib binding added - SDL binding added - Xlib binding added - OpenGL binding added - ODBC binding added - Lua binding added - BUGFIX: ``len`` for cstring now works as expected - changed type names in the Cairo binding - implemented ``noinline`` calling convention - BUGFIX in sigmatch concerning compability of proc types - BUGFIX: some C compiler optimzed the ``setjmp`` call in the GC away with horrible consequences! - BUGFIX: $vars work in the C compiler path again - ``compileTime`` pragma - ``nkStmtListType`` node for macros - removed ``nostatic`` pragma - separate compilation! - BUGFIX: aliasing of object types now works properly - BUGFIX: ccgtypes: generation for var-types was not correct - BUGFIX: debugger now works again - nil for variant objects - BUGFIX: posix module was broken for Mac OS X, because it lacks realtime support - BUGFIX: docgen now replaces ``"`` by ``"e;`` - BUGFIX: ccgexprs: passToOpenArray - BUGFIX: regexprs module compiles again - BUGFIX: Bug in ``isAssignable`` need to check dest type, not source type - BUGFIX: ccgtypes: isInvalidReturnType - streams module - BUGFIX: rawReadLine should not return nil for EOF - BUGFIX: ``lookup`` did not check for ambigious identifiers - BUGFIX: ``isMainModule`` is not ambigious any longer - overloading resolution now takes place in a few more cases; see tests/tambsym2 for an example - implemented ``is`` operator - improved error messages if an OS request failes - BUGFIX: ``extractFilename``, ``extractDir`` - implemented ``newSeq``, compiler already uses it - changed integer conversion handling; breaks code compability again! (For the last time, I promise) - now all magics are kept in the system module - ported to FreeBSD - the ``koch.py`` script now should be more portable to 1.5.2 Python - BUGFIX: lookup: `opr` now supported - changed the installation scheme - improved the ID mechanism; too difficult to explain here - BUGFIX: ``--cc`` now resets compile and link options - Finally found the bug that keeps Visual C++ from compiling a working executable with its optimizer: index checks for strings and sequences need to be turned on, otherwise it breaks. This has probably to do with C aliasing rules. - BUGFIX: aliasing rules for strings and sequence should now be respected; they both inherit from ``TGenericSeq`` now. This still does not fix the serious Visual C bug. - BUGFIX: inheritance from final objects is forbidden, not the other way round - ccgexprs: special cases for string ``==`` - ccgstmts: ``while true`` generates less C code - C code generator: Merged constant data, otherwise too much code is generated - C code generator: fixed a long-standing bug in ``genObjectInit``. - extccomp: C optimization can be disabled for certain files. - BUGFIX: cgen: result sometimes not initialized (?) - ``define`` and ``undef`` pragmas are now deprecated - ``isMainModule`` now in system module and works via compiler magic - implemented simple and powerful template engine; built into the Nimrod compiler - BUGFIX: tuple constructor did not always work - BUGFIX: wrong C code generated for ``openarray[array[]]`` - now much more efficient C code is generated for constant expressions - BUGFIX: sometimes the C generator generated conflicting names - optimization of string concatenations - BUGFIX: docgen: last enum field may lose its comment - the compiler now uses streams internally - changed the style of the generated documentation - BUGFIX: rodgen: stacks would not be properly processed - cggexprs: string literals for field checks are reused - ccgtypes: typeNameOrLiteral takes care of magics - ccgtypes: support for incremental compilation - The C code generator now uses the ast.gid for ID generation. This is needed for proper incremental compilation. - ccgtypes: new change for incremental compilation - polished templ system - BUGFIX: walkFiles does not error if no matching files found - BUGFIX: ``os.copyFile`` - reworked integer conversions - added ``GC_ref`` and ``GC_unref`` procs - implemented `zipfiles` module - BUGFIX: ``$`` now generates efficient code - BUGFIX: C's ``sizeof`` returns an unsigned, the generated code now casts - BUGFIX: trectype never worked, now at the least the compiler does not crash - BUGFIX: times module returned a newline for the `$` operator - sequences now need to be constructed with ``@[]`` - changed the ``rod_gen`` to the ``nimcache`` mechanism, so the compiler does not need to have write access to its directory - BUGFIX: createDir now works for sub directories - changed configuration file handling, so that UNIX-like installations are possible - BUGFIX: ``ParseFloat`` now supports ``inf`` and ``nan`` - the type information code is now smaller (helps GCC's compile times!) - BUGFIX: constant evaluation for mRepr is not possible - refactored the semantic phase into separate modules - BUGFIX: wrong indexing in ``genSetConstr`` - used a node flag to avoid multiple transformation passes over the same tree: this flag is cleared when copying nodes - special case for ``sameType`` - changed order for optimization of ``semMagic`` - optimized ``semexprs.genCall`` - implemented a new passes manager which saves a lot of memory - OPT: GC now MUCH faster, still room for improvement though - OPT: ``system.objectInit`` is now only called iff strictly necessary - OPT: the write barrier can now be inlined by GCC - OPT: Nimrod version of ``addSon`` optimized - parsecfg, lexbase now use streams - the config file now supports ``ccname.exe`` and ``ccname.linkerExe`` configuration for changing the GGC version - BUGFIX: typo for ``succ`` code generation without checks - fixed many bugs in ``os`` module for Windows - bug in ``semVar`` removed standard convertions - BUGFIX: ``setLen`` for sequences may lead to memory leaks For the next versions ===================== - multi-processor support - tuple assignment - IDE - better support for GDB? - support for generation of dynamic libraries - better code generator: skip ropes datastructure, it uses too much memory - make set optimizations part of the transformation (--> all backends profit from it), but this really needs a more abstract code generator Further ideas/nice to have ========================== - introduce: refany type??? - CLR code generator; better use XYZ? --> Version 1.2? - provide an interactive shell: if the user wants his commands to be executed, the command should end with # - add the built-in 'finalize' - implement packed arrays (bit arrays)/ packed records - implement tables (implement as library? - no! Builtin because of constructor syntax is nice to have)