==== News ==== 2011-XX-XX Version 0.8.12 released ================================== Version 0.8.12 has been released! Get it `here `_. Bugfixes -------- - Bugfix: ``httpclient`` correct passes the path starting with ``/``. - Bugfixes for the ``htmlparser`` module. - Bugfix: ``pegs.find`` did not respect ``start`` parameter. - Bugfix: ``dialogs.ChooseFilesToOpen`` did not work if only one file is selected. - Bugfix: niminst: ``nimrod`` is not default dir for *every* project. - Bugfix: Multiple yield statements in iterators did not cause local vars to be copied. - Bugfix: The compiler does not emit very inaccurate floating point literals anymore. - Bugfix: Subclasses are taken into account for ``try except`` matching. - Lots of other bugfixes: Too many to list them all. Changes affecting backwards compatibility ----------------------------------------- - Operators starting with ``^`` are now right-associative and have the highest priority. - Deprecated ``os.getApplicationFilename``: Use ``os.getAppFilename`` instead. - Deprecated ``os.getApplicationDir``: Use ``os.getAppDir`` instead. - Deprecated ``system.copy``: Use ``substr`` or string slicing instead. - Changed and documented how generalized string literals work: The syntax ``module.re"abc"`` is now supported. - Changed the behaviour of ``strutils.%``, ``ropes.%`` if both ``$#`` and ``$i`` are involved. - The ``pegs`` and ``re`` modules distinguish between ``replace`` and ``replacef`` operations. - The pointer dereference operation ``p^`` is deprecated and might become ``^p`` in later versions or be dropped entirely since it is rarely used. Use the new notation ``p[]`` in the rare cases where you need to dereference a pointer explicitely. Additions --------- - Added ``lists`` module which contains generic linked lists. - Added ``sets`` module which contains generic hash sets. - Added ``tables`` module which contains generic hash tables. - Added ``scgi`` module. - Added ``smtp`` module. - Added ``re.findAll``, ``pegs.findAll``. - Added ``os.findExe``. - Added ``parseutils.parseUntil`` and ``parseutils.parseWhile``. - Added ``strutils.align``, ``strutils.tokenize``, ``strutils.wordWrap``. - Pegs support a *captured search loop operator* ``{@}``. - Pegs support new built-ins: ``\letter``, ``\upper``, ``\lower``, ``\title``, ``\white``. - Pegs support the new built-in ``\skip`` operation. - Pegs support the ``$`` and ``^`` anchors. - Source code filters are now documented. - Added ``emit`` pragma for direct code generator control. - Additional operations were added to the ``complex`` module. - Added ``strutils.formatFloat``, ``strutils.formatBiggestFloat``. - A field in an ``enum`` may be given an explicit string representation. This yields more maintainable code than using a constant ``array[TMyEnum, string]`` mapping. - Indices in array literals may be explicitly given, enhancing readability: ``[enumValueA: "a", enumValueB: "b"]``. - Added basic thread support via the ``threads`` core module and the ``--threads:on`` command line switch. - Added unary ``<`` for nice looking excluding upper bounds in ranges. - Added ``math.floor``. - The *interactive mode* (REPL) has been improved and documented for the first time. - Added the ``linearScanEnd``, ``unroll``, ``shallow`` pragmas. - Added ``system.reset`` and a version of ``system.open`` that returns a ``TFile`` and raises an exception in case of an error. - The compiler now might use hashing for string case statements depending on the number of string literals in the case statement. - Added a wrapper for ``redis``. - Added a wrapper for ``0mq`` via the ``zmq`` module. - The compiler now supports array, sequence and string slicing. - Added ``system.newStringOfCap``. - Added ``system.raiseHook``. - ``system.echo`` is guaranteed to be thread-safe. 2010-10-20 Version 0.8.10 released ================================== Bugfixes -------- - Bugfix: Command line parsing on Windows and ``os.parseCmdLine`` now adheres to the same parsing rules as Microsoft's C/C++ startup code. - Bugfix: Passing a ``ref`` pointer to the untyped ``pointer`` type is invalid. - Bugfix: Updated ``keyval`` example. - Bugfix: ``system.splitChunk`` still contained code for debug output. - Bugfix: ``dialogs.ChooseFileToSave`` uses ``STOCK_SAVE`` instead of ``STOCK_OPEN`` for the GTK backend. - Bugfix: Various bugs concerning exception handling fixed. - Bugfix: ``low(somestring)`` crashed the compiler. - Bugfix: ``strutils.endsWith`` lacked range checking. - Bugfix: Better detection for AMD64 on Mac OS X. Changes affecting backwards compatibility ----------------------------------------- - Reversed parameter order for ``os.copyFile`` and ``os.moveFile``!!! - Procs not marked as ``procvar`` cannot only be passed to a procvar anymore, unless they are used in the same module. - Deprecated ``times.getStartMilsecs``: Use ``epochTime`` or ``cpuTime`` instead. - Removed ``system.OpenFile``. - Removed ``system.CloseFile``. - Removed ``strutils.replaceStr``. - Removed ``strutils.deleteStr``. - Removed ``strutils.splitLinesSeq``. - Removed ``strutils.splitSeq``. - Removed ``strutils.toString``. - If a DLL cannot be loaded (via the ``dynlib`` pragma) ``EInvalidLibrary`` is not raised anymore. Instead ``system.quit()`` is called. This is because raising an exception requires heap allocations. However the memory manager might be contained in the DLL that failed to load. - The ``re`` module (and the ``pcre`` wrapper) now depend on the pcre dll. Additions --------- - The ``{.compile: "file.c".}`` pragma uses a CRC check to see if the file needs to be recompiled. - Added ``system.reopen``. - Added ``system.getCurrentException``. - Added ``system.appType``. - Added ``system.compileOption``. - Added ``times.epochTime`` and ``times.cpuTime``. - Implemented explicit type arguments for generics. - Implemented ``{.size: sizeof(cint).}`` pragma for enum types. This is useful for interfacing with C. - Implemented ``{.pragma.}`` pragma for user defined pragmas. - Implemented ``{.extern.}`` pragma for better control of name mangling. - The ``importc`` and ``exportc`` pragmas support format strings: ``proc p{.exportc: "nim_$1".}`` exports ``p`` as ``nim_p``. This is useful for user defined pragmas. - The standard library can be built as a DLL. Generating DLLs has been improved. - Added ``expat`` module. - Added ``json`` module. - Added support for a *Tiny C* backend. Currently this only works on Linux. You need to bootstrap with ``-d:tinyc`` to enable Tiny C support. Nimrod can then execute code directly via ``nimrod run myfile``. 2010-03-14 Version 0.8.8 released ================================= Bugfixes -------- - The Posix version of ``os.copyFile`` has better error handling. - Fixed bug #502670 (underscores in identifiers). - Fixed a bug in the ``parsexml`` module concerning the parsing of ````. - Fixed a bug in the ``parsexml`` module concerning the parsing of enities like ``<XX``. - ``system.write(f: TFile, s: string)`` now works even if ``s`` contains binary zeros. - Fixed a bug in ``os.setFilePermissions`` for Windows. - An overloadable symbol can now have the same name as an imported module. - Fixed a serious bug in ``strutils.cmpIgnoreCase``. - Fixed ``unicode.toUTF8``. - The compiler now rejects ``'\n'`` (use ``"\n"`` instead). - ``times.getStartMilsecs()`` now works on Mac OS X. - Fixed a bug in ``pegs.match`` concerning start offsets. - Lots of other little bugfixes. Additions --------- - Added ``system.cstringArrayToSeq``. - Added ``system.lines(f: TFile)`` iterator. - Added ``system.delete``, ``system.del`` and ``system.insert`` for sequences. - Added ``system./`` for int. - Exported ``system.newException`` template. - Added ``cgi.decodeData(data: string): tuple[key, value: string]``. - Added ``strutils.insertSep``. - Added ``math.trunc``. - Added ``ropes`` module. - Added ``sockets`` module. - Added ``browsers`` module. - Added ``httpserver`` module. - Added ``httpclient`` module. - Added ``parseutils`` module. - Added ``unidecode`` module. - Added ``xmldom`` module. - Added ``xmldomparser`` module. - Added ``xmltree`` module. - Added ``xmlparser`` module. - Added ``htmlparser`` module. - Added ``re`` module. - Added ``graphics`` module. - Added ``colors`` module. - Many wrappers now do not contain redundant name prefixes (like ``GTK_``, ``lua``). The old wrappers are still available in ``lib/oldwrappers``. You can change your configuration file to use these. - Triple quoted strings allow for ``"`` in more contexts. - ``""`` within raw string literals stands for a single quotation mark. - Arguments to ``openArray`` parameters can be left out. - More extensive subscript operator overloading. (To be documented.) - The documentation generator supports the ``.. raw:: html`` directive. - The Pegs module supports back references via the notation ``$capture_index``. Changes affecting backwards compatibility ----------------------------------------- - Overloading of the subscript operator only works if the type does not provide a built-in one. - The search order for libraries which is affected by the ``path`` option has been reversed, so that the project's path is searched before the standard library's path. - The compiler does not include a Pascal parser for bootstrapping purposes any more. Instead there is a ``pas2nim`` tool that contains the old functionality. - The procs ``os.copyFile`` and ``os.moveFile`` have been deprecated temporarily, so that the compiler warns about their usage. Use them with named arguments only, because the parameter order will change the next version! - ``atomic`` and ``let`` are now keywords. - The ``\w`` character class for pegs now includes the digits ``'0'..'9'``. - Many wrappers now do not contain redundant name prefixes (like ``GTK_``, ``lua``) anymore. - Arguments to ``openArray`` parameters can be left out. 2009-12-21 Version 0.8.6 released ================================= The version jump from 0.8.2 to 0.8.6 acknowledges the fact that all development of the compiler is now done in Nimrod. Bugfixes -------- - The pragmas ``hint[X]:off`` and ``warning[X]:off`` now work. - Method call syntax for iterators works again (``for x in lines.split()``). - Fixed a typo in ``removeDir`` for POSIX that lead to an infinite recursion. - The compiler now checks that module filenames are valid identifiers. - Empty patterns for the ``dynlib`` pragma are now possible. - ``os.parseCmdLine`` returned wrong results for trailing whitespace. - Inconsequent tuple usage (using the same tuple with and without named fields) does not crash the code generator anymore. - A better error message is provided when the loading of a proc within a dynamic lib fails. Additions --------- - Added ``system.contains`` for open arrays. - The PEG module now supports the *search loop operator* ``@``. - Grammar/parser: ``SAD|IND`` is allowed before any kind of closing bracket. This allows for more flexible source code formating. - The compiler now uses a *bind* table for symbol lookup within a ``bind`` context. (See ``_ for details.) - ``discard """my long comment"""`` is now optimized away. - New ``--floatChecks: on|off`` switches and pragmas for better debugging of floating point operations. (See ``_ for details.) - The manual has been improved. (Many thanks to Philippe Lhoste!) Changes affecting backwards compatibility ----------------------------------------- - The compiler does not skip the linking step anymore even if no file has changed. - ``os.splitFile(".xyz")`` now returns ``("", ".xyz", "")`` instead of ``("", "", ".xyz")``. So filenames starting with a dot are handled differently. - ``strutils.split(s: string, seps: set[char])`` never yields the empty string anymore. This behaviour is probably more appropriate for whitespace splitting. - The compiler now stops after the ``--version`` command line switch. - Removed support for enum inheritance in the parser; enum inheritance has never been documented anyway. - The ``msg`` field of ``system.E_base`` has now the type ``string``, instead of ``cstring``. This improves memory safety. 2009-10-21 Version 0.8.2 released ================================= Bugfixes -------- - Passing ``--hint[X]:off`` or ``--warning[X]:off`` as command line arguments to the compiler now works. - Default parameters for templates now work. - Fixed security issue in ``system.copy``. - String case without an ``else`` part generated wrong code. - Various fixes for the ``osproc`` module; it now works on Windows. Additions --------- - Implemented multi-methods. - The compiler now detects the number of available processors and executes the C compiler concurrently. This can be adjusted by the ``--parallel_build: number_of_processors`` command line switch. - PEG-based pattern matching via the `pegs `_ module. - Added ``system.definedInScope``. - Added ``system.accumulateResult``. - Added ``os.walkDirRec``. - Added ``osproc.countProcessors``. - Added ``osproc.execProcesses``. - The configuration system now supports ``$cc.options.linker``. - Merged ``expr`` and ``typeDesc`` in the grammar/parser: this will allow for anonymous procs without ``lambda``. - Many scripts have no need for a GC: The new ``--gc:none`` command line switch can be used to exclude the GC from the executable. Changes affecting backwards compatibility ----------------------------------------- - Taking the address of an object discriminant is now invalid. - Passing a proc to a proc var is only allowed for procs marked with ``procvar`` or a calling convention != ``nimcall``. For now this only causes a warning, but this will turn into an error soon. - ``system.&`` and ``system.add`` now receive ``openArray`` instead of ``seq`` parameters. - Removed ``strutils.findSubStr`` and ``strutils.findChars``. They have been deprecated for 3 versions. - The unicode module uses a distinct type for ``TRune``. - Deprecated ``strutils.toString``: use ``$`` instead. - Deprecated ``os.splitPath``: use ``os.splitPath`` that returns a tuple instead. - Deprecated ``os.extractDir``: use ``splitFile(path).dir`` instead. - Deprecated ``os.splitFilename``: use ``splitFile`` instead. - Deprecated ``os.extractFileExt``: use ``splitFile`` instead. - Deprecated ``os.extractFileTrunk``: use ``splitFile`` instead. - Deprecated ``os.appendFileExt``: use ``os.addFileExt`` instead. - Deprecated ``os.executeShellCommand``: use ``os.execShellCmd`` instead. - Deprecated ``os.iterOverEnvironment``: use ``os.envPairs`` instead. - Deprecated ``parseopt.init``: use ``parseopt.initOptParser`` instead. - Deprecated ``parseopt.getRestOfCommandLine``: use ``parseopt.cmdLineRest`` instead. - Deprecated ``os.pcDirectory``: use ``os.pcDir`` instead. - Deprecated ``os.pcLinkToDirectory``: use ``os.pcLinkToDir`` instead. - Deprecated ``osproc.executeProcess``: use ``osproc.execProcess`` instead. - Deprecated ``osproc.executeCommand``: use ``osproc.execCmd`` instead. 2009-09-12 Version 0.8.0 released ================================= Bugfixes -------- - fixed a small bug that caused the compiler to not report unused overloaded symbols - fixed a small bug concerning symbol overloading - fixed a typo: it's "ambiguous", not "ambigious" ;-) - the compiler now detects recursive include files - ``system.card`` should work again - ``items`` for ``set[char]`` and ``array[char, T]`` should work now Additions --------- - implemented generic types and two phase symbol lookup in generic routines - template parameters can now have real types - implemented generalized raw string literals: ``ident"abc"`` is a shortcut for ``ident(r"abc")`` - in overloading resolution iterators are separated from procs; iterators now can have the same name+signature as procs - symbol lookup in templates can be affected by the new ``bind`` keyword - the compiler now accepts a ``--no_main`` switch for better link interoperability with other compiled languages - implemented tuple unpacking in ``var`` sections - the code generator emits ``default: __assume(0);`` for Visual C++ (for optimization) - the compiler now checks if a proc has side effects; procs that are declared to have no side effects are rejected if the compiler cannot verify this - the format operator ``strutils.%`` now supports ``$#`` for automatic argument counting - implemented ``strutils.join`` Changes affecting backwards compatibility ----------------------------------------- - two phase symbol lookup is performed in generic routines - ``bind`` is now a reserved word; ``exception`` is no reserved word anymore - abstract types have been renamed to distinct types; thus ``distinct`` is now a reserved word; ``abstract`` is no reserved word anymore - ``system.openFile`` deprecated: use ``system.open`` instead - ``system.closeFile`` deprecated: use ``system.close`` instead - ``strutils.replaceStr`` deprecated: use ``strutils.replace`` instead - ``strutils.deleteStr`` deprecated: use ``strutils.delete`` instead - ``strutils.splitSeq`` deprecated: use ``strutils.split`` instead - ``strutils.splitLinesSeq`` deprecated: use ``strutils.splitLines`` instead - ``strutils.parseFloat`` does not accept an additional ``start`` parameter anymore Documentation ------------- - the manual has been improved 2009-06-08 Version 0.7.10 released ================================== Nimrod version 0.7.10 has been released! Bugfixes -------- - fixed bug #374441, #376113 - the posix module works for Mac OS X again - returning an array should now work - fixed a serious bug in several parsers: the cached buf pointer must be updated after a reallocation of the buffer - fixed a CSS bug that kept Firefox from rendering parts of the generated documentation properly - fixed a bug concerning evaluation of command statements - overloading of ``inc``, ``dec``, ``pred``, ``succ`` should now work - ``removeDir`` now works as the documentation says: it even removes directories that are not empty Additions --------- * zero argument templates/macros can now be invoked without ``()``, because this is not ambiguous * new modules in the library: - ``dynlib``: load symbols from a shared library - ``python``: wrapper for the Python programming language - ``tcl``: wrapper for the TCL programming language * added ``system.max``, ``system.min`` for open arrays * added ``system.each`` built-in * added ``os.getFilePermissions``, ``os.setFilePermissions``, ``os.inclFilePermissions``, ``os.exclFilePermissions`` * the ``dynlib`` import mechanism now supports a flexible versioning scheme: .. code-block:: nimrod proc Tcl_Eval(interp: pTcl_Interp, script: cstring): int {.cdecl, importc, dynlib: "libtcl(8.5|8.4|8.3|8.2|8.1).so.(1|0)".} * implemented ``abstract`` types Changes affecting backwards compatibility ----------------------------------------- - the organization within the ``lib`` folder now reflects the documentation; as a result old configuration files need to be updated - ``abstract`` is now a reserved keyword - ``echo`` is now a built-in macro that accepts a variable numer of arguments of different types (and calls ``$`` for the arguments that need it); as a result it cannot be overloaded anymore - ``where`` is no keyword anymore - installation on UNIX produces a release version of the compiler 2009-05-08 Version 0.7.8 released ================================= Nimrod version 0.7.8 has been released! Apart from bugfixes and added libraries the biggest change is that Nimrod now has a new memory manager which: - interacts much better with the GC - uses less memory - is faster than the old memory manager (``dlmalloc``) - releases memory back to the operating system Bugfixes -------- - generics are now processed earlier in the pipeline; thus generics can be used within macros - changed bootstrapping in ``koch.py`` and ``boot.nim`` to fix bug #369607 - the compiler now checks that ``yield`` is used inside a loop - fixed a bug in the evaluation code for ``system.len``, ``system.setlen`` and ``system.newSeq`` - overflow checking for ``newSeq`` fixes a security issue Additions --------- - new module: ``parsecsv`` for parsing CSV files - new module: ``xmlgen`` for generating XML or HTML - new module: ``osproc`` for OS process communication - added ``math.TRunningStat`` object and its methods - added ``strutils.validIdentifier`` - the reStructuredText parser now supports the ``container`` directive that translates to the HTML ``div`` element - the ``cgi`` module registers a handler, so that stack traces contain the HTML ``
`` element making CGI applications easier to debug - added the ``cgi.decodeData`` iterator - ``copy`` and ``newString`` can now be evaluated at compile time. As a result more procedures from the ``strutils`` module can be evaluated at compile time. - ``macros.error`` now prints a stack trace - Nimrod now supports the Boehm-Demers-Weiser conservative garbage collector: The ``--gc:boehm`` command line switch activates it. However, the native Nimrod collector is faster! Documentation ------------- - Nimrod's abstract syntax trees are now documented in the `macros `_ module. Unfortunately the documentation is still incomplete. 2009-04-22 Version 0.7.6 released ================================= Nimrod version 0.7.6 has been released! This is mostly a bugfix release. Some new features and libraries have also been implemented. Bugfixes -------- - installation on Windows Vista may now work out of the box; please try! - fixed a bug that kept the "recursive modules" example from working - mixing named and unnamed parameters in a procedure call now works - octal numbers with the prefix ``0c`` are now properly supported - enumerations now may start with negative values - ``parseInt``, ``ParseBiggestInt`` now throw an exception if the string does not end after the parsed number - the compiler now handles top-level statements correctly - generated ``nimcache`` directory never ends in a slash - ``createDir`` now works for global directories under UNIX ("/somepath/here") - the compiler now executes the executable with a leading "./" under UNIX - the compiler now supports constant arrays of procedure pointers - ``elif`` in ``case`` statements now works - iterators using an open array parameter now work - fixed a bug where in some contexts ``$myEnum`` did not work Additions --------- - implemented the passing of a code-block to the last parameter of a template/macro: .. code-block:: nimrod template withFile(f, filename, mode: expr, actions: stmt): stmt = block: var f: TFile if openFile(f, filename, mode): try: actions finally: closeFile(f) else: quit("cannot open: " & filename) withFile(txt, "ttempl3.txt", fmWrite): txt.writeln("line 1") txt.writeln("line 2") - new pragma ``deprecated`` can be used to mark deprecated identifiers - added ``system.pop`` built-in for sequences - added ``addf``, ``addSep`` and ``validEmailAddress`` to the ``strutils`` module - nice ``=~`` template operator for the ``regexprs`` module - the scoping rules for ``for``, ``while``, ``if``, ``case`` changed in a subtle way to support the new ``=~`` template - added common regular expressions for regexprs - ``posix`` module now declares socket stuff - new module: ``cgi`` for creating CGI applications - new module: ``terminal`` for simple terminal output customization - new module: ``parsexml`` for HTML/XML parsing with some support for parsing *dirty* HTML - new module: ``web`` for retrieving web pages - new module: ``md5`` for computation of MD5 checksums - new wrappers: ``mysql``, ``sqlite3``, ``libcurl`` Changes affecting backwards compatibility ----------------------------------------- - ``strutils.findSubStr``, ``strutils.findChars`` deprecated: use ``strutils.find`` instead Documentation ------------- - The library is now divided into *pure libraries*, *impure libraries* and *wrappers*. 2009-01-22 Forum added ====================== We now have a `forum `_ where you can discuss Nimrod. 2009-01-07 Version 0.7.4 released ================================= Nimrod version 0.7.4 has been released! Bugfixes -------- - installation on Windows should work now if the directory contains spaces - the documentation generator now only renders documentation comments - ``\`` is allowed for operators as the manual says - in rare cases, the index check has been optimized away, even though it would have been necessary - several bugfixes for tuple types Additions --------- - added an ``unicode`` module for UTF-8 handling - added ``hostOS`` and ``hostCPU`` magics to the ``system`` module - ``system.echo`` now accepts multiple arguments - added optimization: in some cases inlining of iterators now produces substantially better code - added whole program dead code elimination - the magic ``$`` operator now works for enumerations - in ``const`` sections advanced compile time evaluation is done: .. code-block:: nimrod proc fac(n: int): int = if n <= 1: return 1 else: return n*(fac(n-1)) const z = fac(3) # computes 6 at compile time Changes affecting backwards compatibility ----------------------------------------- - renamed ``in_Operator`` to ``contains``: ``in`` is now a template that translates to ``contains`` - changed ``strutils.quoteIfSpaceExists`` to ``strutils.quoteIfContainsWhite`` - the parser is now much more picky about missings commas, etc. If this affects your code too much, try to run your code through the pretty printer. - the ``macros`` API is no longer part of the ``system`` module, to use this API you now have to import the ``macros`` module Documentation ------------- - added a tutorial 2008-12-12 Version 0.7.2 released ================================= Nimrod version 0.7.2 has been released! This is a bugfix release. This most important fix is that Nimrod now works again on AMD64 (x86_64) processors. No new features have been implemented. 2008-11-16 Version 0.7.0 released ================================= Nimrod version 0.7.0 has been released! Changes: * various bug fixes, too many to list them here * the installation for UNIX-based systems does not depend on Python any longer * the ``koch.py`` script now works with older Python versions (including 1.5.2) * changed integer operations and conversions rules * added ``GC_ref`` and ``GC_unref`` procs * sequences now need to be constructed with the ``@`` operator. This leads to less ambiguities. * the compiler now uses less memory and is much faster * the GC is now much faster * new bindings: zlib, SDL, Xlib, OpenGL, ODBC, Lua * the generated C code is much faster to optimize with GCC * new libraries: streams, zipfiles * the Nimrod compiler has been ported to FreeBSD: it should work on other BSD's too 2008-08-22 Version 0.6.0 released ================================= Nimrod version 0.6.0 has been released! **This is the first version of the compiler that is able to compile itself!** A nice side-effect from this is that a source-based installation does not depend on FreePascal any longer. Changes: * various bug fixes, too many to list them here * cleaned up the type system: records are now superfluous and not supported anymore * improved the performance of the garbage collector * new modules in the library: - ``parseopt``: a simple to use command line parser - ``hashes``: efficient computation of hash values - ``strtabs``: efficient mapping from strings to strings - ``parsecfg``: an efficient configuration file parser * macros and compile-time evaluation implemented (however, still experimental) * generics implemented (however, still experimental)