mirrors/Nim
1
0
Fork 0
mirror of https://github.com/nim-lang/Nim.git synced 2025-12-31 18:32:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

make tests green again

Browse Source
This commit is contained in:
Araq
2012-07-17 01:27:25 +02:00
parent 5e3d42a929
commit 4f582da27f
19 changed files with 166 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/ast.nim
View File

@@ -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,

15
compiler/ccgexprs.nim
View File

@@ -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)

2
compiler/pas2nim/pasparse.nim
View File

@@ -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)

2
examples/x11ex.nim
View File

@@ -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")

201
lib/ecmas/dom.nim
View File

@@ -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

2
lib/pure/events.nim
View File

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

8
lib/pure/ftpclient.nim
View File

@@ -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

5
lib/pure/irc.nim
View File

@@ -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.
##

7
lib/pure/scgi.nim
View File

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

1
lib/system.nim
View File

@@ -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.}

50
lib/system/ecmasys.nim
View File

@@ -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)

2
lib/windows/nb30.nim
View File

@@ -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

2
tests/compile/tnewlibs.nim
View File

@@ -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")

2
tests/compile/tobjcov.nim
View File

@@ -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

2
tests/compile/tvoid.nim
View File

@@ -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:

2
tests/run/tgenericprocvar.nim
View File

@@ -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 = @[]

6
tests/run/toop1.nim
View File

@@ -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)

2
tests/run/topenarrayrepr.nim
View File

@@ -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 ])

2
tests/run/toverl2.nim
View File

@@ -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))