summary refs log blame commit diff stats
path: root/tests/ccgbugs/tcvarargs.nim
blob: ebaf83a4ae901a6b761beb6cc3e6afd4c90c8ce8 (plain) (tree)

































                                              
discard """
  output: '''17
17
17
17
17
17
'''
"""

# bug #1593

{.emit: """
#include <stdarg.h>

void foo(int n, ...) {
  NI64 k;
  int i;
  va_list argp;
  va_start(argp, n);
  for (i = 1; i <= n; i++) {
    k = va_arg(argp, NI64);
    printf("%lld\n", (long long)k);
  }
  va_end(argp);
}
""".}

proc foo(x: cint) {.importc, varargs, nodecl.}

proc main() =
  const k = 17'i64
  foo(6, k, k, k, k, k, k)
main()
0e24d9696326b9bcc9'>^
346443d1b ^
d560e84fc ^
6ca3504df ^
d560e84fc ^
78b3f739b ^
543ec3797 ^
6ca3504df ^
d560e84fc ^
346443d1b ^
d560e84fc ^

6ca3504df ^
d560e84fc ^
346443d1b ^
d560e84fc ^
6ca3504df ^
d560e84fc ^
346443d1b ^
d560e84fc ^
6ca3504df ^
543ec3797 ^
346443d1b ^
543ec3797 ^
6ca3504df ^
543ec3797 ^
d560e84fc ^
f0341979b ^
1cc1a7faf ^
34401a363 ^

f0341979b ^




ebc02f6dc ^
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

 
                                  
                                         




                                                   
                                                                   
 
                                
                         

    
                                                         
                                           




                                           
                                
                   
 
                                             
                                                  
                 
 
                                        
                                                                
                              
 
                               
                             
                  
 
                               
                             
                  

 
                                           
                                              
                   
 
                                             
                                                  
                     
 
                                                       
                                            
                         
 
                                         
                                                     
                     
 
                                            

                                                                 




                 
                 
#
#
#            Nim's Runtime Library
#        (c) Copyright 2015 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

## This module contains Nim's support for locks and condition vars.

const insideRLocksModule = false
include "system/syslocks"

type
  Lock* = SysLock ## Nim lock; whether this is re-entrant
                  ## or not is unspecified!
  Cond* = SysCond ## Nim condition variable

{.deprecated: [TLock: Lock, TCond: Cond].}

proc initLock*(lock: var Lock) {.inline.} =
  ## Initializes the given lock.
  initSysLock(lock)

proc deinitLock*(lock: var Lock) {.inline.} =
  ## Frees the resources associated with the lock.
  deinitSys(lock)

proc tryAcquire*(lock: var Lock): bool =
  ## Tries to acquire the given lock. Returns `true` on success.
  result = tryAcquireSys(lock)

proc acquire*(lock: var Lock) =
  ## Acquires the given lock.
  acquireSys(lock)

proc release*(lock: var Lock) =
  ## Releases the given lock.
  releaseSys(lock)


proc initCond*(cond: var Cond) {.inline.} =
  ## Initializes the given condition variable.
  initSysCond(cond)

proc deinitCond*(cond: var Cond) {.inline.} =
  ## Frees the resources associated with the lock.
  deinitSysCond(cond)

proc wait*(cond: var Cond, lock: var Lock) {.inline.} =
  ## waits on the condition variable `cond`.
  waitSysCond(cond, lock)

proc signal*(cond: var Cond) {.inline.} =
  ## sends a signal to the condition variable `cond`.
  signalSysCond(cond)

template withLock*(a: Lock, body: untyped) =
  ## Acquires the given lock, executes the statements in body and
  ## releases the lock after the statements finish executing.
  a.acquire()
  {.locks: [a].}:
    try:
      body
    finally:
      a.release()