make tests green again

19 files changed, 166 insertions, 149 deletions

diff --git a/compiler/ast.nim b/compiler/ast.nim
index 9f3a99363..7bd893a07 100755
--- a/compiler/ast.nim
+++ b/compiler/ast.nim
@@ -398,7 +398,7 @@ type
     mEqI64, mLeI64, mLtI64, mEqF64, mLeF64, mLtF64, 
     mLeU, mLtU, mLeU64, mLtU64, 
     mEqEnum, mLeEnum, mLtEnum, mEqCh, mLeCh, mLtCh, mEqB, mLeB, mLtB, mEqRef, 
-    mEqProc, mEqUntracedRef, mLePtr, mLtPtr, mEqCString, mXor, mUnaryMinusI, 
+    mEqUntracedRef, mLePtr, mLtPtr, mEqCString, mXor, mEqProc, mUnaryMinusI,
     mUnaryMinusI64, mAbsI, mAbsI64, mNot, 
     mUnaryPlusI, mBitnotI, mUnaryPlusI64, 
     mBitnotI64, mUnaryPlusF64, mUnaryMinusF64, mAbsF64, mZe8ToI, mZe8ToI64, 
diff --git a/compiler/ccgexprs.nim b/compiler/ccgexprs.nim
index 2199f2067..e02a38004 100755
--- a/compiler/ccgexprs.nim
+++ b/compiler/ccgexprs.nim
@@ -458,7 +458,6 @@ proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
       "($1 <= $2)",           # LeB
       "($1 < $2)",            # LtB
       "($1 == $2)",           # EqRef
-      "($1 == $2)",           # EqProc
       "($1 == $2)",           # EqPtr
       "($1 <= $2)",           # LePtr
       "($1 < $2)",            # LtPtr
@@ -477,6 +476,19 @@ proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
               ropef(binArithTab[op], [rdLoc(a), rdLoc(b), toRope(s),
                                       getSimpleTypeDesc(p.module, e.typ)]))
 
