TO IMPLEMENT ============ Plan ---- * implement new memory manager --> hopefully faster turnaround times * implement LLVM backend --> faster turnaround times RST --- - footnotes; prefix :i: whitespace before :i:, _reference, `reference`__ __ anonymous: www.nimrod.org Bugs ---- - BUG: check if "break" is valid is not complete: "break" within "for" may be incorrect, if the called iterator is not in a loop --> check that "yield" is inside a loop! - BUG: returning an array does not work --> see md5.nim module - BUG: if not nodeOfDegree(g, 1) >= 0: inc(counter) - BUG: addr/deref may not work when interpreting - BUG: the parser allows empty 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 - BUG: tlastmod returns wrong results on BSD (Linux, MacOS X: works) High priority ------------- - typeAllowed() for parameters... - implicit conversions from ``ptr/ref T`` to ``var T`` and from ``ptr/ref T`` to ``T``? Yes. - implement generic types - implement tuple unpacking - implement closures for the C code generator - documentation: type converters - implement two-phase lookup for generics (this is hard...): This is useful for macros too! Alternative: Explicit early name binding. Both are hard to implement - language change: inheritance should only work with reference types, so that the ``type`` field is not needed for objects! --> zero overhead aggregation For the next versions ===================== - multi-processor support - 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 ========================== - queues additional to streams: have to positions (read/write) instead of one - 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 # - implement packed arrays (bit arrays)/ packed records - implement tables (implement as library? - no! Builtin because of constructor syntax is nice to have) Version 2 --------- - language support for aggregation: type TMyObject = object x: TOtherObject --> can be done via type converters elegantly - type tags: type sqlString* = type string everywhere where a string is expected, a "sqlString" is allowed, but not vice versa. However, this causes problems: type TDollar = type decimal TDollar * int --> allowed TDollar div int --> allowed TDollar + int --> not allowed TDollar + TEuro --> not allowed, or implicit conversion --> Explicit converters are probably flawed - explicit nil types? * nil seq[int] * nil string * nil ref int * nil ptr THallo * nil proc .. code-block:: nimrod var x: string = nil # initialized with invalid value! if not isNil(x): # now x - better for backwards compability: default nilable, but prefix ``!`` operator to specify that null is not allowed type PWindow = ! ref TWindow Library ------- - gui module - finish json module: hard - socket, http, ftp, email, fastcgi: implement from scratch - ncurses bindings - osproc for Windows - bignums - python - TCL - automate module: expect-like module for Nimrod - parsecsv module - YAML module Low priority ------------ - ``when T is int`` for generic code - ``when validCode( proc () )`` for generic code when compiles: elif compiles: - copy more of C++'s object modell? - syntactic sugar for OOP: type TObj* = object fx = 0.nat fy = 0.nat s = "" proc setX(var, val: int) = my.fx = val proc getX: int = return my.fx `x=`: proc (var, val: int) = setX x: proc: int = getX proc q*(query: int): int = # implicit "my: TObj" parameter # variables are looked up automatically: return fx proc setEvent(var, e: TEvent): int = # implicit "my: var TObj" parameter nil proc init(var) = # constructor nil o.x = 13 # ambigious - implement stack walking via assembler for horribly advanced optimizers - use `` notation for identifier concatenation? - Visual C++: emit ``default: __assume(0);`` for 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 - 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: no, but provide a proc ``typeId`` to allow the user to implement it efficiently - replace ropes with strings in the C code generator: This may yield a HUGE speedup of the compiler! (10%) - code generated for type information is wasteful 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 0.7.1 - gtk2: cleaned up return types for ``Gtk_*_new`` constructors - gtk2: added ``pure`` to ``final`` objects - BUGFIX: ``genTypeSection`` uses ``isPureObject`` now - BUGFIX: ``GetUniqueType`` was wrong - BUGFIX: count references from untraced heap to traced heap! - BUGFIX: fixed owner handling bug; only accessible in semantic checking phase - BUGFIX: ``ParamTypesMatch`` generics resulting in openarray now generate the nkHiddenStdConv tree - BUGFIX: dynamic libraries are reused again -> much smaller C code is produced - small corrections in the manual - BUGFIX: the build script did not detect 64 bit Linux - BUGFIX: the Pascal version did not compile for 64 bit (TUnsignedHash!) - several bugfixes for 64bit version - BUGFIX: no index checking was generated for some code that should be checked! - BUGFIX: docgen did not escape tokens from highlite module - BUGFIX: fixed seldom integer operations - BUGFIX: illegal type recursion detection - BUGFIX: ``for j in 0 .. a.len`` where a is an open array did not transform correctly 0.7.2 - small performance improvements for the RST parser 0.7.3 - (assembler code for GCC, not activated) - BUGFIX: docgen: take care of nkCommentStmt in sections - docgen: only documentation comments are rendered - BUGFIX: rst: getFieldValue(): invalid assertion - BUGFIX: rst: parseFields(): more than one field is now correctly parsed - BUGFIX: docgen: renderImage(): strip the arguments - BUGFIX: ``\`` is allowed for operators like the spec says - system: added ``hostOS`` and ``hostCPU`` magics - system: echo now accepts multiple arguments - added ``nkFastAsgn`` optimization - BUGFIX: in rare cases, the index check has been optimized away, even though it would have been necessary - added dead code elimination - COMP: renamed ``in_Operator`` to ``contains`` - COMP: renamed ``quoteIfSpaceExists`` to ``quoteIfContainsWhite`` - added ``EnumToStr`` magic 0.7.4 - the parser is now much more picky - for the closing parenthesis ``SAD`` token may occur - the parser is now responsible for popping from the indendation stack - constant evaluation in ``const`` sections - removed hintConvToBaseNotNeeded: It is often intended for overloading resolutions - ``macros`` are no longer part of the ``system`` module, to use macros you have to import the ``macros`` module 0.7.5 - GC now uses the simpler "markStackAndRegisters" version - fixed a bug that kept the "recursive modules" example from working - docgen: changed ``
`` to ``

`` to generate valid HTML - BUGFIX: ``nkCommand``, etc. supported by the C code generator for statements - ``addf`` for ``strutils`` - added common regular expressions for regexprs - BUGFIX: ``g.show(name="VC", vc)`` Error: cannot bind parameter 'name' twice - BUGFIX: got rid of debug output in sigmatch module - implemented ``nkMacroStmt`` - ``findSubStr``, ``findChars`` deprecated: use ``find`` instead; the library has already been adapted - deprecated items are now warned for - BUGFIX: octal numbers with the prefix ``0c`` are now properly supported - posix module now declares socket stuff - new ``terminal`` module - BUGFIX: ``parseInt``, ``ParseBiggestInt`` now throw an exception if the string does not end after the parsed number - libcurl wrapper library - BUGFIX: ``semEnum``: enumerations now may start with negative values - started ``web`` library - added ``system.pop`` built-in for sequences - added ``parsexml`` module - BUGFIX: c.p.owner is now never nil - the scoping rules for ``for``, ``while``, ``if``, ``case`` changed in a subtle way to support the new ``=~`` template - BUGFIX: generated ``nimcache`` directory never ends in a slash - BUGFIX: ``createDir`` now works for global directories under UNIX "/somepath/here" - BUGFIX: now executes the executable with "./" &exe under UNIX - added ``strutils.addSep`` proc - BUGFIX: constant array of procs - BUGFIX: elif in case statements - mysql, sqlite3 interface - md5 module - BUGFIX: iterators using open arrays - BUGFIX: [$anyEnum]