start of tests refactoring; sqlite3 new wrapper fixes

author: rumpf_a@web.de <> 2010-02-21 19:42:36 +0100
committer: rumpf_a@web.de <> 2010-02-21 19:42:36 +0100
commit: d913fdb2800d83680e413cd8a5f07b7f85deac6e (patch)
tree: 09a284861adf96520059f211ba8bae1a76294a9c /tests/accept/compile
parent: 6bc16904edd3738ab97573b9eeb3a6a7cce9574c (diff)
download: Nim-d913fdb2800d83680e413cd8a5f07b7f85deac6e.tar.gz
68 files changed, 1863 insertions, 0 deletions
diff --git a/tests/accept/compile/tarrindx.nim b/tests/accept/compile/tarrindx.nim
new file mode 100644
index 000000000..13919cc2c
--- /dev/null
+++ b/tests/accept/compile/tarrindx.nim
@@ -0,0 +1,13 @@
+# test another strange bug ... (I hate this compiler; it is much too buggy!)
+
+proc putEnv(key, val: string) =
+  # XXX: we have to leak memory here, as we cannot
+  # free it before the program ends (says Borland's
+  # documentation)
+  var
+    env: ptr array[0..500000, char]
+  env = cast[ptr array[0..500000, char]](alloc(len(key) + len(val) + 2))
+  for i in 0..len(key)-1: env[i] = key[i]
+  env[len(key)] = '='
+  for i in 0..len(val)-1:
+    env[len(key)+1+i] = val[i]
diff --git a/tests/accept/compile/tassign.nim b/tests/accept/compile/tassign.nim
new file mode 100644
index 000000000..f51c20783
--- /dev/null
+++ b/tests/accept/compile/tassign.nim
@@ -0,0 +1,31 @@
+# Test the assignment operator for complex types which need RTTI
+
+type
+  TRec = object
+    x, y: int
+    s: string
+    seq: seq[string]
+    arr: seq[seq[array[0..3, string]]]
+  TRecSeq = seq[TRec]
+
+proc test() =
+  var
+    a, b: TRec
+  a.x = 1
+  a.y = 2
+  a.s = "Hallo!"
+  a.seq = @["abc", "def", "ghi", "jkl"]
+  a.arr = @[]
+  setLen(a.arr, 4)
+  a.arr[0] = @[]
+  a.arr[1] = @[]
+
+  b = a # perform a deep copy here!
+  b.seq = @["xyz", "huch", "was", "soll"]
+  writeln(stdout, len(a.seq))
+  writeln(stdout, a.seq[3])
+  writeln(stdout, len(b.seq))
+  writeln(stdout, b.seq[3])
+  writeln(stdout, b.y)
+
+test()
diff --git a/tests/accept/compile/tcmdline.nim b/tests/accept/compile/tcmdline.nim
new file mode 100644
index 000000000..f43aecafa
--- /dev/null
+++ b/tests/accept/compile/tcmdline.nim
@@ -0,0 +1,14 @@
+# Test the command line
+
+import
+  os, strutils
+
+var
+  i: int
+  params = paramCount()
+i = 0
+writeln(stdout, "This exe: " & getApplicationFilename())
+writeln(stdout, "Number of parameters: " & $params)
+while i <= params:
+  writeln(stdout, paramStr(i))
+  i = i + 1
diff --git a/tests/accept/compile/tcolors.nim b/tests/accept/compile/tcolors.nim
new file mode 100644
index 000000000..9d1034405
--- /dev/null
+++ b/tests/accept/compile/tcolors.nim
@@ -0,0 +1,39 @@
+import strutils
+
+type
+  TColor = distinct int32
+
+proc rgb(r, g, b: range[0..255]): TColor = 
+  result = TColor(r or g shl 8 or b shl 16)
+
+proc `$`(c: TColor): string =
+  result = "#" & toHex(int32(c), 6)
+
+echo rgb(34, 55, 255)
+
+when false:
+  type
+    TColor = distinct int32
+    TColorComponent = distinct int8
+  
+  proc red(a: TColor): TColorComponent = 
+    result = TColorComponent(int32(a) and 0xff'i32)
+  
+  proc green(a: TColor): TColorComponent = 
+    result = TColorComponent(int32(a) shr 8'i32 and 0xff'i32)
+  
+  proc blue(a: TColor): TColorComponent = 
+    result = TColorComponent(int32(a) shr 16'i32 and 0xff'i32)
+  
+  proc rgb(r, g, b: range[0..255]): TColor = 
+    result = TColor(r or g shl 8 or b shl 8)
+  
+  proc `+!` (a, b: TColorComponent): TColorComponent =  
+    ## saturated arithmetic:
+    result = TColorComponent(min(ze(int8(a)) + ze(int8(b)), 255))
+  
+  proc `+` (a, b: TColor): TColor = 
+    ## saturated arithmetic for colors makes sense, I think:
+    return rgb(red(a) +! red(b), green(a) +! green(b), blue(a) +! blue(b))
+  
+  rgb(34, 55, 255)
diff --git a/tests/accept/compile/tconsteval.nim b/tests/accept/compile/tconsteval.nim
new file mode 100644
index 000000000..ce90d7c27
--- /dev/null
+++ b/tests/accept/compile/tconsteval.nim
@@ -0,0 +1,28 @@
+import strutils
+
+const
+  HelpText = """
++-----------------------------------------------------------------+
+|         Maintenance program for Nimrod                          |
+|             Version $1|
+|             (c) 2009 Andreas Rumpf                              |
++-----------------------------------------------------------------+
+Compiled at: $2, $3
+
+Usage:
+  koch [options] command [options for command]
+Options:
+  --force, -f, -B, -b      forces rebuild
+  --help, -h               shows this help and quits
+Possible Commands:
+  boot [options]           bootstraps with given command line options
+  clean                    cleans Nimrod project; removes generated files
+  web                      generates the website
+  csource [options]        builds the C sources for installation
+  zip                      builds the installation ZIP package
+  inno                     builds the Inno Setup installer
+""" % [NimrodVersion & repeatChar(44-len(NimrodVersion)), 
+       CompileDate, CompileTime]
+
+echo helpText
+
diff --git a/tests/accept/compile/tconvert.nim b/tests/accept/compile/tconvert.nim
new file mode 100644
index 000000000..b23afde74
--- /dev/null
+++ b/tests/accept/compile/tconvert.nim
@@ -0,0 +1,38 @@
+import
+  Cairo
+
+converter FloatConversion64(x: int): float64 = return toFloat(x)
+converter FloatConversion32(x: int): float32 = return toFloat(x)
+converter FloatConversionPlain(x: int): float = return toFloat(x)
+
+const width = 500
+const height = 500
+const outFile = "CairoTest.png"
+
+var surface = Cairo_ImageSurfaceCreate(CAIRO_FORMAT_RGB24, width, height)
+var ç = Cairo_Create(surface)
+
+ç.Cairo_SetSourceRGB(1, 1, 1)
+ç.Cairo_Paint()
+
+ç.Cairo_SetLineWidth(10)
+ç.Cairo_SetLineCap(CAIRO_LINE_CAP_ROUND)
+
+const count = 12
+var winc = width / count
+var hinc = width / count
+for i in 1 .. count-1:
+  var amount = i / count
+  ç.Cairo_SetSourceRGB(0, 1 - amount, amount)
+  ç.Cairo_MoveTo(i * winc, hinc)
+  ç.Cairo_LineTo(width - i * winc, height - hinc)
+  ç.Cairo_Stroke()
+
+  ç.Cairo_SetSourceRGB(1 - amount, 0, amount)
+  ç.Cairo_MoveTo(winc, i * hinc)
+  ç.Cairo_LineTo(width - winc, height - i * hinc)
+  ç.Cairo_Stroke()
+
+echo(surface.Cairo_SurfaceWriteToPNG(outFile))
+surface.Cairo_SurfaceDestroy()
+
diff --git a/tests/accept/compile/tdeprecated.nim b/tests/accept/compile/tdeprecated.nim
new file mode 100644
index 000000000..e287da3f9
--- /dev/null
+++ b/tests/accept/compile/tdeprecated.nim
@@ -0,0 +1,6 @@
+var
+  a {.deprecated.}: array[0..11, int]
+  
+a[8] = 1
+
+
diff --git a/tests/accept/compile/tdialogs.nim b/tests/accept/compile/tdialogs.nim
new file mode 100644
index 000000000..90f241cdf
--- /dev/null
+++ b/tests/accept/compile/tdialogs.nim
@@ -0,0 +1,17 @@
+# Test the dialogs module
+
+import dialogs, gtk2
+
+gtk_nimrod_init()
+
+var x = ChooseFilesToOpen(nil)
+for a in items(x):
+  writeln(stdout, a)
+
+info(nil, "start with an info box")
+warning(nil, "now a warning ...")
+error(nil, "... and an error!")
+
+writeln(stdout, ChooseFileToOpen(nil))
+writeln(stdout, ChooseFileToSave(nil))
+writeln(stdout, ChooseDir(nil))
diff --git a/tests/accept/compile/tdllvar.nim b/tests/accept/compile/tdllvar.nim
new file mode 100644
index 000000000..ab767770c
--- /dev/null
+++ b/tests/accept/compile/tdllvar.nim
@@ -0,0 +1,16 @@
+import os
+
+proc getDllName: string = 
+  result = "mylib.dll"
+  if ExistsFile(result): return
+  result = "mylib2.dll"
+  if ExistsFile(result): return
+  quit("could not load dynamic library")
+
+proc myImport(s: cstring) {.cdecl, importc, dynlib: getDllName().}
+proc myImport2(s: int) {.cdecl, importc, dynlib: getDllName().}
+
+myImport("test2")
+myImport2(12)
+
+
diff --git a/tests/accept/compile/tdumpast.nim b/tests/accept/compile/tdumpast.nim
new file mode 100644
index 000000000..fb31af0ec
--- /dev/null
+++ b/tests/accept/compile/tdumpast.nim
@@ -0,0 +1,35 @@
+# Dump the contents of a PNimrodNode
+
+import macros
+
+proc dumpit(n: PNimrodNode): string {.compileTime.} = 
+  if n == nil: return "nil"
+  result = $n.kind
+  add(result, "(")
+  case n.kind
+  of nnkEmpty: nil # same as nil node in this representation 
+  of nnkNilLit:                  add(result, "nil")
+  of nnkCharLit..nnkInt64Lit:    add(result, $n.intVal)
+  of nnkFloatLit..nnkFloat64Lit: add(result, $n.floatVal)
+  of nnkStrLit..nnkTripleStrLit: add(result, $n.strVal)
+  of nnkIdent:                   add(result, $n.ident)
+  of nnkSym, nnkNone:            assert false
+  else:
+    add(result, dumpit(n[0]))
+    for j in 1..n.len-1:
+      add(result, ", ")
+      add(result, dumpit(n[j]))
+  add(result, ")")
+  
+macro dumpAST(n: stmt): stmt = 
+  # dump AST as a side-effect and return the inner node
+  echo dumpit(n)
+  result = n[1]
+  
+dumpAST:
+  proc add(x, y: int): int =
+    return x + y
+  
+  proc sub(x, y: int): int = return x - y
+
+
diff --git a/tests/accept/compile/techo.nim b/tests/accept/compile/techo.nim
new file mode 100644
index 000000000..beb21fa16
--- /dev/null
+++ b/tests/accept/compile/techo.nim
@@ -0,0 +1,3 @@
+# Simplest Nimrod program
+
+echo "Hallo, World!"
diff --git a/tests/accept/compile/tendian.nim b/tests/accept/compile/tendian.nim
new file mode 100644
index 000000000..256e2653c
--- /dev/null
+++ b/tests/accept/compile/tendian.nim
@@ -0,0 +1,3 @@
+# test the new endian magic
+
+writeln(stdout, repr(system.cpuEndian))
diff --git a/tests/accept/compile/tenum.nim b/tests/accept/compile/tenum.nim
new file mode 100644
index 000000000..6e53b9c08
--- /dev/null
+++ b/tests/accept/compile/tenum.nim
@@ -0,0 +1,8 @@
+# Test enums
+
+type
+  E = enum a, b, c, x, y, z
+
+var
+  en: E
+en = a
diff --git a/tests/accept/compile/tforwty.nim b/tests/accept/compile/tforwty.nim
new file mode 100644
index 000000000..0f1d3697f
--- /dev/null
+++ b/tests/accept/compile/tforwty.nim
@@ -0,0 +1,9 @@
+# Test 13: forward types
+
+type
+  PSym = ref TSym
+
+  TSym = object
+    next: PSym
+
+var s: PSym
diff --git a/tests/accept/compile/tforwty2.nim b/tests/accept/compile/tforwty2.nim
new file mode 100644
index 000000000..5d15e112a
--- /dev/null
+++ b/tests/accept/compile/tforwty2.nim
@@ -0,0 +1,22 @@
+# Test for a hard to fix internal error
+# occured in the SDL library
+
+{.push dynlib: "SDL.dll", callconv: cdecl.}
+
+type
+  PSDL_semaphore = ptr TSDL_semaphore
+  TSDL_semaphore {.final.} = object
+    sem: Pointer             #PSem_t;
+    when not defined(USE_NAMED_SEMAPHORES):
+      sem_data: int
+    when defined(BROKEN_SEMGETVALUE):
+      # This is a little hack for MacOS X -
+      # It's not thread-safe, but it's better than nothing
+      sem_value: cint
+
+type
+  PSDL_Sem = ptr TSDL_Sem
+  TSDL_Sem = TSDL_Semaphore
+
+proc SDL_CreateSemaphore(initial_value: Int32): PSDL_Sem {.
+  importc: "SDL_CreateSemaphore".}
diff --git a/tests/accept/compile/tgtk.nim b/tests/accept/compile/tgtk.nim
new file mode 100644
index 000000000..cd9254e4f
--- /dev/null
+++ b/tests/accept/compile/tgtk.nim
@@ -0,0 +1,61 @@
+
+import
+  gtk2, glib2, atk, gdk2, gdk2pixbuf, libglade2, pango,
+  pangoutils
+
+proc hello(widget: PGtkWidget, data: pointer) {.cdecl.} =
+  write(stdout, "Hello World\n")
+
+proc delete_event(widget: PGtkWidget, event: PGdkEvent,
+                  data: pointer): bool {.cdecl.} =
+  # If you return FALSE in the "delete_event" signal handler,
+  # GTK will emit the "destroy" signal. Returning TRUE means
+  # you don't want the window to be destroyed.
+  # This is useful for popping up 'are you sure you want to quit?'
+  # type dialogs.
+  write(stdout, "delete event occurred\n")
+  # Change TRUE to FALSE and the main window will be destroyed with
+  # a "delete_event".
+  return false
+
+# Another callback
+proc destroy(widget: PGtkWidget, data: pointer) {.cdecl.} =
+  gtk_main_quit()
+
+proc main() =
+  # GtkWidget is the storage type for widgets
+  var
+    window: PGtkWindow 
+    button: PGtkButton
+
+  gtk_nimrod_init()
+  window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL))
+  discard g_signal_connect(window, "delete_event", 
+                           Gcallback(delete_event), nil)
+  discard g_signal_connect(window, "destroy", Gcallback(destroy), nil)
+  # Sets the border width of the window.
+  gtk_container_set_border_width(window, 10)
+
+  # Creates a new button with the label "Hello World".
+  button = GTK_BUTTON(gtk_button_new_with_label("Hello World"))
+
+  discard g_signal_connect(button, "clicked", Gcallback(hello), nil)
+
+  # This will cause the window to be destroyed by calling
+  # gtk_widget_destroy(window) when "clicked".  Again, the destroy
+  # signal could come from here, or the window manager.
+  discard g_signal_connect_swapped(button, "clicked", 
+    Gcallback(gtk_widget_destroy), window)
+
+  # This packs the button into the window (a gtk container).
+  gtk_container_add(window, button)
+
+  # The final step is to display this newly created widget.
+  gtk_widget_show(button)
+
+  # and the window
+  gtk_widget_show(window)
+
+  gtk_main()
+
+main()
diff --git a/tests/accept/compile/thallo.nim b/tests/accept/compile/thallo.nim
new file mode 100644
index 000000000..f1cae5897
--- /dev/null
+++ b/tests/accept/compile/thallo.nim
@@ -0,0 +1,83 @@
+# Hallo
+
+import
+  os, strutils, macros
+
+type
+  TMyEnum = enum
+    meA, meB, meC, meD
+
+when isMainModule:
+  {.hint: "this is the main file".}
+
+proc fac[T](x: T): T =
+  # test recursive generic procs
+  if x <= 1: return 1
+  else: return x.`*`(fac(x-1))
+
+macro macrotest(n: expr): stmt =
+  expectKind(n, nnkCall)
+  expectMinLen(n, 2)
+  result = newNimNode(nnkStmtList, n)
+  for i in 2..n.len-1:
+    result.add(newCall("write", n[1], n[i]))
+  result.add(newCall("writeln", n[1], newStrLitNode("")))
+
+macro debug(n: expr): stmt =
+  result = newNimNode(nnkStmtList, n)
+  for i in 1..n.len-1:
+    result.add(newCall("write", newIdentNode("stdout"), toStrLit(n[i])))
+    result.add(newCall("write", newIdentNode("stdout"), newStrLitNode(": ")))
+    result.add(newCall("writeln", newIdentNode("stdout"), n[i]))
+
+macrotest(stdout, "finally", 4, 5, "variable", "argument lists")
+macrotest(stdout)
+
+#GC_disable()
+
+echo("This was compiled by Nimrod version " & system.nimrodVersion)
+writeln(stdout, "Hallo", " World", "!")
+
+echo(["a", "b", "c", "d"].len)
+for x in items(["What's", "your", "name", "?", ]):
+  echo(x)
+var `name` = readLine(stdin)
+{.breakpoint.}
+echo("Hi " & thallo.name & "!\n")
+debug(name)
+
+var testseq: seq[string] = @[
+  "a", "b", "c", "d", "e"
+]
+echo(repr(testseq))
+
+var dummy = "hallo"
+echo(copy(dummy, 2, 3))
+
+echo($meC)
+
+# test tuples:
+for x, y in items([(1, 2), (3, 4), (6, 1), (5, 2)]):
+  echo x
+  echo y
+  
+proc simpleConst(): int = return 34
+  
+# test constant evaluation: 
+const  
+  constEval3 = simpleConst()
+  constEval = "abc".contains('b')
+  constEval2 = fac(7)
+
+echo(constEval3)
+echo(constEval)
+echo(constEval2)
+echo(1.`+`(2))
+
+for i in 2..6:
+  for j in countdown(i+4, 2):
+    echo(fac(i * j))
+
+when isMainModule:
+  {.hint: "this is the main file".}
+
diff --git a/tests/accept/compile/tident.nim b/tests/accept/compile/tident.nim
new file mode 100644
index 000000000..1ed9894c6
--- /dev/null
+++ b/tests/accept/compile/tident.nim
@@ -0,0 +1,22 @@
+
+type
+  TIdObj* = object of TObject
+    id*: int                  # unique id; use this for comparisons and not the pointers
+  
+  PIdObj* = ref TIdObj
+  PIdent* = ref TIdent
+  TIdent*{.acyclic.} = object
+    s*: string
+
+proc myNewString(L: int): string {.inline.} =
+  result = newString(L)
+  if result.len == L: echo("Length correct")
+  else: echo("bug")
+  for i in 0..L-1:
+    if result[i] == '\0':
+      echo("Correct")
+    else: 
+      echo("Wrong")
+  
+var s = myNewString(8)
+
diff --git a/tests/accept/compile/tindent1.nim b/tests/accept/compile/tindent1.nim
new file mode 100644
index 000000000..0527b6e57
--- /dev/null
+++ b/tests/accept/compile/tindent1.nim
@@ -0,0 +1,24 @@
+
+const romanNumbers1 =
+    [
+    ("M", 1000), ("D", 500), ("C", 100),
+    ("L", 50), ("X", 10), ("V", 5), ("I", 1) ]
+
+const romanNumbers2 =
+    [
+    ("M", 1000), ("D", 500), ("C", 100),
+    ("L", 50), ("X", 10), ("V", 5), ("I", 1)
+    ]
+
+const romanNumbers3 =
+  [
+    ("M", 1000), ("D", 500), ("C", 100),
+    ("L", 50), ("X", 10), ("V", 5), ("I", 1)
+  ]
+
+const romanNumbers4 = [
+    ("M", 1000), ("D", 500), ("C", 100),
+    ("L", 50), ("X", 10), ("V", 5), ("I", 1)
+    ]
+
+
diff --git a/tests/accept/compile/tio.nim b/tests/accept/compile/tio.nim
new file mode 100644
index 000000000..014c32d9f
--- /dev/null
+++ b/tests/accept/compile/tio.nim
@@ -0,0 +1,7 @@
+# test the file-IO
+
+proc main() =
+  for line in lines("thallo.nim"):
+    writeln(stdout, line)
+
+main()
diff --git a/tests/accept/compile/titer.nim b/tests/accept/compile/titer.nim
new file mode 100644
index 000000000..19a11dc4e
--- /dev/null
+++ b/tests/accept/compile/titer.nim
@@ -0,0 +1,44 @@
+# Test the new iterators
+
+iterator xrange(fromm, to: int, step = 1): int =
+  var a = fromm
+  while a <= to:
+    yield a
+    inc(a, step)
+
+iterator interval[T](a, b: T): T =
+  var x = a
+  while x <= b:
+    yield x
+    inc(x)
+
+#
+#iterator lines(filename: string): (line: string) =
+#  var
+#    f: tTextfile
+#    shouldClose = open(f, filename)
+#  if shouldClose:
+#    setSpace(line, 256)
+#    while readTextLine(f, line):
+#      yield line
+#  finally:
+#    if shouldClose: close(f)
+#
+
+for i in xrange(0, 5):
+  for k in xrange(1, 7):
+    write(stdout, "test")
+
+for j in interval(45, 45):
+  write(stdout, "test2!")
+  write(stdout, "test3?")
+
+for x in items(["hi", "what's", "your", "name"]):
+  echo(x)
+  
+const
+  stringArray = ["hi", "what's", "your", "name"]
+
+for i in 0..len(stringArray)-1:
+  echo(stringArray[i])
+
diff --git a/tests/accept/compile/tlastmod.nim b/tests/accept/compile/tlastmod.nim
new file mode 100644
index 000000000..75b047fc8
--- /dev/null
+++ b/tests/accept/compile/tlastmod.nim
@@ -0,0 +1,18 @@
+# test the new LastModificationTime() proc
+
+import
+  os, times, strutils
+
+proc main() =
+  var
+    a, b: TTime
+  a = getLastModificationTime(ParamStr(1))
+  b = getLastModificationTime(ParamStr(2))
+  writeln(stdout, $a)
+  writeln(stdout, $b)
+  if a < b:
+    Write(stdout, "$2 is newer than $1\n" % [ParamStr(1), ParamStr(2)])
+  else:
+    Write(stdout, "$1 is newer than $2\n" % [ParamStr(1), ParamStr(2)])
+
+main()
diff --git a/tests/accept/compile/tlexer.nim b/tests/accept/compile/tlexer.nim
new file mode 100644
index 000000000..fe784280c
--- /dev/null
+++ b/tests/accept/compile/tlexer.nim
@@ -0,0 +1,57 @@
+# We start with a comment
+# This is the same comment
+
+# This is a new one!
+
+import
+  lexbase, os, strutils
+
+type
+  TMyRec {.final.} = object
+    x, y: int     # coordinates
+    c: char       # a character
+    a: int32      # an integer
+
+  PMyRec = ref TMyRec # a reference to `TMyRec`
+
+proc splitText(txt: string): seq[string] # splits a text into several lines
+                                         # the comment continues here
+                                         # this is not easy to parse!
+
+proc anotherSplit(txt: string): list[string] =
+  # the comment should belong to `anotherSplit`!
+  # another problem: comments are statements!
+
+const
+  x = 0B0_10001110100_0000101001000111101011101111111011000101001101001001'f64 # x ~~ 1.72826e35
+  myNan = 0B01111111100000101100000000001000'f32 # NAN
+  y = """
+    a rather long text.
+    Over many
+    lines.
+  """
+  s = "\xff"
+  a = {0..234}
+  b = {0..high(int)}
+  v = 0'i32
+  z = 6767566'f32
+
+# small test program for lexbase
+
+proc main*(infile: string, a, b: int, someverylongnamewithtype = 0,
+           anotherlongthingie = 3) =
+  var
+    myInt: int = 0
+    a b = 9
+    s: sequence[string]
+  # this should be an error!
+  if initBaseLexer(L, infile, 30): nil
+  else:
+    writeln(stdout, "could not open: " & infile)
+  writeln(stdout, "Success!")
+  call(3, # we use 3
+       12, # we use 12
+       43 # we use 43
+       )
+
+main(ParamStr(1))
diff --git a/tests/accept/compile/tlibs.nim b/tests/accept/compile/tlibs.nim
new file mode 100644
index 000000000..e3b6bd4c3
--- /dev/null
+++ b/tests/accept/compile/tlibs.nim
@@ -0,0 +1,21 @@
+# Test wether the bindings at least compile...
+
+import
+  unicode, cgi, terminal, libcurl, web, 
+  parsexml, parseopt, parsecfg,
+  osproc,
+  sdl, smpeg, sdl_gfx, sdl_net, sdl_mixer, sdl_ttf,
+  sdl_image, sdl_mixer_nosmpeg,
+  cursorfont, xatom, xf86vmode, xkb, xrandr, xshm, xvlib, keysym, xcms, xi,
+  xkblib, xrender, xutil, x, xf86dga, xinerama, xlib, xresource, xv,
+  gtk2, glib2, pango, gdk2,
+  cairowin32, cairoxlib,
+  odbcsql,
+  gl, glut, glu, glx, glext, wingl,
+  lua, lualib, lauxlib, mysql, sqlite3, python, tcl
+  
+when defined(linux):
+  import
+    zlib, zipfiles
+
+writeln(stdout, "test compilation of binding modules")
diff --git a/tests/accept/compile/tloops.nim b/tests/accept/compile/tloops.nim
new file mode 100644
index 000000000..3d03256ad
--- /dev/null
+++ b/tests/accept/compile/tloops.nim
@@ -0,0 +1,64 @@
+# Test nested loops and some other things
+
+proc andTest() =
+  var a = 0 == 5 and 6 == 6
+
+proc incx(x: var int) = # is built-in proc
+  x = x + 1
+
+proc decx(x: var int) =
+  x = x - 1
+
+proc First(y: var int) =
+  var x: int
+  i_ncx(x)
+  if x == 10:
+    y = 0
+  else:
+    if x == 0:
+      incx(x)
+    else:
+      x=11
+
+proc TestLoops() =
+  var i, j: int
+  while i >= 0:
+    if i mod 3 == 0:
+      break
+    i = i + 1
+    while j == 13:
+      j = 13
+      break
+    break
+
+  while True:
+    break
+
+
+proc Foo(n: int): int =
+    var
+        a, old: int
+        b, c: bool
+    F_irst(a)
+    if a == 10:
+        a = 30
+    elif a == 11:
+        a = 22
+    elif a == 12:
+        a = 23
+    elif b:
+        old = 12
+    else:
+        a = 40
+
+    #
+    b = false or 2 == 0 and 3 == 9
+    a = 0 + 3 * 5 + 6 + 7 + +8 # 36
+    while b:
+        a = a + 3
+    a = a + 5
+    write(stdout, "Hallo!")
+
+
+# We should come till here :-)
+discard Foo(345)
diff --git a/tests/accept/compile/tmath.nim b/tests/accept/compile/tmath.nim
new file mode 100644
index 000000000..6a1dae54d
--- /dev/null
+++ b/tests/accept/compile/tmath.nim
@@ -0,0 +1,85 @@
+# tests for the interpreter
+
+proc loops(a: var int) =
+  nil
+  #var
+  #  b: int
+  #b = glob
+  #while b != 0:
+  #  b = b + 1
+  #a = b
+
+proc mymax(a, b: int): int =
+  #loops(result)
+  result = a
+  if b > a: result = b
+
+proc test(a, b: int) =
+  var
+    x, y: int
+  x = 0
+  y = 7
+  if x == a + b * 3 - 7 or
+      x == 8 or
+      x == y and y > -56 and y < 699:
+    y = 0
+  elif y == 78 and x == 0:
+    y = 1
+  elif y == 0 and x == 0:
+    y = 2
+  else:
+    y = 3
+
+type
+  TTokType = enum
+    tkNil, tkType, tkConst, tkVar, tkSymbol, tkIf,
+    tkWhile, tkFor, tkLoop, tkCase, tkLabel, tkGoto
+
+proc testCase(t: TTokType): int =
+  case t
+  of tkNil, tkType, tkConst: result = 0
+  of tkVar: result = 1
+  of tkSymbol: result = 2
+  of tkIf..tkFor: result = 3
+  of tkLoop: result = 56
+  else: result = -1
+  test(0, 9) # test the call
+
+proc TestLoops() =
+  var
+    i, j: int
+
+  while i >= 0:
+    if i mod 3 == 0:
+      break
+    i = i + 1
+    while j == 13:
+      j = 13
+      break
+    break
+
+  while True:
+    break
+
+
+var
+  glob: int
+  a: array [0..5, int]
+
+proc main() =
+  #glob = 0
+  #loops( glob )
+  var
+    res: int
+    s: string
+  #write(stdout, mymax(23, 45))
+  write(stdout, "Hallo! Wie hei�t du? ")
+  s = readLine(stdin)
+  # test the case statement
+  case s
+  of "Andreas": write(stdout, "Du bist mein Meister!\n")
+  of "Rumpf": write(stdout, "Du bist in der Familie meines Meisters!\n")
+  else: write(stdout, "ich kenne dich nicht!\n")
+  write(stdout, "Du heisst " & s & "\n")
+
+main()
diff --git a/tests/accept/compile/tnew.nim b/tests/accept/compile/tnew.nim
new file mode 100644
index 000000000..6527541a2
--- /dev/null
+++ b/tests/accept/compile/tnew.nim
@@ -0,0 +1,49 @@
+# Test the implementation of the new operator
+# and the code generation for gc walkers
+# (and the garbage collector):
+
+type
+  PNode = ref TNode
+  TNode = object
+    data: int
+    str: string
+    le, ri: PNode
+
+  TStressTest = ref array [0..45, array [1..45, TNode]]
+
+proc finalizer(n: PNode) =
+  write(stdout, n.data)
+  write(stdout, " is now freed\n")
+
+proc newNode(data: int, le, ri: PNode): PNode =
+  new(result, finalizer)
+  result.le = le
+  result.ri = ri
+  result.data = data
+
+# now loop and build a tree
+proc main() =
+  var
+    i = 0
+    p: TStressTest
+  while i < 1000:
+    var n: PNode
+
+    n = newNode(i, nil, newNode(i + 10000, nil, nil))
+    inc(i)
+  new(p)
+
+  write(stdout, "Simple tree node allocation worked!\n")
+  i = 0
+  while i < 1000:
+    var m = newNode(i + 20000, nil, nil)
+    var k = newNode(i + 30000, nil, nil)
+    m.le = m
+    m.ri = k
+    k.le = m
+    k.ri = k
+    inc(i)
+
+  write(stdout, "Simple cycle allocation worked!\n")
+
+main()
diff --git a/tests/accept/compile/tnewlibs.nim b/tests/accept/compile/tnewlibs.nim
new file mode 100644
index 000000000..aca2e3c30
--- /dev/null
+++ b/tests/accept/compile/tnewlibs.nim
@@ -0,0 +1,16 @@
+# Test wether the bindings at least compile...
+
+import
+  tcl,
+  sdl, smpeg, sdl_gfx, sdl_net, sdl_mixer, sdl_ttf,
+  sdl_image, sdl_mixer_nosmpeg,
+  gtk2, glib2, pango, gdk2,
+  unicode, cgi, terminal, libcurl, 
+  parsexml, parseopt, parsecfg,
+  osproc,
+  cairowin32, cairoxlib,
+  gl, glut, glu, glx, glext, wingl,
+  lua, lualib, lauxlib, mysql, sqlite3, 
+  
+
+writeln(stdout, "test compilation of binding modules")
diff --git a/tests/accept/compile/tnewsets.nim b/tests/accept/compile/tnewsets.nim
new file mode 100644
index 000000000..415fe8f7e
--- /dev/null
+++ b/tests/accept/compile/tnewsets.nim
@@ -0,0 +1,6 @@
+# new test for sets:
+
+const elem = ' '
+
+var s: set[char] = {elem}
+assert(elem in s and 'a' not_in s and 'c' not_in s )
diff --git a/tests/accept/compile/tnewuns.nim b/tests/accept/compile/tnewuns.nim
new file mode 100644
index 000000000..5181e467c
--- /dev/null
+++ b/tests/accept/compile/tnewuns.nim
@@ -0,0 +1,12 @@
+# test the new unsigned operations:
+
+import
+  strutils
+
+var
+  x, y: int
+
+x = 1
+y = high(int)
+
+writeln(stdout, $ ( x +% y ) )
diff --git a/tests/accept/compile/tobjcov.nim b/tests/accept/compile/tobjcov.nim
new file mode 100644
index 000000000..da34fcb60
--- /dev/null
+++ b/tests/accept/compile/tobjcov.nim
@@ -0,0 +1,17 @@
+# Covariance is not type safe:
+
+type
+  TA = object
+    a: int
+  TB = object of TA
+    b: array[0..5000_000, int]
+    
+proc ap(x: var TA) = x.a = -1
+proc bp(x: var TB) = x.b[high(x.b)] = -1
+    
+# in Nimrod proc (x: TB) is compatible to proc (x: TA),
+# but this is not type safe:
+var f: proc (x: var TA) = bp
+var a: TA
+f(a) # bp expects a TB, but gets a TA
+
diff --git a/tests/accept/compile/tobject2.nim b/tests/accept/compile/tobject2.nim
new file mode 100644
index 000000000..8f69a6bac
--- /dev/null
+++ b/tests/accept/compile/tobject2.nim
@@ -0,0 +1,21 @@
+# Tests the object implementation
+
+type
+  TPoint2d = object
+    x, y: int
+
+  TPoint3d = object of TPoint2d
+    z: int # added a field
+
+proc getPoint( p: var TPoint2d) =
+  {.breakpoint.}
+  writeln(stdout, p.x)
+
+var
+  p: TPoint3d
+
+TPoint2d(p).x = 34
+p.y = 98
+p.z = 343
+
+getPoint(p)
diff --git a/tests/accept/compile/tobjects.nim b/tests/accept/compile/tobjects.nim
new file mode 100644
index 000000000..8305e2838
--- /dev/null
+++ b/tests/accept/compile/tobjects.nim
@@ -0,0 +1,42 @@
+type
+  TBase = object
+    x, y: int
+
+  TSubclassKind = enum ka, kb, kc, kd, ke, kf
+  TSubclass = object of TBase
+    case c: TSubclassKind
+    of ka, kb, kc, kd:
+      a, b: int
+    of ke:
+      d, e, f: char
+    else: nil
+    n: bool
+
+var
+  global: int
+
+var
+  s: string
+  r: float = 0.0
+  i: int = 500 + 400
+
+case i
+of 500..999: write(stdout, "ha!\n")
+of 1000..3000, 12: write(stdout, "ganz schön groß\n")
+of 1, 2, 3: write(stdout, "1 2 oder 3\n")
+else: write(stdout, "sollte nicht passieren\n")
+
+case readLine(stdin)
+of "Rumpf": write(stdout, "Hallo Meister!\n")
+of "Andreas": write(stdout, "Hallo Meister!\n")
+else: write(stdout, "Nicht mein Meister!\n")
+
+global = global + 1
+write(stdout, "Hallo wie heißt du? \n")
+s = readLine(stdin)
+i = 0
+while i < len(s):
+  if s[i] == 'c': write(stdout, "'c' in deinem Namen gefunden\n")
+  i = i + 1
+
+write(stdout, "Du heißt " & s)
diff --git a/tests/accept/compile/toptions.nim b/tests/accept/compile/toptions.nim
new file mode 100644
index 000000000..95bb5cfbc
--- /dev/null
+++ b/tests/accept/compile/toptions.nim
@@ -0,0 +1,22 @@
+# Converted by Pas2mor v1.54
+# Used command line arguments:
+# -m -q -o bootstrap\options.mor options.pas
+#
+
+type
+  # please make sure we have under 32 options (improves code efficiency!)
+  TOption = enum
+    optNone, optForceFullMake, optBoehmGC, optRefcGC, optRangeCheck,
+    optBoundsCheck, optOverflowCheck, optNilCheck, optAssert, optLineDir,
+    optWarns, optHints, optDeadCodeElim, optListCmd, optCompileOnly,
+    optSafeCode,             # only allow safe code
+    optStyleCheck, optOptimizeSpeed, optOptimizeSize, optGenDynLib,
+    optGenGuiApp, optStackTrace
+
+  TOptionset = set[TOption]
+
+var
+  gOptions: TOptionset = {optRefcGC, optRangeCheck, optBoundsCheck,
+    optOverflowCheck, optAssert, optWarns, optHints, optLineDir, optStackTrace}
+  compilerArgs: int
+  gExitcode: int8
diff --git a/tests/accept/compile/tos.nim b/tests/accept/compile/tos.nim
new file mode 100644
index 000000000..9ab4295f8
--- /dev/null
+++ b/tests/accept/compile/tos.nim
@@ -0,0 +1,12 @@
+# test some things of the os module
+
+import os
+
+proc walkDirTree(root: string) = 
+  for k, f in walkDir(root):
+    case k 
+    of pcFile, pcLinkToFile: echo(f)
+    of pcDirectory: walkDirTree(f)
+    of pcLinkToDirectory: nil
+
+walkDirTree(".")
diff --git a/tests/accept/compile/toverprc.nim b/tests/accept/compile/toverprc.nim
new file mode 100644
index 000000000..f35528ace
--- /dev/null
+++ b/tests/accept/compile/toverprc.nim
@@ -0,0 +1,25 @@
+# Test overloading of procs when used as function pointers
+
+import strutils
+
+proc parseInt(x: float): int = nil
+proc parseInt(x: bool): int = nil
+proc parseInt(x: float32): int = nil
+proc parseInt(x: int8): int = nil
+proc parseInt(x: TFile): int = nil
+proc parseInt(x: char): int = nil
+proc parseInt(x: int16): int = nil
+
+type
+  TParseInt = proc (x: string): int
+
+var
+  q = TParseInt(parseInt)
+  p: TParseInt = parseInt
+
+proc takeParseInt(x: proc (y: string): int): int = 
+  result = x("123")
+  
+echo "Give a list of numbers (separated by spaces): "
+var x = stdin.readline.split.each(parseInt).max
echo x, " is the maximum!"
echo "another number: ", takeParseInt(parseInt)
+
diff --git a/tests/accept/compile/tparedef.nim b/tests/accept/compile/tparedef.nim
new file mode 100644
index 000000000..dedebf6b7
--- /dev/null
+++ b/tests/accept/compile/tparedef.nim
@@ -0,0 +1,4 @@
+# This test is now superfluous:
+
+proc a(a: int) = 
+  return
diff --git a/tests/accept/compile/tparscfg.nim b/tests/accept/compile/tparscfg.nim
new file mode 100644
index 000000000..618ecadd6
--- /dev/null
+++ b/tests/accept/compile/tparscfg.nim
@@ -0,0 +1,25 @@
+
+import
+  os, parsecfg, strutils, streams
+  
+var f = newFileStream(paramStr(1), fmRead)
+if f != nil:
+  var p: TCfgParser
+  open(p, f, paramStr(1))
+  while true:
+    var e = next(p)
+    case e.kind
+    of cfgEof: 
+      echo("EOF!")
+      break
+    of cfgSectionStart:   ## a ``[section]`` has been parsed
+      echo("new section: " & e.section)
+    of cfgKeyValuePair:
+      echo("key-value-pair: " & e.key & ": " & e.value)
+    of cfgOption:
+      echo("command: " & e.key & ": " & e.value)
+    of cfgError:
+      echo(e.msg)
+  close(p)
+else:
+  echo("cannot open: " & paramStr(1))
diff --git a/tests/accept/compile/tparsefloat.nim b/tests/accept/compile/tparsefloat.nim
new file mode 100644
index 000000000..38ed2db6d
--- /dev/null
+++ b/tests/accept/compile/tparsefloat.nim
@@ -0,0 +1,3 @@
+import strutils
+
+echo ParseFloat("5000") / ParseFloat("10")
diff --git a/tests/accept/compile/tparsopt.nim b/tests/accept/compile/tparsopt.nim
new file mode 100644
index 000000000..2b2da7e51
--- /dev/null
+++ b/tests/accept/compile/tparsopt.nim
@@ -0,0 +1,27 @@
+# Test the new parseopt module
+
+import
+  parseopt
+
+proc writeHelp() = 
+  writeln(stdout, "Usage: tparsopt [options] filename [options]")
+
+proc writeVersion() = 
+  writeln(stdout, "Version: 1.0.0")
+  
+var
+  filename = ""
+for kind, key, val in getopt():
+  case kind
+  of cmdArgument: 
+    filename = key
+  of cmdLongOption, cmdShortOption:
+    case key
+    of "help", "h": writeHelp()
+    of "version", "v": writeVersion()
+    else: 
+      writeln(stdout, "Unknown command line option: ", key, ": ", val)
+  of cmdEnd: assert(false) # cannot happen
+if filename == "":
+  # no filename has been given, so we show the help:
+  writeHelp()
diff --git a/tests/accept/compile/tposix.nim b/tests/accept/compile/tposix.nim
new file mode 100644
index 000000000..bf0b49586
--- /dev/null
+++ b/tests/accept/compile/tposix.nim
@@ -0,0 +1,16 @@
+# Test Posix interface
+
+when not defined(windows):
+
+  import posix
+
+  var
+    u: Tutsname
+
+  discard uname(u)
+
+  writeln(stdout, u.sysname)
+  writeln(stdout, u.nodename)
+  writeln(stdout, u.release)
+  writeln(stdout, u.machine)
+
diff --git a/tests/accept/compile/tprep.nim b/tests/accept/compile/tprep.nim
new file mode 100644
index 000000000..999b2f57f
--- /dev/null
+++ b/tests/accept/compile/tprep.nim
@@ -0,0 +1,28 @@
+# Test the features that used to belong to the preprocessor
+
+import
+  times
+
+{.warning: "This is only a test warning!".}
+
+{.define: case2.}
+{.define: case3.}
+when defined(case1):
+  {.hint: "Case 1".}
+  when defined(case3):
+    {.hint: "Case 1.3".}
+elif defined(case2):
+  {.hint: "Case 2".}
+  when defined(case3):
+    {.hint: "Case 2.3".}
+elif defined(case3):
+  {.hint: "Case 3".}
+else:
+  {.hint: "unknown case".}
+
+var
+  s: string
+write(stdout, "compiled at " & system.compileDate &
+              " " & compileTime & "\n")
+echo getDateStr()
+echo getClockStr()
diff --git a/tests/accept/compile/tpush.nim b/tests/accept/compile/tpush.nim
new file mode 100644
index 000000000..5fb411a79
--- /dev/null
+++ b/tests/accept/compile/tpush.nim
@@ -0,0 +1,15 @@
+# test the new pragmas
+
+{.push warnings: off, hints: off.}
+proc noWarning() =
+  var
+    x: int
+  echo(x)
+
+{.pop.}
+
+proc WarnMe() =
+  var
+    x: int
+  echo(x)
+
diff --git a/tests/accept/compile/tquicksort.nim b/tests/accept/compile/tquicksort.nim
new file mode 100644
index 000000000..421564ecd
--- /dev/null
+++ b/tests/accept/compile/tquicksort.nim
@@ -0,0 +1,24 @@
+proc QuickSort(list: seq[int]): seq[int] =
+    if len(list) == 0:
+        return @[]
+    var pivot = list[0]
+    var left: seq[int] = @[]
+    var right: seq[int] = @[]
+    for i in low(list)..high(list):
+        if list[i] < pivot:
+            left.add(list[i])
+        elif list[i] > pivot:
+            right.add(list[i])
+    result = QuickSort(left) & pivot & QuickSort(right)
+    
+proc echoSeq(a: seq[int]) =
+    for i in low(a)..high(a):
+        echo(a[i])
+
+var
+    list: seq[int]
+        
+list = QuickSort(@[89,23,15,23,56,123,356,12,7,1,6,2,9,4,3])
+echoSeq(list)
+
+
diff --git a/tests/accept/compile/tquit.nim b/tests/accept/compile/tquit.nim
new file mode 100644
index 000000000..d4dc1522d
--- /dev/null
+++ b/tests/accept/compile/tquit.nim
@@ -0,0 +1,6 @@
+# Test the new beforeQuit variable: 
+
+proc myExit() {.noconv.} = 
+  write(stdout, "just exiting...\n")
+
+addQuitProc(myExit)
diff --git a/tests/accept/compile/tradix.nim b/tests/accept/compile/tradix.nim
new file mode 100644
index 000000000..e7ca210e4
--- /dev/null
+++ b/tests/accept/compile/tradix.nim
@@ -0,0 +1,319 @@
+# implements and tests an efficient radix tree
+
+## another method to store an efficient array of pointers: 
+## We use a radix tree with node compression. 
+## There are two node kinds:
+
+const bitsPerUnit = 8*sizeof(int)
+
+type
+  TRadixNodeKind = enum rnLinear, rnFull, rnLeafBits, rnLeafLinear
+  PRadixNode = ptr TRadixNode
+  TRadixNode {.pure.} = object
+    kind: TRadixNodeKind
+  TRadixNodeLinear = object of TRadixNode
+    len: byte
+    keys: array [0..31, byte]
+    vals: array [0..31, PRadixNode]
+  
+  TRadixNodeFull = object of TRadixNode
+    b: array [0..255, PRadixNode]
+  TRadixNodeLeafBits = object of TRadixNode
+    b: array [0..7, int]
+  TRadixNodeLeafLinear = object of TRadixNode
+    len: byte
+    keys: array [0..31, byte]
+
+var
+  root: PRadixNode
+
+proc searchInner(r: PRadixNode, a: int): PRadixNode = 
+  case r.kind
+  of rnLinear:
+    var x = cast[ptr TRadixNodeLinear](r)
+    for i in 0..ze(x.len)-1: 
+      if ze(x.keys[i]) == a: return x.vals[i]
+  of rnFull: 
+    var x = cast[ptr TRadixNodeFull](r)
+    return x.b[a]
+  else: assert(false)
+
+proc testBit(w, i: int): bool {.inline.} = 
+  result = (w and (1 shl (i %% BitsPerUnit))) != 0
+
+proc setBit(w: var int, i: int) {.inline.} = 
+  w = w or (1 shl (i %% bitsPerUnit))
+
+proc resetBit(w: var int, i: int) {.inline.} = 
+  w = w and not (1 shl (i %% bitsPerUnit))
+
+proc testOrSetBit(w: var int, i: int): bool {.inline.} = 
+  var x = (1 shl (i %% bitsPerUnit))
+  if (w and x) != 0: return true
+  w = w or x
+
+proc searchLeaf(r: PRadixNode, a: int): bool = 
+  case r.kind
+  of rnLeafBits:
+    var x = cast[ptr TRadixNodeLeafBits](r)
+    return testBit(x.b[a /% BitsPerUnit], a)
+  of rnLeafLinear:
+    var x = cast[ptr TRadixNodeLeafLinear](r)
+    for i in 0..ze(x.len)-1: 
+      if ze(x.keys[i]) == a: return true
+  else: assert(false)
+
+proc exclLeaf(r: PRadixNode, a: int) = 
+  case r.kind
+  of rnLeafBits:
+    var x = cast[ptr TRadixNodeLeafBits](r)
+    resetBit(x.b[a /% BitsPerUnit], a)
+  of rnLeafLinear:
+    var x = cast[ptr TRadixNodeLeafLinear](r)
+    var L = ze(x.len)
+    for i in 0..L-1: 
+      if ze(x.keys[i]) == a: 
+        x.keys[i] = x.keys[L-1]
+        dec(x.len)
+        return
+  else: assert(false)
+
+proc in_Operator*(r: PRadixNode, a: TAddress): bool =
+  if r == nil: return false
+  var x = searchInner(r, a shr 24 and 0xff)
+  if x == nil: return false
+  x = searchInner(x, a shr 16 and 0xff)
+  if x == nil: return false
+  x = searchInner(x, a shr 8 and 0xff)
+  if x == nil: return false
+  return searchLeaf(x, a and 0xff)
+
+proc excl*(r: PRadixNode, a: TAddress): bool =
+  if r == nil: return false
+  var x = searchInner(r, a shr 24 and 0xff)
+  if x == nil: return false
+  x = searchInner(x, a shr 16 and 0xff)
+  if x == nil: return false
+  x = searchInner(x, a shr 8 and 0xff)
+  if x == nil: return false
+  exclLeaf(x, a and 0xff)
+
+proc addLeaf(r: var PRadixNode, a: int): bool = 
+  if r == nil:
+    # a linear node:
+    var x = cast[ptr TRadixNodeLinear](alloc(sizeof(TRadixNodeLinear)))
+    x.kind = rnLeafLinear
+    x.len = 1'i8
+    x.keys[0] = toU8(a)
+    r = x
+    return false # not already in set
+  case r.kind 
+  of rnLeafBits: 
+    var x = cast[ptr TRadixNodeLeafBits](r)
+    return testOrSetBit(x.b[a /% BitsPerUnit], a)
+  of rnLeafLinear: 
+    var x = cast[ptr TRadixNodeLeafLinear](r)
+    var L = ze(x.len)
+    for i in 0..L-1: 
+      if ze(x.keys[i]) == a: return true
+    if L <= high(x.keys):
+      x.keys[L] = toU8(a)
+      inc(x.len)
+    else: 
+      # transform into a full node:
+      var y = cast[ptr TRadixNodeLeafBits](alloc0(sizeof(TRadixNodeLeafBits)))
+      y.kind = rnLeafBits
+      for i in 0..ze(x.len)-1: 
+        var u = ze(x.keys[i])
+        setBit(y.b[u /% BitsPerUnit], u)
+      setBit(y.b[a /% BitsPerUnit], a)
+      dealloc(r)
+      r = y
+  else: assert(false)
+
+proc addInner(r: var PRadixNode, a: int, d: int): bool = 
+  if d == 0: 
+    return addLeaf(r, a and 0xff)
+  var k = a shr d and 0xff
+  if r == nil:
+    # a linear node:
+    var x = cast[ptr TRadixNodeLinear](alloc(sizeof(TRadixNodeLinear)))
+    x.kind = rnLinear
+    x.len = 1'i8
+    x.keys[0] = toU8(k)
+    r = x
+    return addInner(x.vals[0], a, d-8)
+  case r.kind
+  of rnLinear:
+    var x = cast[ptr TRadixNodeLinear](r)
+    var L = ze(x.len)
+    for i in 0..L-1: 
+      if ze(x.keys[i]) == k: # already exists
+        return addInner(x.vals[i], a, d-8)
+    if L <= high(x.keys):
+      x.keys[L] = toU8(k)
+      inc(x.len)
+      return addInner(x.vals[L], a, d-8)
+    else: 
+      # transform into a full node:
+      var y = cast[ptr TRadixNodeFull](alloc0(sizeof(TRadixNodeFull)))
+      y.kind = rnFull
+      for i in 0..L-1: y.b[ze(x.keys[i])] = x.vals[i]
+      dealloc(r)
+      r = y
+      return addInner(y.b[k], a, d-8)
+  of rnFull: 
+    var x = cast[ptr TRadixNodeFull](r)
+    return addInner(x.b[k], a, d-8)
+  else: assert(false)
+
+proc incl*(r: var PRadixNode, a: TAddress) {.inline.} = 
+  discard addInner(r, a, 24)
+  
+proc testOrIncl*(r: var PRadixNode, a: TAddress): bool {.inline.} = 
+  return addInner(r, a, 24)
+      
+iterator innerElements(r: PRadixNode): tuple[prefix: int, n: PRadixNode] = 
+  if r != nil:
+    case r.kind 
+    of rnFull: 
+      var r = cast[ptr TRadixNodeFull](r)
+      for i in 0..high(r.b):
+        if r.b[i] != nil: 
+          yield (i, r.b[i])
+    of rnLinear: 
+      var r = cast[ptr TRadixNodeLinear](r)
+      for i in 0..ze(r.len)-1: 
+        yield (ze(r.keys[i]), r.vals[i])
+    else: assert(false)
+
+iterator leafElements(r: PRadixNode): int = 
+  if r != nil:
+    case r.kind
+    of rnLeafBits: 
+      var r = cast[ptr TRadixNodeLeafBits](r)
+      # iterate over any bit:
+      for i in 0..high(r.b): 
+        if r.b[i] != 0: # test all bits for zero
+          for j in 0..BitsPerUnit-1: 
+            if testBit(r.b[i], j): 
+              yield i*BitsPerUnit+j
+    of rnLeafLinear: 
+      var r = cast[ptr TRadixNodeLeafLinear](r)
+      for i in 0..ze(r.len)-1: 
+        yield ze(r.keys[i])
+    else: assert(false)
+    
+iterator elements*(r: PRadixNode): TAddress {.inline.} = 
+  for p1, n1 in innerElements(r): 
+    for p2, n2 in innerElements(n1):
+      for p3, n3 in innerElements(n2):
+        for p4 in leafElements(n3): 
+          yield p1 shl 24 or p2 shl 16 or p3 shl 8 or p4
+  
+proc main() =
+  const
+    numbers = [128, 1, 2, 3, 4, 255, 17, -8, 45, 19_000]
+  var
+    r: PRadixNode = nil
+  for x in items(numbers):
+    echo testOrIncl(r, x)
+  for x in elements(r): echo(x)
+
+main()
+
+
+when false:
+  proc traverse(r: PRadixNode, prefix: int, d: int) = 
+    if r == nil: return
+    case r.kind 
+    of rnLeafBits: 
+      assert(d == 0)
+      var x = cast[ptr TRadixNodeLeafBits](r)
+      # iterate over any bit:
+      for i in 0..high(x.b): 
+        if x.b[i] != 0: # test all bits for zero
+          for j in 0..BitsPerUnit-1: 
+            if testBit(x.b[i], j): 
+              visit(prefix or i*BitsPerUnit+j)
+    of rnLeafLinear: 
+      assert(d == 0)
+      var x = cast[ptr TRadixNodeLeafLinear](r)
+      for i in 0..ze(x.len)-1: 
+        visit(prefix or ze(x.keys[i]))
+    of rnFull: 
+      var x = cast[ptr TRadixNodeFull](r)
+      for i in 0..high(r.b):
+        if r.b[i] != nil: 
+          traverse(r.b[i], prefix or (i shl d), d-8)
+    of rnLinear: 
+      var x = cast[ptr TRadixNodeLinear](r)
+      for i in 0..ze(x.len)-1: 
+        traverse(x.vals[i], prefix or (ze(x.keys[i]) shl d), d-8)
+
+  type
+    TRadixIter {.final.} = object
+      r: PRadixNode
+      p: int
+      x: int
+
+  proc init(i: var TRadixIter, r: PRadixNode) =
+    i.r = r
+    i.x = 0
+    i.p = 0
+    
+  proc nextr(i: var TRadixIter): PRadixNode = 
+    if i.r == nil: return nil
+    case i.r.kind 
+    of rnFull: 
+      var r = cast[ptr TRadixNodeFull](i.r)
+      while i.x <= high(r.b):
+        if r.b[i.x] != nil: 
+          i.p = i.x
+          return r.b[i.x]
+        inc(i.x)
+    of rnLinear: 
+      var r = cast[ptr TRadixNodeLinear](i.r)
+      if i.x < ze(r.len): 
+        i.p = ze(r.keys[i.x])
+        result = r.vals[i.x]
+        inc(i.x)
+    else: assert(false)
+
+  proc nexti(i: var TRadixIter): int = 
+    result = -1
+    case i.r.kind 
+    of rnLeafBits: 
+      var r = cast[ptr TRadixNodeLeafBits](i.r)
+      # iterate over any bit:    
+      for i in 0..high(r.b): 
+        if x.b[i] != 0: # test all bits for zero
+          for j in 0..BitsPerUnit-1: 
+            if testBit(x.b[i], j): 
+              visit(prefix or i*BitsPerUnit+j)
+    of rnLeafLinear: 
+      var r = cast[ptr TRadixNodeLeafLinear](i.r)
+      if i.x < ze(r.len): 
+        result = ze(r.keys[i.x])
+        inc(i.x)
+
+  iterator elements(r: PRadixNode): TAddress {.inline.} = 
+    var
+      a, b, c, d: TRadixIter
+    init(a, r)
+    while true: 
+      var x = nextr(a)
+      if x != nil: 
+        init(b, x)
+        while true: 
+          var y = nextr(b)
+          if y != nil: 
+            init(c, y)
+            while true:
+              var z = nextr(c)
+              if z != nil: 
+                init(d, z)
+                while true:
+                  var q = nexti(d)
+                  if q != -1: 
+                    yield a.p shl 24 or b.p shl 16 or c.p shl 8 or q
diff --git a/tests/accept/compile/treadln.nim b/tests/accept/compile/treadln.nim
new file mode 100644
index 000000000..7703d5a56
--- /dev/null
+++ b/tests/accept/compile/treadln.nim
@@ -0,0 +1,12 @@
+# test the improved readline handling that does not care whether its
+# Macintosh, Unix or Windows text format.
+
+var
+  inp: TFile
+  line: string
+
+if openFile(inp, "readme.txt"):
+  while not EndOfFile(inp):
+    line = readLine(inp)
+    echo("#" & line & "#")
+  closeFile(inp)
diff --git a/tests/accept/compile/treadx.nim b/tests/accept/compile/treadx.nim
new file mode 100644
index 000000000..13acb0514
--- /dev/null
+++ b/tests/accept/compile/treadx.nim
@@ -0,0 +1,12 @@
+import posix
+
+var inp = ""
+var buf: array[0..10, char]
+while true:
+  var r = read(0, addr(buf), sizeof(buf)-1)
+  add inp, $buf
+  if r != sizeof(buf)-1: break
+
+echo inp
+#dafkladskölklödsaf ölksdakölfölksfklwe4iojr389wr 89uweokf sdlkf jweklr jweflksdj fioewjfsdlfsd
+
diff --git a/tests/accept/compile/trecmod.nim b/tests/accept/compile/trecmod.nim
new file mode 100644
index 000000000..9d39d3ff7
--- /dev/null
+++ b/tests/accept/compile/trecmod.nim
@@ -0,0 +1,2 @@
+# recursive module
+import mrecmod
diff --git a/tests/accept/compile/trecmod2.nim b/tests/accept/compile/trecmod2.nim
new file mode 100644
index 000000000..85fe2215f
--- /dev/null
+++ b/tests/accept/compile/trecmod2.nim
@@ -0,0 +1,10 @@
+type
+  T1* = int  # Module A exports the type ``T1``
+
+import mrecmod2   # the compiler starts parsing B
+
+proc main() =
+  var i = p(3) # works because B has been parsed completely here
+
+main()
+
diff --git a/tests/accept/compile/trepr.nim b/tests/accept/compile/trepr.nim
new file mode 100644
index 000000000..4a56842f6
--- /dev/null
+++ b/tests/accept/compile/trepr.nim
@@ -0,0 +1,32 @@
+# test the new "repr" built-in proc
+
+type
+  TEnum = enum
+    en1, en2, en3, en4, en5, en6
+
+  TPoint {.final.} = object
+    x, y, z: int
+    s: array [0..1, string]
+    e: TEnum
+
+var
+  p: TPoint
+  q: ref TPoint
+  s: seq[ref TPoint]
+
+p.x = 0
+p.y = 13
+p.z = 45
+p.s[0] = "abc"
+p.s[1] = "xyz"
+p.e = en6
+
+new(q)
+q^ = p
+
+s = @[q, q, q, q]
+
+writeln(stdout, repr(p))
+writeln(stdout, repr(q))
+writeln(stdout, repr(s))
+writeln(stdout, repr(en4))
diff --git a/tests/accept/compile/tseq2.nim b/tests/accept/compile/tseq2.nim
new file mode 100644
index 000000000..03bdb3fab
--- /dev/null
+++ b/tests/accept/compile/tseq2.nim
@@ -0,0 +1,13 @@
+
+  
+proc `*` *(a, b: seq[int]): seq[int] = 
+  # allocate a new sequence:
+  newSeq(result, len(a))
+  # multiply two int sequences:
+  for i in 0..len(a)-1: result[i] = a[i] * b[i]
+
+when isMainModule: 
+  # test the new ``*`` operator for sequences:
+  assert(@[1, 2, 3] * @[1, 2, 3] == @[1, 4, 9])
+
+
diff --git a/tests/accept/compile/tseqcon2.nim b/tests/accept/compile/tseqcon2.nim
new file mode 100644
index 000000000..6225c3bb1
--- /dev/null
+++ b/tests/accept/compile/tseqcon2.nim
@@ -0,0 +1,9 @@
+import os
+
+proc rec_dir(dir: string): seq[string] =
+  result = @[]
+  for kind, path in walk_dir(dir):
+    if kind == pcDirectory:
+      add(result, rec_dir(path))
+    else:
+      add(result, path)
diff --git a/tests/accept/compile/tsizeof.nim b/tests/accept/compile/tsizeof.nim
new file mode 100644
index 000000000..f7b70dd4d
--- /dev/null
+++ b/tests/accept/compile/tsizeof.nim
@@ -0,0 +1,10 @@
+# Test the sizeof proc
+
+type
+  TMyRecord {.final.} = object
+    x, y: int
+    b: bool
+    r: float
+    s: string
+
+write(stdout, sizeof(TMyRecord))
diff --git a/tests/accept/compile/tsockets.nim b/tests/accept/compile/tsockets.nim
new file mode 100644
index 000000000..cc7d18b87
--- /dev/null
+++ b/tests/accept/compile/tsockets.nim
@@ -0,0 +1,11 @@
+import sockets
+var s: TSocket
+s = socket()
+
+s.connect("www.google.com", TPort(80))
+
+var recvData: string = ""
+echo(s.recvLine(recvData))
+echo(recvData)
+
+
diff --git a/tests/accept/compile/tstrace.nim b/tests/accept/compile/tstrace.nim
new file mode 100644
index 000000000..56f20a0dd
--- /dev/null
+++ b/tests/accept/compile/tstrace.nim
@@ -0,0 +1,16 @@
+# Test the new stacktraces (great for debugging!)
+
+{.push stack_trace: on.}
+
+proc recTest(i: int) =
+  # enter
+  if i < 10:
+    recTest(i+1)
+  else: # should printStackTrace()
+    var p: ptr int = nil
+    p^ = 12
+  # leave
+
+{.pop.}
+
+recTest(0)
diff --git a/tests/accept/compile/tstrdesc.nim b/tests/accept/compile/tstrdesc.nim
new file mode 100644
index 000000000..1c2e85b4b
--- /dev/null
+++ b/tests/accept/compile/tstrdesc.nim
@@ -0,0 +1,14 @@
+var
+  x: array [0..2, int]
+
+x = [0, 1, 2]
+
+type
+  TStringDesc {.final.} = object
+    len, space: int # len and space without counting the terminating zero
+    data: array [0..0, char] # for the '\0' character
+
+var
+  emptyString {.exportc: "emptyString".}: TStringDesc 
+
+
diff --git a/tests/accept/compile/tstrdist.nim b/tests/accept/compile/tstrdist.nim
new file mode 100644
index 000000000..3e1939e73
--- /dev/null
+++ b/tests/accept/compile/tstrdist.nim
@@ -0,0 +1,26 @@
+# compute the edit distance between two strings
+
+proc editDistance(a, b: string): int =
+  var
+    c: seq[int]
+    n = a.len
+    m = b.len
+  newSeq(c, (n+1)*(m+1))
+  for i in 0..n:
+    c[i*n] = i # [i,0]
+  for j in 0..m:
+    c[j] = j # [0,j]
+
+  for i in 1..n:
+    for j in 1..m:
+      var x = c[(i-1)*n + j]+1
+      var y = c[i*n + j-1]+1
+      var z: int
+      if a[i-1] == b[j-1]:
+        z = c[(i-1)*n + j-1]
+      else:
+        z = c[(i-1)*n + j-1]+1
+      c[(i-1)*n + (j-1)] = min(x,min(y,z))
+  return c[n*m]
+
+write(stdout, editDistance("abc", "abd"))
diff --git a/tests/accept/compile/tstreams.nim b/tests/accept/compile/tstreams.nim
new file mode 100644
index 000000000..68ca8eeeb
--- /dev/null
+++ b/tests/accept/compile/tstreams.nim
@@ -0,0 +1,7 @@
+import streams
+
+var outp = newFileStream(stdout)
+var inp = newFileStream(stdin)
+write(outp, "Hallo! What is your name?")
+var line = readLine(inp)
+write(outp, "nice name: " & line)
diff --git a/tests/accept/compile/tstrset.nim b/tests/accept/compile/tstrset.nim
new file mode 100644
index 000000000..e19ccee4d
--- /dev/null
+++ b/tests/accept/compile/tstrset.nim
@@ -0,0 +1,74 @@
+# test a simple yet highly efficient set of strings
+
+type
+  TRadixNodeKind = enum rnLinear, rnFull, rnLeaf
+  PRadixNode = ref TRadixNode
+  TRadixNode = object
+    kind: TRadixNodeKind
+  TRadixNodeLinear = object of TRadixNode
+    len: byte
+    keys: array [0..31, char]
+    vals: array [0..31, PRadixNode]  
+  TRadixNodeFull = object of TRadixNode
+    b: array [char, PRadixNode]
+  TRadixNodeLeaf = object of TRadixNode
+    s: string
+  PRadixNodeLinear = ref TRadixNodeLinear
+  PRadixNodeFull = ref TRadixNodeFull
+  PRadixNodeLeaf = ref TRadixNodeLeaf
+    
+proc search(r: PRadixNode, s: string): PRadixNode =
+  var r = r
+  var i = 0
+  while r != nil:
+    case r.kind
+    of rnLinear:
+      var x = PRadixNodeLinear(r)
+      for j in 0..ze(x.len)-1:
+        if x.keys[j] == s[i]:
+          if s[i] == '\0': return r
+          r = x.vals[j]
+          inc(i)
+          break
+      break # character not found
+    of rnFull:
+      var x = PRadixNodeFull(r)
+      var y = x.b[s[i]]
+      if s[i] == '\0':
+        return if y != nil: r else: nil
+      r = y
+      inc(i)
+    of rnLeaf:
+      var x = PRadixNodeLeaf(r)
+      var j = 0
+      while true:
+        if x.s[j] != s[i]: return nil
+        if s[i] == '\0': return r
+        inc(j)
+        inc(i)
+
+proc in_Operator*(r: PRadixNode, s: string): bool =
+  return search(r, s) != nil
+
+proc testOrincl*(r: var PRadixNode, s: string): bool =
+  nil
+    
+proc incl*(r: var PRadixNode, s: string) = discard testOrIncl(r, s)
+
+proc excl*(r: var PRadixNode, s: string) =
+  var x = search(r, s)
+  if x == nil: return
+  case x.kind
+  of rnLeaf: PRadixNodeLeaf(x).s = ""
+  of rnFull: PRadixNodeFull(x).b['\0'] = nil
+  of rnLinear:
+    var x = PRadixNodeLinear(x)
+    for i in 0..ze(x.len)-1:
+      if x.keys[i] == '\0':
+        swap(x.keys[i], x.keys[ze(x.len)-1])
+        dec(x.len)
+        break
+
+var
+  root: PRadixNode
+
diff --git a/tests/accept/compile/tstrtabs.nim b/tests/accept/compile/tstrtabs.nim
new file mode 100644
index 000000000..299db609d
--- /dev/null
+++ b/tests/accept/compile/tstrtabs.nim
@@ -0,0 +1,12 @@
+import strtabs
+
+var tab = newStringTable(["key1", "val1", "key2", "val2"], 
+                         modeStyleInsensitive)
+for i in 0..80:
+  tab["key_" & $i] = "value" & $i
+  
+for key, val in pairs(tab):
+  writeln(stdout, key, ": ", val)
+writeln(stdout, "length of table ", $tab.len)
+
+writeln(stdout, `%`("$key1 = $key2; ${PATH}", tab, {useEnvironment}))
diff --git a/tests/accept/compile/ttempl.nim b/tests/accept/compile/ttempl.nim
new file mode 100644
index 000000000..dcf096671
--- /dev/null
+++ b/tests/accept/compile/ttempl.nim
@@ -0,0 +1,27 @@
+# Test the new template file mechanism
+
+import
+  os, times
+
+include "sunset.tmpl"
+
+const
+  tabs = [["home", "index"],
+          ["news", "news"],
+          ["documentation", "documentation"],
+          ["download", "download"],
+          ["FAQ", "question"],
+          ["links", "links"]]
+
+
+var i = 0
+for item in items(tabs): 
+  var content = $i
+  var file: TFile
+  if openFile(file, changeFileExt(item[1], "html"), fmWrite): 
+    write(file, sunsetTemplate(current=item[1], ticker="", content=content,
+                               tabs=tabs))
+    closeFile(file)
+  else:
+    write(stdout, "cannot open file for writing")
+  inc(i)
diff --git a/tests/accept/compile/ttempl3.nim b/tests/accept/compile/ttempl3.nim
new file mode 100644
index 000000000..0c8fa9a94
--- /dev/null
+++ b/tests/accept/compile/ttempl3.nim
@@ -0,0 +1,26 @@
+
+template withOpenFile(f: expr, filename: string, mode: TFileMode,
+                      actions: stmt): stmt =
+  block:
+    var f: TFile
+    if open(f, filename, mode):
+      try:
+        actions
+      finally:
+        close(f)
+    else:
+      quit("cannot open for writing: " & filename)
+    
+withOpenFile(txt, "ttempl3.txt", fmWrite):
+  writeln(txt, "line 1")
+  txt.writeln("line 2")
+  
+# Test zero argument template: 
+template ha: expr = myVar[0]
+  
+var
+  myVar: array[0..1, int]
+  
+ha = 1  
+echo(ha)
+
diff --git a/tests/accept/compile/ttime.nim b/tests/accept/compile/ttime.nim
new file mode 100644
index 000000000..bad818816
--- /dev/null
+++ b/tests/accept/compile/ttime.nim
@@ -0,0 +1,6 @@
+# test the new time module
+
+import
+  times
+
+write(stdout, $getTime())
diff --git a/tests/accept/compile/ttuple1.nim b/tests/accept/compile/ttuple1.nim
new file mode 100644
index 000000000..5787cc309
--- /dev/null
+++ b/tests/accept/compile/ttuple1.nim
@@ -0,0 +1,16 @@
+const romanNumbers = [
+    ("M", 1000), ("D", 500), ("C", 100),
+    ("L", 50), ("X", 10), ("V", 5), ("I", 1) ]
+
+var c = 0
+for key, val in items(romanNumbers):
+  inc(c)
+  stdout.write(key & "=" & $val)
+  if c < romanNumbers.len: stdout.write(", ") else: echo""
+#echo""
+
+proc PrintBiTuple(t: tuple[k: string, v: int]): int =
+  stdout.write(t.k & "=" & $t.v & ", ")
+  return 0
+  
+
diff --git a/tests/accept/compile/tvarious.nim b/tests/accept/compile/tvarious.nim
new file mode 100644
index 000000000..52dd46184
--- /dev/null
+++ b/tests/accept/compile/tvarious.nim
@@ -0,0 +1,43 @@
+# Test various aspects
+
+import
+  mvarious
+
+type
+  PA = ref TA
+  PB = ref TB
+
+  TB = object
+    a: PA
+
+  TA = object
+    b: TB
+    x: int
+
+proc getPA(): PA =
+  var
+    b: bool
+  b = not false
+  return nil
+
+var
+  global: int
+
+var
+  s: string
+  i: int
+  r: TA
+
+r.b.a.x = 0
+global = global + 1
+exportme()
+write(stdout, "Hallo wie hei�t du? ")
+write(stdout, getPA().x)
+s = readLine(stdin)
+i = 0
+while i < s.len:
+  if s[i] == 'c': write(stdout, "'c' in deinem Namen gefunden\n")
+  i = i + 1
+
+write(stdout, "Du hei�t " & s)
+
diff --git a/tests/accept/compile/twalker.nim b/tests/accept/compile/twalker.nim
new file mode 100644
index 000000000..ba89ee7c6
--- /dev/null
+++ b/tests/accept/compile/twalker.nim
@@ -0,0 +1,13 @@
+# iterate over all files with a given filter:
+
+import
+  os, times
+
+proc main(filter: string) =
+  for filename in walkFiles(filter):
+    writeln(stdout, filename)
+
+  for key, val in iterOverEnvironment():
+    writeln(stdout, key & '=' & val)
+
+main("*.nim")
diff --git a/tests/accept/compile/typalias.nim b/tests/accept/compile/typalias.nim
new file mode 100644
index 000000000..ba9f38ed9
--- /dev/null
+++ b/tests/accept/compile/typalias.nim
@@ -0,0 +1,15 @@
+
+type
+  TMyObj = TYourObj
+  TYourObj = object of TObject
+    x, y: int
+  
+proc init: TYourObj =
+  result.x = 0
+  result.y = -1
+  
+proc f(x: var TYourObj) =
+  nil
+  
+var m: TMyObj = init()
+f(m)
author	rumpf_a@web.de <>	2010-02-21 19:42:36 +0100
committer	rumpf_a@web.de <>	2010-02-21 19:42:36 +0100
commit	d913fdb2800d83680e413cd8a5f07b7f85deac6e (patch)
tree	09a284861adf96520059f211ba8bae1a76294a9c /tests/accept/compile
parent	6bc16904edd3738ab97573b9eeb3a6a7cce9574c (diff)
download	Nim-d913fdb2800d83680e413cd8a5f07b7f85deac6e.tar.gz