test.vd

func exit(no: int)

func asserti(actual: int, expected: int) {
  if actual != expected {
    exit(1)
  }
}

func assertb(actual: bool, expected: bool) {
  if actual != expected {
    exit(1)
  }
}

func hoge(): int {
  return 1 * 2 + 3 * 4
}

func fuga(): int {
  return 3 * 4 + 1 * hoge()
}

func addf(a: int, b: int): int {
  return a + b
}

func fib(n: int): int {
  if n <= 1 {
    return n
  } else {
    return fib(n - 1) + fib(n - 2)
  }
}

func // hoge
test1(): // bool
int {
  /*/ return 0
  /*/
  return 1
}

func test2(): int {
  hoge()hoge()hoge()hoge()hoge()
  return 1
}

func test3(): int {
  return 1
  if true {
    return 0
  }
}

func test4(arr: *int): int {
  return arr[2]
}

func _test5_(_x_: int): int {
  return _x_
}

var global1: int
var global2: byte[2]

func main(): int {
  asserti(0, 0)
  asserti(42, 42)
  asserti(0x08, 8)
  asserti(0xff, 255)

  asserti(1 + 2, 3)
  asserti(1 + 2 + 3, 6)
  asserti(6 - 1, 5)
  asserti(20 - 5 + 2, 17)

  asserti(2 * 2 * 5, 20)
  asserti(20 / 4, 5)
  asserti(1 + 2 * 3 + 5 / 1, 12)

  asserti(3 + 5 * 7, 38)
  asserti((3 + 5) * 7, 56)
  asserti(((1)), 1)

  asserti(--2, 2)
  asserti(-3 * -1, 3)

  asserti(3 % 2, 1)
  asserti(6 % 3, 0)

  asserti(1 & 0, 0)
  asserti(1 & 1, 1)
  asserti(0 | 0, 0)
  asserti(1 | 1, 1)
  asserti(1 ^ 1, 0)
  asserti(1 ^ 0, 1)

  assertb(0 == 1, false)
  assertb(1 == 1, true)
  assertb(0 != 1, true)
  assertb(1 != 1, false)

  assertb(1 < 1, false)
  assertb(0 < 1, true)
  assertb(2 <= 1, false)
  assertb(1 <= 1, true)
  assertb(1 > 1, false)
  assertb(2 > 1, true)
  assertb(0 >= 1, false)
  assertb(1 >= 1, true)
  assertb(!true, false)
  assertb(!false, true)


  {
    var i: int
    asserti(i, 0)
  }

  {
    var i: int
    if true {
      i = 1
    } else {
      i = 0
    }
    asserti(i, 1)
  }

  {
    var i: int
    if false {
      i = 1
    } else {
      i = 0
    }
    asserti(i, 0)
  }

  {
    var i: int
    if true {
      if true {
        i = 2
      } else {
        i = 1
      }
    } else {
      i = 0
    }
    asserti(i, 2)
  }

  {
    var i: int
    if true {
      if false {
        i = 2
      } else {
        i = 1
      }
    } else {
      i = 0
    }
    asserti(i, 1)
  }


  {
    var i: int
    if false {
      i = 0
    } else if false {
      i = 1
    } else {
      i = 2
    }
    asserti(i, 2)
  }

  {
    var a: int = 10
    asserti(a, 10)
  }

  {
    var a: int = 10
    var b: int = 5
    asserti(a + b, 15)
  }

  {
    var a: int = 10
    var b: int = a
    a = -10
    asserti(a + b, 0)
  }

  {
    var a: int = 10
    var b: int = a
    asserti(a + b, 20)
  }

  {
    var a: int = 0
    var i: int = 0
    while i <= 10 {
      a += i
      i += 1
    }
    asserti(a, 55)
  }

  {
    var a: int = 0
    var i: int = 0
    while i < 2 {
      var j: int = 0
      while j <= 10 {
        a = a + j
        j += 1
      }
      i += 1
    }
    asserti(a, 110)
  }

  asserti(test1(), 1)

  asserti(hoge() + fuga(), 40)

  asserti(test2(), 1)

  asserti(test3(), 1)

  asserti(addf(1, 2), 3)

  asserti(fib(5), 5)

  {
    var arr: int[10]
    var i: int = 0
    while i < 10 {
      asserti(arr[i], 0)
      arr[i] = i * 2
      asserti(arr[i], i * 2)
      i += 1
    }
  }

  {
    var a: int = 0
    var ap: *int = &a
    asserti(a, 0)
    asserti(*ap, 0)

    *ap = 1
    asserti(a, 1)
    asserti(*ap, 1)

    ap[0] = 2
    asserti(a, 2)
    asserti(*ap, 2)
  }

  {
    var a: int
    var ap: *int = &a
    var app: **int = &ap
    *ap = 3
    asserti(**app, 3)
  }

  {
    var arr: int[3]
    arr[0] = 0
    arr[1] = 1
    arr[2] = 2
    asserti(test4(arr), 2)
  }

  {
    var arr: bool[3]
    arr[0] = true
    arr[1] = false
    arr[2] = true
    assertb(arr[1], false)
  }
  
  {
    var arr: byte[3]
    arr[0] = 0 
    arr[1] = 1
    arr[2] = 2
    asserti(arr[1], 1)
  }

  asserti('a', 97)
  asserti('A', 65)
  asserti('\n', 10)
  asserti('\r', 13)
  asserti('\t', 9)
  asserti('\\', 92)
  asserti('\0', 0)
  asserti('A' + 3, 68)
  assertb('A' == 'A', true)
  assertb('A' != 'A', false)

  {
    var a: int = 0
    a += 2
    asserti(a, 2)
    a -= 1
    asserti(a, 1)
    a *= 8
    asserti(a, 8)
    a /= 2
    asserti(a, 4)
  }

  {
    var arr: int[2]
    arr[0] += 2
    asserti(arr[0], 2)
    arr[0] -= 1
    asserti(arr[0], 1)
    arr[0] *= 8
    asserti(arr[0], 8)
    arr[0] /= 2
    asserti(arr[0], 4)
  }

  {
    asserti(global1, 0)
    global1 = 10
    asserti(global1, 10)
  }

  {
    asserti(global2[0], 0)
    asserti(global2[1], 0)

    global2[0] = 2
    global2[1] = 4

    asserti(global2[0], 2)
    asserti(global2[1], 4)
  }

  {
    var str: *byte = "hoge\'\"\n"
    asserti(str[0], 'h')
    asserti(str[1], 'o')
    asserti(str[2], 'g')
    asserti(str[3], 'e')
    asserti(str[4], '\'')
    asserti(str[5], '\"')
    asserti(str[6], '\n')
  }

  {
    var _a_: int = 10
    asserti(_a_, 10)
    asserti(_test5_(5), 5)
  }

  return 0
}