Nimrod

Nimrod is an open source, free, statically typed, imperative programming language designed to support procedural, object-oriented, generic and functional programming styles, while remaining efficient and simple.

Nimrod is able to abstract syntax tree (AST) as part of a specification, allowing a powerful macro system that can be used to create domain specific languages. A features inherited from Lisp.

The software features native code generation, garbage collection, zero-overhead iterators, user-defineable operators, high level datatypes, compile time evaluation, forward compability, GTK2, Windows API, POSIX API bindings, a plugable parser system, a documentation generator, and a Pascal to Nimrod conversion utility.

Nimrod is portable, which means that it can run on Linux, BSD, Mac OS X and Windows operating systems.

What is new in this release:

• Bugfixes:
• The old GC never collected cycles correctly. Fixed but it can cause performance regressions. However you can deactivate the cycle collector with GC_disableMarkAndSweep and run it explicitly at an appropriate time or not at all. There is also a new GC you can activate with --gc:markAndSweep which does not have this problem but is slower in general and has no realtime guarantees.
• cast for floating point types now does the bitcast as specified in the manual. This breaks code that erroneously uses cast to convert different floating point values.
• SCGI module's performance has been improved greatly, it will no longer block on many concurrent requests.
• In total fixed over 70 github issues and merged over 60 pull requests.
• Library Additions:
• There is a new experimental mark&sweep GC which can be faster (or much slower) than the default GC. Enable with --gc:markAndSweep.
• Added system.onRaise to support a condition system.
• Added system.locals that provides access to a proc's locals.
• Added macros.quote for AST quasi-quoting.
• Added system.unsafeNew to support hacky variable length objects.
• system.fields and system.fieldPairs support object too; they used to only support tuples.
• Added system.CurrentSourcePath returning the full file-system path of the current source file.
• The macros module now contains lots of useful helpers for building up abstract syntax trees.
• Changes affecting backwards compatibility:
• shared is a keyword now.
• Deprecated sockets.recvLine and asyncio.recvLine, added readLine instead.
• The way indentation is handled in the parser changed significantly. However, this affects very little (if any) real world code.
• The expression/statement unification has been implemented. Again this only affects edge cases and no known real world code.
• Changed the async interface of the scgi module.
• WideStrings are now garbage collected like other string types.
• Compiler Additions:
• The doc2 command does not generate output for the whole project anymore. Use the new --project switch to enable this behaviour.
• The compiler can now warn about shadowed local variables. However, this needs to be turned on explicitly via --warning[ShadowIdent]:on.
• The compiler now supports almost every pragma in a push pragma.
• Generic converters have been implemented.
• Added a highly experimental noforward pragma enabling a special compilation mode that largely eliminates the need for forward declarations.
• Language Additions:
• case expressions are now supported.
• Table constructors now mimic more closely the syntax of the case statement.
• Nimrod can now infer the return type of a proc from its body.
• Added a mixin declaration to affect symbol binding rules in generics.
• Exception tracking has been added and the doc2 command annotates possible exceptions for you.
• User defined effects ("tags") tracking has been added and the doc2 command annotates possible tags for you.
• Types can be annotated with the new syntax not nil to explicitly state that nil is not allowed. However currently the compiler performs no advanced static checking for this; for now it's merely for documentation purposes.
• An export statement has been added to the language: It can be used for symbol forwarding so client modules don't have to import a module's dependencies explicitly.
• Overloading based on ASTs has been implemented.
• Generics are now supported for multi methods.
• Objects can be initialized via an object constructor expression.
• There is a new syntactic construct (;) unifying expressions and statements.
• You can now use from module import nil if you want to import the module but want to enforce fully qualified access to every symbol in module.

What is new in version 0.8.14:

• Fixed a serious memory corruption concerning message passing.
• Fixed a serious bug concerning different instantiations of a generic proc.
• Fixed a newly introduced bug where a wrong EIO exception was raised for the end of file for text files that do not end with a newline.
• Bugfix c2nim, c2pas: the --out option has never worked properly.
• Bugfix: forwarding of generic procs never worked.
• Some more bugfixes for macros and compile-time evaluation.
• The GC now takes into account interior pointers on the stack which may be introduced by aggressive C optimizers.
• Nimrod's native allocator/GC now works on PowerPC.
• Lots of other bugfixes: Too many to list them all.

What is new in version 0.8.6:

• 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 manual.html#templates 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 manual.html#pre-defined-floating-point-types 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"). 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.

What is new in version 0.8.2:

• 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 compability:
• 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.

What is new in version 0.8.0:

• 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 be 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 compability:
• 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

What is new in version 0.7.6:

• 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

What is new in version 0.7.4:

• installation on Windows should work now if the directory contains spaces
• the documentation generator now only renders documentation comments
• ```` is allowed for operators like the manual says
• in rare cases, the index check has been optimized away, even though it would have been necessary
• several bug fixes for tuple types
• 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
• 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
• added a tutorial

What is new in version 0.7.2:

• 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.

What is new in version 0.7.0:

• 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

Requirements:

• Python