program
# s1 - Contains the current position in the source text.

import dummy

const
	SOURCE_BUFFER_SIZE := 40960

var
	source_code: [40960]Byte

# Ignores the import.
proc _compile_import()
var loca0: Word
begin
	_advance(6)
	_skip_spaces()
	loca0 := _read_token()
	_advance(loca0) # Skip the imported module name.
end

proc _build_binary_expression()
begin
	_build_expression(0)

	_skip_spaces()
	call _read_token
	sw a0, 20(sp)

	li t0, 0x26 # &
	sw t0, 16(sp)
	mv a0, s1
	lw a1, 20(sp)
	addi a2, sp, 16
	call _token_compare
	beqz a0, .L_build_binary_expression_and

	li t0, 0x3d # =
	sw t0, 16(sp)
	mv a0, s1
	lw a1, 20(sp)
	addi a2, sp, 16
	call _token_compare
	beqz a0, .L_build_binary_expression_equal

	/* DEBUG
	mv a0, s1
	li a1, 8
	call _write_error */

	j .Lbuild_binary_expression_end

.L_build_binary_expression_equal:
	addi s1, s1, 1 # Skip =.
	_build_expression(1)
	li t0, 0x0a3161 # a1\n
	sw t0, 16(sp)
	li t0, 0x202c3061 # a0,_
	sw t0, 12(sp)
	li t0, 0x202c3061 # a0,_
	sw t0, 8(sp)
	li t0, 0x20627573 # sub_
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 15
	call _write_out

	li t0, 0x0a306120 # _a0\n
	sw t0, 16(sp)
	li t0, 0x2c306120 # _a0,
	sw t0, 12(sp)
	li t0, 0x7a716573 # seqz
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 12
	call _write_out

	j .Lbuild_binary_expression_end

.L_build_binary_expression_and:
	addi s1, s1, 1 # Skip &.
	_build_expression(1)
	li t0, 0x0a3161 # a1\n
	sw t0, 16(sp)
	li t0, 0x202c3061 # a0,_
	sw t0, 12(sp)
	li t0, 0x202c3061 # a0,_
	sw t0, 8(sp)
	li t0, 0x20646e61 # and_
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 15
	call _write_out

	j .Lbuild_binary_expression_end

.Lbuild_binary_expression_end:
end

# Evalutes an expression and saves the result in a0.
#
# a0 - X in aX, the register number to save the result.
proc _build_expression()
begin
	addi a0, a0, '0' # Make the register number to a character.
	sw a0, 20(sp) # And save it.

	_skip_spaces()
	call _read_token
	sw s1, 16(sp)
	sw a0, 12(sp)

	# Integer literal.
	addi a0, s1, 0
	lbu a0, (a0)
	call _is_digit
	bnez a0, .Lbuild_expression_literal

	addi a0, s1, 0
	lbu a0, (a0)
	li t0, 0x5f # _
	beq a0, t0, .Lbuild_expression_call

	li t0, 0x61636f6c # loca
	sw t0, 8(sp)
	mv a0, s1
	addi a1, sp, 8
	li a2, 4
	call _memcmp
	beqz a0, .Lbuild_expression_identifier

	# Named identifier.
	lw t1, 20(sp)
	li t0, 0x00202c00 # \0,_
	or t0, t0, t1
	sw t0, 8(sp)
	li t0, 0x6120616c # la a
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 7
	call _write_out

	lw a0, 16(sp)
	lw a1, 12(sp)
	call _write_out

	li t0, 0x0a # \n
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 1
	call _write_out

	goto .Lbuild_expression_advance

	.Lbuild_expression_identifier
	lw t1, 20(sp)
	li t0, 0x00202c00 # \0,_
	or t0, t0, t1
	sw t0, 8(sp)
	li t0, 0x6120776c # lw a
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 7
	call _write_out

	lw a0, 16(sp)
	lw a1, 12(sp)
	addi a0, a0, 4 # Skip the "loca" variable prefix.
	addi a1, a1, -4 # Skip the "loca" variable prefix.
	call _write_out

	li t0, 0x0a # \n
	sw t0, 8(sp)
	li t0, 0x29707328 # (sp)
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 5
	call _write_out

	goto .Lbuild_expression_advance

	.Lbuild_expression_call
	lw a0, 16(sp)
	lw a1, 12(sp)
	add s1, s1, a1
	addi s1, s1, 1
	call _compile_call

	goto .Lbuild_expression_end

	.Lbuild_expression_literal
	lw t1, 20(sp)
	li t0, 0x00202c00 # \0,_
	or t0, t0, t1
	sw t0, 8(sp)
	li t0, 0x6120696c # li a
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 7
	call _write_out

	lw a0, 16(sp)
	lw a1, 12(sp)
	call _write_out

	li t0, 0x0a # \n
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 1
	call _write_out

	goto .Lbuild_expression_advance

	.Lbuild_expression_advance
	lw a0, 12(sp)
	add s1, s1, a0

	.Lbuild_expression_end
