jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

make tests green again

Browse source
This commit is contained in:
Araq 2012-07-17 01:27:25 +02:00
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, mEqI64, mLeI64, mLtI64, mEqF64, mLeF64, mLtF64,
mLeU, mLtU, mLeU64, mLtU64, mLeU, mLtU, mLeU64, mLtU64,
mEqEnum, mLeEnum, mLtEnum, mEqCh, mLeCh, mLtCh, mEqB, mLeB, mLtB, mEqRef, 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, mUnaryMinusI64, mAbsI, mAbsI64, mNot,
mUnaryPlusI, mBitnotI, mUnaryPlusI64, mUnaryPlusI, mBitnotI, mUnaryPlusI64,
mBitnotI64, mUnaryPlusF64, mUnaryMinusF64, mAbsF64, mZe8ToI, mZe8ToI64, 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)", # LeB
"($1 < $2)", # LtB "($1 < $2)", # LtB
"($1 == $2)", # EqRef "($1 == $2)", # EqRef
"($1 == $2)", # EqProc
"($1 == $2)", # EqPtr "($1 == $2)", # EqPtr
"($1 <= $2)", # LePtr "($1 <= $2)", # LePtr
"($1 < $2)", # LtPtr "($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), ropef(binArithTab[op], [rdLoc(a), rdLoc(b), toRope(s),
getSimpleTypeDesc(p.module, e.typ)])) 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) = proc unaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
const const
unArithTab: array[mNot..mToBiggestInt, string] = ["!($1)", # Not 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 mUnaryMinusI..mAbsI64: unaryArithOverflow(p, e, d, op)
of mAddF64..mDivF64: binaryFloatArith(p, e, d, op) of mAddF64..mDivF64: binaryFloatArith(p, e, d, op)
of mShrI..mXor: binaryArith(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 mAddi..mModi64: binaryArithOverflow(p, e, d, op)
of mRepr: genRepr(p, e, d) of mRepr: genRepr(p, e, d)
of mGetTypeInfo: genGetTypeInfo(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) getTok(p)
type type
TSymbolParser = proc (p: var TParser): PNode TSymbolParser = proc (p: var TParser): PNode {.nimcall.}
proc rawIdent(p: var TParser): PNode = proc rawIdent(p: var TParser): PNode =
result = createIdentNodeP(p.tok.ident, p) result = createIdentNodeP(p.tok.ident, p)

2
examples/x11ex.nim
View file

@ -51,7 +51,7 @@ proc process_event =
case int(xev.theType) case int(xev.theType)
of KeyPress: of KeyPress:
key = XLookupKeysym(cast[ptr TXKeyEvent](addr(xev)), 0) key = XLookupKeysym(cast[ptr TXKeyEvent](addr(xev)), 0)
if key != 0: if key.int != 0:
echo("keyboard event") echo("keyboard event")
of ButtonPressMask, PointerMotionMask: of ButtonPressMask, PointerMotionMask:
Echo("Mouse event") Echo("Mouse event")

201
lib/ecmas/dom.nim
View file

@ -14,26 +14,26 @@ when not defined(ecmascript):
type type
TEventHandlers* {.importc.} = object of TObject TEventHandlers* {.importc.} = object of TObject
onabort*: proc (event: ref TEvent) onabort*: proc (event: ref TEvent) {.nimcall.}
onblur*: proc (event: ref TEvent) onblur*: proc (event: ref TEvent) {.nimcall.}
onchange*: proc (event: ref TEvent) onchange*: proc (event: ref TEvent) {.nimcall.}
onclick*: proc (event: ref TEvent) onclick*: proc (event: ref TEvent) {.nimcall.}
ondblclick*: proc (event: ref TEvent) ondblclick*: proc (event: ref TEvent) {.nimcall.}
onerror*: proc (event: ref TEvent) onerror*: proc (event: ref TEvent) {.nimcall.}
onfocus*: proc (event: ref TEvent) onfocus*: proc (event: ref TEvent) {.nimcall.}
onkeydown*: proc (event: ref TEvent) onkeydown*: proc (event: ref TEvent) {.nimcall.}
onkeypress*: proc (event: ref TEvent) onkeypress*: proc (event: ref TEvent) {.nimcall.}
onkeyup*: proc (event: ref TEvent) onkeyup*: proc (event: ref TEvent) {.nimcall.}
onload*: proc (event: ref TEvent) onload*: proc (event: ref TEvent) {.nimcall.}
onmousedown*: proc (event: ref TEvent) onmousedown*: proc (event: ref TEvent) {.nimcall.}
onmousemove*: proc (event: ref TEvent) onmousemove*: proc (event: ref TEvent) {.nimcall.}
onmouseout*: proc (event: ref TEvent) onmouseout*: proc (event: ref TEvent) {.nimcall.}
onmouseover*: proc (event: ref TEvent) onmouseover*: proc (event: ref TEvent) {.nimcall.}
onmouseup*: proc (event: ref TEvent) onmouseup*: proc (event: ref TEvent) {.nimcall.}
onreset*: proc (event: ref TEvent) onreset*: proc (event: ref TEvent) {.nimcall.}
onselect*: proc (event: ref TEvent) onselect*: proc (event: ref TEvent) {.nimcall.}
onsubmit*: proc (event: ref TEvent) onsubmit*: proc (event: ref TEvent) {.nimcall.}
onunload*: proc (event: ref TEvent) onunload*: proc (event: ref TEvent) {.nimcall.}
TWindow* {.importc.} = object of TEventHandlers TWindow* {.importc.} = object of TEventHandlers
document*: ref TDocument document*: ref TDocument
@ -54,36 +54,37 @@ type
status*: cstring status*: cstring
toolbar*: ref TToolBar toolbar*: ref TToolBar
alert*: proc (msg: cstring) alert*: proc (msg: cstring) {.nimcall.}
back*: proc () back*: proc () {.nimcall.}
blur*: proc () blur*: proc () {.nimcall.}
captureEvents*: proc (eventMask: int) captureEvents*: proc (eventMask: int) {.nimcall.}
clearInterval*: proc (interval: ref TInterval) clearInterval*: proc (interval: ref TInterval) {.nimcall.}
clearTimeout*: proc (timeout: ref TTimeOut) clearTimeout*: proc (timeout: ref TTimeOut) {.nimcall.}
close*: proc () close*: proc () {.nimcall.}
confirm*: proc (msg: cstring): bool confirm*: proc (msg: cstring): bool {.nimcall.}
disableExternalCapture*: proc () disableExternalCapture*: proc () {.nimcall.}
enableExternalCapture*: proc () enableExternalCapture*: proc () {.nimcall.}
find*: proc (text: cstring, caseSensitive = false, backwards = false) find*: proc (text: cstring, caseSensitive = false,
focus*: proc () backwards = false) {.nimcall.}
forward*: proc () focus*: proc () {.nimcall.}
handleEvent*: proc (e: ref TEvent) forward*: proc () {.nimcall.}
home*: proc () handleEvent*: proc (e: ref TEvent) {.nimcall.}
moveBy*: proc (x, y: int) home*: proc () {.nimcall.}
moveTo*: proc (x, y: int) moveBy*: proc (x, y: int) {.nimcall.}
moveTo*: proc (x, y: int) {.nimcall.}
open*: proc (uri, windowname: cstring, open*: proc (uri, windowname: cstring,
properties: cstring = nil): ref TWindow properties: cstring = nil): ref TWindow {.nimcall.}
print*: proc () print*: proc () {.nimcall.}
prompt*: proc (text, default: cstring): cstring prompt*: proc (text, default: cstring): cstring {.nimcall.}
releaseEvents*: proc (eventMask: int) releaseEvents*: proc (eventMask: int) {.nimcall.}
resizeBy*: proc (x, y: int) resizeBy*: proc (x, y: int) {.nimcall.}
resizeTo*: proc (x, y: int) resizeTo*: proc (x, y: int) {.nimcall.}
routeEvent*: proc (event: ref TEvent) routeEvent*: proc (event: ref TEvent) {.nimcall.}
scrollBy*: proc (x, y: int) scrollBy*: proc (x, y: int) {.nimcall.}
scrollTo*: proc (x, y: int) scrollTo*: proc (x, y: int) {.nimcall.}
setInterval*: proc (code: cstring, pause: int): ref TInterval setInterval*: proc (code: cstring, pause: int): ref TInterval {.nimcall.}
setTimeout*: proc (code: cstring, pause: int): ref TTimeOut setTimeout*: proc (code: cstring, pause: int): ref TTimeOut {.nimcall.}
stop*: proc () stop*: proc () {.nimcall.}
frames*: seq[TFrame] frames*: seq[TFrame]
TFrame* {.importc.} = object of TWindow TFrame* {.importc.} = object of TWindow
@ -101,20 +102,20 @@ type
title*: cstring title*: cstring
URL*: cstring URL*: cstring
vlinkColor*: cstring vlinkColor*: cstring
captureEvents*: proc (eventMask: int) captureEvents*: proc (eventMask: int) {.nimcall.}
createAttribute*: proc (identifier: cstring): ref TNode createAttribute*: proc (identifier: cstring): ref TNode {.nimcall.}
createElement*: proc (identifier: cstring): ref TNode createElement*: proc (identifier: cstring): ref TNode {.nimcall.}
createTextNode*: proc (identifier: cstring): ref TNode createTextNode*: proc (identifier: cstring): ref TNode {.nimcall.}
getElementById*: proc (id: cstring): ref TNode getElementById*: proc (id: cstring): ref TNode {.nimcall.}
getElementsByName*: proc (name: cstring): seq[ref TNode] getElementsByName*: proc (name: cstring): seq[ref TNode] {.nimcall.}
getElementsByTagName*: proc (name: cstring): seq[ref TNode] getElementsByTagName*: proc (name: cstring): seq[ref TNode] {.nimcall.}
getSelection*: proc (): cstring getSelection*: proc (): cstring {.nimcall.}
handleEvent*: proc (event: ref TEvent) handleEvent*: proc (event: ref TEvent) {.nimcall.}
open*: proc () open*: proc () {.nimcall.}
releaseEvents*: proc (eventMask: int) releaseEvents*: proc (eventMask: int) {.nimcall.}
routeEvent*: proc (event: ref TEvent) routeEvent*: proc (event: ref TEvent) {.nimcall.}
write*: proc (text: cstring) write*: proc (text: cstring) {.nimcall.}
writeln*: proc (text: cstring) writeln*: proc (text: cstring) {.nimcall.}
anchors*: seq[ref TAnchor] anchors*: seq[ref TAnchor]
forms*: seq[ref TForm] forms*: seq[ref TForm]
images*: seq[ref TImage] images*: seq[ref TImage]
@ -137,8 +138,8 @@ type
width*: int width*: int
`type`*: cstring `type`*: cstring
vspace*: int vspace*: int
play*: proc () play*: proc () {.nimcall.}
stop*: proc () stop*: proc () {.nimcall.}
TAnchor* {.importc.} = object of TObject TAnchor* {.importc.} = object of TObject
name*: cstring name*: cstring
@ -157,11 +158,11 @@ type
readOnly*: bool readOnly*: bool
`type`*: cstring `type`*: cstring
value*: cstring value*: cstring
blur*: proc () blur*: proc () {.nimcall.}
click*: proc () click*: proc () {.nimcall.}
focus*: proc () focus*: proc () {.nimcall.}
handleEvent*: proc (event: ref TEvent) handleEvent*: proc (event: ref TEvent) {.nimcall.}
select*: proc () select*: proc () {.nimcall.}
options*: seq[ref TOption] options*: seq[ref TOption]
TOption* {.importc.} = object of TObject TOption* {.importc.} = object of TObject
@ -177,9 +178,9 @@ type
`method`*: cstring `method`*: cstring
name*: cstring name*: cstring
target*: cstring target*: cstring
handleEvent*: proc (event: ref TEvent) handleEvent*: proc (event: ref TEvent) {.nimcall.}
reset*: proc () reset*: proc () {.nimcall.}
submit*: proc () submit*: proc () {.nimcall.}
elements*: seq[ref TElement] elements*: seq[ref TElement]
TImage* {.importc.} = object of TEventHandlers TImage* {.importc.} = object of TEventHandlers
@ -192,7 +193,7 @@ type
src*: cstring src*: cstring
vspace*: int vspace*: int
width*: int width*: int
handleEvent*: proc (event: ref TEvent) handleEvent*: proc (event: ref TEvent) {.nimcall.}
TNodeType* = enum TNodeType* = enum
ElementNode = 1, ElementNode = 1,
@ -219,24 +220,24 @@ type
nodeValue*: cstring nodeValue*: cstring
parentNode*: ref TNode parentNode*: ref TNode
previousSibling*: ref TNode previousSibling*: ref TNode
appendChild*: proc (child: ref TNode) appendChild*: proc (child: ref TNode) {.nimcall.}
appendData*: proc (data: cstring) appendData*: proc (data: cstring) {.nimcall.}
cloneNode*: proc (copyContent: bool) cloneNode*: proc (copyContent: bool) {.nimcall.}
deleteData*: proc (start, len: int) deleteData*: proc (start, len: int) {.nimcall.}
getAttribute*: proc (attr: cstring): cstring getAttribute*: proc (attr: cstring): cstring {.nimcall.}
getAttributeNode*: proc (attr: cstring): ref TNode getAttributeNode*: proc (attr: cstring): ref TNode {.nimcall.}
getElementsByTagName*: proc (): seq[ref TNode] getElementsByTagName*: proc (): seq[ref TNode] {.nimcall.}
hasChildNodes*: proc (): bool hasChildNodes*: proc (): bool {.nimcall.}
innerHTML*: cstring innerHTML*: cstring
insertBefore*: proc (newNode, before: ref TNode) insertBefore*: proc (newNode, before: ref TNode) {.nimcall.}
insertData*: proc (position: int, data: cstring) insertData*: proc (position: int, data: cstring) {.nimcall.}
removeAttribute*: proc (attr: cstring) removeAttribute*: proc (attr: cstring) {.nimcall.}
removeAttributeNode*: proc (attr: ref TNode) removeAttributeNode*: proc (attr: ref TNode) {.nimcall.}
removeChild*: proc (child: ref TNode) removeChild*: proc (child: ref TNode) {.nimcall.}
replaceChild*: proc (newNode, oldNode: ref TNode) replaceChild*: proc (newNode, oldNode: ref TNode) {.nimcall.}
replaceData*: proc (start, len: int, text: cstring) replaceData*: proc (start, len: int, text: cstring) {.nimcall.}
setAttribute*: proc (name, value: cstring) setAttribute*: proc (name, value: cstring) {.nimcall.}
setAttributeNode*: proc (attr: ref TNode) setAttributeNode*: proc (attr: ref TNode) {.nimcall.}
style*: ref TStyle style*: ref TStyle
TStyle* {.importc.} = object of TObject TStyle* {.importc.} = object of TObject
@ -329,9 +330,9 @@ type
width*: cstring width*: cstring
wordSpacing*: cstring wordSpacing*: cstring
zIndex*: int zIndex*: int
getAttribute*: proc (attr: cstring, caseSensitive=false): cstring getAttribute*: proc (attr: cstring, caseSensitive=false): cstring {.nimcall.}
removeAttribute*: proc (attr: cstring, caseSensitive=false) removeAttribute*: proc (attr: cstring, caseSensitive=false) {.nimcall.}
setAttribute*: proc (attr, value: cstring, caseSensitive=false) setAttribute*: proc (attr, value: cstring, caseSensitive=false) {.nimcall.}
TEvent* {.importc.} = object of TObject TEvent* {.importc.} = object of TObject
altKey*, ctrlKey*, shiftKey*: bool altKey*, ctrlKey*, shiftKey*: bool
@ -380,14 +381,14 @@ type
port*: cstring port*: cstring
protocol*: cstring protocol*: cstring
search*: cstring search*: cstring
reload*: proc () reload*: proc () {.nimcall.}
replace*: proc (s: cstring) replace*: proc (s: cstring) {.nimcall.}
THistory* {.importc.} = object of TObject THistory* {.importc.} = object of TObject
length*: int length*: int
back*: proc () back*: proc () {.nimcall.}
forward*: proc () forward*: proc () {.nimcall.}
go*: proc (pagesToJump: int) go*: proc (pagesToJump: int) {.nimcall.}
TNavigator* {.importc.} = object of TObject TNavigator* {.importc.} = object of TObject
appCodeName*: cstring appCodeName*: cstring
@ -397,7 +398,7 @@ type
language*: cstring language*: cstring
platform*: cstring platform*: cstring
userAgent*: cstring userAgent*: cstring
javaEnabled*: proc (): bool javaEnabled*: proc (): bool {.nimcall.}
mimeTypes*: seq[ref TMimeType] mimeTypes*: seq[ref TMimeType]
TPlugin* {.importc.} = object of TObject TPlugin* {.importc.} = object of TObject

2
lib/pure/events.nim
View file

@ -36,7 +36,7 @@
type type
TEventArgs* = object of TObject ## Base object for event arguments that are passed to callback functions. 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 type
TEventEmitter* = object {.pure, final.} ## An object that fires events and holds event handlers for an object. TEventEmitter* = object {.pure, final.} ## An object that fires events and holds event handlers for an object.

6
lib/pure/ftpclient.nim
View file

@ -43,7 +43,7 @@ type
JRetrText, JRetr, JStore JRetrText, JRetr, JStore
TFTPJob = object TFTPJob = object
prc: proc (ftp: var TFTPClient, async: bool): bool prc: proc (ftp: var TFTPClient, async: bool): bool {.nimcall.}
case typ*: FTPJobType case typ*: FTPJobType
of JRetrText: of JRetrText:
lines: string lines: string
@ -60,7 +60,7 @@ type
PAsyncFTPClient* = ref TAsyncFTPClient ## Async alternative to TFTPClient. PAsyncFTPClient* = ref TAsyncFTPClient ## Async alternative to TFTPClient.
TAsyncFTPClient* = object of TFTPClient TAsyncFTPClient* = object of TFTPClient
handleEvent*: proc (ftp: var TAsyncFTPClient, ev: TFTPEvent, handleEvent*: proc (ftp: var TAsyncFTPClient, ev: TFTPEvent,
userArg: PObject) userArg: PObject) {.nimcall.}
dele: PDelegate dele: PDelegate
userArg: PObject userArg: PObject
@ -116,7 +116,7 @@ proc assertReply(received: TaintedString, expected: openarray[string]) =
[expected.join("' or '"), received.string]) [expected.join("' or '"), received.string])
proc createJob(ftp: var TFTPClient, proc createJob(ftp: var TFTPClient,
prc: proc (ftp: var TFTPClient, async: bool): bool, prc: proc (ftp: var TFTPClient, async: bool): bool {.nimcall.},
cmd: FTPJobType) = cmd: FTPJobType) =
if ftp.jobInProgress: if ftp.jobInProgress:
raise newException(EFTP, "Unable to do two jobs at once.") raise newException(EFTP, "Unable to do two jobs at once.")

