summary refs log tree commit diff stats
path: root/tests/vm/tnimnode.nim
diff options
context:
space:
mode:
authorLemonBoy <thatlemon@gmail.com>2018-06-25 15:56:13 +0200
committerLemonBoy <thatlemon@gmail.com>2018-06-25 15:56:13 +0200
commitf559e62e45b4be227d494e75fe82f571ee410840 (patch)
tree82a0acd835fa368046d0601f876c23345822cb4f /tests/vm/tnimnode.nim
parent95436893061176d51b1c11fdf5418b3ed17a8455 (diff)
downloadNim-f559e62e45b4be227d494e75fe82f571ee410840.tar.gz
Adjust some tests to make them pass
The non-scoped behaviour of static blocks was exploited by those tests,
replace all the variables declared whithin one with compileTime marked
ones.
Diffstat (limited to 'tests/vm/tnimnode.nim')
-rw-r--r--tests/vm/tnimnode.nim20
1 files changed, 9 insertions, 11 deletions
diff --git a/tests/vm/tnimnode.nim b/tests/vm/tnimnode.nim
index 188bac9bf..4210ab41d 100644
--- a/tests/vm/tnimnode.nim
+++ b/tests/vm/tnimnode.nim
@@ -4,14 +4,12 @@ proc assertEq(arg0,arg1: string): void =
   if arg0 != arg1:
     raiseAssert("strings not equal:\n" & arg0 & "\n" & arg1)
 
-static:
-  # a simple assignment of stmtList to another variable
-  var node: NimNode
-  # an assignment of stmtList into an array
-  var nodeArray: array[1, NimNode]
-  # an assignment of stmtList into a seq
-  var nodeSeq = newSeq[NimNode](2)
-
+# a simple assignment of stmtList to another variable
+var node {.compileTime.}: NimNode
+# an assignment of stmtList into an array
+var nodeArray {.compileTime.}: array[1, NimNode]
+# an assignment of stmtList into a seq
+var nodeSeq {.compileTime.} = newSeq[NimNode](2)
 
 proc checkNode(arg: NimNode; name: string): void {. compileTime .} =
   echo "checking ", name
@@ -35,10 +33,10 @@ proc checkNode(arg: NimNode; name: string): void {. compileTime .} =
 
   echo "OK"
 
-static:
-  # the root node that is used to generate the Ast
-  var stmtList: NimNode
+# the root node that is used to generate the Ast
+var stmtList {.compileTime.}: NimNode
 
+static:
   stmtList = newStmtList(nnkDiscardStmt.newTree(newEmptyNode()))
 
   checkNode(stmtList, "direct construction")
d1b10f1dde2c287ebe84ef37'>a654e4ec ^
3e1349d2 ^

dcc060c7 ^

a654e4ec ^





dcc060c7 ^

a654e4ec ^
15ed8cc1 ^

dcc060c7 ^

6c69569a ^
f918675c ^
dcc060c7 ^
f918675c ^
48835572 ^
dcc060c7 ^

48835572 ^

dcc060c7 ^


4690ce81 ^
6c69569a ^
ee67ca53 ^
4690ce81 ^
ee67ca53 ^
48835572 ^
4690ce81 ^

f918675c ^
48835572 ^












4690ce81 ^


dcc060c7 ^
f344b250 ^

1167f877 ^
dcc060c7 ^

1167f877 ^
f344b250 ^
dcc060c7 ^



f344b250 ^
dcc060c7 ^

f918675c ^
1167f877 ^
f918675c ^
dcc060c7 ^

f344b250 ^
dcc060c7 ^

f918675c ^


1167f877 ^
9d9da2ad ^
1167f877 ^

f918675c ^

dcc060c7 ^
1167f877 ^

4690ce81 ^

48835572 ^
dcc060c7 ^

f918675c ^


1167f877 ^
9d9da2ad ^
1167f877 ^

48835572 ^






f918675c ^
dcc060c7 ^
1167f877 ^







dcc060c7 ^


