# emit_decl.ludic — functions, main, and the whole-program driver. A function's
# body is built into a scratch buffer so entry-block allocas can be spliced in
# ahead of it (see emit_alloca). Returns go through a %retval slot + `ret` label.

fn emit_params_sig(d: Node) -> void {
  var i = 0
  while i < len(d.kids) {
    if i > 0 { emit(", ") }
    emit(llty(d.kids[i].ty));  emit(" %arg_");  emit(d.kids[i].s)
    i = i + 1
  }
}

fn emit_fn(d: Node) -> void {
  ll_t = 0;  ll_lbl = 0;  g_term = false;  loc_reset();  nloop = 0
  ret_ty = d.ty
  let fbody = buf_new()
  falloc = buf_new()
  let saved = code
  code = fbody
  let rl = llty(ret_ty)
  if not (rl == "void") { buf_puts(falloc, "  %retval = alloca ");  buf_puts(falloc, rl);  buf_puts(falloc, "\n") }
  # params: store each incoming argument into a stack slot
  var i = 0
  while i < len(d.kids) {
    let p = d.kids[i]
    let slot = emit_alloca(llty(p.ty))
    emit("  store ");  emit(llty(p.ty));  emit(" %arg_");  emit(p.s);  emit(", ptr ");  emit(slot);  emit("\n")
    loc_push(p.s, slot, p.ty)
    i = i + 1
  }
  emit_block(d.a)
  if not g_term { emit("  br label %ret\n") }
  emit("ret:\n")
  if (rl == "void") { emit("  ret void\n") }
  else { let r = emit_bind(("load " + (rl + (", ptr %retval"))));  emit("  ret ");  emit(rl);  emit(" ");  emit(r);  emit("\n") }
  code = saved
  emit("define ");  emit(rl);  emit(" @fn_");  emit(d.s);  emit("(");  emit_params_sig(d);  emit(") {\nentry:\n")
  emit(buf_str(falloc))
  emit(buf_str(fbody))
  emit("}\n\n")
}

fn emit_main(d: Node) -> void {
  ll_t = 0;  ll_lbl = 0;  g_term = false;  loc_reset();  nloop = 0
  ret_ty = "int"
  let fbody = buf_new()
  falloc = buf_new()
  let saved = code
  code = fbody
  buf_puts(falloc, "  %retval = alloca i32\n")
  emit("  store i32 %argc, ptr @L_argc\n")
  emit("  store ptr %argv, ptr @L_argv\n")
  emit("  store i32 0, ptr %retval\n")
  emit_block(d.a)
  if not g_term { emit("  br label %ret\n") }
  emit("ret:\n")
  let r = emit_bind("load i32, ptr %retval")
  emit("  ret i32 ");  emit(r);  emit("\n")
  code = saved
  emit("define i32 @main(i32 %argc, ptr %argv) {\nentry:\n")
  emit(buf_str(falloc))
  emit(buf_str(fbody))
  emit("}\n")
}

fn emit_program() -> void {
  head = buf_new()
  code = buf_new()
  g_uses_str = false
  g_uses_intstr = false
  loc_name = new []ptr;  loc_reg = new []ptr;  loc_ty = new []ptr;  loc_mut = new []int
  brk_lbl = new []ptr;   cnt_lbl = new []ptr
  self_stk = new []ptr
  mach_stk = new []Node
  emit_header()
  if has_ecs() { emit_ecs_storage() }
  var i = 0
  while i < len(prog) { if prog[i].kind == N_FN { emit_fn(prog[i]) };  i = i + 1 }
  if has_ecs() { emit_ecs_allocator();  emit_snapshot() }
  if has_ui() { emit_ui_build() }
  if has_systems() { emit_game_main() }
  else {
    i = 0
    while i < len(prog) { if prog[i].kind == N_MAIN { emit_main(prog[i]) };  i = i + 1 }
  }
  if g_uses_str { emit_str_prelude() }          # @fn_str_eq / @fn_str_concat, after all uses are seen
  if g_uses_intstr { emit_int_str() }           # @fn_int_str, for str(int) in interpolation
}

# Flush the emitted IR. With a null path it goes to stdout (the pipe the shell
# drivers read); with a path it is written to that file so ludicc can hand it to
# clang itself.
fn ir_flush(path: ptr) -> bool {
  let h = buf_str(head)
  let c = buf_str(code)
  if (path == null) {                             # raw IR to stdout (no trailing newline)
    let out = file_stdout()
    file_write(out, h, slen(h))
    file_write(out, c, slen(c))
    return true
  }
  let f = file_open(path, "wb")
  if (f == null) { return false }
  file_write(f, h, slen(h))
  file_write(f, c, slen(c))
  file_close(f)
  return true
}