end

# Compiles a statement beginning with an identifier.
#
# Left values should be variables named "loca n", where n is the offset
# of the variable on the stack, like loca8 or loca4.
proc _compile_identifier()
begin
	call _read_token

	# Save the pointer to the identifier and its length on the stack.
	sw s1, 20(sp)
	sw a0, 16(sp)

	add s1, s1, a0
	_skip_spaces()
	call _read_token

	# Save the pointer and the length of the token following the identifier.
	sw s1, 12(sp)
	sw a0, 8(sp)

	add s1, s1, a0 # Skip that token.
	_skip_spaces()

	li t0, 0x3d3a # :=
	sw t0, 4(sp)
	lw a0, 12(sp)
	lw a1, 8(sp)
	addi a2, sp, 4
	call _token_compare
	beqz a0, .Lcompile_identifier_assign

	lw t0, 12(sp)
	lbu t0, (t0)
	li t1, 0x28 # (
	beq t0, t1, .Lcompile_identifier_call

	goto .Lcompile_identifier_end

	.Lcompile_identifier_call
	lw a0, 20(sp)
	lw a1, 16(sp)
	call _compile_call

	goto .Lcompile_identifier_end

	.Lcompile_identifier_assign
	_build_binary_expression()

	li t0, 0x202c30 # 0,_
	sw t0, 12(sp)
	li t0, 0x61207773 # sw a
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 7
	call _write_out

	lw a0, 20(sp)
	lw a1, 16(sp)
	addi a0, a0, 4 # Skip the "loca" variable prefix.
	addi a1, a1, -4 # Skip the "loca" variable prefix.
	call _write_out

	li t0, 0x0a # \n
	sw t0, 12(sp)
	li t0, 0x29707328 # (sp)
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 5
	call _write_out

	goto .Lcompile_identifier_end

	.Lcompile_identifier_end
end

# Compiles a procedure call. Expects s1 to point to the first argument.
# a0 - Pointer to the procedure name.
# a1 - Length of the procedure name.
#
# Returns the procedure result in a0.
proc _compile_call()
begin
	sw a0, 20(sp)
	sw a1, 16(sp)
	sw zero, 12(sp) # Argument count for a procedure call.

	.Lcompile_call_paren
	_skip_spaces()
	call _read_token
	lbu t0, (s1)
	li t1, 0x29 # )
	beq t0, t1, .Lcompile_call_complete

	.Lcompile_call_argument
	_build_expression(0)

	li t0, 0x202c30 # 0,_
	sw t0, 8(sp)
	li t0, 0x61207773 # sw a
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 7
	call _write_out

	lw t0, 12(sp) # Argument count for a procedure call.

	# Only 6 arguments are supported with a0-a5.
	# Save all arguments on the stack so they aren't overriden afterwards.
	# The offset on the stack always has two digits in this case.
	li t1, -4
	mul t1, t0, t1
	addi t1, t1, 60
	li t2, 10
	div t3, t1, t2
	rem t4, t1, t2
	addi t3, t3, '0'
	addi t4, t4, '0'

	sw t3, 8(sp)
	sw t4, 4(sp)

	addi a0, sp, 8
	li a1, 1
	call _write_out

	addi a0, sp, 4
	li a1, 1
	call _write_out

	li t0, 0x0a # \n
	sw t0, 8(sp)
	li t0, 0x29707328 # (sp)
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 5
	call _write_out

	_skip_spaces()
	call _read_token
	lbu t0, (s1)
	li t1, ','
	bne t0, t1, .Lcompile_call_paren

	lw t0, 12(sp) # Argument count for a procedure call.
	addi t0, t0, 1
	sw t0, 12(sp)

	_advance(1) # Skip the comma between the arguments.
	goto .Lcompile_call_argument

	.Lcompile_call_complete
	sw zero, 12(sp)

	.Lcompile_call_restore
	# Just go through all a0-a5 registers and read them from stack.
	# If this stack value contains garbage, the procedure just shouldn't use it.
	lw t0, 12(sp)
	li t1, 5
	bgt t0, t1, .Lcompile_call_perform

	li t0, 0x6120776c # lw a
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 4
	call _write_out

	lw t0, 12(sp) # Argument count for a procedure call.

	li t1, -4
	mul t1, t0, t1
	addi t1, t1, 60
	li t2, 10
	div t3, t1, t2
	rem t4, t1, t2
	addi t3, t3, '0'
	addi t4, t4, '0'
	addi t0, t0, '0'

	li t5, 0x0a # \n
	sb t5, 11(sp)
	li t5, 0x29707328 # (sp)
	sw t5, 7(sp)
	sb t4, 6(sp)
	sb t3, 5(sp)
	li t5, 0x202c # ,_
	sh t5, 3(sp)
	sb t0, 2(sp)

	addi a0, sp, 2
	li a1, 10
	call _write_out

	lw t0, 12(sp) # Increment.
	addi t0, t0, 1
	sw t0, 12(sp)

	goto .Lcompile_call_restore

	.Lcompile_call_perform
	li t0, 0x20
	sw t0, 8(sp)
	li t0, 0x6c6c6163
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 5
	call _write_out

	lw a0, 20(sp)
	lw a1, 16(sp)
	call _write_out

	li t0, 0x0a # \n
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 1
	call _write_out

	_skip_spaces()
	_advance(1) # Skip the close paren.