5
lib/pure/irc.nim
View file

@ -45,7 +45,8 @@ type
PAsyncIRC* = ref TAsyncIRC PAsyncIRC* = ref TAsyncIRC
TAsyncIRC* = object of TIRC TAsyncIRC* = object of TIRC
userArg: PObject userArg: PObject
handleEvent: proc (irc: var TAsyncIRC, ev: TIRCEvent, userArg: PObject) handleEvent: proc (irc: var TAsyncIRC, ev: TIRCEvent,
userArg: PObject) {.nimcall.}
lineBuffer: TaintedString lineBuffer: TaintedString
TIRCMType* = enum TIRCMType* = enum
@ -366,7 +367,7 @@ proc asyncIRC*(address: string, port: TPort = 6667.TPort,
joinChans: seq[string] = @[], joinChans: seq[string] = @[],
msgLimit: bool = true, msgLimit: bool = true,
ircEvent: proc (irc: var TAsyncIRC, ev: TIRCEvent, ircEvent: proc (irc: var TAsyncIRC, ev: TIRCEvent,
userArg: PObject), userArg: PObject) {.nimcall.},
userArg: PObject = nil): PAsyncIRC = userArg: PObject = nil): PAsyncIRC =
## Use this function if you want to use asyncio's dispatcher. ## 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 TAsyncScgiState* = object of TScgiState
handleRequest: proc (server: var TAsyncScgiState, client: TSocket, handleRequest: proc (server: var TAsyncScgiState, client: TSocket,
input: string, headers: PStringTable,userArg: PObject) input: string, headers: PStringTable,
userArg: PObject) {.nimcall.}
userArg: PObject userArg: PObject
PAsyncScgiState* = ref TAsyncScgiState PAsyncScgiState* = ref TAsyncScgiState
@ -128,7 +129,7 @@ proc writeStatusOkTextContent*(c: TSocket, contentType = "text/html") =
"Content-Type: $1\r\L\r\L" % contentType) "Content-Type: $1\r\L\r\L" % contentType)
proc run*(handleRequest: proc (client: TSocket, input: string, proc run*(handleRequest: proc (client: TSocket, input: string,
headers: PStringTable): bool, headers: PStringTable): bool {.nimcall.},
port = TPort(4000)) = port = TPort(4000)) =
## encapsulates the SCGI object and main loop. ## encapsulates the SCGI object and main loop.
var s: TScgiState var s: TScgiState
@ -142,7 +143,7 @@ proc run*(handleRequest: proc (client: TSocket, input: string,
proc open*(handleRequest: proc (server: var TAsyncScgiState, client: TSocket, proc open*(handleRequest: proc (server: var TAsyncScgiState, client: TSocket,
input: string, headers: PStringTable, input: string, headers: PStringTable,
userArg: PObject), userArg: PObject) {.nimcall.},
port = TPort(4000), address = "127.0.0.1", port = TPort(4000), address = "127.0.0.1",
userArg: PObject = nil): PAsyncScgiState = userArg: PObject = nil): PAsyncScgiState =
## Alternative of ``open`` for asyncio compatible SCGI. ## 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: set[T]): bool {.magic: "EqSet", noSideEffect.}
proc `==` *[T](x, y: ref T): bool {.magic: "EqRef", noSideEffect.} proc `==` *[T](x, y: ref T): bool {.magic: "EqRef", noSideEffect.}
proc `==` *[T](x, y: ptr 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 `<=` *[TEnum: enum](x, y: TEnum): bool {.magic: "LeEnum", noSideEffect.}
proc `<=` *(x, y: string): bool {.magic: "LeStr", 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 type
TDocument {.importc.} = object of TObject TDocument {.importc.} = object of TObject
write: proc (text: cstring) write: proc (text: cstring) {.nimcall.}
writeln: proc (text: cstring) writeln: proc (text: cstring) {.nimcall.}
createAttribute: proc (identifier: cstring): ref TNode createAttribute: proc (identifier: cstring): ref TNode {.nimcall.}
createElement: proc (identifier: cstring): ref TNode createElement: proc (identifier: cstring): ref TNode {.nimcall.}
createTextNode: proc (identifier: cstring): ref TNode createTextNode: proc (identifier: cstring): ref TNode {.nimcall.}
getElementById: proc (id: cstring): ref TNode getElementById: proc (id: cstring): ref TNode {.nimcall.}
getElementsByName: proc (name: cstring): seq[ref TNode] getElementsByName: proc (name: cstring): seq[ref TNode] {.nimcall.}
getElementsByTagName: proc (name: cstring): seq[ref TNode] getElementsByTagName: proc (name: cstring): seq[ref TNode] {.nimcall.}
TNodeType* = enum TNodeType* = enum
ElementNode = 1, ElementNode = 1,
@ -281,23 +281,23 @@ type
nodeValue*: cstring nodeValue*: cstring
parentNode*: ref TNode parentNode*: ref TNode
previousSibling*: ref TNode previousSibling*: ref TNode
appendChild*: proc (child: ref TNode) appendChild*: proc (child: ref TNode) {.nimcall.}
appendData*: proc (data: cstring) appendData*: proc (data: cstring) {.nimcall.}
cloneNode*: proc (copyContent: bool) cloneNode*: proc (copyContent: bool) {.nimcall.}
deleteData*: proc (start, len: int) deleteData*: proc (start, len: int) {.nimcall.}
getAttribute*: proc (attr: cstring): cstring getAttribute*: proc (attr: cstring): cstring {.nimcall.}
getAttributeNode*: proc (attr: cstring): ref TNode getAttributeNode*: proc (attr: cstring): ref TNode {.nimcall.}
getElementsByTagName*: proc (): seq[ref TNode] getElementsByTagName*: proc (): seq[ref TNode] {.nimcall.}
hasChildNodes*: proc (): bool hasChildNodes*: proc (): bool {.nimcall.}
insertBefore*: proc (newNode, before: ref TNode) insertBefore*: proc (newNode, before: ref TNode) {.nimcall.}
insertData*: proc (position: int, data: cstring) insertData*: proc (position: int, data: cstring) {.nimcall.}
removeAttribute*: proc (attr: cstring) removeAttribute*: proc (attr: cstring) {.nimcall.}
removeAttributeNode*: proc (attr: ref TNode) removeAttributeNode*: proc (attr: ref TNode) {.nimcall.}
removeChild*: proc (child: ref TNode) removeChild*: proc (child: ref TNode) {.nimcall.}
replaceChild*: proc (newNode, oldNode: ref TNode) replaceChild*: proc (newNode, oldNode: ref TNode) {.nimcall.}
replaceData*: proc (start, len: int, text: cstring) replaceData*: proc (start, len: int, text: cstring) {.nimcall.}
setAttribute*: proc (name, value: cstring) setAttribute*: proc (name, value: cstring) {.nimcall.}
setAttributeNode*: proc (attr: ref TNode) setAttributeNode*: proc (attr: ref TNode) {.nimcall.}
when defined(nodejs): when defined(nodejs):
proc ewriteln(x: cstring) = log(x) proc ewriteln(x: cstring) = log(x)

2
lib/windows/nb30.nim
View file

@ -21,7 +21,7 @@ const
type # Network Control Block type # Network Control Block
PNCB* = ptr TNCB 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 TNCB* {.final.} = object # Structure returned to the NCB command NCBASTAT is ADAPTER_STATUS followed
# by an array of NAME_BUFFER structures. # by an array of NAME_BUFFER structures.
ncb_command*: Char # command code ncb_command*: Char # command code

2
tests/compile/tnewlibs.nim
View file

@ -11,7 +11,7 @@ import
cairowin32, cairoxlib, cairowin32, cairoxlib,
gl, glut, glu, glx, glext, wingl, gl, glut, glu, glx, glext, wingl,
lua, lualib, lauxlib, mysql, sqlite3, db_mongo, md5, asyncio, mimetypes, 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") 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), # in Nimrod proc (x: TB) is compatible to proc (x: TA),
# but this is not type safe: # 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 var a: TA
f(a) # bp expects a TB, but gets 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 = proc nothing(x, y: void): void =
echo "ha" 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: when T is void:
p() p()
else: else:

2
tests/run/tgenericprocvar.nim
View file

@ -18,7 +18,7 @@ threadProcWrapper[int]()
threadProcWrapper[bool]() threadProcWrapper[bool]()
type 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] = proc filter[T,D](data: seq[T], env:D, pred: TFilterProc[T,D]): seq[T] =
result = @[] result = @[]

6
tests/run/toop1.nim
View file

@ -7,7 +7,7 @@ import macros
type type
TFigure = object of TObject # abstract base class: 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) = proc init(f: var TFigure) =
f.draw = nil f.draw = nil
@ -21,7 +21,7 @@ proc drawCircle(my: var TCircle) = stdout.writeln("o " & $my.radius)
proc init(my: var TCircle) = proc init(my: var TCircle) =
init(TFigure(my)) # call base constructor init(TFigure(my)) # call base constructor
my.radius = 5 my.radius = 5
my.draw = cast[proc (my: var TFigure)](drawCircle) my.draw = cast[proc (my: var TFigure) {.nimcall.}](drawCircle)
type type
TRectangle = object of TFigure TRectangle = object of TFigure
@ -33,7 +33,7 @@ proc init(my: var TRectangle) =
init(TFigure(my)) # call base constructor init(TFigure(my)) # call base constructor
my.width = 5 my.width = 5
my.height = 10 my.height = 10
my.draw = cast[proc (my: var TFigure)](drawRectangle) my.draw = cast[proc (my: var TFigure) {.nimcall.}](drawRectangle)
macro `!` (n: expr): stmt = macro `!` (n: expr): stmt =
result = newNimNode(nnkCall, n) result = newNimNode(nnkCall, n)

2
tests/run/topenarrayrepr.nim
View file

@ -3,7 +3,7 @@ discard """
output: "5 - [1]" output: "5 - [1]"
""" """
type type
TProc = proc (n: int, m: openarray[int64]) TProc = proc (n: int, m: openarray[int64]) {.nimcall.}
proc Foo(x: int, P: TProc) = proc Foo(x: int, P: TProc) =
P(x, [ 1'i64 ]) P(x, [ 1'i64 ])

2
tests/run/toverl2.nim
View file

@ -16,7 +16,7 @@ iterator toverl2(x: int): int =
inc(res) inc(res)
var var
pp: proc (x: bool): string = toverl2 pp: proc (x: bool): string {.nimcall.} = toverl2
stdout.write(pp(true)) stdout.write(pp(true))