diff options
| -rw-r--r-- | Rakefile | 43 | ||||
| -rw-r--r-- | boot/common-boot.s | 368 | ||||
| -rw-r--r-- | boot/stage7.elna | 302 | ||||
| -rw-r--r-- | boot/stage8.elna | 347 | ||||
| -rw-r--r-- | boot/stage9.elna | 1503 |
5 files changed, 2101 insertions, 462 deletions
@@ -39,11 +39,44 @@ end desc 'Convert previous stage language into the current stage language' task :convert do - File.open('boot/stage4.elna', 'w') do |current_stage| - li_value = nil - - File.readlines('boot/stage3.elna').each do |line| - current_stage << line + File.open('boot/stage8.elna', 'w') do |current_stage| + File.readlines('boot/stage7.elna').each do |line| + if line == ".section .bss\n" + current_stage << <<~SECTION + const + symbol_builtin_name_int := "Int"; + symbol_builtin_name_word := "Word"; + symbol_builtin_name_pointer := "Pointer"; + symbol_builtin_name_char := "Char"; + symbol_builtin_name_bool := "Bool"; + + # Every type info starts with a word describing what type it is. + # + # PRIMITIVE_TYPE = 1 + # + # Primitive types have only type size. + symbol_builtin_type_int := S(1, 4); + symbol_builtin_type_word := S(1, 4); + symbol_builtin_type_pointer := S(1, 4); + symbol_builtin_type_char := S(1, 1); + symbol_builtin_type_bool := S(1, 1); + + # Info objects start with a word describing its type. + # + # INFO_TYPE = 1 + # + # Type info has the type it belongs to. + symbol_type_info_int := S(1, @symbol_builtin_type_int); + symbol_type_info_word := S(1, @symbol_builtin_type_word); + symbol_type_info_pointer := S(1, @symbol_builtin_type_pointer); + symbol_type_info_char := S(1, @symbol_builtin_type_char); + symbol_type_info_bool := S(1, @symbol_builtin_type_bool); + SECTION + elsif line == ".section .data\n" + current_stage << "var\n" + elsif !(line == ".section .text\n" || line == ".globl _start\n") + current_stage << line + end end end end diff --git a/boot/common-boot.s b/boot/common-boot.s deleted file mode 100644 index 9305d40..0000000 --- a/boot/common-boot.s +++ /dev/null @@ -1,368 +0,0 @@ -# This Source Code Form is subject to the terms of the Mozilla Public License, -# v. 2.0. If a copy of the MPL was not distributed with this file, You can -# obtain one at https://mozilla.org/MPL/2.0/. - -.global _read_file, _write_error -.global _memcmp, _memchr, _memmem, _mmap -.global _current, _get, _advance, _label_counter -.global _divide_by_zero_error, _strings_index, _string_equal - -.section .rodata - -.equ SYS_READ, 63 -.equ SYS_WRITE, 64 -.equ SYS_MMAP2, 222 -.equ STDIN, 0 -.equ STDOUT, 1 -.equ STDERR, 2 -.equ PROT_READ, 0x1 -.equ PROT_WRITE, 0x2 -.equ MAP_PRIVATE, 0x02 -.equ MAP_ANONYMOUS, 0x20 - -new_line: .ascii "\n" - -.section .text - -# Write the current token to stderr. Ends the output with a newline. -# -# a0 - String pointer. -# a1 - String length. -.type _write_error, @function -_write_error: - mv t0, a0 - mv t1, a1 - - li a0, STDERR - mv a1, t0 - mv a2, t1 - li a7, SYS_WRITE - ecall - - li a0, STDERR - la a1, new_line - li a2, 1 - li a7, SYS_WRITE - ecall - - ret - -# a0 - First pointer. -# a1 - Second pointer. -# a2 - The length to compare. -# -# Returns 0 in a0 if memory regions are equal. -.type _memcmp, @function -_memcmp: - mv t0, a0 - li a0, 0 - -.Lmemcmp_loop: - beqz a2, .Lmemcmp_end - - lbu t1, (t0) - lbu t2, (a1) - sub a0, t1, t2 - - bnez a0, .Lmemcmp_end - - addi t0, t0, 1 - addi a1, a1, 1 - addi a2, a2, -1 - - j .Lmemcmp_loop - -.Lmemcmp_end: - ret - -# Reads standard input into a buffer. -# a0 - Buffer pointer. -# a1 - Buffer size. -# -# Sets s1 to the buffer passed in a0. -# -# Returns the amount of bytes written in a0. -.type _read_file, @function -_read_file: - # Prologue. - addi sp, sp, -8 - sw ra, 4(sp) - sw s0, 0(sp) - addi s0, sp, 8 - - mv s1, a0 - - li a0, STDIN - mv a2, a1 - mv a1, s1 - li a7, SYS_READ - ecall - - # Epilogue. - lw ra, 4(sp) - lw s0, 0(sp) - addi sp, sp, 8 - ret - -.type _divide_by_zero_error, @function -_divide_by_zero_error: - addi a7, zero, 172 # getpid - ecall - - addi a1, zero, 8 # SIGFPE - addi a7, zero, 129 # kill - ecall - ret - -# a0 - Pointer to an array to get the first element. -# -# Dereferences a pointer and returns what is on the address in a0. -.type _get, @function -_get: - lw a0, (a0) - ret - -# Searches for the occurences of a character in the given memory block. -# -# Parameters: -# a0 - Memory block. -# a1 - Needle. -# a2 - Memory size. -# -# Sets a0 to the pointer to the found character or to null if the character -# doesn't occur in the memory block. -.type _memchr, @function -_memchr: -.Lmemchr_loop: - beqz a2, .Lmemchr_nil # Exit if the length is 0. - - lbu t0, (a0) # Load the character from the memory block. - beq t0, a1, .Lmemchr_end # Exit if the character was found. - - # Otherwise, continue with the next character. - addi a0, a0, 1 - addi a2, a2, -1 - - j .Lmemchr_loop - -.Lmemchr_nil: - li a0, 0 - -.Lmemchr_end: - ret - -# Locates a substring. -# -# Parameters: -# a0 - Haystack. -# a1 - Haystack size. -# a2 - Needle. -# a3 - Needle size. -# -# Sets a0 to the pointer to the beginning of the substring in memory or to 0 -# if the substring doesn't occur in the block. -.type _memmem, @function -_memmem: - # Prologue. - addi sp, sp, -24 - sw ra, 20(sp) - sw s0, 16(sp) - addi s0, sp, 24 - - # Save preserved registers. They are used to keep arguments. - sw s1, 12(sp) - sw s2, 8(sp) - sw s3, 4(sp) - sw s4, 0(sp) - - mv s1, a0 - mv s2, a1 - mv s3, a2 - mv s4, a3 - -.Lmemmem_loop: - blt s2, s3, .Lmemmem_nil # Exit if the needle length is greater than memory. - - mv a0, s1 - mv a1, s3 - mv a2, s4 - call _memcmp - - mv t0, a0 # memcmp result. - mv a0, s1 # Memory pointer for the case the substring was found. - beqz t0, .Lmemmem_end - - addi s1, s1, 1 - add s2, s2, -1 - - j .Lmemmem_loop - -.Lmemmem_nil: - li a0, 0 - -.Lmemmem_end: - - # Restore the preserved registers. - lw s1, 12(sp) - lw s2, 8(sp) - lw s3, 4(sp) - lw s4, 0(sp) - - # Epilogue. - lw ra, 20(sp) - lw s0, 16(sp) - add sp, sp, 24 - ret - -# Searches for a string in a string array. -# -# Parameters: -# a0 - Number of elements in the string array. -# a1 - String array. -# a2 - Needle length. -# a3 - Needle. -# -# Sets a0 to the 1-based index of the needle in the haystack or to 0 if the -# element could not be found. -.type _strings_index, @function -_strings_index: - # Prologue. - addi sp, sp, -32 - sw ra, 28(sp) - sw s0, 24(sp) - addi s0, sp, 32 - - sw s1, 20(sp) - mv s1, a0 - sw s2, 16(sp) - mv s2, a1 - sw s3, 12(sp) - mv s3, a2 - sw s4, 8(sp) - mv s4, a3 - sw s5, 4(sp) - li s5, 0 # Index counter. - -.Lstrings_index_loop: - addi s5, s5, 1 - beqz s1, .Lstrings_index_missing - - lw a2, (s2) # Read the length of the current element in the haystack. - bne a2, s3, .Lstrings_index_next # Lengths don't match, skip the iteration. - - addi a0, s2, 4 - mv a1, s4 - call _memcmp - - beqz a0, .Lstrings_index_end - -.Lstrings_index_next: - # Advance the pointer, reduce the length. - lw a2, (s2) - addi s2, s2, 4 - add s2, s2, a2 - addi s1, s1, -1 - j .Lstrings_index_loop - -.Lstrings_index_missing: - li s5, 0 - -.Lstrings_index_end: - mv a0, s5 - - lw s1, 20(sp) - lw s2, 16(sp) - lw s3, 12(sp) - lw s4, 8(sp) - lw s5, 4(sp) - - # Epilogue. - lw ra, 28(sp) - lw s0, 24(sp) - add sp, sp, 32 - ret - -# Compares two strings for equality. -# -# Parameters: -# a0 - Length of the first string. -# a1 - Pointer to the first string. -# a2 - Length of the second string. -# a3 - Pointer to the second string. -# -# Sets a0 to 1 if the string are equal, to 0 if not. -.type _string_equal, @function -_string_equal: - # Prologue. - addi sp, sp, -32 - sw ra, 28(sp) - sw s0, 24(sp) - addi s0, sp, 32 - - # Compare string lengths. - bne a0, a2, .Lstring_equal_not_found - - # If lengths match, compare the content. - mv a0, a1 - mv a1, a3 - # a2 is already set to the length. - call _memcmp - - bnez a0, .Lstring_equal_not_found - - li a0, 1 - j .Lstring_equal_end - -.Lstring_equal_not_found: - mv a0, zero - -.Lstring_equal_end: - # Epilogue. - lw ra, 28(sp) - lw s0, 24(sp) - addi sp, sp, 32 - ret - -# Sets a0 to the mapping address. -.type _mmap, @function -_mmap: - li a0, 0 # Address at which to create the mapping. - li a1, 4096 # The length of the mapping. - li a2, PROT_READ | PROT_WRITE # Protection flags. - li a3, MAP_ANONYMOUS | MAP_PRIVATE # The mapping is not backed by a file. - li a4, -1 # File descriptor. - li a5, 0 # Page offset. - li a7, SYS_MMAP2 - ecall - - ret - -# Sets the a0 to the current position in the source text (s1). -.type _current, @function -_current: - mv a0, s1 - ret - -# Advances the position of the source text. -# -# Parameters: -# a0 - The number of bytes to advance. -.type _advance, @function -_advance: - add s1, s1, a0 - ret - -# Advances the global label counter by 1 setting a0 to the previous value. -# -# Parameters: -# a0 - If it is 0, resets the counter to 1. -.type _label_counter, @function -_label_counter: - bnez a0, .Llabel_counter_advance - li s2, 0 - -.Llabel_counter_advance: - mv a0, s2 - addi s2, s2, 1 - - ret diff --git a/boot/stage7.elna b/boot/stage7.elna index 6973963..f83a8a5 100644 --- a/boot/stage7.elna +++ b/boot/stage7.elna @@ -4,7 +4,9 @@ # Stage 7 compiler. # -# - String literals. +# - Static global variable and constant initialization. +# - Objct sections are determined automatically. +# - _start is always exported. .section .bss @@ -1098,57 +1100,291 @@ begin _advance_token(5); end; -proc _compile_type(); +proc _skip_newlines(); begin - # Print and skip the ".type" (5 characters) directive and a space after it. - _write_token(6); - _advance_token(); + # Skip newlines. + la t0, source_code_position + lw t1, (t0) - # Read and print the symbol name. - _read_token(); +.skip_newlines_loop: + lb t2, (t1) + li t3, '\n' + bne t2, t3, .skip_newlines_end + beqz t2, .skip_newlines_end + + addi t1, t1, 1 + sw t1, (t0) + + goto .skip_newlines_loop; + +.skip_newlines_end: +end; + +# Skip newlines and comments. +proc _skip_empty_lines(); +begin +.skip_empty_lines_loop: + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, '#' + beq t0, t1, .skip_empty_lines_comment + + li t1, '\n' + beq t0, t1, .skip_empty_lines_newline + + goto .skip_empty_lines_end; + +.skip_empty_lines_comment: + _skip_comment(); + goto .skip_empty_lines_loop; + +.skip_empty_lines_newline: + _advance_token(1); + goto .skip_empty_lines_loop; - # Print and skip the symbol name, comma, space and @. - addi a0, a0, 3 +.skip_empty_lines_end: +end; + +proc _compile_global_initializer(); +begin + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, '"' + beq t0, t1, .compile_global_initializer_string + + li t1, 'S' + beq t0, t1, .compile_global_initializer_record + + li t1, '@' + beq t0, t1, .compile_global_initializer_pointer + + la a0, source_code_position + lw a0, (a0) + lb a0, (a0) + _is_digit(); + bnez a0, .compile_global_initializer_number + + unimp + +.compile_global_initializer_pointer: + # Skip @. + _advance_token(1); + _write_z("\n\t.word \0"); + _read_token(); _write_token(); _advance_token(); - # Read the symbol type. - _read_token(); + goto .compile_global_initializer_end; - # Print the symbol type and newline. - addi a0, a0, 1 +.compile_global_initializer_number: + _write_z("\n\t.word \0"); + _read_token(); _write_token(); + _advance_token(1); + + goto .compile_global_initializer_end; + +.compile_global_initializer_record: + # Skip "S(". + _advance_token(2); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, ')' + beq t0, t1, .compile_global_initializer_closing + +.compile_global_initializer_loop: + _compile_global_initializer(); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, ')' + beq t0, t1, .compile_global_initializer_closing + + # Skip comma and whitespace after it. + _advance_token(2); + + goto .compile_global_initializer_loop; + +.compile_global_initializer_closing: + # Skip ")" + _advance_token(1); + + goto .compile_global_initializer_end; + +.compile_global_initializer_string: + _write_z("\n\t.word strings + \0"); + _string_length(source_code_position); + sw a0, 4(sp) + + _add_string(source_code_position); + _write_i(); + + # Skip the quoted string. + _advance_token(v4 + 2); + + goto .compile_global_initializer_end; + +.compile_global_initializer_end: +end; + +proc _compile_constant_declaration(); +begin + _read_token(); + sw a0, 0(sp) + + _write_z(".type \0"); + _write_token(v0); + _write_z(", @object\n\0"); + + _write_token(v0); + _write_c(':'); + + # Skip the constant name with assignment sign and surrounding whitespaces. + _advance_token(v0 + 4); + _compile_global_initializer(); + # Skip semicolon and newline. + _advance_token(2); + _write_c('\n'); +end; + +proc _compile_const_part(); +begin + _skip_empty_lines(); + + _memcmp(source_code_position, "const\0", 5); + bnez a0, .compile_const_part_end + + # Skip "const" with the newline after it. + _advance_token(6); + _write_z(".section .rodata # Compiled from const section.\n\n\0"); + +.compile_const_part_loop: + _skip_empty_lines(); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + # If the character at the line beginning is not indentation, + # it is probably the next code section. + li t1, '\t' + bne t0, t1, .compile_const_part_end + + _advance_token(1); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, '#' + beq t0, t1, .compile_const_part_loop + + _compile_constant_declaration(); + goto .compile_const_part_loop; + +.compile_const_part_end: +end; + +proc _compile_variable_declaration(); +begin + _read_token(); + sw a0, 0(sp) + + _write_z(".type \0"); + _write_token(v0); + _write_z(", @object\n\0"); + + _write_token(v0); + _write_c(':'); + + # Skip the variable name and colon with space before the type. + _advance_token(v0 + 2); + + # Skip the type name. + _read_token(); _advance_token(); - # Write the object definition itself. - _compile_line(); + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, ' ' + beq t0, t1, .compile_variable_declaration_initializer + + # Else we assume this is a zeroed 81920 bytes big array. + _write_z(" .zero 81920\0"); + goto .compile_variable_declaration_finalize; -.compile_type_end: +.compile_variable_declaration_initializer: + # Skip the assignment sign with surrounding whitespaces. + _advance_token(4); + _compile_global_initializer(); + goto .compile_variable_declaration_finalize; + +.compile_variable_declaration_finalize: + # Skip semicolon and newline. + _advance_token(2); + _write_c('\n'); end; -proc _skip_newlines(); +proc _compile_var_part(); begin - # Skip newlines. + _memcmp(source_code_position, "var\0", 3); + bnez a0, .compile_var_part_end + + # Skip "var" and newline. + _advance_token(4); + _write_z(".section .data\n\0"); + +.compile_var_part_loop: la t0, source_code_position - lw t1, (t0) + lw t0, (t0) + lb t0, (t0) -.skip_newlines_loop: - lb t2, (t1) - li t3, '\n' - bne t2, t3, .skip_newlines_end - beqz t2, .skip_newlines_end + li t1, 'p' + beq t0, t1, .compile_var_part_end - addi t1, t1, 1 - sw t1, (t0) + li t1, '\t' + beq t0, t1, .compile_var_part_declaration - goto .skip_newlines_loop; + _compile_line(); + goto .compile_var_part_loop; -.skip_newlines_end: +.compile_var_part_declaration: + _advance_token(1); + _compile_variable_declaration(); + goto .compile_var_part_loop; + +.compile_var_part_end: end; # Process the source code and print the generated code. proc _compile_module(); begin + _compile_const_part(); + _write_z(".section .bss\n\0"); + +.compile_module_bss: + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, 'v' + beq t0, t1, .compile_module_code + + li t1, 'p' + beq t0, t1, .compile_module_code + + _compile_line(); + goto .compile_module_bss; + +.compile_module_code: + _compile_var_part(); + _write_z(".section .text\n\0"); .compile_module_loop: _skip_newlines(); @@ -1163,10 +1399,6 @@ begin _memcmp(source_code_position, ".section", 8); beqz a0, .compile_module_section - # 5 is ".type" length. - _memcmp(source_code_position, ".type", 5); - beqz a0, .compile_module_type - # 5 is "proc " length. Space is needed to distinguish from "procedure". _memcmp(source_code_position, "proc ", 5); beqz a0, .compile_module_procedure @@ -1183,11 +1415,6 @@ begin goto .compile_module_loop; -.compile_module_type: - _compile_type(); - - goto .compile_module_loop; - .compile_module_global: _compile_line(); @@ -1208,6 +1435,7 @@ end; proc _compile(); begin + _write_z(".globl _start\n\n\0"); _compile_module(); _write_z(".section .rodata\n.type strings, @object\nstrings: .ascii \0"); diff --git a/boot/stage8.elna b/boot/stage8.elna index 6973963..c88e19d 100644 --- a/boot/stage8.elna +++ b/boot/stage8.elna @@ -2,11 +2,37 @@ # v. 2.0. If a copy of the MPL was not distributed with this file, You can # obtain one at https://mozilla.org/MPL/2.0/. -# Stage 7 compiler. +# Stage 8 compiler. # -# - String literals. -.section .bss +const + symbol_builtin_name_int := "Int"; + symbol_builtin_name_word := "Word"; + symbol_builtin_name_pointer := "Pointer"; + symbol_builtin_name_char := "Char"; + symbol_builtin_name_bool := "Bool"; + + # Every type info starts with a word describing what type it is. + # + # PRIMITIVE_TYPE = 1 + # + # Primitive types have only type size. + symbol_builtin_type_int := S(1, 4); + symbol_builtin_type_word := S(1, 4); + symbol_builtin_type_pointer := S(1, 4); + symbol_builtin_type_char := S(1, 1); + symbol_builtin_type_bool := S(1, 1); + + # Info objects start with a word describing its type. + # + # INFO_TYPE = 1 + # + # Type info has the type it belongs to. + symbol_type_info_int := S(1, @symbol_builtin_type_int); + symbol_type_info_word := S(1, @symbol_builtin_type_word); + symbol_type_info_pointer := S(1, @symbol_builtin_type_pointer); + symbol_type_info_char := S(1, @symbol_builtin_type_char); + symbol_type_info_bool := S(1, @symbol_builtin_type_bool); # When modifiying also change the read size in the entry point procedure. .type source_code, @object @@ -15,18 +41,10 @@ source_code: .zero 81920 .type compiler_strings, @object compiler_strings: .zero 8192 -.section .data - -.type compiler_strings_position, @object -compiler_strings_position: .word compiler_strings - -.type compiler_strings_length, @object -compiler_strings_length: .word 0 - -.type source_code_position, @object -source_code_position: .word source_code - -.section .text +var + compiler_strings_position: Pointer := @compiler_strings; + compiler_strings_length: Word := 0; + source_code_position: Pointer := @source_code; # Calculates and returns the string token length between quotes, including the # escaping slash characters. @@ -1098,57 +1116,291 @@ begin _advance_token(5); end; -proc _compile_type(); +proc _skip_newlines(); begin - # Print and skip the ".type" (5 characters) directive and a space after it. - _write_token(6); - _advance_token(); + # Skip newlines. + la t0, source_code_position + lw t1, (t0) - # Read and print the symbol name. - _read_token(); +.skip_newlines_loop: + lb t2, (t1) + li t3, '\n' + bne t2, t3, .skip_newlines_end + beqz t2, .skip_newlines_end + + addi t1, t1, 1 + sw t1, (t0) + + goto .skip_newlines_loop; + +.skip_newlines_end: +end; - # Print and skip the symbol name, comma, space and @. - addi a0, a0, 3 +# Skip newlines and comments. +proc _skip_empty_lines(); +begin +.skip_empty_lines_loop: + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, '#' + beq t0, t1, .skip_empty_lines_comment + + li t1, '\n' + beq t0, t1, .skip_empty_lines_newline + + goto .skip_empty_lines_end; + +.skip_empty_lines_comment: + _skip_comment(); + goto .skip_empty_lines_loop; + +.skip_empty_lines_newline: + _advance_token(1); + goto .skip_empty_lines_loop; + +.skip_empty_lines_end: +end; + +proc _compile_global_initializer(); +begin + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, '"' + beq t0, t1, .compile_global_initializer_string + + li t1, 'S' + beq t0, t1, .compile_global_initializer_record + + li t1, '@' + beq t0, t1, .compile_global_initializer_pointer + + la a0, source_code_position + lw a0, (a0) + lb a0, (a0) + _is_digit(); + bnez a0, .compile_global_initializer_number + + unimp + +.compile_global_initializer_pointer: + # Skip @. + _advance_token(1); + _write_z("\n\t.word \0"); + _read_token(); _write_token(); _advance_token(); - # Read the symbol type. - _read_token(); + goto .compile_global_initializer_end; - # Print the symbol type and newline. - addi a0, a0, 1 +.compile_global_initializer_number: + _write_z("\n\t.word \0"); + _read_token(); _write_token(); + _advance_token(1); + + goto .compile_global_initializer_end; + +.compile_global_initializer_record: + # Skip "S(". + _advance_token(2); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, ')' + beq t0, t1, .compile_global_initializer_closing + +.compile_global_initializer_loop: + _compile_global_initializer(); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, ')' + beq t0, t1, .compile_global_initializer_closing + + # Skip comma and whitespace after it. + _advance_token(2); + + goto .compile_global_initializer_loop; + +.compile_global_initializer_closing: + # Skip ")" + _advance_token(1); + + goto .compile_global_initializer_end; + +.compile_global_initializer_string: + _write_z("\n\t.word strings + \0"); + _string_length(source_code_position); + sw a0, 4(sp) + + _add_string(source_code_position); + _write_i(); + + # Skip the quoted string. + _advance_token(v4 + 2); + + goto .compile_global_initializer_end; + +.compile_global_initializer_end: +end; + +proc _compile_constant_declaration(); +begin + _read_token(); + sw a0, 0(sp) + + _write_z(".type \0"); + _write_token(v0); + _write_z(", @object\n\0"); + + _write_token(v0); + _write_c(':'); + + # Skip the constant name with assignment sign and surrounding whitespaces. + _advance_token(v0 + 4); + _compile_global_initializer(); + # Skip semicolon and newline. + _advance_token(2); + _write_c('\n'); +end; + +proc _compile_const_part(); +begin + _skip_empty_lines(); + + _memcmp(source_code_position, "const\0", 5); + bnez a0, .compile_const_part_end + + # Skip "const" with the newline after it. + _advance_token(6); + _write_z(".section .rodata # Compiled from const section.\n\n\0"); + +.compile_const_part_loop: + _skip_empty_lines(); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + # If the character at the line beginning is not indentation, + # it is probably the next code section. + li t1, '\t' + bne t0, t1, .compile_const_part_end + + _advance_token(1); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, '#' + beq t0, t1, .compile_const_part_loop + + _compile_constant_declaration(); + goto .compile_const_part_loop; + +.compile_const_part_end: +end; + +proc _compile_variable_declaration(); +begin + _read_token(); + sw a0, 0(sp) + + _write_z(".type \0"); + _write_token(v0); + _write_z(", @object\n\0"); + + _write_token(v0); + _write_c(':'); + + # Skip the variable name and colon with space before the type. + _advance_token(v0 + 2); + + # Skip the type name. + _read_token(); _advance_token(); - # Write the object definition itself. - _compile_line(); + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, ' ' + beq t0, t1, .compile_variable_declaration_initializer -.compile_type_end: + # Else we assume this is a zeroed 81920 bytes big array. + _write_z(" .zero 81920\0"); + goto .compile_variable_declaration_finalize; + +.compile_variable_declaration_initializer: + # Skip the assignment sign with surrounding whitespaces. + _advance_token(4); + _compile_global_initializer(); + goto .compile_variable_declaration_finalize; + +.compile_variable_declaration_finalize: + # Skip semicolon and newline. + _advance_token(2); + _write_c('\n'); end; -proc _skip_newlines(); +proc _compile_var_part(); begin - # Skip newlines. + _memcmp(source_code_position, "var\0", 3); + bnez a0, .compile_var_part_end + + # Skip "var" and newline. + _advance_token(4); + _write_z(".section .data\n\0"); + +.compile_var_part_loop: la t0, source_code_position - lw t1, (t0) + lw t0, (t0) + lb t0, (t0) -.skip_newlines_loop: - lb t2, (t1) - li t3, '\n' - bne t2, t3, .skip_newlines_end - beqz t2, .skip_newlines_end + li t1, 'p' + beq t0, t1, .compile_var_part_end - addi t1, t1, 1 - sw t1, (t0) + li t1, '\t' + beq t0, t1, .compile_var_part_declaration - goto .skip_newlines_loop; + _compile_line(); + goto .compile_var_part_loop; -.skip_newlines_end: +.compile_var_part_declaration: + _advance_token(1); + _compile_variable_declaration(); + goto .compile_var_part_loop; + +.compile_var_part_end: end; # Process the source code and print the generated code. proc _compile_module(); begin + _compile_const_part(); + _write_z(".section .bss\n\0"); + +.compile_module_bss: + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, 'v' + beq t0, t1, .compile_module_code + + li t1, 'p' + beq t0, t1, .compile_module_code + + _compile_line(); + goto .compile_module_bss; + +.compile_module_code: + _compile_var_part(); + _write_z(".section .text\n\0"); .compile_module_loop: _skip_newlines(); @@ -1163,10 +1415,6 @@ begin _memcmp(source_code_position, ".section", 8); beqz a0, .compile_module_section - # 5 is ".type" length. - _memcmp(source_code_position, ".type", 5); - beqz a0, .compile_module_type - # 5 is "proc " length. Space is needed to distinguish from "procedure". _memcmp(source_code_position, "proc ", 5); beqz a0, .compile_module_procedure @@ -1183,11 +1431,6 @@ begin goto .compile_module_loop; -.compile_module_type: - _compile_type(); - - goto .compile_module_loop; - .compile_module_global: _compile_line(); @@ -1208,6 +1451,7 @@ end; proc _compile(); begin + _write_z(".globl _start\n\n\0"); _compile_module(); _write_z(".section .rodata\n.type strings, @object\nstrings: .ascii \0"); @@ -1247,7 +1491,6 @@ begin end; # Entry point. -.globl _start proc _start(); begin # Read the source from the standard input. diff --git a/boot/stage9.elna b/boot/stage9.elna new file mode 100644 index 0000000..f429b10 --- /dev/null +++ b/boot/stage9.elna @@ -0,0 +1,1503 @@ +# This Source Code Form is subject to the terms of the Mozilla Public License, +# v. 2.0. If a copy of the MPL was not distributed with this file, You can +# obtain one at https://mozilla.org/MPL/2.0/. + +# Stage 9 compiler. +# + +const + symbol_builtin_name_int := "Int"; + symbol_builtin_name_word := "Word"; + symbol_builtin_name_pointer := "Pointer"; + symbol_builtin_name_char := "Char"; + symbol_builtin_name_bool := "Bool"; + + # Every type info starts with a word describing what type it is. + # + # PRIMITIVE_TYPE = 1 + # + # Primitive types have only type size. + symbol_builtin_type_int := S(1, 4); + symbol_builtin_type_word := S(1, 4); + symbol_builtin_type_pointer := S(1, 4); + symbol_builtin_type_char := S(1, 1); + symbol_builtin_type_bool := S(1, 1); + + # Info objects start with a word describing its type. + # + # INFO_TYPE = 1 + # + # Type info has the type it belongs to. + symbol_type_info_int := S(1, @symbol_builtin_type_int); + symbol_type_info_word := S(1, @symbol_builtin_type_word); + symbol_type_info_pointer := S(1, @symbol_builtin_type_pointer); + symbol_type_info_char := S(1, @symbol_builtin_type_char); + symbol_type_info_bool := S(1, @symbol_builtin_type_bool); + +# When modifiying also change the read size in the entry point procedure. +.type source_code, @object +source_code: .zero 81920 + +.type compiler_strings, @object +compiler_strings: .zero 8192 + +var + compiler_strings_position: Pointer := @compiler_strings; + compiler_strings_length: Word := 0; + source_code_position: Pointer := @source_code; + +# Calculates and returns the string token length between quotes, including the +# escaping slash characters. +# +# Parameters: +# a0 - String token pointer. +# +# Returns the length in a0. +proc _string_length(); +begin + # Reset the counter. + v0 := 0; + +.string_length_loop: + v88 := v88 + 1; + + lw t0, 88(sp) + lb t0, (t0) + + li t1, '"' + beq t0, t1, .string_length_end + + v0 := v0 + 1; + goto .string_length_loop; + +.string_length_end: + return v0 +end; + +# Adds a string to the global, read-only string storage. +# +# Parameters: +# a0 - String token. +# +# Returns the offset from the beginning of the storage to the new string in a0. +proc _add_string(); +begin + v0 := v88 + 1; + v4 := compiler_strings_length; + +.add_string_loop: + lw t0, 0(sp) + lb t1, (t0) + li t2, '"' + + beq t1, t2, .add_string_end + + la t2, compiler_strings_position + lw t3, (t2) + sb t1, (t3) + + addi t3, t3, 1 + sw t3, (t2) + + addi t0, t0, 1 + sw t0, 0(sp) + + li t2, '\\' + bne t1, t2, .add_string_increment + + goto .add_string_loop; + +.add_string_increment: + la t2, compiler_strings_length + lw t4, (t2) + addi t4, t4, 1 + sw t4, (t2) + + goto .add_string_loop; + +.add_string_end: + return v4 +end; + +# Reads standard input into a buffer. +# a0 - Buffer pointer. +# a1 - Buffer size. +# +# Returns the amount of bytes written in a0. +proc _read_file(); +begin + mv a2, a1 + mv a1, a0 + # STDIN. + li a0, 0 + li a7, 63 # SYS_READ. + ecall +end; + +# Writes to the standard output. +# +# Parameters: +# a0 - Buffer. +# a1 - Buffer length. +proc _write_s(); +begin + mv a2, a1 + mv a1, a0 + # STDOUT. + li a0, 1 + li a7, 64 # SYS_WRITE. + ecall +end; + +# Writes a number to a string buffer. +# +# t0 - Local buffer. +# t1 - Constant 10. +# t2 - Current character. +# t3 - Whether the number is negative. +# +# Parameters: +# a0 - Whole number. +# a1 - Buffer pointer. +# +# Sets a0 to the length of the written number. +proc _print_i(); +begin + li t1, 10 + addi t0, s0, -9 + + li t3, 0 + bgez a0, .print_i_digit10 + li t3, 1 + neg a0, a0 + +.print_i_digit10: + rem t2, a0, t1 + addi t2, t2, '0' + sb t2, 0(t0) + div a0, a0, t1 + addi t0, t0, -1 + bne zero, a0, .print_i_digit10 + + beq zero, t3, .print_i_write_call + addi t2, zero, '-' + sb t2, 0(t0) + addi t0, t0, -1 + +.print_i_write_call: + mv a0, a1 + addi a1, t0, 1 + sub a2, s0, t0 + addi a2, a2, -9 + sw a2, 0(sp) + + _memcpy(); + + return v0 +end; + +# Writes a number to the standard output. +# +# Parameters: +# a0 - Whole number. +proc _write_i(); +begin + _print_i(v88, @v0); + + mv a1, a0 + addi a0, sp, 0 + _write_s(); + +end; + +# Writes a character from a0 into the standard output. +proc _write_c(); +begin + _write_s(@v88, 1); +end; + +# Write null terminated string. +# +# Parameters: +# a0 - String. +proc _write_z(); +begin +.write_z_loop: + # Check for 0 character. + lw a0, 88(sp) + lb a0, (a0) + beqz a0, .write_z_end + + # Print a character. + _write_c(); + + # Advance the input string by one byte. + v88 := v88 + 1; + + goto .write_z_loop; + +.write_z_end: +end; + +# Detects if a0 is an uppercase character. Sets a0 to 1 if so, otherwise to 0. +proc _is_upper(); +begin + v0 := v88 >= 'A'; + v4 := v88 <= 'Z'; + + return v0 & v4 + +end; + +# Detects if a0 is an lowercase character. Sets a0 to 1 if so, otherwise to 0. +proc _is_lower(); +begin + v0 := v88 >= 'a'; + v4 := v88 <= 'z'; + + return v0 & v4 + +end; + +# Detects if the passed character is a 7-bit alpha character or an underscore. +# +# Paramters: +# a0 - Tested character. +# +# Sets a0 to 1 if the character is an alpha character or underscore, sets it to 0 otherwise. +proc _is_alpha(); +begin + sw a0, 0(sp) + + _is_upper(); + sw a0, 4(sp) + + _is_lower(v0); + + lw t0, 0(sp) + xori t1, t0, '_' + seqz t1, t1 + + lw t0, 4(sp) + or a0, a0, t0 + or a0, a0, t1 +end; + +# Detects whether the passed character is a digit +# (a value between 0 and 9). +# +# Parameters: +# a0 - Exemined value. +# +# Sets a0 to 1 if it is a digit, to 0 otherwise. +proc _is_digit(); +begin + v0 := v88 >= '0'; + v4 := v88 <= '9'; + + return v0 & v4 +end; + +proc _is_alnum(); +begin + sw a0, 4(sp) + + _is_alpha(); + sw a0, 0(sp) + + _is_digit(v4); + + lw a1, 0(sp) + or a0, a0, a1 +end; + +# Reads the next token. +# +# Returns token length in a0. +proc _read_token(); +begin + # Current token position. + v0 := source_code_position; + # Token length. + v4 := 0; + +.read_token_loop: + lw t0, 0(sp) + lb t0, (t0) # Current character. + + # First we try to read a derictive. + # A derictive can contain a dot and characters. + li t1, '.' + beq t0, t1, .read_token_next + + lw a0, 0(sp) + lb a0, (a0) + _is_alnum(); + bnez a0, .read_token_next + + goto .read_token_end; + +.read_token_next: + # Advance the source code position and token length. + v4 := v4 + 1; + v0 := v0 + 1; + + goto .read_token_loop; + +.read_token_end: + return v4 +end; + +# a0 - First pointer. +# a1 - Second pointer. +# a2 - The length to compare. +# +# Returns 0 in a0 if memory regions are equal. +proc _memcmp(); +begin + mv t0, a0 + li a0, 0 + +.memcmp_loop: + beqz a2, .memcmp_end + + lbu t1, (t0) + lbu t2, (a1) + sub a0, t1, t2 + + bnez a0, .memcmp_end + + addi t0, t0, 1 + addi a1, a1, 1 + addi a2, a2, -1 + + goto .memcmp_loop; + +.memcmp_end: +end; + +# Copies memory. +# +# Parameters: +# a0 - Destination. +# a1 - Source. +# a2 - Size. +# +# Preserves a0. +proc _memcpy(); +begin + mv t0, a0 + +.memcpy_loop: + beqz a2, .memcpy_end + + lbu t1, (a1) + sb t1, (a0) + + addi a0, a0, 1 + addi a1, a1, 1 + addi a2, a2, -1 + + goto .memcpy_loop + +.memcpy_end: + mv a0, t0 +end; + +# Advances the token stream by a0 bytes. +proc _advance_token(); +begin + la t0, source_code_position + lw t1, (t0) + add t1, t1, a0 + sw t1, (t0) +end; + +# Prints the current token. +# +# Parameters: +# a0 - Token length. +# +# Returns a0 unchanged. +proc _write_token(); +begin + _write_s(source_code_position, v88); + return v88 +end; + +proc _compile_section(); +begin + # Print and skip the ".section" (8 characters) directive and a space after it. + _write_token(9); + _advance_token(); + + # Read the section name. + _read_token(); + addi a0, a0, 1 + + _write_token(); + _advance_token(); +end; + +# Prints and skips a line. +proc _skip_comment(); +begin + la t0, source_code_position + lw t1, (t0) + +.skip_comment_loop: + # Check for newline character. + lb t2, (t1) + li t3, '\n' + beq t2, t3, .skip_comment_end + + # Advance the input string by one byte. + addi t1, t1, 1 + sw t1, (t0) + + goto .skip_comment_loop; + +.skip_comment_end: + # Skip the newline. + addi t1, t1, 1 + sw t1, (t0) +end; + +# Prints and skips a line. +proc _compile_line(); +begin +.compile_line_loop: + la a0, source_code_position + lw a1, (a0) + + lb t0, (a1) + li t1, '\n' + beq t0, t1, .compile_line_end + + # Print a character. + lw a0, (a1) + _write_c(); + + # Advance the input string by one byte. + _advance_token(1); + + goto .compile_line_loop; + +.compile_line_end: + _write_c('\n'); + + _advance_token(1); +end; + +proc _compile_integer_literal(); +begin + _write_z("\tli t0, \0"); + + _read_token(); + _write_token(); + _advance_token(); + + _write_c('\n'); +end; + +proc _compile_character_literal(); +begin + _write_z("\tli t0, \0"); + + _write_c('\''); + _advance_token(1); + + la t0, source_code_position + lw t0, (t0) + lb a0, (t0) + li t1, '\\' + bne a0, t1, .compile_character_literal_end + + _write_c('\\'); + _advance_token(1); + +.compile_character_literal_end: + la t0, source_code_position + lw t0, (t0) + lb a0, (t0) + _write_c(); + + _write_c('\''); + _write_c('\n'); + + _advance_token(2); + +end; + +proc _compile_variable_expression(); +begin + _compile_designator(); + _write_z("\tlw t0, (t0)\n\0"); +end; + +proc _compile_address_expression(); +begin + # Skip the "@" sign. + _advance_token(1); + _compile_designator(); + +end; + +proc _compile_negate_expression(); +begin + # Skip the "-" sign. + _advance_token(1); + _compile_term(); + + _write_z("\tneg t0, t0\n\0"); +end; + +proc _compile_not_expression(); +begin + # Skip the "~" sign. + _advance_token(1); + _compile_term(); + + _write_z("\tnot t0, t0\n\0"); +end; + +proc _compile_string_literal(); +begin + _string_length(source_code_position); + sw a0, 0(sp) + + _add_string(source_code_position); + sw a0, 4(sp) + + _advance_token(v0 + 2); + _write_z("\tla t0, strings\n\0"); + + _write_z("\tli t1, \0"); + _write_i(v4); + _write_c('\n'); + + _write_z("\tadd t0, t0, t1\n\0"); +end; + +proc _compile_term(); +begin + la t0, source_code_position + lw t0, (t0) + lb a0, (t0) + sw a0, 0(sp) + + li t1, '\'' + beq a0, t1, .compile_term_character_literal + + li t1, '@' + beq a0, t1, .compile_term_address + + li t1, '-' + beq a0, t1, .compile_term_negation + + li t1, '~' + beq a0, t1, .compile_term_not + + li t1, '"' + beq a0, t1, .compile_term_string_literal + + _is_digit(v0); + bnez a0, .compile_term_integer_literal + + goto .compile_term_variable; + +.compile_term_character_literal: + _compile_character_literal(); + goto .compile_term_end; + +.compile_term_integer_literal: + _compile_integer_literal(); + goto .compile_term_end; + +.compile_term_address: + _compile_address_expression(); + goto .compile_term_end; + +.compile_term_negation: + _compile_negate_expression(); + goto .compile_term_end; + +.compile_term_not: + _compile_not_expression(); + goto .compile_term_end; + +.compile_term_string_literal: + _compile_string_literal(); + goto .compile_term_end; + +.compile_term_variable: + _compile_variable_expression(); + goto .compile_term_end; + +.compile_term_end: +end; + +proc _compile_binary_rhs(); +begin + # Skip the whitespace after the binary operator. + _advance_token(1); + _compile_term(); + + # Load the left expression from the stack; + _write_z("\tlw t1, 24(sp)\n\0"); +end; + +proc _compile_expression(); +begin + _compile_term(); + + la t0, source_code_position + lw t0, (t0) + lb a0, (t0) + + li t1, ' ' + bne a0, t1, .compile_expression_end + + # It is a binary expression. + + # Save the value of the left expression on the stack. + _write_z("sw t0, 24(sp)\n\0"); + + # Skip surrounding whitespace in front of the operator. + _advance_token(1); + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, '+' + beq t0, t1, .compile_expression_add + + li t1, '*' + beq t0, t1, .compile_expression_mul + + li t1, '&' + beq t0, t1, .compile_expression_and + + li t1, 'o' + beq t0, t1, .compile_expression_or + + li t1, 'x' + beq t0, t1, .compile_expression_xor + + li t1, '=' + beq t0, t1, .compile_expression_equals + + li t1, '<' + beq t0, t1, .compile_expression_less + + li t1, '>' + beq t0, t1, .compile_expression_greater + + # Unknown binary operator. + unimp + +.compile_expression_add: + _advance_token(1); + _compile_binary_rhs(); + + # Execute the operation. + _write_z("add t0, t0, t1\n\0"); + + goto .compile_expression_end; + +.compile_expression_mul: + _advance_token(1); + _compile_binary_rhs(); + + # Execute the operation. + _write_z("\tmul t0, t0, t1\n\0"); + + goto .compile_expression_end; + +.compile_expression_and: + _advance_token(1); + _compile_binary_rhs(); + + # Execute the operation. + _write_z("\tand t0, t0, t1\n\0"); + + goto .compile_expression_end; + +.compile_expression_or: + _advance_token(2); + _compile_binary_rhs(); + + # Execute the operation. + _write_z("or t0, t0, t1\n\0"); + + goto .compile_expression_end; + +.compile_expression_xor: + _advance_token(3); + _compile_binary_rhs(); + + # Execute the operation. + _write_z("xor t0, t0, t1\n\0"); + + goto .compile_expression_end; + +.compile_expression_equals: + _advance_token(1); + _compile_binary_rhs(); + + # Execute the operation. + _write_z("xor t0, t0, t1\nseqz t0, t0\n\0"); + + goto .compile_expression_end; + +.compile_expression_less: + _advance_token(1); + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, '>' + beq t0, t1, .compile_expression_not_equal + + li t1, '=' + beq t0, t1, .compile_expression_less_equal + + _compile_binary_rhs(); + + # Execute the operation. + _write_z("slt t0, t0, t1\n\0"); + + goto .compile_expression_end; + +.compile_expression_not_equal: + _advance_token(1); + _compile_binary_rhs(); + + # Execute the operation. + _write_z("\txor t0, t0, t1\nsnez t0, t0\n\0"); + + goto .compile_expression_end; + +.compile_expression_less_equal: + _advance_token(1); + _compile_binary_rhs(); + + # Execute the operation. + _write_z("\tslt t0, t0, t1\nxori t0, t0, 1\n\0"); + + goto .compile_expression_end; + +.compile_expression_greater: + _advance_token(1); + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, '=' + beq t0, t1, .compile_expression_greater_equal + + _compile_binary_rhs(); + + # Execute the operation. + _write_z("\tslt t0, t1, t0\n\0"); + + goto .compile_expression_end; + +.compile_expression_greater_equal: + _advance_token(1); + _compile_binary_rhs(); + + # Execute the operation. + _write_z("\tslt t0, t1, t0\nxori t0, t0, 1\n\0"); + + goto .compile_expression_end; + +.compile_expression_end: +end; + +proc _compile_call(); +begin + # Stack variables: + # v0 - Procedure name length. + # v4 - Procedure name pointer. + # v8 - Argument count. + + _read_token(); + sw a0, 0(sp) + v4 := source_code_position; + v8 := 0; + + # Skip the identifier and left paren. + _advance_token(v0 + 1); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, ')' + beq t0, t1, .compile_call_finalize + +.compile_call_loop: + _compile_expression(); + + # Save the argument on the stack. + _write_z("\tsw t0, \0"); + + # Calculate the stack offset: 116 - (4 * argument_counter) + v12 := v8 * 4; + v12 := 116 + -v12; + _write_i(v12); + + _write_z("(sp)\n\0"); + + # Add one to the argument counter. + v8 := v8 + 1; + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, ',' + bne t0, t1, .compile_call_finalize + + _advance_token(2); + goto .compile_call_loop; + +.compile_call_finalize: + # Load the argument from the stack. + + lw t0, 8(sp) + beqz t0, .compile_call_end + + # Decrement the argument counter. + v8 := v8 + -1; + + _write_z("\tlw a\0"); + _write_i(v8); + + _write_z(", \0"); + + # Calculate the stack offset: 116 - (4 * argument_counter) + v12 := v8 * 4; + v12 := 116 + -v12; + _write_i(v12); + + _write_z("(sp)\n\0"); + + goto .compile_call_finalize; + +.compile_call_end: + _write_z("\tcall \0"); + _write_s(v4, v0); + + # Skip the right paren. + _advance_token(1); +end; + +proc _compile_goto(); +begin + _advance_token(5); + + _read_token(); + sw a0, 0(sp) + + _write_z("\tj \0"); + + _write_token(v0); + _advance_token(); +end; + +proc _compile_local_designator(); +begin + # Skip "v" in the local variable name. + _advance_token(1); + _write_z("\t addi t0, sp, \0"); + + # Read local variable stack offset and save it. + _read_token(); + _write_token(); + _advance_token(); + _write_c('\n'); +end; + +proc _compile_global_designator(); +begin + _write_z("\tla t0, \0"); + + _read_token(); + _write_token(); + _advance_token(); + + _write_c('\n'); +end; + +proc _compile_designator(); +begin + la t0, source_code_position + lw t0, (t0) + lb a0, (t0) + + li t1, 'v' + beq a0, t1, .compile_designator_local + + goto .compile_designator_global; + +.compile_designator_local: + _compile_local_designator(); + goto .compile_designator_end; + +.compile_designator_global: + _compile_global_designator(); + goto .compile_designator_end; + +.compile_designator_end: +end; + +proc _compile_assignment(); +begin + _compile_designator(); + + # Save the assignee address on the stack. + _write_z("\tsw t0, 20(sp)\n\0"); + + # Skip the assignment sign (:=) with surrounding whitespaces. + _advance_token(4); + + # Compile the assignment. + _compile_expression(); + + _write_z("\tlw t1, 20(sp)\nsw t0, (t1)\n\0"); +end; + +proc _compile_return_statement(); +begin + # Skip "return" keyword and whitespace after it. + _advance_token(7); + _compile_expression(); + + _write_z("mv a0, t0\n\0"); +end; + +proc _compile_statement(); +begin + # This is a call if the statement starts with an underscore. + la t0, source_code_position + lw t0, (t0) + # First character after alignment tab. + addi t0, t0, 1 + lb t0, (t0) + + li t1, '_' + beq t0, t1, .compile_statement_call + + li t1, 'g' + beq t0, t1, .compile_statement_goto + + li t1, 'v' + beq t0, t1, .compile_statement_assignment + + # keyword_ret contains "\tret", so it's 4 bytes long. + _memcmp(source_code_position, "\treturn", 7); + beqz a0, .compile_statement_return + + _compile_line(); + goto .compile_statement_end; + +.compile_statement_call: + _advance_token(1); + _compile_call(); + + goto .compile_statement_semicolon; + +.compile_statement_goto: + _advance_token(1); + _compile_goto(); + + goto .compile_statement_semicolon; + +.compile_statement_assignment: + _advance_token(1); + _compile_assignment(); + + goto .compile_statement_semicolon; + +.compile_statement_return: + _advance_token(1); + _compile_return_statement(); + _write_c('\n'); + + goto .compile_statement_end; + +.compile_statement_semicolon: + _advance_token(2); + _write_c('\n'); + +.compile_statement_end: +end; + +proc _compile_procedure_body(); +begin +.compile_procedure_body_loop: + # 3 is "end" length. + _memcmp(source_code_position, "end", 3); + + beqz a0, .compile_procedure_body_epilogue + + _compile_statement(); + goto .compile_procedure_body_loop; + +.compile_procedure_body_epilogue: +end; + +# Writes a regster name to the standard output. +# +# Parameters: +# a0 - Register character. +# a1 - Register number. +proc _write_register(); +begin + _write_c(v88); + v84 := v84 + '0'; + _write_c(v84); +end; + +proc _compile_procedure_prologue(); +begin + _write_z("\taddi sp, sp, -128\n\tsw ra, 124(sp)\n\tsw s0, 120(sp)\n\taddi s0, sp, 128\n\0"); + v0 := 0; + +.compile_procedure_prologue_loop: + _write_z("\tsw a\0"); + _write_i(v0); + _write_z(", \0"); + + # Calculate the stack offset: 88 - (4 * parameter_counter) + v4 := v0 * 4; + v4 := 88 + -v4; + _write_i(v4); + + _write_z("(sp)\n\0"); + + v0 := v0 + 1; + lw a0, 0(sp) + + li t0, 8 + bne a0, t0, .compile_procedure_prologue_loop +end; + +proc _compile_procedure(); +begin + # Skip "proc ". + _advance_token(5); + + _read_token(); + sw a0, 0(sp) # Save the procedure name length. + + # Write .type _procedure_name, @function. + _write_z(".type \0"); + + _write_token(v0); + _write_z(", @function\n\0"); + + # Write procedure label, _procedure_name: + _write_token(v0); + _write_z(":\n\0"); + + # Skip the function name and trailing parens, semicolon, "begin" and newline. + _advance_token(v0 + 10); + + _compile_procedure_prologue(); + _compile_procedure_body(); + + # Write the epilogue. + _write_z("\tlw ra, 124(sp)\n\tlw s0, 120(sp)\n\taddi sp, sp, 128\n\tret\n\0"); + + # Skip the "end" keyword, semicolon and newline. + _advance_token(5); +end; + +proc _skip_newlines(); +begin + # Skip newlines. + la t0, source_code_position + lw t1, (t0) + +.skip_newlines_loop: + lb t2, (t1) + li t3, '\n' + bne t2, t3, .skip_newlines_end + beqz t2, .skip_newlines_end + + addi t1, t1, 1 + sw t1, (t0) + + goto .skip_newlines_loop; + +.skip_newlines_end: +end; + +# Skip newlines and comments. +proc _skip_empty_lines(); +begin +.skip_empty_lines_loop: + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, '#' + beq t0, t1, .skip_empty_lines_comment + + li t1, '\n' + beq t0, t1, .skip_empty_lines_newline + + goto .skip_empty_lines_end; + +.skip_empty_lines_comment: + _skip_comment(); + goto .skip_empty_lines_loop; + +.skip_empty_lines_newline: + _advance_token(1); + goto .skip_empty_lines_loop; + +.skip_empty_lines_end: +end; + +proc _compile_global_initializer(); +begin + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, '"' + beq t0, t1, .compile_global_initializer_string + + li t1, 'S' + beq t0, t1, .compile_global_initializer_record + + li t1, '@' + beq t0, t1, .compile_global_initializer_pointer + + la a0, source_code_position + lw a0, (a0) + lb a0, (a0) + _is_digit(); + bnez a0, .compile_global_initializer_number + + unimp + +.compile_global_initializer_pointer: + # Skip @. + _advance_token(1); + _write_z("\n\t.word \0"); + _read_token(); + _write_token(); + _advance_token(); + + goto .compile_global_initializer_end; + +.compile_global_initializer_number: + _write_z("\n\t.word \0"); + _read_token(); + _write_token(); + _advance_token(1); + + goto .compile_global_initializer_end; + +.compile_global_initializer_record: + # Skip "S(". + _advance_token(2); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, ')' + beq t0, t1, .compile_global_initializer_closing + +.compile_global_initializer_loop: + _compile_global_initializer(); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, ')' + beq t0, t1, .compile_global_initializer_closing + + # Skip comma and whitespace after it. + _advance_token(2); + + goto .compile_global_initializer_loop; + +.compile_global_initializer_closing: + # Skip ")" + _advance_token(1); + + goto .compile_global_initializer_end; + +.compile_global_initializer_string: + _write_z("\n\t.word strings + \0"); + _string_length(source_code_position); + sw a0, 4(sp) + + _add_string(source_code_position); + _write_i(); + + # Skip the quoted string. + _advance_token(v4 + 2); + + goto .compile_global_initializer_end; + +.compile_global_initializer_end: +end; + +proc _compile_constant_declaration(); +begin + _read_token(); + sw a0, 0(sp) + + _write_z(".type \0"); + _write_token(v0); + _write_z(", @object\n\0"); + + _write_token(v0); + _write_c(':'); + + # Skip the constant name with assignment sign and surrounding whitespaces. + _advance_token(v0 + 4); + _compile_global_initializer(); + # Skip semicolon and newline. + _advance_token(2); + _write_c('\n'); +end; + +proc _compile_const_part(); +begin + _skip_empty_lines(); + + _memcmp(source_code_position, "const\0", 5); + bnez a0, .compile_const_part_end + + # Skip "const" with the newline after it. + _advance_token(6); + _write_z(".section .rodata # Compiled from const section.\n\n\0"); + +.compile_const_part_loop: + _skip_empty_lines(); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + # If the character at the line beginning is not indentation, + # it is probably the next code section. + li t1, '\t' + bne t0, t1, .compile_const_part_end + + _advance_token(1); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, '#' + beq t0, t1, .compile_const_part_loop + + _compile_constant_declaration(); + goto .compile_const_part_loop; + +.compile_const_part_end: +end; + +proc _compile_variable_declaration(); +begin + _read_token(); + sw a0, 0(sp) + + _write_z(".type \0"); + _write_token(v0); + _write_z(", @object\n\0"); + + _write_token(v0); + _write_c(':'); + + # Skip the variable name and colon with space before the type. + _advance_token(v0 + 2); + + # Skip the type name. + _read_token(); + _advance_token(); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, ' ' + beq t0, t1, .compile_variable_declaration_initializer + + # Else we assume this is a zeroed 81920 bytes big array. + _write_z(" .zero 81920\0"); + goto .compile_variable_declaration_finalize; + +.compile_variable_declaration_initializer: + # Skip the assignment sign with surrounding whitespaces. + _advance_token(4); + _compile_global_initializer(); + goto .compile_variable_declaration_finalize; + +.compile_variable_declaration_finalize: + # Skip semicolon and newline. + _advance_token(2); + _write_c('\n'); +end; + +proc _compile_var_part(); +begin + _memcmp(source_code_position, "var\0", 3); + bnez a0, .compile_var_part_end + + # Skip "var" and newline. + _advance_token(4); + _write_z(".section .data\n\0"); + +.compile_var_part_loop: + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + + li t1, 'p' + beq t0, t1, .compile_var_part_end + + li t1, '\t' + beq t0, t1, .compile_var_part_declaration + + _compile_line(); + goto .compile_var_part_loop; + +.compile_var_part_declaration: + _advance_token(1); + _compile_variable_declaration(); + goto .compile_var_part_loop; + +.compile_var_part_end: +end; + +# Process the source code and print the generated code. +proc _compile_module(); +begin + _compile_const_part(); + _write_z(".section .bss\n\0"); + +.compile_module_bss: + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + li t1, 'v' + beq t0, t1, .compile_module_code + + li t1, 'p' + beq t0, t1, .compile_module_code + + _compile_line(); + goto .compile_module_bss; + +.compile_module_code: + _compile_var_part(); + _write_z(".section .text\n\0"); +.compile_module_loop: + _skip_newlines(); + + la t0, source_code_position + lw t0, (t0) + lb t0, (t0) + beqz t0, .compile_module_end + li t1, '#' + beq t0, t1, .compile_module_comment + + # 8 is ".section" length. + _memcmp(source_code_position, ".section", 8); + beqz a0, .compile_module_section + + # 5 is "proc " length. Space is needed to distinguish from "procedure". + _memcmp(source_code_position, "proc ", 5); + beqz a0, .compile_module_procedure + + # 6 is ".globl" length. + _memcmp(source_code_position, ".globl", 6); + beqz a0, .compile_module_global + + # Not a known token, exit. + goto .compile_module_end; + +.compile_module_section: + _compile_section(); + + goto .compile_module_loop; + +.compile_module_global: + _compile_line(); + + goto .compile_module_loop; + +.compile_module_comment: + _skip_comment(); + + goto .compile_module_loop; + +.compile_module_procedure: + _compile_procedure(); + + goto .compile_module_loop; + +.compile_module_end: +end; + +proc _compile(); +begin + _write_z(".globl _start\n\n\0"); + _compile_module(); + + _write_z(".section .rodata\n.type strings, @object\nstrings: .ascii \0"); + _write_c('"'); + + la t0, compiler_strings + sw t0, 0(sp) + +.compile_loop: + lw t0, 0(sp) + la t1, compiler_strings_position + lw t1, (t1) + bge t0, t1, .compile_end + + lb a0, (t0) + + addi t0, t0, 1 + sw t0, 0(sp) + + _write_c(); + + j .compile_loop + +.compile_end: + _write_c('"'); + _write_c('\n'); +end; + +# Terminates the program. a0 contains the return code. +# +# Parameters: +# a0 - Status code. +proc _exit(); +begin + li a7, 93 # SYS_EXIT + ecall +end; + +# Entry point. +proc _start(); +begin + # Read the source from the standard input. + # Second argument is buffer size. Modifying update the source_code definition. + _read_file(@source_code, 81920); + _compile(); + + _exit(0); + +end; |