end

# Reads a token and returns its length in a0.
# _read_token doesn't change s1, it finds the length of the token s1 is pointing to.
proc _read_token()
begin
	lbu t0, (s1) # t0 = Current character.
	sw zero, 4(sp)

	li t1, '.'
	beq t0, t1, .Ltoken_character_single

	li t1, ','
	beq t0, t1, .Ltoken_character_single

	li t1, ':'
	beq t0, t1, .Ltoken_character_colon

	li t1, ';'
	beq t0, t1, .Ltoken_character_single

	li t1, '('
	beq t0, t1, .Ltoken_character_single

	li t1, ')'
	beq t0, t1, .Ltoken_character_single

	li t1, '['
	beq t0, t1, .Ltoken_character_single

	li t1, ']'
	beq t0, t1, .Ltoken_character_single

	li t1, '^'
	beq t0, t1, .Ltoken_character_single

	li t1, '&'
	beq t0, t1, .Ltoken_character_single

	li t1, '='
	beq t0, t1, .Ltoken_character_single
	# Expect an identifier or a number.
	.Ltoken_character_loop_do
	lw t6, 4(sp)
	add t1, s1, t6
	lbu a0, (t1) # a0 = Current character.

	call _is_alnum

	beqz a0, .Ltoken_character_end
	lw t6, 4(sp)
	addi t6, t6, 1
	sw t6, 4(sp)
	goto .Ltoken_character_loop_do

	.Ltoken_character_single
	lw t6, 4(sp)
	addi t6, t6, 1
	sw t6, 4(sp)
	goto .Ltoken_character_end

	.Ltoken_character_colon
	lbu t0, 1(s1) # t0 = The character after the colon.
	lw t6, 4(sp)
	addi t6, t6, 1
	sw t6, 4(sp)

	li t1, '='
	beq t0, t1, .Ltoken_character_single
	goto .Ltoken_character_end

	.Ltoken_character_end
	lw a0, 4(sp)
end

# Skips the spaces till the next non space character.
proc _skip_spaces()
begin
	.Lspace_loop_do
	lbu t0, (s1) # t0 = Current character.

	li t1, ' '
	beq t0, t1, .Lspace_loop_repeat
	li t1, '\t'
	beq t0, t1, .Lspace_loop_repeat
	li t1, '\n'
	beq t0, t1, .Lspace_loop_repeat
	li t1, '\r'
	beq t0, t1, .Lspace_loop_repeat

	goto .Lspace_loop_end
	.Lspace_loop_repeat
	_advance(1)
	goto .Lspace_loop_do

	.Lspace_loop_end
end

# Skips tabs at the line beginning.
proc _skip_indentation()
begin
	.Lskip_indentation_do
	lbu t0, (s1)

	li t1, '\t'
	beq t0, t1, .Lskip_indentation_skip

	goto .Lskip_indentation_end

	.Lskip_indentation_skip
	_advance(1)
	goto .Lskip_indentation_do

	.Lskip_indentation_end
end

# Parameters:
# a0 - Line length.
proc _skip_comment(loca84: Word)
begin
	_advance(loca84)
	_advance(1) # Skip the new line.
end

# Parameters:
# a0 - Line length.
proc _compile_assembly(loca84: Word)
var loca0: ^Byte
begin
	# Write the source to the standard output.
	loca0 := _current()

	_write_out(loca0, loca84)
	_advance(loca84)

	li t0, '\n'
	sb t0, 0(sp)
	addi a0, sp, 0
	li a1, 1
	call _write_out

	_advance(1) # Skip the new line.