+proc genEqProc(p: BProc, e: PNode, d: var TLoc) =
+  var a, b: TLoc
+  assert(e.sons[1].typ != nil)
+  assert(e.sons[2].typ != nil)
+  InitLocExpr(p, e.sons[1], a)
+  InitLocExpr(p, e.sons[2], b)
+  if a.t.callConv == ccClosure:
+    putIntoDest(p, d, e.typ, 
+      ropef("($1.ClPrc == $2.ClPrc && $1.ClEnv == $2.ClEnv)", [
+      rdLoc(a), rdLoc(b)]))
+  else:
+    putIntoDest(p, d, e.typ, ropef("($1 == $2)", [rdLoc(a), rdLoc(b)]))
+
 proc unaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
   const
     unArithTab: array[mNot..mToBiggestInt, string] = ["!($1)", # Not
@@ -1367,6 +1379,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
   of mUnaryMinusI..mAbsI64: unaryArithOverflow(p, e, d, op)
   of mAddF64..mDivF64: binaryFloatArith(p, e, d, op)
   of mShrI..mXor: binaryArith(p, e, d, op)
+  of mEqProc: genEqProc(p, e, d)
   of mAddi..mModi64: binaryArithOverflow(p, e, d, op)
   of mRepr: genRepr(p, e, d)
   of mGetTypeInfo: genGetTypeInfo(p, e, d)
diff --git a/compiler/pas2nim/pasparse.nim b/compiler/pas2nim/pasparse.nim
index 2154b4add..da716c621 100755
--- a/compiler/pas2nim/pasparse.nim
+++ b/compiler/pas2nim/pasparse.nim
@@ -1032,7 +1032,7 @@ proc identVis(p: var TParser): PNode =
   getTok(p)
 
 type 
-  TSymbolParser = proc (p: var TParser): PNode
+  TSymbolParser = proc (p: var TParser): PNode {.nimcall.}
 
 proc rawIdent(p: var TParser): PNode = 
   result = createIdentNodeP(p.tok.ident, p)
diff --git a/examples/x11ex.nim b/examples/x11ex.nim
index eb4ae9274..6c63d0a01 100755
--- a/examples/x11ex.nim
+++ b/examples/x11ex.nim
@@ -51,7 +51,7 @@ proc process_event =
   case int(xev.theType)
   of KeyPress:
     key = XLookupKeysym(cast[ptr TXKeyEvent](addr(xev)), 0)
-    if key != 0:
+    if key.int != 0:
       echo("keyboard event")
   of ButtonPressMask, PointerMotionMask:
     Echo("Mouse event")
diff --git a/lib/ecmas/dom.nim b/lib/ecmas/dom.nim
index 8f29dc9f8..1ee8f9ace 100755
--- a/lib/ecmas/dom.nim
+++ b/lib/ecmas/dom.nim
@@ -14,26 +14,26 @@ when not defined(ecmascript):
 
 type
   TEventHandlers* {.importc.} = object of TObject
-    onabort*: proc (event: ref TEvent)
-    onblur*: proc (event: ref TEvent)
-    onchange*: proc (event: ref TEvent)
-    onclick*: proc (event: ref TEvent)
-    ondblclick*: proc (event: ref TEvent)
-    onerror*: proc (event: ref TEvent)
-    onfocus*: proc (event: ref TEvent)
-    onkeydown*: proc (event: ref TEvent)
-    onkeypress*: proc (event: ref TEvent)
-    onkeyup*: proc (event: ref TEvent)
-    onload*: proc (event: ref TEvent)
-    onmousedown*: proc (event: ref TEvent)
-    onmousemove*: proc (event: ref TEvent)
-    onmouseout*: proc (event: ref TEvent)
-    onmouseover*: proc (event: ref TEvent)
-    onmouseup*: proc (event: ref TEvent)
-    onreset*: proc (event: ref TEvent)
-    onselect*: proc (event: ref TEvent)
-    onsubmit*: proc (event: ref TEvent)
-    onunload*: proc (event: ref TEvent)
+    onabort*: proc (event: ref TEvent) {.nimcall.}
+    onblur*: proc (event: ref TEvent) {.nimcall.}
+    onchange*: proc (event: ref TEvent) {.nimcall.}
+    onclick*: proc (event: ref TEvent) {.nimcall.}
+    ondblclick*: proc (event: ref TEvent) {.nimcall.}
+    onerror*: proc (event: ref TEvent) {.nimcall.}
+    onfocus*: proc (event: ref TEvent) {.nimcall.}
+    onkeydown*: proc (event: ref TEvent) {.nimcall.}
+    onkeypress*: proc (event: ref TEvent) {.nimcall.}
+    onkeyup*: proc (event: ref TEvent) {.nimcall.}
+    onload*: proc (event: ref TEvent) {.nimcall.}
+    onmousedown*: proc (event: ref TEvent) {.nimcall.}
+    onmousemove*: proc (event: ref TEvent) {.nimcall.}
+    onmouseout*: proc (event: ref TEvent) {.nimcall.}
+    onmouseover*: proc (event: ref TEvent) {.nimcall.}
+    onmouseup*: proc (event: ref TEvent) {.nimcall.}
+    onreset*: proc (event: ref TEvent) {.nimcall.}
+    onselect*: proc (event: ref TEvent) {.nimcall.}
+    onsubmit*: proc (event: ref TEvent) {.nimcall.}
+    onunload*: proc (event: ref TEvent) {.nimcall.}
 
   TWindow* {.importc.} = object of TEventHandlers
     document*: ref TDocument
@@ -54,36 +54,37 @@ type
     status*: cstring
     toolbar*: ref TToolBar
 
-    alert*: proc (msg: cstring)
-    back*: proc ()
-    blur*: proc ()
-    captureEvents*: proc (eventMask: int)
-    clearInterval*: proc (interval: ref TInterval)
-    clearTimeout*: proc (timeout: ref TTimeOut)
-    close*: proc ()
-    confirm*: proc (msg: cstring): bool
-    disableExternalCapture*: proc ()
-    enableExternalCapture*: proc ()
-    find*: proc (text: cstring, caseSensitive = false, backwards = false)
-    focus*: proc ()
-    forward*: proc ()
-    handleEvent*: proc (e: ref TEvent)
-    home*: proc ()
-    moveBy*: proc (x, y: int)
-    moveTo*: proc (x, y: int)
+    alert*: proc (msg: cstring) {.nimcall.}
+    back*: proc () {.nimcall.}
+    blur*: proc () {.nimcall.}
+    captureEvents*: proc (eventMask: int) {.nimcall.}
+    clearInterval*: proc (interval: ref TInterval) {.nimcall.}
+    clearTimeout*: proc (timeout: ref TTimeOut) {.nimcall.}
+    close*: proc () {.nimcall.}
+    confirm*: proc (msg: cstring): bool {.nimcall.}
+    disableExternalCapture*: proc () {.nimcall.}
+    enableExternalCapture*: proc () {.nimcall.}
+    find*: proc (text: cstring, caseSensitive = false, 
+                 backwards = false) {.nimcall.}
+    focus*: proc () {.nimcall.}
+    forward*: proc () {.nimcall.}
+    handleEvent*: proc (e: ref TEvent) {.nimcall.}
+    home*: proc () {.nimcall.}
+    moveBy*: proc (x, y: int) {.nimcall.}
+    moveTo*: proc (x, y: int) {.nimcall.}
     open*: proc (uri, windowname: cstring,
-                 properties: cstring = nil): ref TWindow
-    print*: proc ()
-    prompt*: proc (text, default: cstring): cstring
-    releaseEvents*: proc (eventMask: int)
-    resizeBy*: proc (x, y: int)
-    resizeTo*: proc (x, y: int)
-    routeEvent*: proc (event: ref TEvent)
-    scrollBy*: proc (x, y: int)
-    scrollTo*: proc (x, y: int)
-    setInterval*: proc (code: cstring, pause: int): ref TInterval
-    setTimeout*: proc (code: cstring, pause: int): ref TTimeOut
-    stop*: proc ()
+                 properties: cstring = nil): ref TWindow {.nimcall.}
+    print*: proc () {.nimcall.}
+    prompt*: proc (text, default: cstring): cstring {.nimcall.}
+    releaseEvents*: proc (eventMask: int) {.nimcall.}
+    resizeBy*: proc (x, y: int) {.nimcall.}
+    resizeTo*: proc (x, y: int) {.nimcall.}
+    routeEvent*: proc (event: ref TEvent) {.nimcall.}
+    scrollBy*: proc (x, y: int) {.nimcall.}
+    scrollTo*: proc (x, y: int) {.nimcall.}
+    setInterval*: proc (code: cstring, pause: int): ref TInterval {.nimcall.}
+    setTimeout*: proc (code: cstring, pause: int): ref TTimeOut {.nimcall.}
+    stop*: proc () {.nimcall.}
     frames*: seq[TFrame]
 
   TFrame* {.importc.} = object of TWindow
