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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
echo T.func: test user-defined functions
awk=${awk-../a.out}
echo '10 2
2 10
10 10
10 1e1
1e1 9' | $awk '
# tests whether function returns sensible type bits
function assert(cond) { # assertion
if (cond) print 1; else print 0
}
function i(x) { return x }
{ m=$1; n=i($2); assert(m>n) }
' >foo1
echo '1
0
0
0
1' >foo2
diff foo1 foo2 || echo 'BAD: T.func (function return type)'
echo 'data: data' >foo1
$awk '
function test1(array) { array["test"] = "data" }
function test2(array) { return(array["test"]) }
BEGIN { test1(foo); print "data: " test2(foo) }
' >foo2
diff foo1 foo2 || echo 'BAD: T.func (array type)'
$awk '
BEGIN { code() }
END { codeout("x") }
function code() { ; }
function codeout(ex) { print ex }
' /dev/null >foo1
echo x >foo2
diff foo1 foo2 || echo 'BAD: T.func (argument passing)'
$awk '
BEGIN { unireghf() }
function unireghf(hfeed) {
hfeed[1]=0
rcell("foo",hfeed)
hfeed[1]=0
rcell("bar",hfeed)
}
function rcell(cellname,hfeed) {
print cellname
}
' >foo1
echo "foo
bar" >foo2
diff foo1 foo2 || echo 'BAD: T.func (convert arg to array)'
$awk '
function f(n) {
if (n <= 1)
return 1
else
return n * f(n-1)
}
{ print f($1) }
' <<! >foo2
0
1
2
3
4
5
6
7
8
9
!
cat <<! >foo1
1
1
2
6
24
120
720
5040
40320
362880
!
diff foo1 foo2 || echo 'BAD: T.func (factorial)'
$awk '
function ack(m,n) {
k = k+1
if (m == 0) return n+1
if (n == 0) return ack(m-1, 1)
return ack(m-1, ack(m, n-1))
}
{ k = 0; print ack($1,$2), "(" k " calls)" }
' <<! >foo2
0 0
1 1
2 2
3 3
3 4
3 5
!
cat <<! >foo1
1 (1 calls)
3 (4 calls)
7 (27 calls)
61 (2432 calls)
125 (10307 calls)
253 (42438 calls)
!
diff foo1 foo2 || echo 'BAD: T.func (ackermann)'
$awk '
END { print "end" }
{ print fib($1) }
function fib(n) {
if (n <= 1) return 1
else return add(fib(n-1), fib(n-2))
}
function add(m,n) { return m+n }
BEGIN { print "begin" }
' <<! >foo2
1
3
5
10
!
cat <<! >foo1
begin
1
3
8
89
end
!
diff foo1 foo2 || echo 'BAD: T.func (fib)'
$awk '
function foo() {
for (i = 1; i <= 2; i++)
return 3
print "should not see this"
}
BEGIN { foo(); exit }
' >foo1
grep 'should not' foo1 && echo 'BAD: T.func (return)'
# this exercises multiple free of temp cells
echo 'eqn
eqn2' >foo1
$awk 'BEGIN { eprocess("eqn", "x", contig)
process("tbl" )
eprocess("eqn" "2", "x", contig)
}
function eprocess(file, first, contig) {
print file
}
function process(file) {
close(file)
}' >foo2
diff foo1 foo2 || echo 'BAD: T.func (eqn)'
echo 1 >foo1
$awk 'function f() { n = 1; exit }
BEGIN { n = 0; f(); n = 2 }; END { print n}' >foo2
diff foo1 foo2 || echo 'BAD: T.func (exit in function)'
echo 1 >foo1
$awk '
BEGIN { n = 10
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
x[i,j] = n * i + j
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if ((i,j) in x)
k++
print (k == n^2)
}
' >foo2
diff foo1 foo2 || echo 'BAD: T.func (multi-dim subscript)'
echo '<> 0' >foo1
$awk '
function foo() { i = 0 }
BEGIN { x = foo(); printf "<%s> %d\n", x, x }' >foo2
diff foo1 foo2 || echo 'BAD: T.func (fall off end)'
|
