DLLs should work again; fixes #169

12 files changed, 29 insertions, 410 deletions

diff --git a/compiler/ccgexprs.nim b/compiler/ccgexprs.nim
index 37908f09c..ee2b5159a 100755
--- a/compiler/ccgexprs.nim
+++ b/compiler/ccgexprs.nim
@@ -1311,6 +1311,8 @@ proc genRangeChck(p: BProc, n: PNode, d: var TLoc, magic: string) =
         [getTypeDesc(p.module, dest), rdCharLoc(a)]))
   else:
     InitLocExpr(p, n.sons[0], a)
+    if leValue(n.sons[2], n.sons[1]):
+      InternalError(n.info, "range check will always fail; empty range")
     putIntoDest(p, d, dest, ropecg(p.module, "(($1)#$5($2, $3, $4))", [
         getTypeDesc(p.module, dest), rdCharLoc(a),
         genLiteral(p, n.sons[1], dest), genLiteral(p, n.sons[2], dest),
diff --git a/doc/intern.txt b/doc/intern.txt
index 748b648fb..c84797251 100755
--- a/doc/intern.txt
+++ b/doc/intern.txt
@@ -518,5 +518,3 @@ backend somehow. We deal with this by modifying ``s.ast[paramPos]`` to contain
 the formal hidden parameter, but not ``s.typ``!
 
 
-
-
diff --git a/lib/system.nim b/lib/system.nim
index 8f19f93f1..84a3034f0 100755
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -85,6 +85,9 @@ proc defined*(x: expr): bool {.magic: "Defined", noSideEffect.}
   ##     # provide our own toUpper proc here, because strutils is
   ##     # missing it.
 
+when defined(useNimRtl):
+  {.deadCodeElim: on.}
+
 proc definedInScope*(x: expr): bool {.
   magic: "DefinedInScope", noSideEffect.}
   ## Special compile-time procedure that checks whether `x` is
diff --git a/lib/system/alloc.nim b/lib/system/alloc.nim
index ba172373d..53c20316c 100755
--- a/lib/system/alloc.nim
+++ b/lib/system/alloc.nim
@@ -179,9 +179,10 @@ var
 
 {.push stack_trace: off.}
 proc initAllocator() =
-  bottom = addr(bottomData)
-  bottom.link[0] = bottom
-  bottom.link[1] = bottom
+  when not defined(useNimRtl):
+    bottom = addr(bottomData)
+    bottom.link[0] = bottom
+    bottom.link[1] = bottom
 {.pop.}
 
 proc incCurrMem(a: var TMemRegion, bytes: int) {.inline.} = 
diff --git a/lib/system/gc.nim b/lib/system/gc.nim
index 18a7a81ed..470064c5f 100755
--- a/lib/system/gc.nim
+++ b/lib/system/gc.nim
@@ -536,7 +536,7 @@ proc doOperation(p: pointer, op: TWalkOp) =
     sysAssert(c.refcount >=% rcIncrement, "doOperation 3")
     c.refcount = c.refcount -% rcIncrement
 
-proc nimGCvisit(d: pointer, op: int) {.compilerProc.} =
+proc nimGCvisit(d: pointer, op: int) {.compilerRtl.} =
   doOperation(d, TWalkOp(op))
 
 # we now use a much simpler and non-recursive algorithm for cycle removal
diff --git a/lib/system/sysio.nim b/lib/system/sysio.nim
index d5234e62f..012e5d95a 100755
--- a/lib/system/sysio.nim
+++ b/lib/system/sysio.nim
@@ -228,6 +228,7 @@ proc ReadBytes(f: TFile, a: var openarray[int8], start, len: int): int =
 proc ReadChars(f: TFile, a: var openarray[char], start, len: int): int =
   result = readBuffer(f, addr(a[start]), len)
 
+{.push stackTrace:off.}
 proc writeBytes(f: TFile, a: openarray[int8], start, len: int): int =
   var x = cast[ptr array[0..1000_000_000, int8]](a)
   result = writeBuffer(f, addr(x[start]), len)
@@ -240,6 +241,7 @@ proc writeBuffer(f: TFile, buffer: pointer, len: int): int =
 proc write(f: TFile, s: string) =
   if writeBuffer(f, cstring(s), s.len) != s.len:
     raiseEIO("cannot write string to file")
+{.pop.}
 
 proc setFilePos(f: TFile, pos: int64) =
   if fseek(f, clong(pos), 0) != 0:
diff --git a/lib/system/sysstr.nim b/lib/system/sysstr.nim
index c61cf2bea..5d2113439 100755
--- a/lib/system/sysstr.nim
+++ b/lib/system/sysstr.nim
@@ -69,10 +69,10 @@ proc toNimStr(str: CString, len: int): NimString {.compilerProc.} =
   c_memcpy(result.data, str, (len+1) * sizeof(Char))
   #result.data[len] = '\0' # readline relies on this!
 
-proc cstrToNimstr(str: CString): NimString {.compilerProc.} =
+proc cstrToNimstr(str: CString): NimString {.compilerRtl.} =
   result = toNimstr(str, c_strlen(str))
 
-proc copyString(src: NimString): NimString {.compilerProc.} =
+proc copyString(src: NimString): NimString {.compilerRtl.} =
   if (src.reserved and seqShallowFlag) != 0:
     result = src
   elif src != nil:
@@ -80,7 +80,7 @@ proc copyString(src: NimString): NimString {.compilerProc.} =
     result.len = src.len
     c_memcpy(result.data, src.data, (src.len + 1) * sizeof(Char))
 
-proc copyStringRC1(src: NimString): NimString {.compilerProc.} =
+proc copyStringRC1(src: NimString): NimString {.compilerRtl.} =
   if src != nil:
     var s = src.space
     if s < 8: s = 7
@@ -148,7 +148,7 @@ proc addChar(s: NimString, c: char): NimString =
 #   <generated C code>
 #   s = rawNewString(0);
 
-proc resizeString(dest: NimString, addlen: int): NimString {.compilerproc.} =
+proc resizeString(dest: NimString, addlen: int): NimString {.compilerRtl.} =
   if dest.len + addLen <= dest.space:
     result = dest
   else: # slow path:
@@ -168,7 +168,7 @@ proc appendChar(dest: NimString, c: char) {.compilerproc, inline.} =
   dest.data[dest.len+1] = '\0'
   inc(dest.len)
 
-proc setLengthStr(s: NimString, newLen: int): NimString {.compilerProc.} =
+proc setLengthStr(s: NimString, newLen: int): NimString {.compilerRtl.} =
   var n = max(newLen, 0)
   if n <= s.space:
     result = s
@@ -254,10 +254,10 @@ proc nimInt64ToStr(x: int64): string {.compilerRtl.} =
   for j in 0..i div 2 - 1:
     swap(result[j], result[i-j-1])
 
-proc nimBoolToStr(x: bool): string {.compilerproc.} =
+proc nimBoolToStr(x: bool): string {.compilerRtl.} =
   return if x: "true" else: "false"
 
-proc nimCharToStr(x: char): string {.compilerproc.} =
+proc nimCharToStr(x: char): string {.compilerRtl.} =
   result = newString(1)
   result[0] = x
 
diff --git a/tests/dll/client.nimrod.cfg b/tests/dll/client.nimrod.cfg
new file mode 100644
index 000000000..0e044a829
--- /dev/null
+++ b/tests/dll/client.nimrod.cfg
@@ -0,0 +1 @@
+--define:useNimRtl
diff --git a/tests/dll/server.nim b/tests/dll/server.nim
index a826ee2a7..ae2acc893 100644
--- a/tests/dll/server.nim
+++ b/tests/dll/server.nim
@@ -25,3 +25,10 @@ proc newOp(k: TNodeKind, a, b: PNode): PNode {.exportc: "newOp", dynlib.} =
   
 proc buildTree(x: int): PNode {.exportc: "buildTree", dynlib.} = 
   result = newOp(nkMul, newOp(nkAdd, newLit(x), newLit(x)), newLit(x))
+
+when false:
+  # Test the GC:
+  for i in 0..100_000:
+    discard buildTree(2)
+    
+  echo "Done"
diff --git a/tests/dll/server.nimrod.cfg b/tests/dll/server.nimrod.cfg
new file mode 100644
index 000000000..02393ba8b
--- /dev/null
+++ b/tests/dll/server.nimrod.cfg
@@ -0,0 +1,2 @@
+--define:useNimRtl
+--app:lib
diff --git a/todo.txt b/todo.txt
index 4cd1eed4f..acda1c2ba 100755
--- a/todo.txt
+++ b/todo.txt
@@ -1,7 +1,6 @@
 version 0.9.0
 =============
 
-- fix DLLs #169
 - implicit deref for parameter matching
 - deprecate ``var x, y = 0`` as it's confusing for tuple consistency
 
diff --git a/web/news.txt b/web/news.txt
index b99d97f91..63dd7587b 100755
--- a/web/news.txt
+++ b/web/news.txt
@@ -632,425 +632,29 @@ Changes affecting backwards compatibility
 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 <pegs.html>`_ 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 ``<br />`` 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 <macros.html>`_ 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 <http://www.ethexor.com/heimdall>`_ 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)