@@ -101,20 +102,20 @@ type
     title*: cstring
     URL*: cstring
     vlinkColor*: cstring
-    captureEvents*: proc (eventMask: int)
-    createAttribute*: proc (identifier: cstring): ref TNode
-    createElement*: proc (identifier: cstring): ref TNode
-    createTextNode*: proc (identifier: cstring): ref TNode
-    getElementById*: proc (id: cstring): ref TNode
-    getElementsByName*: proc (name: cstring): seq[ref TNode]
-    getElementsByTagName*: proc (name: cstring): seq[ref TNode]
-    getSelection*: proc (): cstring
-    handleEvent*: proc (event: ref TEvent)
-    open*: proc ()
-    releaseEvents*: proc (eventMask: int)
-    routeEvent*: proc (event: ref TEvent)
-    write*: proc (text: cstring)
-    writeln*: proc (text: cstring)
+    captureEvents*: proc (eventMask: int) {.nimcall.}
+    createAttribute*: proc (identifier: cstring): ref TNode {.nimcall.}
+    createElement*: proc (identifier: cstring): ref TNode {.nimcall.}
+    createTextNode*: proc (identifier: cstring): ref TNode {.nimcall.}
+    getElementById*: proc (id: cstring): ref TNode {.nimcall.}
+    getElementsByName*: proc (name: cstring): seq[ref TNode] {.nimcall.}
+    getElementsByTagName*: proc (name: cstring): seq[ref TNode] {.nimcall.}
+    getSelection*: proc (): cstring {.nimcall.}
+    handleEvent*: proc (event: ref TEvent) {.nimcall.}
+    open*: proc () {.nimcall.}
+    releaseEvents*: proc (eventMask: int) {.nimcall.}
+    routeEvent*: proc (event: ref TEvent) {.nimcall.}
+    write*: proc (text: cstring) {.nimcall.}
+    writeln*: proc (text: cstring) {.nimcall.}
     anchors*: seq[ref TAnchor]
     forms*: seq[ref TForm]
     images*: seq[ref TImage]
