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()
}