// grammar{} -- define Pratt parser rules
// prefix, infix, and statement rules parse YOUR language's source

grammar {
  // Statement rule: say "text";
  rule stmt.say {
    expect keyword.say;
    let text: string = currentText();
    advance();
    let nd: handle = getResultNode();
    setAttr(nd, "message", text);
    requireToken("delimiter.semi");
  }

  // Statement rule: let x = expr;
  rule stmt.var_decl {
    expect keyword.let;
    let name: string = currentText();
    advance();
    requireToken("operator.assign");
    parseExpr();
    requireToken("delimiter.semi");
  }

  // Infix rule: a + b
  rule infix.add {
    trigger operator.plus;
    precedence = 50;
    parseExpr(precedence);
  }
}

// semantics{} -- analysis passes over the AST
// Scope management, symbol declaration, type checking

semantics {
  on stmt.var_decl {
    let name: string = getAttr(node, "name");

    // Check for duplicate declaration
    if scopeHas(name) {
      diagError("duplicate: " + name, node);
    }

    // Declare in current scope
    scopeDeclare(name, "variable");

    // Walk child nodes (the initializer expression)
    walkChildren(node);
  }

  on expr.identifier {
    let name: string = getAttr(node, "name");
    if !scopeHas(name) {
      diagError("undeclared: " + name, node);
    }
  }

  on stmt.say {
    // Validate: no-op for this simple language
  }
}

// emitters{} -- walk the AST, emit output
// For native compilation, emit MIR instructions

emitters {
  on stmt.say {
    let msg: string = getAttr(node, "message");
    // Strip surrounding quotes
    let text: string = substr(msg, 1, len(msg) - 2);
    let text_nl: string = text + "\n";

    // Emit string data into MIR
    let str_name: string = "msg_" + toString(g_str_count);
    mirString(str_name, text_nl);
    g_str_count = g_str_count + 1;

    // Emit: call printf with the string
    mirInsn("call", "p_printf",
           "printf", "_", str_name);
  }
}

// MIR -- a virtual CPU assembly language
// Written inline or built programmatically by emitters

mir {
  m0: module
    import printf, ExitProcess
    export main

    p_printf: proto void, p:fmt, ...
    p_exit:   proto void, i32:code

    msg: string "Hello MIR!\n"

    main: func i64
      local i64:n
      mov  n, 0
      add  n, n, 1
      call p_printf, printf, msg
      call p_exit, ExitProcess, 0
      ret  n
    endfunc
  endmodule
}

// on-handlers lower each MIR event to real x64:
mir {
  on module {
    g_ib = ib_create();
    g_cb = cb_create(1024);
    g_db = db_create();
  }
  on func {
    cb_emit_sub_rsp_imm8(g_cb, 0x28);
  }
  on insn {
    if opcode == "call" {
      cb_emit_call_rip_disp32(g_cb);
    }
  }
  on endfunc {
    cb_emit_add_rsp_imm8(g_cb, 0x28);
    cb_emit_ret(g_cb);
  }
  on endmodule {
    let image: map = pe_build_exe(...);
    bufSave(image, exe_path);
    ExitCode = runPE(exe_path);
  }
}

// Buffer builtins make binary data construction possible
// This is how PE/ELF images are built from script

let buf: any = buffer(4096);

// Write PE DOS header
bufWriteU16(buf, 0, 0x5A4D);      // MZ signature
bufWriteU32(buf, 0x3C, 0x80);     // PE header offset

// Write PE signature
bufWriteU32(buf, 0x80, 0x00004550); // "PE\0\0"

// Write machine code directly
bufWriteU8(buf, offset, 0x48);     // REX.W prefix
bufWriteU8(buf, offset+1, 0x83);   // sub r/m64, imm8
bufWriteU8(buf, offset+2, 0xEC);   // ModRM: rsp
bufWriteU8(buf, offset+3, 0x28);   // 40 bytes shadow

// Copy between buffers
bufCopyBytes(dst, dst_off, src, src_off, count);

// Save to disk and execute
bufSave(buf, "output.exe");
let code: int = runPE("output.exe");

// The .lvm scripting language is Turing-complete
// Variables, control flow, routines, data structures

let count: int = 0;
let names: list = ["alpha", "beta", "gamma"];
let config: map = {"debug": true, "level": 3};

// For loop with range
for i = 0 to len(names) - 1 {
  println(names[i]);
}

// While loop
while count < 10 {
  count = count + 1;
  if count == 5 { continue; }
  println(toString(count));
}

// Routines with return values
routine fib(n: int): int {
  if n <= 1 { return n; }
  return fib(n - 1) + fib(n - 2);
}

println("fib(10) = " + toString(fib(10)));