@@ -137,8 +138,8 @@ type
     width*: int
     `type`*: cstring
     vspace*: int
-    play*: proc ()
-    stop*: proc ()
+    play*: proc () {.nimcall.}
+    stop*: proc () {.nimcall.}
 
   TAnchor* {.importc.} = object of TObject
     name*: cstring
@@ -157,11 +158,11 @@ type
     readOnly*: bool
     `type`*: cstring
     value*: cstring
-    blur*: proc ()
-    click*: proc ()
-    focus*: proc ()
-    handleEvent*: proc (event: ref TEvent)
-    select*: proc ()
+    blur*: proc () {.nimcall.}
+    click*: proc () {.nimcall.}
+    focus*: proc () {.nimcall.}
+    handleEvent*: proc (event: ref TEvent) {.nimcall.}
+    select*: proc () {.nimcall.}
     options*: seq[ref TOption]
 
   TOption* {.importc.} = object of TObject
@@ -177,9 +178,9 @@ type
     `method`*: cstring
     name*: cstring
     target*: cstring
-    handleEvent*: proc (event: ref TEvent)
-    reset*: proc ()
-    submit*: proc ()
+    handleEvent*: proc (event: ref TEvent) {.nimcall.}
+    reset*: proc () {.nimcall.}
+    submit*: proc () {.nimcall.}
     elements*: seq[ref TElement]
 
   TImage* {.importc.} = object of TEventHandlers
@@ -192,7 +193,7 @@ type
     src*: cstring
     vspace*: int
     width*: int
-    handleEvent*: proc (event: ref TEvent)
+    handleEvent*: proc (event: ref TEvent) {.nimcall.}
 
   TNodeType* = enum
     ElementNode = 1,
@@ -219,24 +220,24 @@ type
     nodeValue*: cstring
     parentNode*: ref TNode
     previousSibling*: ref TNode
-    appendChild*: proc (child: ref TNode)
-    appendData*: proc (data: cstring)
-    cloneNode*: proc (copyContent: bool)
-    deleteData*: proc (start, len: int)
-    getAttribute*: proc (attr: cstring): cstring
-    getAttributeNode*: proc (attr: cstring): ref TNode
-    getElementsByTagName*: proc (): seq[ref TNode]
-    hasChildNodes*: proc (): bool
+    appendChild*: proc (child: ref TNode) {.nimcall.}
+    appendData*: proc (data: cstring) {.nimcall.}
+    cloneNode*: proc (copyContent: bool) {.nimcall.}
+    deleteData*: proc (start, len: int) {.nimcall.}
+    getAttribute*: proc (attr: cstring): cstring {.nimcall.}
+    getAttributeNode*: proc (attr: cstring): ref TNode {.nimcall.}
+    getElementsByTagName*: proc (): seq[ref TNode] {.nimcall.}
+    hasChildNodes*: proc (): bool {.nimcall.}
     innerHTML*: cstring
-    insertBefore*: proc (newNode, before: ref TNode)
-    insertData*: proc (position: int, data: cstring)
-    removeAttribute*: proc (attr: cstring)
-    removeAttributeNode*: proc (attr: ref TNode)
-    removeChild*: proc (child: ref TNode)
-    replaceChild*: proc (newNode, oldNode: ref TNode)
-    replaceData*: proc (start, len: int, text: cstring)
-    setAttribute*: proc (name, value: cstring)
-    setAttributeNode*: proc (attr: ref TNode)
+    insertBefore*: proc (newNode, before: ref TNode) {.nimcall.}
+    insertData*: proc (position: int, data: cstring) {.nimcall.}
+    removeAttribute*: proc (attr: cstring) {.nimcall.}
+    removeAttributeNode*: proc (attr: ref TNode) {.nimcall.}
+    removeChild*: proc (child: ref TNode) {.nimcall.}
+    replaceChild*: proc (newNode, oldNode: ref TNode) {.nimcall.}
+    replaceData*: proc (start, len: int, text: cstring) {.nimcall.}
+    setAttribute*: proc (name, value: cstring) {.nimcall.}
+    setAttributeNode*: proc (attr: ref TNode) {.nimcall.}
     style*: ref TStyle
 
   TStyle* {.importc.} = object of TObject