end

proc _compile_program()
begin
	# .global _start
	li t0, 0x0a7472 # rt\n
	sw t0, 20(sp)
	li t0, 0x6174735f # _sta
	sw t0, 16(sp)
	li t0, 0x206c6162 # bal_
	sw t0, 12(sp)
	li t0, 0x6f6c672e # .glo
	sw t0, 8(sp)

	addi a0, sp, 8
	li a1, 15
	call _write_out

	_advance(8) # program\n.
end

proc _compile_constant_section()
begin
	# .section .rodata
	li t0, 0x0a # \n
	sw t0, 20(sp)
	li t0, 0x61746164 # data
	sw t0, 16(sp)
	li t0, 0x6f722e20 # _.ro
	sw t0, 12(sp)
	li t0, 0x6e6f6974 # tion
	sw t0, 8(sp)
	li t0, 0x6365732e # .sec
	sw t0, 4(sp)

	addi a0, sp, 4
	li a1, 17
	call _write_out

	_advance(6) # const\n.

	.Lcompile_constant_section_item
	_skip_spaces()
	lbu a0, (s1)
	call _is_upper
	beqz a0, .Lcompile_constant_section_end

	_compile_constant()
	goto .Lcompile_constant_section_item

	.Lcompile_constant_section_end
end

proc _compile_constant()
begin
	call _read_token

	mv a1, a0 # The identifier length from _read_token should be in a1.
	mv a0, s1 # Save the identifier pointer before advancing it.
	add s1, s1, a1
	call _write_out

	_skip_spaces()
	call _read_token
	_advance(2) # Skip the assignment sign.

	# : .long
	li t0, 0x20676e6f # ong_
	sw t0, 4(sp)
	li t0, 0x6c2e203a # : .l
	sw t0, 0(sp)
	mv a0, sp
	li a1, 8
	call _write_out

	_skip_spaces()
	call _read_token

	mv a1, a0 # The literal length from _read_token should be in a1.
	mv a0, s1 # Save the literal pointer before advancing it.
	add s1, s1, a1
	call _write_out

	li t0, '\n'
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 1
	call _write_out
end

proc _compile_variable_section()
begin
	# .section .bss
	li t0, 0x0a73 # s\n
	sw t0, 12(sp)
	li t0, 0x73622e20 # _.bs
	sw t0, 8(sp)
	li t0, 0x6e6f6974 # tion
	sw t0, 4(sp)
	li t0, 0x6365732e # .sec
	sw t0, 0(sp)

	addi a0, sp, 0
	li a1, 14
	call _write_out

	_advance(4) # var\n.

	.Lcompile_variable_section_item
	_skip_spaces()
	lbu a0, (s1)
	call _is_lower
	beqz a0, .Lcompile_variable_section_end

	_compile_variable()
	goto .Lcompile_variable_section_item

	.Lcompile_variable_section_end
end

proc _compile_variable()
begin
	call _read_token

	# Save the identifier on the stack since it should emitted multiple times.
	sw s1, 28(sp)
	sw a0, 24(sp)
	add s1, s1, a0

	_skip_spaces()
	_advance(1) # Skip the colon in front of the type.

	_skip_spaces()
	_advance(1) # Skip the opening bracket.

	call _read_token

	# Save the array size on the stack since it has to be emitted multiple times.
	sw s1, 20(sp)
	sw a0, 16(sp)
	add s1, s1, a0

	_skip_spaces()
	_advance(1) # Skip the closing bracket.

	_skip_spaces()
	call _read_token
	add s1, s1, a0 # Skip the type.

	# .type identifier, @object
	li t0, 0x2065 # e_
	sw t0, 12(sp)
	li t0, 0x7079742e # .typ
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 6
	call _write_out

	lw a0, 28(sp)
	lw a1, 24(sp)
	call _write_out

	li t0, 0x0a74 # t\n
	sw t0, 12(sp)
	li t0, 0x63656a62 # bjec
	sw t0, 8(sp)
	li t0, 0x6f40202c # , @o
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 10
	call _write_out

	# .size identifier, size
	li t0, 0x2065 # e_
	sw t0, 12(sp)
	li t0, 0x7a69732e # .siz
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 6
	call _write_out

	lw a0, 28(sp)
	lw a1, 24(sp)
	call _write_out

	li t0, 0x202c # ,
	sw t0, 12(sp)
	addi a0, sp, 12
	li a1, 2
	call _write_out

	lw a0, 20(sp)
	lw a1, 16(sp)
	call _write_out

	li t0, 0x0a # \n
	sw t0, 12(sp)
	addi a0, sp, 12
	li a1, 1
	call _write_out

	# identifier: .zero size
	lw a0, 28(sp)
	lw a1, 24(sp)
	call _write_out

	li t0, 0x206f7265 # ero_
	sw t0, 12(sp)
	li t0, 0x7a2e203a # : .z
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 8
	call _write_out

	lw a0, 20(sp)
	lw a1, 16(sp)
	call _write_out

	li t0, 0x0a # \n
	sw t0, 12(sp)
	addi a0, sp, 12
	li a1, 1
	call _write_out
