Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package statements

var expr bool

func use(x interface{}) {}

// Formatting of if-statement headers.

func _() {

        if true {}

        if; true {}  // no semicolon printed

        if expr{}

        if;expr{}  // no semicolon printed

        if (expr){}  // no parens printed

        if;((expr)){}  // no semicolon and parens printed

        if x:=expr;true{

        use(x)}

        if x:=expr; expr {use(x)}

}

// Formatting of switch-statement headers.

func _() {

        switch {}

        switch;{}  // no semicolon printed

        switch expr {}

        switch;expr{}  // no semicolon printed

        switch (expr) {}  // no parens printed

        switch;((expr)){}  // no semicolon and parens printed

        switch x := expr; { default:use(

x)

        }

        switch x := expr; expr {default:use(x)}

}

// Formatting of switch statement bodies.

func _() {

        switch {

        }

        switch x := 0; x {

        case 1:

                use(x)

                use(x)  // followed by an empty line

        case 2:  // followed by an empty line

                use(x)  // followed by an empty line

        case 3:  // no empty lines

                use(x)

                use(x)

        }

        switch x {

        case 0:

                use(x)

        case 1:  // this comment should have no effect on the previous or next line

                use(x)

        }

        switch x := 0; x {

        case 1:

                x = 0

                // this comment should be indented

        case 2:

                x = 0

        // this comment should not be indented, it is aligned with the next case

        case 3:

                x = 0

                /* indented comment

                   aligned

                   aligned

                */

                // bla

                /* and more */

        case 4:

                x = 0

        /* not indented comment

           aligned

           aligned

        */

        // bla

        /* and more */

        case 5:

        }

}

// Formatting of selected select statements.

func _() {

        select {

        }

        select { /* this comment should not be tab-aligned because the closing } is on the same line */ }

        select { /* this comment should be tab-aligned */

        }

        select { // this comment should be tab-aligned

        }

        select { case <-c: }

}

// Formatting of for-statement headers.

func _() {

        for{}

        for expr {}

        for (expr) {}  // no parens printed

        for;;{}  // no semicolons printed

        for x :=expr;; {use( x)}

        for; expr;{}  // no semicolons printed

        for; ((expr));{}  // no semicolons and parens printed

        for; ; expr = false {}

        for x :=expr; expr; {use(x)}

        for x := expr;; expr=false {use(x)}

        for;expr;expr =false {

        }

        for x := expr;expr;expr = false { use(x) }

        for x := range []int{} { use(x) }

        for x := range (([]int{})) { use(x) }  // no parens printed

}

// Don't remove mandatory parentheses around composite literals in control clauses.

func _() {

        // strip parentheses - no composite literals or composite literals don't start with a type name

        if (x) {}

        if (((x))) {}

        if ([]T{}) {}

        if (([]T{})) {}

        if ; (((([]T{})))) {}

        for (x) {}

        for (((x))) {}

        for ([]T{}) {}

        for (([]T{})) {}

        for ; (((([]T{})))) ; {}

        switch (x) {}

        switch (((x))) {}

        switch ([]T{}) {}

        switch ; (((([]T{})))) {}

        for _ = range ((([]T{T{42}}))) {}

        // leave parentheses - composite literals start with a type name

        if (T{}) {}

        if ((T{})) {}

        if ; ((((T{})))) {}

        for (T{}) {}

        for ((T{})) {}

        for ; ((((T{})))) ; {}

        switch (T{}) {}

        switch ; ((((T{})))) {}

        for _ = range (((T1{T{42}}))) {}

        if x == (T{42}[0]) {}

        if (x == T{42}[0]) {}

        if (x == (T{42}[0])) {}

        if (x == (((T{42}[0])))) {}

        if (((x == (T{42}[0])))) {}

        if x == a + b*(T{42}[0]) {}

        if (x == a + b*T{42}[0]) {}

        if (x == a + b*(T{42}[0])) {}

        if (x == a + ((b * (T{42}[0])))) {}

        if (((x == a + b * (T{42}[0])))) {}

        if (((a + b * (T{42}[0])) == x)) {}

        if (((a + b * (T{42}[0])))) == x {}

        if (struct{x bool}{false}.x) {}

        if (struct{x bool}{false}.x) == false {}

        if (struct{x bool}{false}.x == false) {}

}

// Extra empty lines inside functions. Do respect source code line

// breaks between statement boundaries but print at most one empty

// line at a time.

func _() {

        const _ = 0

        const _ = 1

        type _ int

        type _ float

        var _ = 0

        var x = 1

        // Each use(x) call below should have at most one empty line before and after.

        // Known bug: The first use call may have more than one empty line before

        //            (see go/printer/nodes.go, func linebreak).

        use(x)

        if x < x {

                use(x)

        } else {

                use(x)

        }

}

// Formatting around labels.

func _() {

        L:

}

func _() {

        // this comment should be indented

        L: ;  // no semicolon needed

}

func _() {

        switch 0 {

        case 0:

                L0: ;  // semicolon required

        case 1:

                L1: ;  // semicolon required

        default:

                L2: ;  // no semicolon needed

        }

}

func _() {

        f()

L1:

        f()

L2:

        ;

L3:

}

func _() {

        // this comment should be indented

        L:

}

func _() {

        L: _ = 0

}

func _() {

        // this comment should be indented

        L: _ = 0

}

func _() {

        for {

        L1: _ = 0

        L2:

                _ = 0

        }

}

func _() {

                // this comment should be indented

        for {

        L1: _ = 0

        L2:

                _ = 0

        }

}

func _() {

        if true {

                _ = 0

        }

        _ = 0  // the indentation here should not be affected by the long label name

AnOverlongLabel:

        _ = 0

        if true {

                _ = 0

        }

        _ = 0

L:      _ = 0

}

func _() {

        for {

                goto L

        }

L:

        MoreCode()

}

func _() {

        for {

                goto L

        }

L:      // A comment on the same line as the label, followed by a single empty line.

        // Known bug: There may be more than one empty line before MoreCode()

        //            (see go/printer/nodes.go, func linebreak).

        MoreCode()

}

func _() {

        for {

                goto L

        }

L:

        // There should be a single empty line before this comment.

        MoreCode()

}

func _() {

        for {

                goto AVeryLongLabelThatShouldNotAffectFormatting

        }

AVeryLongLabelThatShouldNotAffectFormatting:

        // There should be a single empty line after this comment.

        // There should be a single empty line before this comment.

        MoreCode()

}