@@ -329,9 +330,9 @@ type
     width*: cstring
     wordSpacing*: cstring
     zIndex*: int
-    getAttribute*: proc (attr: cstring, caseSensitive=false): cstring
-    removeAttribute*: proc (attr: cstring, caseSensitive=false)
-    setAttribute*: proc (attr, value: cstring, caseSensitive=false)
+    getAttribute*: proc (attr: cstring, caseSensitive=false): cstring {.nimcall.}
+    removeAttribute*: proc (attr: cstring, caseSensitive=false) {.nimcall.}
+    setAttribute*: proc (attr, value: cstring, caseSensitive=false) {.nimcall.}
 
   TEvent* {.importc.} = object of TObject
     altKey*, ctrlKey*, shiftKey*: bool
@@ -380,14 +381,14 @@ type
     port*: cstring
     protocol*: cstring
     search*: cstring
-    reload*: proc ()
-    replace*: proc (s: cstring)
+    reload*: proc () {.nimcall.}
+    replace*: proc (s: cstring) {.nimcall.}
 
   THistory* {.importc.} = object of TObject
     length*: int
-    back*: proc ()
-    forward*: proc ()
-    go*: proc (pagesToJump: int)
+    back*: proc () {.nimcall.}
+    forward*: proc () {.nimcall.}
+    go*: proc (pagesToJump: int) {.nimcall.}
 
   TNavigator* {.importc.} = object of TObject
     appCodeName*: cstring
@@ -397,7 +398,7 @@ type
     language*: cstring
     platform*: cstring
     userAgent*: cstring
-    javaEnabled*: proc (): bool
+    javaEnabled*: proc (): bool {.nimcall.}
     mimeTypes*: seq[ref TMimeType]
 
   TPlugin* {.importc.} = object of TObject
diff --git a/lib/pure/events.nim b/lib/pure/events.nim
index 894091bf7..e76b846cf 100644
--- a/lib/pure/events.nim
+++ b/lib/pure/events.nim
@@ -36,7 +36,7 @@
 
 type
   TEventArgs* = object of TObject ## Base object for event arguments that are passed to callback functions.
-  TEventHandler* = tuple[name: string, handlers: seq[proc(e:TEventArgs)]] ## An eventhandler for an event.
+  TEventHandler* = tuple[name: string, handlers: seq[proc(e:TEventArgs) {.closure.}]] ## An eventhandler for an event.
 
 type
   TEventEmitter* = object {.pure, final.} ## An object that fires events and holds event handlers for an object.
diff --git a/lib/pure/ftpclient.nim b/lib/pure/ftpclient.nim
index 669499342..fc049e3b7 100644
--- a/lib/pure/ftpclient.nim
+++ b/lib/pure/ftpclient.nim
@@ -43,7 +43,7 @@ type
     JRetrText, JRetr, JStore
 
   TFTPJob = object
-    prc: proc (ftp: var TFTPClient, async: bool): bool
+    prc: proc (ftp: var TFTPClient, async: bool): bool {.nimcall.}
     case typ*: FTPJobType
     of JRetrText:
       lines: string
@@ -60,7 +60,7 @@ type
   PAsyncFTPClient* = ref TAsyncFTPClient ## Async alternative to TFTPClient.
   TAsyncFTPClient* = object of TFTPClient
     handleEvent*: proc (ftp: var TAsyncFTPClient, ev: TFTPEvent, 
-                        userArg: PObject)
+                        userArg: PObject) {.nimcall.}
     dele: PDelegate
     userArg: PObject
 
@@ -116,8 +116,8 @@ proc assertReply(received: TaintedString, expected: openarray[string]) =
                      [expected.join("' or '"), received.string])
 
 proc createJob(ftp: var TFTPClient,
-                 prc: proc (ftp: var TFTPClient, async: bool): bool,
-                 cmd: FTPJobType) =
+               prc: proc (ftp: var TFTPClient, async: bool): bool {.nimcall.},
+               cmd: FTPJobType) =
   if ftp.jobInProgress:
     raise newException(EFTP, "Unable to do two jobs at once.")
   ftp.jobInProgress = true
diff --git a/lib/pure/irc.nim b/lib/pure/irc.nim
index 81dff024e..cc9157053 100644
--- a/lib/pure/irc.nim
+++ b/lib/pure/irc.nim
@@ -45,7 +45,8 @@ type
   PAsyncIRC* = ref TAsyncIRC
   TAsyncIRC* = object of TIRC
     userArg: PObject
