compiler.asm

section .data
    input_buffer db 256 dup(0)
    output_buffer db 2048 dup(0)
    token_buffer db 64 dup(0)
    
    err_syntax db "Syntax error", 10, 0
    err_div_zero db "Division by zero", 10, 0
    err_invalid_char db "Invalid character", 10, 0
    
    asm_header db "section .data", 10
              db "section .text", 10
              db "global _start", 10
              db "_start:", 10, 0
              
    asm_footer db "    mov eax, 60", 10
              db "    mov edi, 0", 10
              db "    syscall", 10, 0
              
    mov_rax db "    mov rax, ", 0
    add_rax db "    add rax, ", 0
    sub_rax db "    sub rax, ", 0
    mul_rax db "    imul rax, ", 0
    div_setup db "    mov rdx, 0", 10, "    mov rbx, ", 0
    div_rax db "    idiv rbx", 10, 0
    newline db 10, 0
    
    reg_counter dq 0

section .bss
    input_ptr resq 1
    output_ptr resq 1
    current_token resq 1
    token_type resq 1
    token_value resq 1

section .text
global _start

%define TOKEN_NUMBER 1
%define TOKEN_PLUS 2  
%define TOKEN_MINUS 3
%define TOKEN_MUL 4
%define TOKEN_DIV 5
%define TOKEN_LPAREN 6
%define TOKEN_RPAREN 7
%define TOKEN_EOF 8

_start:
    call read_input
    
    mov rax, input_buffer
    mov [input_ptr], rax
    mov rax, output_buffer
    mov [output_ptr], rax
    
    call write_header
    
    call get_next_token
    call parse_expression
    
    call write_footer
    
    call write_output
    
    mov eax, 60
    mov edi, 0
    syscall

read_input:
    mov eax, 0         
    mov edi, 0        
    mov rsi, input_buffer
    mov rdx, 255
    syscall
    
    mov byte [input_buffer + rax], 0
    ret

write_output:
    mov rsi, output_buffer
    call strlen
    mov rdx, rax
    
    mov eax, 1          ; sys_write
    mov edi, 1          ; stdout
    mov rsi, output_buffer
    syscall
    ret

strlen:
    mov rax, 0
.loop:
    cmp byte [rsi + rax], 0
    je .done
    inc rax
    jmp .loop
.done:
    ret

skip_whitespace:
    mov rsi, [input_ptr]
.loop:
    mov al, [rsi]
    cmp al, ' '
    je .skip
    cmp al, '\t'
    je .skip
    cmp al, '\n'
    je .skip
    cmp al, '\r'
    je .skip
    jmp .done
.skip:
    inc rsi
    jmp .loop
.done:
    mov [input_ptr], rsi
    ret

is_digit:
    cmp al, '0'
    jl .no
    cmp al, '9'
    jg .no
    mov rax, 1
    ret
.no:
    mov rax, 0
    ret

parse_number:
    mov rax, 0          ; result
    mov rsi, [input_ptr]
.loop:
    mov bl, [rsi]
    mov al, bl
    call is_digit
    test rax, rax
    jz .done
    
    mov rax, [token_value]
    mov rcx, 10
    mul rcx
    movzx rdx, bl
    sub rdx, '0'
    add rax, rdx
    mov [token_value], rax
    
    inc rsi
    jmp .loop
.done:
    mov [input_ptr], rsi
    ret

get_next_token:
    call skip_whitespace
    
    mov rsi, [input_ptr]
    mov al, [rsi]
    
    test al, al
    jz .eof
    
    call is_digit
    test rax, rax
    jnz .number
    
    cmp al, '+'
    je .plus
    cmp al, '-'
    je .minus
    cmp al, '*'
    je .mul
    cmp al, '/'
    je .div
    cmp al, '('
    je .lparen
    cmp al, ')'
    je .rparen
    
    call error_invalid_char
    
.eof:
    mov qword [token_type], TOKEN_EOF
    ret
    
.number:
    mov qword [token_type], TOKEN_NUMBER
    mov qword [token_value], 0
    call parse_number
    ret
    
.plus:
    mov qword [token_type], TOKEN_PLUS
    inc rsi
    mov [input_ptr], rsi
    ret
    
.minus:
    mov qword [token_type], TOKEN_MINUS
    inc rsi
    mov [input_ptr], rsi
    ret
    
.mul:
    mov qword [token_type], TOKEN_MUL
    inc rsi
    mov [input_ptr], rsi
    ret
    
.div:
    mov qword [token_type], TOKEN_DIV
    inc rsi
    mov [input_ptr], rsi
    ret
    