end

proc _compile_procedure()
begin
	_advance(5) # Skip proc_
	call _read_token
	sw s1, 20(sp)
	sw a0, 16(sp)
	add s1, s1, a0

	# .type identifier, @function
	li t0, 0x2065 # e_
	sw t0, 12(sp)
	li t0, 0x7079742e # .typ
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 6
	call _write_out

	lw a0, 20(sp)
	lw a1, 16(sp)
	call _write_out

	li t0, 0x0a6e6f69 # ion\n
	sw t0, 12(sp)
	li t0, 0x74636e75 # unct
	sw t0, 8(sp)
	li t0, 0x6640202c # , @f
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 12
	call _write_out

	lw a0, 20(sp)
	lw a1, 16(sp)
	call _write_out

	li t0, 0x0a3a # :\n
	sw t0, 12(sp)
	addi a0, sp, 12
	li a1, 2
	call _write_out

	_skip_spaces()
	_advance(1) # Skip opening argument paren.
	_skip_spaces()
	_advance(1) # Skip closing argument paren.

	li t0, 0x6e # n
	sw t0, 12(sp)
	li t0, 0x69676562 # begi
	sw t0, 8(sp)

	# Skip all declarations until we find the "begin" keyword, denoting the
	# beginning of the procedure body.
	.Lcompile_procedure_begin
	_skip_spaces()
	call _read_token

	mv a1, a0
	mv a0, s1
	addi a2, sp, 8
	add s1, s1, a1
	call _token_compare

	bnez a0, .Lcompile_procedure_begin

	# Generate the procedure prologue with a predefined stack size.
	li t0, 0x69646461 # addi
	sw t0, 12(sp)
	addi a0, sp, 12
	li a1, 4
	call _write_out

	li t0, 0x2c707320 # _sp,
	sw t0, 12(sp)

	addi a0, sp, 12
	li a1, 4
	call _write_out

	addi a0, sp, 12
	li a1, 4
	call _write_out

	li t0, 0x0a36392d # -96\n
	sw t0, 12(sp)
	addi a0, sp, 12
	li a1, 4
	call _write_out

	li t0, 0x0a29 # )\n
	sw t0, 12(sp)
	li t0, 0x70732832 # 2(sp
	sw t0, 8(sp)
	li t0, 0x39202c61 # a, 9
	sw t0, 4(sp)
	li t0, 0x72207773 # sw r
	sw t0, 0(sp)
	addi a0, sp, 0
	li a1, 14
	call _write_out

	li t0, 0x0a29 # )\n
	sw t0, 12(sp)
	li t0, 0x70732838 # 8(sp
	sw t0, 8(sp)
	li t0, 0x38202c30 # 0, 8
	sw t0, 4(sp)
	li t0, 0x73207773 # sw s
	sw t0, 0(sp)
	addi a0, sp, 0
	li a1, 14
	call _write_out

	li t0, 0x0a363920 # _96\n
	sw t0, 12(sp)
	li t0, 0x2c707320 # _sp,
	sw t0, 8(sp)
	li t0, 0x2c307320 # _s0,
	sw t0, 4(sp)
	li t0, 0x69646461 # addi
	sw t0, 0(sp)
	addi a0, sp, 0
	li a1, 16
	call _write_out

	# Save passed arguments on the stack.
	li t0, 0x0a29 # )\n
	sw t0, 12(sp)
	li t0, 0x70732834 # 4(sp
	sw t0, 8(sp)
	li t0, 0x38202c30 # 0, 8
	sw t0, 4(sp)
	li t0, 0x61207773 # sw a
	sw t0, 0(sp)
	addi a0, sp, 0
	li a1, 14
	call _write_out

	li t0, '0'
	sb t0, 8(sp)
	li t0, 0x38202c31 # 1, 8
	sw t0, 4(sp)
	addi a0, sp, 0
	li a1, 14
	call _write_out

	li t0, '6'
	sb t0, 8(sp)
	li t0, 0x37202c32 # 2, 7
	sw t0, 4(sp)
	addi a0, sp, 0
	li a1, 14
	call _write_out

	li t0, '2'
	sb t0, 8(sp)
	li t0, 0x37202c33 # 3, 7
	sw t0, 4(sp)
	addi a0, sp, 0
	li a1, 14
	call _write_out

	li t0, '8'
	sb t0, 8(sp)
	li t0, 0x36202c34 # 4, 6
	sw t0, 4(sp)
	addi a0, sp, 0
	li a1, 14
	call _write_out

	li t0, '4'
	sb t0, 8(sp)
	li t0, 0x36202c35 # 5, 6
	sw t0, 4(sp)
	addi a0, sp, 0
	li a1, 14
	call _write_out

	# Generate the body of the procedure.
	.Lcompile_procedure_body
	_skip_indentation()
	call _read_line
	sw a0, 12(sp)
	li t0, 0x0a646e65 # end\n
	sw t0, 8(sp)
	mv a0, s1
	addi a1, sp, 8
	li a2, 4
	call _memcmp

	beqz a0, .Lcompile_procedure_end

	lw a0, 12(sp)
	call _compile_line
	goto .Lcompile_procedure_body

	.Lcompile_procedure_end
	add s1, s1, 4 # Skip end\n.

	# Generate the procedure epilogue with a predefined stack size.
	li t0, 0x0a29 # )\n
	sw t0, 12(sp)
	li t0, 0x70732832 # 2(sp
	sw t0, 8(sp)
	li t0, 0x39202c61 # a, 9
	sw t0, 4(sp)
	li t0, 0x7220776c # lw r
	sw t0, 0(sp)
	addi a0, sp, 0
	li a1, 14
	call _write_out

	li t0, 0x0a29 # )\n
	sw t0, 12(sp)
	li t0, 0x70732838 # 8(sp
	sw t0, 8(sp)
	li t0, 0x38202c30 # 0, 8
	sw t0, 4(sp)
	li t0, 0x7320776c # lw s
	sw t0, 0(sp)
	addi a0, sp, 0
	li a1, 14
	call _write_out

	li t0, 0x69646461 # addi
	sw t0, 12(sp)
	addi a0, sp, 12
	li a1, 4
	call _write_out

	li t0, 0x2c707320 # _sp,
	sw t0, 12(sp)

	addi a0, sp, 12
	li a1, 4
	call _write_out

	addi a0, sp, 12
	li a1, 4
	call _write_out

	li t0, 0x0a3639 # 96\n
	sw t0, 12(sp)
	addi a0, sp, 12
	li a1, 3
	call _write_out

	li t0, 0x0a746572 # ret\n
	sw t0, 12(sp)
	addi a0, sp, 12
	li a1, 4
	call _write_out