-    handleEvent: proc (irc: var TAsyncIRC, ev: TIRCEvent, userArg: PObject)
+    handleEvent: proc (irc: var TAsyncIRC, ev: TIRCEvent, 
+                       userArg: PObject) {.nimcall.}
     lineBuffer: TaintedString
 
   TIRCMType* = enum
@@ -366,7 +367,7 @@ proc asyncIRC*(address: string, port: TPort = 6667.TPort,
               joinChans: seq[string] = @[],
               msgLimit: bool = true,
               ircEvent: proc (irc: var TAsyncIRC, ev: TIRCEvent,
-                  userArg: PObject),
+                  userArg: PObject) {.nimcall.},
               userArg: PObject = nil): PAsyncIRC =
   ## Use this function if you want to use asyncio's dispatcher.
   ## 
diff --git a/lib/pure/scgi.nim b/lib/pure/scgi.nim
index 53bee5ced..48e1e3362 100755
--- a/lib/pure/scgi.nim
+++ b/lib/pure/scgi.nim
@@ -67,7 +67,8 @@ type
   
   TAsyncScgiState* = object of TScgiState
     handleRequest: proc (server: var TAsyncScgiState, client: TSocket, 
-                         input: string, headers: PStringTable,userArg: PObject)
+                         input: string, headers: PStringTable,
+                         userArg: PObject) {.nimcall.}
     userArg: PObject
   PAsyncScgiState* = ref TAsyncScgiState
     
@@ -128,7 +129,7 @@ proc writeStatusOkTextContent*(c: TSocket, contentType = "text/html") =
          "Content-Type: $1\r\L\r\L" % contentType)
 
 proc run*(handleRequest: proc (client: TSocket, input: string, 
-                               headers: PStringTable): bool,
+                               headers: PStringTable): bool {.nimcall.},
           port = TPort(4000)) = 
   ## encapsulates the SCGI object and main loop.
   var s: TScgiState
