// Regression test: exercises grammar constructs documented in grammar/chaiscript.ebnf

// --- Variable declarations ---
var a = 1
auto b = 2
global c = 3
const d = 42

assert_equal(1, a)
assert_equal(2, b)
assert_equal(3, c)
assert_equal(42, d)

// --- Reference variables ---
var orig = 10
var &ref = orig
ref = 20
assert_equal(20, orig)

// --- Numeric literals ---
assert_equal(255, 0xFF)
assert_equal(255, 0xff)
assert_equal(5, 0b101)
assert_equal(42, 42)
assert_equal(3.14, 3.14)

// --- String interpolation ---
var name = "world"
assert_equal("hello world", "hello ${name}")

// --- Escape sequences ---
assert_equal("\n", "\n")
assert_equal("\t", "\t")

// --- Single-quoted char ---
assert_equal('A', 'A')

// --- Operators and precedence ---
assert_equal(7, 1 + 2 * 3)
assert_equal(true, 5 > 3 && 2 < 4)
assert_equal(true, false || true)
assert_equal(6, 3 << 1)
assert_equal(1, 3 >> 1)
assert_equal(5, 7 & 5)
assert_equal(7, 5 | 3)
assert_equal(6, 5 ^ 3)
assert_equal(-1, ~0)

// --- Ternary operator ---
assert_equal("yes", true ? "yes" : "no")
assert_equal("no", false ? "yes" : "no")

// --- Prefix operators ---
var x = 5
++x
assert_equal(6, x)
--x
assert_equal(5, x)
assert_equal(true, !false)

// --- Assignment operators ---
var v = 10
v += 5; assert_equal(15, v)
v -= 3; assert_equal(12, v)
v *= 2; assert_equal(24, v)
v /= 4; assert_equal(6, v)
v %= 4; assert_equal(2, v)
v <<= 2; assert_equal(8, v)
v >>= 1; assert_equal(4, v)
v |= 3; assert_equal(7, v)
v &= 5; assert_equal(5, v)
v ^= 3; assert_equal(6, v)

// --- Lambda ---
var add = fun(a, b) { a + b }
assert_equal(5, add(2, 3))

// --- Lambda with capture ---
var captured = 100
var get_captured = fun[captured]() { captured }
assert_equal(100, get_captured())

// --- Function definition ---
def multiply(a, b) { a * b }
assert_equal(12, multiply(3, 4))

// --- Guard condition on function ---
def abs_val(x) : x >= 0 { x }
def abs_val(x) : x < 0 { -x }
assert_equal(5, abs_val(5))
assert_equal(5, abs_val(-5))

// --- Class definition ---
class Animal
{
  attr sound
  def Animal(s) { this.sound = s }
  def speak() { this.sound }
}

var dog = Animal("woof")
assert_equal("woof", dog.speak())

// --- Class with inheritance ---
class Puppy : Animal
{
  attr name
  def Puppy(n, s) { this.name = n; this.sound = s }
  def greet() { to_string(this.name) + " says " + to_string(this.speak()) }
}

var p = Puppy("Rex", "yip")
assert_equal("Rex says yip", p.greet())

// --- Control flow: if/else ---
var result = ""
if (true) { result = "yes" } else { result = "no" }
assert_equal("yes", result)

// --- Control flow: while ---
var counter = 0
while (counter < 3) { ++counter }
assert_equal(3, counter)

// --- Control flow: for ---
var sum = 0
for (var i = 0; i < 5; ++i) { sum += i }
assert_equal(10, sum)

// --- Control flow: ranged for ---
var items = [10, 20, 30]
var total = 0
for (item : items) { total += item }
assert_equal(60, total)

// --- Switch/case ---
def classify(n) {
  var label = ""
  switch (n) {
    case (1) { label = "one"; break }
    case (2) { label = "two"; break }
    default { label = "other" }
  }
  return label
}
assert_equal("one", classify(1))
assert_equal("two", classify(2))
assert_equal("other", classify(99))

// --- Try/catch/finally ---
var caught = false
var finalized = false
try {
  throw("oops")
} catch (e) {
  caught = true
} finally {
  finalized = true
}
assert_true(caught)
assert_true(finalized)

// --- Inline containers ---
var vec = [1, 2, 3]
assert_equal(3, vec.size())

var m = ["a": 1, "b": 2]
assert_equal(1, m["a"])

var r = [1, 2, 3, 4, 5]
assert_equal(5, r.size())

// --- Dot access chaining ---
assert_equal(3, [1, 2, 3].size())

// --- Array access ---
var arr = [10, 20, 30]
assert_equal(20, arr[1])

// --- Backtick identifier ---
var `my var` = 42
assert_equal(42, `my var`)

// --- Special identifiers ---
assert_equal(true, true)
assert_equal(false, false)

// --- Nested block ---
var block_result = 0
{ block_result = 42 }
assert_equal(42, block_result)

// --- Break and continue ---
var break_sum = 0
for (var i = 0; i < 10; ++i) {
  if (i == 5) { break }
  break_sum += i
}
assert_equal(10, break_sum)

var cont_sum = 0
for (var i = 0; i < 5; ++i) {
  if (i == 2) { continue }
  cont_sum += i
}
assert_equal(8, cont_sum)

// --- Return from function ---
def early_return(n) {
  if (n > 0) { return "positive" }
  return "non-positive"
}
assert_equal("positive", early_return(1))
assert_equal("non-positive", early_return(-1))

// --- Colon assignment ---
var ca = 0
ca := 99
assert_equal(99, ca)