Method compileLoop

src/core/compileLoop.go:12–172

compileLoop compiles an endless loop.

(node *ast.Loop)

// compileLoop compiles an endless loop.
func (f *Function) compileLoop(node *ast.Loop) error {
	f.Count.Loop++
	headLabel := f.CreateLabel("loop.head", f.Count.Loop)
	exitLabel := f.CreateLabel("loop.exit", f.Count.Loop)
	beforeLoop := f.Block()
	loopHead := ssa.NewBlock(headLabel)
	loopExit := ssa.NewBlock(exitLabel)
	loopBlockIndex := len(f.Blocks)

	loop := &Loop{
		Head: loopHead,
		Exit: loopExit,
	}

	if node.Head != nil {
		// Before the loop starts, we evaluate the lower limit
		// and identify it as the loop counter.
		name, from, to := f.parseLoopHeader(node.Head)

		if from == nil {
			return errors.New(InvalidLoopHeader, f.File, node.Head.Source())
		}

		loop.IteratorName = name
		fromValue, err := f.evaluateRight(from)

		if err != nil {
			return err
		}

		if !types.Is(fromValue.Type(), types.AnyInt) {
			return errors.New(&TypeMismatch{Encountered: fromValue.Type().Name(), Expected: types.AnyInt.Name()}, f.File, from.Source())
		}

		if f.Block().IsIdentified(fromValue) {
			fromValue = f.copy(fromValue, from.Source())
		}

		beforeLoop.Identify(name, fromValue)
		f.jump(loopHead)

		// Loop starts, this is the jump target for new iterations.
		// The upper limit is recalculated on every iteration.
		// We check that the condition to jump to the loop body is true,
		// otherwise we jump to the loop exit.
		f.AddBlock(loopHead)
		toValue, err := f.evaluateRight(to)

		if err != nil {
			return err
		}

		if !types.Is(toValue.Type(), fromValue.Type()) {
			return errors.New(&TypeMismatch{Encountered: toValue.Type().Name(), Expected: fromValue.Type().Name()}, f.File, to.Source())
		}

		condition := f.Append(&ssa.BinaryOp{
			Op:    token.Less,