end

# Compares two string, which of one has a length, the other one is null-terminated.
#
# a0 - The address of the token string.
# a1 - The length of the string in a0.
# a2 - The address of the null-terminated string.
#
# If the strings match sets a0 to 0, otherwise sets it to 1.
proc _token_compare()
begin
	addi t0, a0, 0
	addi t1, a1, 0
	addi t2, a2, 0

	.Ltoken_compare_loop
	lbu t3, (t2)

	# Will only be 0 if the current character in the null terminated string is \0 and the remaining length of the
	# another string is 0.
	or t4, t3, t1
	beqz t4, .Ltoken_compare_equal

	beqz t1, .Ltoken_compare_not_equal
	beqz t3, .Ltoken_compare_not_equal

	lbu t4, (t0)
	bne t3, t4, .Ltoken_compare_not_equal

	addi t0, t0, 1
	addi t1, t1, -1
	addi t2, t2, 1
	goto .Ltoken_compare_loop

	.Ltoken_compare_not_equal
	li a0, 1
	goto .Ltoken_compare_end

	.Ltoken_compare_equal
	li a0, 0

	.Ltoken_compare_end
end

proc _compile_goto()
begin
	addi s1, s1, 4 # Skip the goto keyword.

	li t0, 0x206a # j_
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 2
	call _write_out

	_skip_spaces()
	sw s1, 8(sp) # We should be on dot the label is beginning with.
	_advance(1)

	call _read_token
	add s1, s1, a0
	addi a1, a0, 1 # Label length and the dot.
	lw a0, 8(sp) # Saved dot position.
	call _write_out

	_advance(1) # Skip the new line.

	li t0, 0x0a # \n
	sw t0, 8(sp)
	addi a0, sp, 8
	li a1, 1
	call _write_out
end