.lparen:
    mov qword [token_type], TOKEN_LPAREN
    inc rsi
    mov [input_ptr], rsi
    ret
    
.rparen:
    mov qword [token_type], TOKEN_RPAREN
    inc rsi
    mov [input_ptr], rsi
    ret

parse_expression:
    call parse_term
    
.loop:
    mov rax, [token_type]
    cmp rax, TOKEN_PLUS
    je .add
    cmp rax, TOKEN_MINUS
    je .sub
    ret
    
.add:
    call get_next_token
    call parse_term
    call emit_add
    jmp .loop
    
.sub:
    call get_next_token  
    call parse_term
    call emit_sub
    jmp .loop

parse_term:
    call parse_factor
    
.loop:
    mov rax, [token_type]
    cmp rax, TOKEN_MUL
    je .mul
    cmp rax, TOKEN_DIV
    je .div
    ret
    
.mul:
    call get_next_token
    call parse_factor
    call emit_mul
    jmp .loop
    
.div:
    call get_next_token
    call parse_factor
    call emit_div
    jmp .loop

parse_factor:
    mov rax, [token_type]
    cmp rax, TOKEN_NUMBER
    je .number
    cmp rax, TOKEN_LPAREN
    je .paren
    call error_syntax
    
.number:
    mov rax, [token_value]
    call emit_load_immediate
    call get_next_token
    ret
    
.paren:
    call get_next_token
    call parse_expression
    
    mov rax, [token_type]
    cmp rax, TOKEN_RPAREN
    jne .syntax_error
    call get_next_token
    ret
    
.syntax_error:
    call error_syntax

emit_load_immediate:
    call append_string_mov_rax
    call append_number
    call append_newline
    ret

emit_add:
    call append_string_add
    call append_newline
    ret

emit_sub:
    call append_string_sub
    call append_newline
    ret

emit_mul:
    call append_string_mul
    call append_newline
    ret

emit_div:
    call append_string_div_setup
    call append_string_div
    ret

append_string_mov_rax:
    mov rsi, mov_rax
    call append_string
    ret

append_string_add:
    mov rsi, add_rax
    call append_string
    mov rsi, token_buffer
    call append_string
    ret

append_string_sub:
    mov rsi, sub_rax  
    call append_string
    mov rsi, token_buffer
    call append_string
    ret

append_string_mul:
    mov rsi, mul_rax
    call append_string
    mov rsi, token_buffer
    call append_string
    ret

append_string_div_setup:
    mov rsi, div_setup
    call append_string
    mov rsi, token_buffer
    call append_string
    call append_newline
    ret

append_string_div:
    mov rsi, div_rax
    call append_string
    ret

append_string:
    mov rdi, [output_ptr]
.loop:
    mov al, [rsi]
    test al, al
    jz .done
    mov [rdi], al
    inc rsi
    inc rdi
    jmp .loop
.done:
    mov [output_ptr], rdi
    ret

append_number:
    mov rax, [token_value]
    call number_to_string
    ret

append_newline:
    mov rsi, newline
    call append_string
    ret

number_to_string:
    mov rbx, 10
    mov rcx, 0          ; digit count
    mov rdx, [output_ptr]
    
    test rax, rax
    jnz .convert
    mov byte [rdx], '0'
    inc rdx
    mov [output_ptr], rdx
    ret
    
.convert:
    push rdx
.digit_loop:
    test rax, rax
    jz .reverse
    mov rdx, 0
    div rbx
    add rdx, '0'
    push rdx
    inc rcx
    jmp .digit_loop
    
.reverse:
    pop rdx            
.write_loop:
    test rcx, rcx
    jz .done
    pop rax
    mov [rdx], al
    inc rdx
    dec rcx
    jmp .write_loop
.done:
    mov [output_ptr], rdx
    ret

write_header:
    mov rsi, asm_header
    call append_string
    ret

write_footer:
    mov rsi, asm_footer
    call append_string
    ret

error_syntax:
    mov eax, 1
    mov edi, 2          ; stderr
    mov rsi, err_syntax
    mov rdx, 13
    syscall
    mov eax, 60
    mov edi, 1
    syscall

error_invalid_char:
    mov eax, 1
    mov edi, 2
    mov rsi, err_invalid_char
    mov rdx, 17
    syscall
    mov eax, 60
    mov edi, 1
    syscall

error_div_zero:
    mov eax, 1
    mov edi, 2
    mov rsi, err_div_zero
    mov rdx, 15
    syscall
    mov eax, 60
    mov edi, 1
    syscall