@@ -142,7 +143,7 @@ proc run*(handleRequest: proc (client: TSocket, input: string,
 
 proc open*(handleRequest: proc (server: var TAsyncScgiState, client: TSocket, 
                                 input: string, headers: PStringTable,
-                                userArg: PObject),
+                                userArg: PObject) {.nimcall.},
            port = TPort(4000), address = "127.0.0.1",
            userArg: PObject = nil): PAsyncScgiState =
   ## Alternative of ``open`` for asyncio compatible SCGI.
diff --git a/lib/system.nim b/lib/system.nim
index 6e8fd00b3..dbbe75a57 100755
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -614,6 +614,7 @@ proc `==` *(x, y: bool): bool {.magic: "EqB", noSideEffect.}
 proc `==` *[T](x, y: set[T]): bool {.magic: "EqSet", noSideEffect.}
 proc `==` *[T](x, y: ref T): bool {.magic: "EqRef", noSideEffect.}
 proc `==` *[T](x, y: ptr T): bool {.magic: "EqRef", noSideEffect.}
+proc `==` *[T: proc](x, y: T): bool {.magic: "EqProc", noSideEffect.}
 
 proc `<=` *[TEnum: enum](x, y: TEnum): bool {.magic: "LeEnum", noSideEffect.}
 proc `<=` *(x, y: string): bool {.magic: "LeStr", noSideEffect.}
diff --git a/lib/system/ecmasys.nim b/lib/system/ecmasys.nim
index 8f4585931..0c9db2206 100755
--- a/lib/system/ecmasys.nim
+++ b/lib/system/ecmasys.nim
@@ -247,14 +247,14 @@ proc eqStrings(a, b: string): bool {.noStackFrame, compilerProc.} =
 
 type
   TDocument {.importc.} = object of TObject
-    write: proc (text: cstring)
-    writeln: proc (text: cstring)
-    createAttribute: proc (identifier: cstring): ref TNode
-    createElement: proc (identifier: cstring): ref TNode
-    createTextNode: proc (identifier: cstring): ref TNode
-    getElementById: proc (id: cstring): ref TNode
-    getElementsByName: proc (name: cstring): seq[ref TNode]
-    getElementsByTagName: proc (name: cstring): seq[ref TNode]
+    write: proc (text: cstring) {.nimcall.}
+    writeln: proc (text: cstring) {.nimcall.}
+    createAttribute: proc (identifier: cstring): ref TNode {.nimcall.}
+    createElement: proc (identifier: cstring): ref TNode {.nimcall.}
+    createTextNode: proc (identifier: cstring): ref TNode {.nimcall.}
+    getElementById: proc (id: cstring): ref TNode {.nimcall.}
+    getElementsByName: proc (name: cstring): seq[ref TNode] {.nimcall.}
+    getElementsByTagName: proc (name: cstring): seq[ref TNode] {.nimcall.}
 
   TNodeType* = enum
     ElementNode = 1,
@@ -281,23 +281,23 @@ type
     nodeValue*: cstring
     parentNode*: ref TNode
     previousSibling*: ref TNode
-    appendChild*: proc (child: ref TNode)
-    appendData*: proc (data: cstring)
-    cloneNode*: proc (copyContent: bool)
-    deleteData*: proc (start, len: int)
-    getAttribute*: proc (attr: cstring): cstring
-    getAttributeNode*: proc (attr: cstring): ref TNode
-    getElementsByTagName*: proc (): seq[ref TNode]
-    hasChildNodes*: proc (): bool
-    insertBefore*: proc (newNode, before: ref TNode)
-    insertData*: proc (position: int, data: cstring)
-    removeAttribute*: proc (attr: cstring)
-    removeAttributeNode*: proc (attr: ref TNode)
-    removeChild*: proc (child: ref TNode)
-    replaceChild*: proc (newNode, oldNode: ref TNode)
-    replaceData*: proc (start, len: int, text: cstring)
-    setAttribute*: proc (name, value: cstring)
-    setAttributeNode*: proc (attr: ref TNode)
+    appendChild*: proc (child: ref TNode) {.nimcall.}
+    appendData*: proc (data: cstring) {.nimcall.}
+    cloneNode*: proc (copyContent: bool) {.nimcall.}
+    deleteData*: proc (start, len: int) {.nimcall.}
+    getAttribute*: proc (attr: cstring): cstring {.nimcall.}
+    getAttributeNode*: proc (attr: cstring): ref TNode {.nimcall.}
+    getElementsByTagName*: proc (): seq[ref TNode] {.nimcall.}
+    hasChildNodes*: proc (): bool {.nimcall.}
+    insertBefore*: proc (newNode, before: ref TNode) {.nimcall.}
+    insertData*: proc (position: int, data: cstring) {.nimcall.}
+    removeAttribute*: proc (attr: cstring) {.nimcall.}
+    removeAttributeNode*: proc (attr: ref TNode) {.nimcall.}
+    removeChild*: proc (child: ref TNode) {.nimcall.}
+    replaceChild*: proc (newNode, oldNode: ref TNode) {.nimcall.}
+    replaceData*: proc (start, len: int, text: cstring) {.nimcall.}
+    setAttribute*: proc (name, value: cstring) {.nimcall.}
+    setAttributeNode*: proc (attr: ref TNode) {.nimcall.}
     
 when defined(nodejs):
   proc ewriteln(x: cstring) = log(x)
diff --git a/lib/windows/nb30.nim b/lib/windows/nb30.nim
index 527e3a9e2..a7fd526aa 100755
--- a/lib/windows/nb30.nim
+++ b/lib/windows/nb30.nim
@@ -21,7 +21,7 @@ const
 
 type                          # Network Control Block
   PNCB* = ptr TNCB
-  TNCBPostProc* = proc (P: PNCB)
+  TNCBPostProc* = proc (P: PNCB) {.stdcall.}
   TNCB* {.final.} = object # Structure returned to the NCB command NCBASTAT is ADAPTER_STATUS followed
                            # by an array of NAME_BUFFER structures.
     ncb_command*: Char        # command code
diff --git a/tests/compile/tnewlibs.nim b/tests/compile/tnewlibs.nim
index 041316290..bdb53ae0b 100755
--- a/tests/compile/tnewlibs.nim
+++ b/tests/compile/tnewlibs.nim
@@ -11,7 +11,7 @@ import
   cairowin32, cairoxlib,
   gl, glut, glu, glx, glext, wingl,
   lua, lualib, lauxlib, mysql, sqlite3, db_mongo, md5, asyncio, mimetypes,
-  cookies, events, ftpclient
+  cookies, events, ftpclient, scgi, irc
   
 
 writeln(stdout, "test compilation of binding modules")
diff --git a/tests/compile/tobjcov.nim b/tests/compile/tobjcov.nim
index 17bc8d80d..40360020a 100755
--- a/tests/compile/tobjcov.nim
+++ b/tests/compile/tobjcov.nim
@@ -11,7 +11,7 @@ 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 = cast[proc (x: var TA)](bp)
+var f = cast[proc (x: var TA) {.nimcall.}](bp)
 var a: TA
 f(a) # bp expects a TB, but gets a TA
 
diff --git a/tests/compile/tvoid.nim b/tests/compile/tvoid.nim
index b286010dc..bb569e7f8 100644
--- a/tests/compile/tvoid.nim
+++ b/tests/compile/tvoid.nim
@@ -11,7 +11,7 @@ proc ReturnT[T](x: T): T =
 proc nothing(x, y: void): void =
   echo "ha"
 
-proc callProc[T](p: proc (x: T), x: T) =
+proc callProc[T](p: proc (x: T) {.nimcall.}, x: T) =
   when T is void: 
     p()
   else:
diff --git a/tests/run/tgenericprocvar.nim b/tests/run/tgenericprocvar.nim
index 088909d58..1eba81fec 100644
--- a/tests/run/tgenericprocvar.nim
+++ b/tests/run/tgenericprocvar.nim
@@ -18,7 +18,7 @@ threadProcWrapper[int]()
 threadProcWrapper[bool]()
 
 type
-  TFilterProc[T,D] = proc (item: T, env:D): bool
+  TFilterProc[T,D] = proc (item: T, env:D): bool {.nimcall.}
 
 proc filter[T,D](data: seq[T], env:D, pred: TFilterProc[T,D]): seq[T] =
   result = @[]
diff --git a/tests/run/toop1.nim b/tests/run/toop1.nim
index 35af2fcc2..017facc4c 100755
--- a/tests/run/toop1.nim
+++ b/tests/run/toop1.nim
@@ -7,7 +7,7 @@ import macros
 
 type
   TFigure = object of TObject    # abstract base class:
-    draw: proc (my: var TFigure) # concrete classes implement this proc
+    draw: proc (my: var TFigure) {.nimcall.} # concrete classes implement this
   
 proc init(f: var TFigure) = 
   f.draw = nil
@@ -21,7 +21,7 @@ proc drawCircle(my: var TCircle) = stdout.writeln("o " & $my.radius)
 proc init(my: var TCircle) = 
   init(TFigure(my)) # call base constructor
   my.radius = 5
-  my.draw = cast[proc (my: var TFigure)](drawCircle)
+  my.draw = cast[proc (my: var TFigure) {.nimcall.}](drawCircle)
 
 type
   TRectangle = object of TFigure
@@ -33,7 +33,7 @@ proc init(my: var TRectangle) =
   init(TFigure(my)) # call base constructor
   my.width = 5
   my.height = 10
-  my.draw = cast[proc (my: var TFigure)](drawRectangle)
+  my.draw = cast[proc (my: var TFigure) {.nimcall.}](drawRectangle)
 
 macro `!` (n: expr): stmt = 
   result = newNimNode(nnkCall, n)
diff --git a/tests/run/topenarrayrepr.nim b/tests/run/topenarrayrepr.nim
index ec7be722a..d276756bc 100755
--- a/tests/run/topenarrayrepr.nim
+++ b/tests/run/topenarrayrepr.nim
@@ -3,7 +3,7 @@ discard """
   output: "5 - [1]"
 """
 type
-  TProc = proc (n: int, m: openarray[int64])
+  TProc = proc (n: int, m: openarray[int64]) {.nimcall.}
 
 proc Foo(x: int, P: TProc) =
   P(x, [ 1'i64 ])
diff --git a/tests/run/toverl2.nim b/tests/run/toverl2.nim
index dd9f075a8..ea0249e9f 100755
--- a/tests/run/toverl2.nim
+++ b/tests/run/toverl2.nim
@@ -16,7 +16,7 @@ iterator toverl2(x: int): int =
     inc(res)
 
 var
-  pp: proc (x: bool): string = toverl2
+  pp: proc (x: bool): string {.nimcall.} = toverl2
 
 stdout.write(pp(true))