a654e4ec ^
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143



                                                                                          
                               

                                                
                                   

                                                                                         

                       
                                                                                                 
                                                                                            
                                      
                           

                              
                            

                             

                               

        





                               

       
                         

                                                                                                          

                                                           
                                           
                                                                                                       
       
                                                                                     
                                                                                                                                                                    

                         

                                                                                                                                             


   
                                                                       
                                           
                                                                                                        
       
                                                                                            
                                                                                                                                                                         

                         
                                                                                                       












                                                                                                                                                                         


   
                                                         

              
                                    

 
                                                             
                



              
                                                                                                                             

                                                
                                                                                                                                         
                                                                                                                                                                                   
                                                                                                         

 
                                                                                                                                                                     

                                                


                                                                                                           
                                                                                         
                                                                                                                                                                                            

                                                                                                                                   

                                                                                                         
                                                                                   

                                                                                                                         

 
                                                                                                                                                

                                                


                                                                                                           
                                                                                         
                                                                                                                                                                                            

                                                                                                                                   






                                                                                                      
                                                                                             
 







                                                                                                       


       
                                     
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - 070table.mu</title>
<meta name="Generator" content="Vim/7.4">
<meta name="plugin-version" content="vim7.4_v2">
<meta name="syntax" content="none">
<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy=">
<meta name="colorscheme" content="minimal">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
* { font-size: 12pt; font-size: 1em; }
.muData { color: #ffff00; }
.muControl { color: #c0a020; }
.Delimiter { color: #800080; }
.Comment { color: #9090ff; }
.Constant { color: #00a0a0; }
.Special { color: #c00000; }
.muRecipe { color: #ff8700; }
.muScenario { color: #00af00; }
-->
</style>

<script type='text/javascript'>
<!--

-->
</script>
</head>
<body>
<pre id='vimCodeElement'>
<span class="Comment"># A table is like an array, except that you can index it with arbitrary types</span>
<span class="Comment"># and not just non-negative whole numbers.</span>

<span class="muScenario">scenario</span> table-read-write [
  <span class="Constant">local-scope</span>
  tab:&amp;:table:num:num <span class="Special">&lt;-</span> new-table<span class="Constant"> 30</span>
  run [
    put-index tab,<span class="Constant"> 12</span>,<span class="Constant"> 34</span>
    60:num/<span class="Special">raw</span>, 61:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> index tab,<span class="Constant"> 12</span>
  ]
  memory-should-contain [
   <span class="Constant"> 60</span> <span class="Special">&lt;-</span><span class="Constant"> 34</span>
   <span class="Constant"> 61</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># found</span>
  ]
]

<span class="muScenario">scenario</span> table-read-write-non-integer [
  <span class="Constant">local-scope</span>
  tab:&amp;:table:text:num <span class="Special">&lt;-</span> new-table<span class="Constant"> 30</span>
  run [
    put-index tab, <span class="Constant">[abc def]</span>,<span class="Constant"> 34</span>
    1:num/<span class="Special">raw</span>, 2:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> index tab, <span class="Constant">[abc def]</span>
  ]
  memory-should-contain [
   <span class="Constant"> 1</span> <span class="Special">&lt;-</span><span class="Constant"> 34</span>
   <span class="Constant"> 2</span> <span class="Special">&lt;-</span><span class="Constant"> 1</span>  <span class="Comment"># found</span>
  ]
]

<span class="muScenario">scenario</span> table-read-not-found [
  <span class="Constant">local-scope</span>
  tab:&amp;:table:text:num <span class="Special">&lt;-</span> new-table<span class="Constant"> 30</span>
  run [
    1:num/<span class="Special">raw</span>, 2:bool/<span class="Special">raw</span> <span class="Special">&lt;-</span> index tab, <span class="Constant">[abc def]</span>
  ]
  memory-should-contain [
   <span class="Constant"> 1</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>
   <span class="Constant"> 2</span> <span class="Special">&lt;-</span><span class="Constant"> 0</span>  <span class="Comment"># not found</span>
  ]
]

<span class="muData">container</span> table:_key:_value [
  length:num
  capacity:num
  data:&amp;:@:table-row:_key:_value
]

<span class="muData">container</span> table-row:_key:_value [
  occupied?:bool
  key:_key
  value:_value
]

<span class="muRecipe">def</span> new-table capacity:num<span class="muRecipe"> -&gt; </span>result:&amp;:table:_key:_value [
  <span class="Constant">local-scope</span>
  <span class="Constant">load-ingredients</span>
  result <span class="Special">&lt;-</span> new <span class="Delimiter">{</span>(table _key _value): type<span class="Delimiter">}</span>
  data:&amp;:@:table-row:_key:_value <span class="Special">&lt;-</span> new <span class="Delimiter">{</span>(table-row _key _value): type<span class="Delimiter">}</span>, capacity
  *result <span class="Special">&lt;-</span> merge <span class="Constant">0/length</span>, capacity, data
]

<span class="muRecipe">def</span> put-index table:&amp;:table:_key:_value, key:_key, value:_value<span class="muRecipe"> -&gt; </span>table:&amp;:table:_key:_value [
  <span class="Constant">local-scope</span>
  <span class="Constant">load-ingredients</span>
  hash:num <span class="Special">&lt;-</span> hash key
  hash <span class="Special">&lt;-</span> abs hash
  capacity:num <span class="Special">&lt;-</span> get *table, <span class="Constant">capacity:offset</span>
  _, hash-key:num <span class="Special">&lt;-</span> divide-with-remainder hash, capacity
  hash-key <span class="Special">&lt;-</span> abs hash-key  <span class="Comment"># in case hash overflows from a double into a negative integer inside 'divide-with-remainder' above</span>
  table-data:&amp;:@:table-row:_key:_value <span class="Special">&lt;-</span> get *table, <span class="Constant">data:offset</span>
  x:table-row:_key:_value <span class="Special">&lt;-</span> index *table-data, hash-key
  occupied?:bool <span class="Special">&lt;-</span> get x, <span class="Constant">occupied?:offset</span>
  not-occupied?:bool <span class="Special">&lt;-</span> not occupied?:bool
  assert not-occupied?, <span class="Constant">[can't handle collisions yet]</span>
  new-row:table-row:_key:_value <span class="Special">&lt;-</span> merge <span class="Constant">1/true</span>, key, value
  *table-data <span class="Special">&lt;-</span> put-index *table-data, hash-key, new-row
]

<span class="muRecipe">def</span> index table:&amp;:table:_key:_value, key:_key<span class="muRecipe"> -&gt; </span>result:_value, found?:bool [
  <span class="Constant">local-scope</span>
  <span class="Constant">load-ingredients</span>
  hash:num <span class="Special">&lt;-</span> hash key
  hash <span class="Special">&lt;-</span> abs hash
  capacity:num <span class="Special">&lt;-</span> get *table, <span class="Constant">capacity:offset</span>
  _, hash-key:num <span class="Special">&lt;-</span> divide-with-remainder hash, capacity
  hash-key <span class="Special">&lt;-</span> abs hash-key  <span class="Comment"># in case hash overflows from a double into a negative integer inside 'divide-with-remainder' above</span>
  table-data:&amp;:@:table-row:_key:_value <span class="Special">&lt;-</span> get *table, <span class="Constant">data:offset</span>
  x:table-row:_key:_value <span class="Special">&lt;-</span> index *table-data, hash-key
  empty:&amp;:_value <span class="Special">&lt;-</span> new <span class="Constant">_value:type</span>
  result <span class="Special">&lt;-</span> copy *empty
  found?:bool <span class="Special">&lt;-</span> get x, <span class="Constant">occupied?:offset</span>
  <span class="muControl">return-unless</span> found?
  key2:_key <span class="Special">&lt;-</span> get x, <span class="Constant">key:offset</span>
  found?:bool <span class="Special">&lt;-</span> equal key, key2
  <span class="muControl">return-unless</span> found?
  result <span class="Special">&lt;-</span> get x, <span class="Constant">value:offset</span>
]

<span class="muRecipe">def</span> abs n:num<span class="muRecipe"> -&gt; </span>result:num [
  <span class="Constant">local-scope</span>
  <span class="Constant">load-ingredients</span>
  positive?:bool <span class="Special">&lt;-</span> greater-or-equal n,<span class="Constant"> 0</span>
  <span class="muControl">return-if</span> positive?, n
  result <span class="Special">&lt;-</span> multiply n,<span class="Constant"> -1</span>
]
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->