# a0 - Line length.
proc _compile_label()
begin
	sw a0, 0(sp) # Save the line length.

	# Write the whole line as is.
	mv a0, s1
	lw a1, 0(sp)
	call _write_out

	lw t0, 0(sp) # Line length.
	mv t1, s1 # Line start.

	add t1, t1, t0
	addi t1, t1, -1 # Last character on the line.

	lbu t1, (t1)
	li t2, ':'
	beq t1, t2, .Lcompile_label_colon

	li t0, 0x3a # :
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 1
	call _write_out

	.Lcompile_label_colon
	li t0, 0x0a # \n
	sw t0, 4(sp)
	addi a0, sp, 4
	li a1, 1
	call _write_out

	lw a0, 0(sp)
	addi a0, a0, 1 # Skip the new line as well.
	add s1, s1, a0 # Skip the line.
end

# Parameters:
# a0 - Line length.
# a1 - Whether the section header was already emitted. If not it should be
# emitted before any code is written.
#
# Returns 1 in a0 if the parsed line contained a text section element such a
# procedure or the program entry point. Otherwise sets a0 to 0.
proc _compile_line()
begin
	# Preserve passed arguments.
	sw a0, 20(sp)
	sw a1, 16(sp)

	beqz a0, .Lcompile_line_empty # Skip an empty line.

	lbu t0, (s1)
	li t1, '#'
	beq t0, t1, .Lcompile_line_comment

	li t0, 0x0a6d6172 # ram\n
	sw t0, 12(sp)
	li t0, 0x676f7270 # prog
	sw t0, 8(sp)
	mv a0, s1
	addi a1, sp, 8
	li a2, 8
	call _memcmp
	beqz a0, .Lcompile_line_program

	li t0, 0x0a74 # t\n
	sw t0, 12(sp)
	li t0, 0x736e6f63 # cons
	sw t0, 8(sp)
	mv a0, s1
	addi a1, sp, 8
	li a2, 6
	call _memcmp
	beqz a0, .Lcompile_line_const

	li t0, 0x0a726176 # var\n
	sw t0, 12(sp)
	mv a0, s1
	addi a1, sp, 12
	li a2, 4
	call _memcmp
	beqz a0, .Lcompile_line_var

	li t0, 0x20 # _
	sw t0, 12(sp)
	li t0, 0x636f7270 # proc
	sw t0, 8(sp)
	mv a0, s1
	addi a1, sp, 8
	li a2, 5
	call _memcmp
	beqz a0, .Lcompile_line_procedure

	li t0, 0x0a6e # n\n
	sw t0, 12(sp)
	li t0, 0x69676562 # begi
	sw t0, 8(sp)
	mv a0, s1
	addi a1, sp, 8
	li a2, 6
	call _memcmp
	beqz a0, .Lcompile_line_begin

	li t0, 0x2e646e65 # end.
	sw t0, 12(sp)
	mv a0, s1
	addi a1, sp, 12
	li a2, 4
	call _memcmp
	beqz a0, .Lcompile_line_exit

	li t0, 0x61636f6c # loca
	sw t0, 12(sp)
	mv a0, s1
	addi a1, sp, 12
	li a2, 4
	call _memcmp
	beqz a0, .Lcompile_line_identifier

	li t0, 0x7472 # rt
	sw t0, 12(sp)
	li t0, 0x6f706d69 # impo
	sw t0, 8(sp)
	mv a0, s1
	addi a1, sp, 8
	li a2, 6
	call _memcmp
	beqz a0, .Lcompile_line_import

	li t0, 0x6f746f67 # goto
	sw t0, 12(sp)
	mv a0, s1
	addi a1, sp, 12
	li a2, 4
	call _memcmp
	beqz a0, .Lcompile_line_goto

	lbu t0, (s1)
	li t1, '.'
	beq t0, t1, .Lcompile_line_label
	li t1, '_'
	beq t0, t1, .Lcompile_line_identifier

	goto .Lcompile_line_unchanged # Else.

	.Lcompile_line_label
	lw a0, 20(sp)
	call _compile_label
	goto .Lcompile_line_section

	.Lcompile_line_goto
	_compile_goto()
	goto .Lcompile_line_section

	.Lcompile_line_import
	_compile_import()
	goto .Lcompile_line_section

	.Lcompile_line_identifier
	_compile_identifier()
	goto .Lcompile_line_section

	.Lcompile_line_exit
	_compile_exit()
	goto .Lcompile_line_section

	.Lcompile_line_begin
	lw a1, 16(sp)
	bnez a1, .Lcompile_line_compile_entry
	_compile_text_section()
	.Lcompile_line_compile_entry
	_compile_entry_point()
	li a0, 1
	goto .Lcompile_line_end

	.Lcompile_line_const
	_compile_constant_section()
	goto .Lcompile_line_section

	.Lcompile_line_procedure
	lw a1, 16(sp)
	bnez a1, .Lcompile_line_compile_procedure
	_compile_text_section()
	.Lcompile_line_compile_procedure
	_compile_procedure()
	li a0, 1
	goto .Lcompile_line_end

	.Lcompile_line_var
	_compile_variable_section()
	goto .Lcompile_line_section

	.Lcompile_line_program
	_compile_program()
	goto .Lcompile_line_section

	.Lcompile_line_comment
	lw a0, 20(sp)
	call _skip_comment
	goto .Lcompile_line_section

	.Lcompile_line_empty
	_advance(1)
	goto .Lcompile_line_section

	.Lcompile_line_unchanged
	lw a0, 20(sp)
	call _compile_assembly
	goto .Lcompile_line_section

	.Lcompile_line_section
	mv a0, zero

	.Lcompile_line_end
