#include <iostream>

#include <assembler/compiler.h>
#include <assembler.h>

int
main (int argc, char *argv[])
{
  compiler comp;
  // compile a named file "-" is stdin
  comp.compile (argc > 1 ? argv[1] : "-");
  // do some semantic checks such as whether all used
  // instructions actually exist, whether all arguments
  // are correctly typed, whether
  comp.check ();
  // store the parse tree into a string and load it back
  // to test whether serialisation works
  // deserialisation, by the way, generates the same AST the
  // parser did, so comp.check () could be done again to verify
  // the byte-code
  comp.load (comp.store ());
  // print out the AST in the same format it was read
  // (lightning asm). this output could be stored to a file
  // and is basically a disassembly of the byte-code
  std::cout << "Printing the parse tree back into lightning-asm:\n";
  std::cout << "------------------------------------------------\n";
  comp.print (std::cout);

  // assembler is an object whose only job is to transform
  // lightning-asm to machine code. it utilises lightning's
  // jit_* macros to do so
  assembler as;
  // generate machine code
  comp.assemble (as);
  // print a disassembly of the generated code to stdout
  std::cout << "\nPrinting a disassembly of the machine code:\n";
  std::cout << "-------------------------------------------\n";
  as.disassemble (std::cout);

  // assembler::cast can cast to any pointer type. before it does
  // so, it calls jit::flush_code.
  int (*func) (int) = as.cast ();
  // call the function
  std::cout << "\nCalling the function:\n";
  std::cout << "---------------------\n";
  std::cout << func (32) << '\n';

  return 0;
}

/* This is the input file I fed it:

# mnemonic      op1             op2             op3     ret
prolog          1
arg_ui                                                  => $in
getarg_ui       %v0,            $in                                   # V0 = n
blti_ui         !forward,       %v0,            2       => @ref       # If V0 < 2, jump
subi_ui         %v1,            %v0,            1                     # V1 = n - 1
subi_ui         %v2,            %v0,            2                     # V2 = n - 2
prepare_i       1                                                     # Prepare for a call with one argument
pusharg_ui      %v1                                                   # Push the argument
finish          @self         # The self-pointer is a pointer to the
                              # beginning of the code block (entry point).
                              # This instruction jumps to the beginning of the
                              # code, causing recursion

retval_i        %v1                                   # Store the result in V1
prepare_i       1                                     # Another
pusharg_ui      %v2                                   # recursive
finish          @self                                 # call
retval_i        %v2                                   # Store the result in V2
addi_ui         %v1,            %v1,            1     # V1++
addr_ui         %ret,           %v1,            %v2   # RET = V1 + V2
ret                                                   # Return

patch           @ref                                  # Patch jump, we get here if V0 was < 2
movi_i          %ret,           1                     # RET = 1
ret                                                   # Return

 */

/* This is the output of the program on my x86_64 machine:

Printing the parse tree back into lightning-asm:
------------------------------------------------
prolog 1
arg_ui => $in
getarg_ui %v0, $in
blti_ui !forward, %v0, 2 => @ref
subi_ui %v1, %v0, 1
subi_ui %v2, %v0, 2
prepare_i 1
pusharg_ui %v1
finish @self
retval_i %v1
prepare_i 1
pusharg_ui %v2
finish @self
retval_i %v2
addi_ui %v1, %v1, 1
addr_ui %ret, %v1, %v2
ret
patch @ref
movi_i %ret, 1
ret

Printing a disassembly of the machine code:
-------------------------------------------
0000000000000000 53                       push %rbx
0000000000000001 41 54                    push %r12
0000000000000003 41 55                    push %r13
0000000000000005 55                       push %rbp
0000000000000006 48 89 e5                 mov %rsp, %rbp
0000000000000009 89 fb                    mov %edi, %ebx
000000000000000b 83 fb 02                 cmp $0x2, %ebx
000000000000000e 0f 82 55 00 00 00        jb 0x69
0000000000000014 8d 73 ff                 lea -0x1(%rbx), %esi
0000000000000017 8d 7b fe                 lea -0x2(%rbx), %edi
000000000000001a 49 89 f0                 mov %rsi, %r8
000000000000001d 49 bb 48 3a 1f 8d ff 7f  mov $0x7fff8d1f3a48, %r11
               - 00 00
0000000000000027 49 89 f4                 mov %rsi, %r12
000000000000002a 49 89 fd                 mov %rdi, %r13
000000000000002d 4c 89 c7                 mov %r8, %rdi
0000000000000030 49 ff d3                 callq %r11
0000000000000033 4c 89 e6                 mov %r12, %rsi
0000000000000036 4c 89 ef                 mov %r13, %rdi
0000000000000039 89 c6                    mov %eax, %esi
000000000000003b 49 89 f8                 mov %rdi, %r8
000000000000003e 49 bb 48 3a 1f 8d ff 7f  mov $0x7fff8d1f3a48, %r11
               - 00 00
0000000000000048 49 89 f4                 mov %rsi, %r12
000000000000004b 49 89 fd                 mov %rdi, %r13
000000000000004e 4c 89 c7                 mov %r8, %rdi
0000000000000051 49 ff d3                 callq %r11
0000000000000054 4c 89 e6                 mov %r12, %rsi
0000000000000057 4c 89 ef                 mov %r13, %rdi
000000000000005a 89 c7                    mov %eax, %edi
000000000000005c 83 c6 01                 add $0x1, %esi
000000000000005f 8d 04 3e                 lea (%rsi,%rdi), %eax
0000000000000062 5d                       pop %rbp
0000000000000063 41 5d                    pop %r13
0000000000000065 41 5c                    pop %r12
0000000000000067 5b                       pop %rbx
0000000000000068 c3                       ret
0000000000000069 b8 01 00 00 00           mov $0x1, %eax
000000000000006e 5d                       pop %rbp
000000000000006f 41 5d                    pop %r13
0000000000000071 41 5c                    pop %r12
0000000000000073 5b                       pop %rbx
0000000000000074 c3                       ret

Calling the function:
---------------------
7049155

 */