// #target: x64-darwin
module examples;

import std::io;

func void example_for()
{
    // the for-loop is the same as C99.
    for (int i = 0; i < 10; i++)
    {
        io::printf("%d\n", i);
    }

    // also equal
    for (;;)
    {
        // ..
    }
}

enum Height : uint
{
    LOW = 0,
    MEDIUM,
    HIGH,
}

func void demo_enum(Height h)
{
    switch (h)
    {
        case LOW:
        case MEDIUM:
            io::println("Not high");
            // Implicit break.
        case HIGH:
            io::println("High");
    }

    // This also works
    switch (h)
    {
        case LOW:
        case MEDIUM:
            io::println("Not high");
            // Implicit break.
        case Height.HIGH:
            io::println("High");
    }

    // Completely empty cases are not allowed.
    switch (h)
    {
        case LOW:
            break; // Explicit break required, since switches can't be empty.
        case MEDIUM:
            io::println("Medium");
        case HIGH:
            break;
    }

    // special checking of switching on enum types
    switch (h)
    {
        case LOW:
        case MEDIUM:
        case HIGH:
            break;
        default:    // warning: default label in switch which covers all enumeration value
            break;
    }

    // Using "nextcase" will fallthrough to the next case statement,
    // and each case statement starts its own scope.
    switch (h)
    {
        case LOW:
            int a = 1;
            io::println("A");
            nextcase;
        case MEDIUM:
            int a = 2;
            io::println("B");
            nextcase;
        case HIGH:
            // a is not defined here
            io::println("C");
    }
}
// #expect: examples.ll

define void @examples.example_for() #0 {
entry:
  %i = alloca i32, align 4
  store i32 0, i32* %i, align 4
  br label %for.cond

for.cond:                                         ; preds = %for.inc, %entry
  %0 = load i32, i32* %i, align 4
  %lt = icmp slt i32 %0, 10
  br i1 %lt, label %for.body, label %for.exit

for.body:                                         ; preds = %for.cond
  %1 = load i32, i32* %i, align 4
  %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %1)
  br label %for.inc

for.inc:                                          ; preds = %for.body
  %3 = load i32, i32* %i, align 4
  %add = add i32 %3, 1
  store i32 %add, i32* %i, align 4
  br label %for.cond

for.exit:                                         ; preds = %for.cond
  br label %infiniteloop

infiniteloop:                                     ; preds = %infiniteloop, %for.exit
  br label %infiniteloop
}

; Function Attrs: nounwind
define void @examples.demo_enum(i32 %0) #0 {
entry:
  %h = alloca i32, align 4
  %switch = alloca i32, align 4
  %switch2 = alloca i32, align 4
  %switch7 = alloca i32, align 4
  %switch13 = alloca i32, align 4
  %switch17 = alloca i32, align 4
  %a = alloca i32, align 4
  %a21 = alloca i32, align 4
  store i32 %0, i32* %h, align 4
  %1 = load i32, i32* %h, align 4
  store i32 %1, i32* %switch, align 4
  br label %switch.entry

switch.entry:                                     ; preds = %entry
  %2 = load i32, i32* %switch, align 4
  switch i32 %2, label %switch.exit [
    i32 0, label %switch.case
    i32 1, label %switch.case
    i32 2, label %switch.case1
  ]

switch.case:                                      ; preds = %switch.entry, %switch.entry
  %3 = call i32 @"std::io.println"(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i32 0, i32 0)) #1
  br label %switch.exit

switch.case1:                                     ; preds = %switch.entry
  %4 = call i32 @"std::io.println"(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i32 0, i32 0)) #1
  br label %switch.exit

switch.exit:                                      ; preds = %switch.case1, %switch.case, %switch.entry
  %5 = load i32, i32* %h, align 4
  store i32 %5, i32* %switch2, align 4
  br label %switch.entry3

switch.entry3:                                    ; preds = %switch.exit
  %6 = load i32, i32* %switch2, align 4
  switch i32 %6, label %switch.exit6 [
    i32 0, label %switch.case4
    i32 1, label %switch.case4
    i32 2, label %switch.case5
  ]

switch.case4:                                     ; preds = %switch.entry3, %switch.entry3
  %7 = call i32 @"std::io.println"(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i32 0, i32 0)) #1
  br label %switch.exit6

switch.case5:                                     ; preds = %switch.entry3
  %8 = call i32 @"std::io.println"(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i32 0, i32 0)) #1
  br label %switch.exit6

switch.exit6:                                     ; preds = %switch.case5, %switch.case4, %switch.entry3
  %9 = load i32, i32* %h, align 4
  store i32 %9, i32* %switch7, align 4
  br label %switch.entry8

switch.entry8:                                    ; preds = %switch.exit6
  %10 = load i32, i32* %switch7, align 4
  switch i32 %10, label %switch.exit12 [
    i32 0, label %switch.case9
    i32 1, label %switch.case10
    i32 2, label %switch.case11
  ]

switch.case9:                                     ; preds = %switch.entry8
  br label %switch.exit12

switch.case10:                                    ; preds = %switch.entry8
  %11 = call i32 @"std::io.println"(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i32 0, i32 0)) #1
  br label %switch.exit12

switch.case11:                                    ; preds = %switch.entry8
  br label %switch.exit12

switch.exit12:                                    ; preds = %switch.case11, %switch.case10, %switch.case9, %switch.entry8
  %12 = load i32, i32* %h, align 4
  store i32 %12, i32* %switch13, align 4
  br label %switch.entry14

switch.entry14:                                   ; preds = %switch.exit12
  %13 = load i32, i32* %switch13, align 4
  switch i32 %13, label %switch.default [
    i32 0, label %switch.case15
    i32 1, label %switch.case15
    i32 2, label %switch.case15
  ]

switch.case15:                                    ; preds = %switch.entry14, %switch.entry14, %switch.entry14
  br label %switch.exit16

switch.default:                                   ; preds = %switch.entry14
  br label %switch.exit16

switch.exit16:                                    ; preds = %switch.default, %switch.case15
  %14 = load i32, i32* %h, align 4
  store i32 %14, i32* %switch17, align 4
  br label %switch.entry18

switch.entry18:                                   ; preds = %switch.exit16
  %15 = load i32, i32* %switch17, align 4
  switch i32 %15, label %switch.exit23 [
    i32 0, label %switch.case19
    i32 1, label %switch.case20
    i32 2, label %switch.case22
  ]

switch.case19:                                    ; preds = %switch.entry18
  store i32 1, i32* %a, align 4
  %16 = call i32 @"std::io.println"(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i32 0, i32 0)) #1
  br label %switch.case20

switch.case20:                                    ; preds = %switch.entry18, %switch.case19
  store i32 2, i32* %a21, align 4
  %17 = call i32 @"std::io.println"(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i32 0, i32 0)) #1
  br label %switch.case22

switch.case22:                                    ; preds = %switch.entry18, %switch.case20
  %18 = call i32 @"std::io.println"(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i32 0, i32 0)) #1
  br label %switch.exit23

switch.exit23:                                    ; preds = %switch.case22, %switch.entry18
  ret void
}