end

# Prints ".section .text" and exits.
proc _compile_text_section()
begin
	# .section .text
	li t0, 0x0a7478 # xt\n
	sw t0, 12(sp)
	li t0, 0x65742e20 # _.te
	sw t0, 8(sp)
	li t0, 0x6e6f6974 # tion
	sw t0, 4(sp)
	li t0, 0x6365732e # .sec
	sw t0, 0(sp)

	addi a0, sp, 0
	li a1, 15
	call _write_out
end

proc _compile_entry_point()
begin
	# .type _start, @function
	li t0, 0x0a3a7472 # rt:\n
	sw t0, 52(sp)
	li t0, 0x6174735f # _sta
	sw t0, 48(sp)
	li t0, 0x0a6e6f69 # ion\n
	sw t0, 44(sp)
	li t0, 0x74636e75 # unct
	sw t0, 40(sp)
	li t0, 0x6640202c # , @f
	sw t0, 36(sp)
	li t0, 0x74726174 # tart
	sw t0, 32(sp)
	li t0, 0x735f2065 # e _s
	sw t0, 28(sp)
	li t0, 0x7079742e # .typ
	sw t0, 24(sp)
	addi a0, sp, 24
	li a1, 32
	call _write_out

	_advance(6) # Skip begin\n.
end

proc _compile_exit()
begin
	# li a0, 0
	# li a7, SYS_EXIT
	# ecall
	li t0, 0x0a # \n
	sw t0, 52(sp)
	li t0, 0x6c6c6163 # call
	sw t0, 48(sp)
	li t0, 0x650a3339 # 93\ne
	sw t0, 44(sp)
	li t0, 0x202c3761 # a7,_
	sw t0, 40(sp)
	li t0, 0x20696c0a # \nli_
	sw t0, 36(sp)
	li t0, 0x30202c30 # 0, 0
	sw t0, 32(sp)
	li t0, 0x6120696c # li a
	sw t0, 28(sp)
	addi a0, sp, 28
	li a1, 25
	call _write_out

	_advance(4) # Skip end.
	_skip_spaces() # Read the possible new line at the end of the file.
end

# Finds the end of the line and returns its length in a0.
proc _read_line()
begin
	mv t0, s1 # Local position in the source text.

	.Lread_line_do
	lbu t1, (t0) # t1 = Current character.
	beqz t1, .Lread_line_end # Exit the loop on the NUL character.
	li t2, '\n'
	beq t1, t2, .Lread_line_end # Exit the loop on the new line.

	addi t0, t0, 1
	goto .Lread_line_do

	.Lread_line_end
	sub a0, t0, s1 # Return the line length.
end

proc _compile()
begin
	sw zero, 4(sp) # Whether the text section header was already emitted.

	.Lcompile_do
	lbu t0, (s1) # t0 = Current character.
	beqz t0, .Lcompile_end # Exit the loop on the NUL character.

	_skip_indentation()
	call _read_line
	lw a1, 4(sp)
	call _compile_line

	beqz a0, .Lcompile_do
	# Update whether the text section header was already emitted.
	lw t0, 4(sp)
	or t0, t0, a0
	sw t0, 4(sp)

	goto .Lcompile_do
	.Lcompile_end
end

# Returns the pointer to the current position in the source text in a0.
proc _current()
begin
	mv a0, s1
end

# a0 is the number of bytes to advance in the source text.
proc _advance()
begin
	add s1, s1, a0
end

# Returns the first character in the remaining source text.
proc _front()
begin
	lbu a0, (s1)
end

# Entry point.
begin
	# Read the source from the standard input.
	la a0, source_code
	la a1, SOURCE_BUFFER_SIZE # Buffer size.
	lw a1, (a1)
	call _read_file

	la s1, source_code # s1 = Source code position.
	_compile()
end.