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