Nim/todo.txt

TO IMPLEMENT
============

Plan
----

* implement LLVM backend --> faster turnaround times
* implement ``p(.int, int.): string`` notation for resolution of overloaded
  procs

Bugs
----

- BUG: seq[TLoc] in C code generator always failed --> probably some reference
  counting is wrong; try to reproduce this in the GC test
- BUG: returning an array does not work --> see md5.nim module
- BUG: if not nodeOfDegree(g, 1) >= 0: inc(counter)
- BUG: the parser allows empty object case branches
- BUG: when optmizing cgen.c with Visual C++, GCC, LLVM (O3), it breaks.
- BUG: symbol files still do not work
- BUG: tlastmod returns wrong results on BSD (Linux, MacOS X: works)


High priority
-------------

- new $$ string interpolation operator? 
  $$"The value is $var &var" -- too hard to implement

- find a way to reindroduce the cleanup() pass for C code generation: this
  is hard because of partial evaluation --> symbol files will fix this as
  a side effect
- 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
- resizing of strings/sequences could take into account the memory that
  is allocated


Library
-------

- socket, http, ftp, email, fastcgi: implement from scratch
- osproc for Windows
- bignums

- gui module
- finish json module: hard

- YAML module
- ncurses bindings
- python
- TCL
- automate module: expect-like module for Nimrod

- for system:
  proc `@` [T](a: openArray[T]): seq[T] = 
    newSeq(result, a.len)
    for i in 0..a.len-1: result[i] = a[i]
    
  --> ensure @[] calls the array version!


For the next versions
=====================

- multi-processor support
- IDE
- support for generation of dynamic libraries
- 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 two positions (read/write) instead of one
- introduce: refany type???
- 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
    


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

- 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
- 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
- code generated for type information is wasteful


RST
---
- footnotes; prefix :i: whitespace before :i:, _reference, `reference`__
  __ anonymous: www.nimrod.org


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 ``&quote;``
- 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 ``<blockquote>`` to ``<blockquote><p>`` 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]

0.7.6: release
0.7.7:
- implemented the "parsecsv" module
- added ``math.TRunningStat`` object and its methods
- added ``strutils.validIdentifier``
- reStructuredText parser: implemented ``.. container ::`` directive
- updated the website
- ``cgi.stackTraceNewLine`` functionality
- added ``cgi.decodeData`` 
- BUGFIX: evaluation for ``mLengthSeq``, ``mLengthOpenArray``, 
  ``evalSetLengthSeq``, ``evalNewSeq``
- ``copy`` and ``newString`` are magics now; thus several more things
  can be evaluated
- ``evalAddr`` fixed
- BUGFIX: generics are now processed earlier in the pipeline; thus 
  generics can be used within macros
- new module ``xmlgen``
- ``macros.error`` now prints a stack trace
- changed bootstrapping in ``koch.py`` and ``boot.nim`` to fix bug 
  #369607.
- implemented the new memory management; the GC does not take advantage of
  it yet
- BUGFIX: magics don't imply ``lfNoDecl`` any longer
- BUGFIX: ``newString`` is not evaluated at compile-time anymore, unless
  evaluation is requested
- the GC now relies on the new memory manager
- BUGFIX: check that "yield" is inside a loop!
- BUGFIX: ``isAllocatedPtr`` still had a small bug
- overflow checking for ``newSeq`` now works
- BUGFIX: ``commands.processSwitch`` no errors if an argument is given to a
  switch that does not receive one

0.7.8: release