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