package a

import (
	"unsafe"
)

func recurse(i int, s []byte) byte {
	s[0] = byte(i)
	if i == 0 {
		return s[i]
	} else {
		var a [1024]byte
		r := recurse(i-1, a[:])
		return r + a[0]
	}
}

//go:uintptrescapes
func F1(a uintptr) {
	var s [16]byte
	recurse(4096, s[:])
	*(*int)(unsafe.Pointer(a)) = 42
}

//go:uintptrescapes
func F2(a ...uintptr) {

        class Recurse {
            void recurse(Element annotatedElement) {
                annotatedElement.getAnnotationMirrors().forEach(annotationMirror -> {
                    Element element = annotationMirror.getAnnotationType().asElement();
                    if (element instanceof TypeElement && result.add(annotationMirror)) {
                        recurse(element);
                    }
                });

            else -> { error("Unhandled language result type: ${current.javaClass.simpleName}") }
        }
    }
    return buildString { recurse(languageResult, startDepth) }
}


fun prettyPrintLanguageTree(languageTreeElement: LanguageTreeElement): String {
    fun StringBuilder.recurse(current: LanguageTreeElement, depth: Int) {
        fun indent() = "    ".repeat(depth)
        fun nextIndent() = "    ".repeat(depth + 1)

	// to be the address of i.
	// v is also the address of i.
	// p has a base type which is marked not-in-heap, so it
	// should not be adjusted when the stack is copied.
	recurse(100, p, v)
}
func recurse(n int, p *S, v uintptr) {
	if n > 0 {
		recurse(n-1, p, v)
	}
	if uintptr(unsafe.Pointer(p)) != v {
		panic("adjusted notinheap pointer")
	}

                        append(nextIndent() + it.key.name + " = ")
                        recurse(it.value.value, depth + 1)
                        append("\n")
                    }
                    current.addedObjects.forEach {
                        append("${nextIndent()}+ ")
                        recurse(it, depth + 1)
                        append("\n")
                    }

    }
  }

  @Benchmark
  public boolean timeFindCaller(int reps) {
    return timeFindCaller(reps, recursionCount);
  }

  private boolean timeFindCaller(int reps, int recurse) {
    return recurse > 0 ? timeFindCaller(reps, recurse - 1) : mode.timeIt(reps, breakAt);
  }

    }
  }

  @Benchmark
  public boolean timeFindCaller(int reps) {
    return timeFindCaller(reps, recursionCount);
  }

  private boolean timeFindCaller(int reps, int recurse) {
    return recurse > 0 ? timeFindCaller(reps, recurse - 1) : mode.timeIt(reps, breakAt);
  }

		{testBuckets[0], "newPrefix0", "newPrefix0", nil},
		{testBuckets[0], "newPrefix1", "newPrefix1", nil},
		{testBuckets[0], "newzen/zen/recurse/again/again/again/pics", "recurse", nil},
		{testBuckets[0], "obj0", "obj0", nil},
		{testBuckets[0], "obj1", "obj1", nil},
		{testBuckets[0], "obj2", "obj2", nil},
		{testBuckets[1], "obj1", "obj1", nil},

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// gc used to recurse infinitely when dowidth is applied
// to a broken recursive type again.
// See golang.org/issue/9432.
package p

type foo struct { // ERROR "invalid recursive type|cycle"
	bar  foo
	blah foo

            def found = [] as List<Operation>
            def recurse
            recurse = { List<Operation> children ->
                children.each { child ->
                    if (filter.isSatisfiedBy(child)) {
                        found << child
                    }
                    recurse child.children
                }
            }
            recurse children
            found
        }