summaryrefslogtreecommitdiff
path: root/04b/in03
diff options
context:
space:
mode:
Diffstat (limited to '04b/in03')
-rw-r--r--04b/in032532
1 files changed, 0 insertions, 2532 deletions
diff --git a/04b/in03 b/04b/in03
deleted file mode 100644
index 8fb9ade..0000000
--- a/04b/in03
+++ /dev/null
@@ -1,2532 +0,0 @@
-; initialize global_variables_end
-C=:global_variables_end
-D=:global_variables
-8C=D
-; initialize static_memory_end
-C=:static_memory_end
-; 0x80000 = 512KB for code
-D=x480000
-8C=D
-; initialize labels_end
-C=:labels_end
-D=:labels
-8C=D
-
-I=8S
-A=d2
-?I>A:argv_file_names
- ; use default input/output filenames
- ; open input file
- J=:input_filename
- I=d0
- syscall x2
- J=A
- ?J<0:input_file_error
- ; open output file
- J=:output_filename
- I=x241
- D=x1ed
- syscall x2
- J=A
- ?J<0:output_file_error
- !:second_pass_starting_point
-:argv_file_names
- ; open input file
- J=S
- ; argv[1] is at *(rsp+16)
- J+=d16
- J=8J
- I=d0
- syscall x2
- J=A
- ?J<0:input_file_error
- ; open output file
- J=S
- ; argv[2] is at *(rsp+24)
- J+=d24
- J=8J
- I=x241
- D=x1ed
- syscall x2
- J=A
- ?J<0:output_file_error
-
-
-:second_pass_starting_point
-; write ELF header
-J=d4
-I=:ELF_header
-D=x78
-syscall x1
-
-:read_line
-; increment line number
-D=:line_number
-C=8D
-C+=d1
-8D=C
-
-; use rbp to store line pointer
-R=:line
-:read_line_loop
- ; read 1 byte into rbp
- J=d3
- I=R
- D=d1
- syscall x0
- D=A
- ?D=0:eof
-
- ; check if the character was a newline:
- C=1R
- D=xa
- ?C=D:read_line_loop_end
- ; check if the character was a tab:
- D=x9
- ; if so, don't increment rbp
- ?C=D:read_line_loop
- ; check if the character was a semicolon:
- D=';
- ; if so, it's a comment
- ?C=D:handle_comment
-
- R+=d1
- !:read_line_loop
-
- :handle_comment
- ; read out rest of line from file
- J=d3
- I=R
- D=d1
- syscall x0
- D=A
- ?D=0:eof
- C=1R
- D=xa
- ; if we didn't reach the end of the line, keep going
- ?C!D:handle_comment
-
- !:read_line_loop_end
-:read_line_loop_end
-
-; remove whitespace (specifically, ' ' characters) at end of line
-I=R
-:remove_terminal_whitespace_loop
- I-=d1
- C=1I
- D=x20
- ?C!D:remove_terminal_whitespace_loop_end
- ; replace ' ' with a newline
- D=xa
- 1I=D
- !:remove_terminal_whitespace_loop
-:remove_terminal_whitespace_loop_end
-
-; check if this is a blank line
-C=:line
-D=1C
-C=xa
-?C=D:read_line
-
-C=':
-?C=D:handle_label_definition
-
-I=:line
-J=:"global"
-C=x20
-call :string=
-D=A
-?D!0:handle_global
-
-I=:line
-J=:"local"
-C=x20
-call :string=
-D=A
-?D!0:handle_local
-; arguments are treated the same as local variables
-I=:line
-J=:"argument"
-C=x20
-call :string=
-D=A
-?D!0:handle_local
-
-I=:line
-J=:"return"
-C=x20
-call :string=
-D=A
-?D!0:handle_return
-
-I=:line
-J=:"byte"
-C=x20
-call :string=
-D=A
-?D!0:handle_byte
-
-I=:line
-J=:"string"
-C=x20
-call :string=
-D=A
-?D!0:handle_string
-
-I=:line
-J=:"goto"
-C=x20
-call :string=
-D=A
-?D!0:handle_goto
-
-I=:line
-J=:"if"
-C=x20
-call :string=
-D=A
-?D!0:handle_if
-
-I=:line
-J=:"function"
-call :string=
-D=A
-?D!0:handle_function
-
-
-; set delimiter to newline
-C=xa
-
-I=:line
-J=:"return\n"
-call :string=
-D=A
-?D!0:handle_return
-
-; check if this is an assignment
-I=:line
-:assignment_check_loop
- C=1I
- D=xa
- ?C=D:assignment_check_loop_end
- D='=
- ?C=D:handle_assignment
- I+=d1
- !:assignment_check_loop
-:assignment_check_loop_end
-
-; check if this is a function call (where we discard the return value)
-I=:line
-; (check for an opening bracket not preceded by a space)
-:call_check_loop
- C=1I
- D=x20
- ?C=D:call_check_loop_end
- D=xa
- ?C=D:call_check_loop_end
- D='(
- ?C=D:handle_call
- I+=d1
- !:call_check_loop
-:call_check_loop_end
-
-!:bad_statement
-
-!:read_line
-
-:eof
- C=:second_pass
- D=1C
- ?D!0:exit_success
- ; set 2nd pass to 1
- 1C=d1
- ; make sure output file is large enough for static memory
- ; we'll use the ftruncate syscall to set the size of the file
- J=d4
- I=:static_memory_end
- I=8I
- I-=x400000
- syscall x4d
- ; seek both files back to start
- J=d3
- I=d0
- D=d0
- syscall x8
- J=d4
- I=d0
- D=d0
- syscall x8
- ; set line number to 0
- C=:line_number
- 8C=0
-
- !:second_pass_starting_point
-
-:exit_success
- J=d0
- syscall x3c
-
-align
-:local_variable_name
- reserve d8
-
-:handle_byte
- I=:line
- ; 5 = length of "byte "
- I+=d5
- call :read_number
- ; make sure byte is 0-255
- C=A
- D=xff
- ?CaD:bad_byte
- ; write byte
- I=:byte
- 1I=C
- J=d4
- D=d1
- syscall x1
- !:read_line
-:byte
- reserve d1
-
-:handle_string
- I=:line
- ; 7 = length of "string "
- I+=d7
- J=I
- ; find end of string
- :string_loop
- C=1J
- D=xa
- ?C=D:string_loop_end
- J+=d1
- !:string_loop
- :string_loop_end
- ; get length of string
- D=J
- D-=I
- ; output fd
- J=d4
- syscall x1
- !:read_line
-
-:handle_call
- J=I
- ; just use the rvalue function call code
- C=:rvalue
- D=:line
- 8C=D
- I=:line
- call :rvalue_function_call
- !:read_line
-
-:handle_local
- ; skip ' '
- I+=d1
-
- ; store away pointer to variable name
- C=:local_variable_name
- 8C=I
-
- ; check if already defined
- J=:local_variables
- call :ident_lookup
- C=A
- ?C!0:local_redeclaration
-
- C=:local_variable_name
- I=8C
- J=:local_variables_end
- J=8J
- call :ident_copy
-
- ; increase stack_end, store it in J
- C=:stack_end
- D=4C
- D+=d8
- 4C=D
- 4J=D
- J+=d4
- ; store null terminator
- 1J=0
-
- ; update :local_variables_end
- I=:local_variables_end
- 8I=J
-
- ; set rsp appropriately
- C=:rbp_offset
- J=d0
- J-=D
- 4C=J
-
- J=d4
- I=:lea_rsp_[rbp_offset]
- D=d7
- syscall x1
-
-
- ; read the next line
- !:read_line
-
-:lea_rsp_[rbp_offset]
- x48
- x8d
- xa5
-:rbp_offset
- reserve d4
-
-align
-:global_start
- reserve d8
-:global_variable_name
- reserve d8
-:global_variable_size
- reserve d8
-:handle_global
- ; ignore if this is the second pass
- C=:second_pass
- C=1C
- ?C!0:read_line
-
- ; skip ' '
- I+=d1
-
- C=1I
- D='9
- ?C>D:global_default_size
- ; read specific size of global
- call :read_number
- D=A
- C=:global_variable_size
- 8C=D
- ; check and skip space after number
- C=1I
- D=x20
- ?C!D:bad_number
- I+=d1
- !:global_cont
- :global_default_size
- ; default size = 8
- C=:global_variable_size
- D=d8
- 8C=D
- :global_cont
-
- ; store away pointer to variable name
- C=:global_variable_name
- 8C=I
-
- ; check if already defined
- J=:global_variables
- call :ident_lookup
- C=A
- ?C!0:global_redeclaration
-
- C=:global_variable_name
- I=8C
-
- J=:global_variables_end
- J=8J
- call :ident_copy
- ; store address
- D=:static_memory_end
- C=4D
- 4J=C
- J+=d4
- ; increase static_memory_end by size
- D=:global_variable_size
- D=8D
- C+=D
- D=:static_memory_end
- 4D=C
- ; store null terminator
- 1J=0
- ; update :global_variables_end
- I=:global_variables_end
- 8I=J
- ; go read the next line
- !:read_line
-
-:handle_function
- I=:line
- ; length of "function "
- I+=d9
- ; make function name a label
- call :add_label
-
- ; emit prologue
- J=d4
- I=:function_prologue
- D=d14
- syscall x1
-
- ; reset local variable table
- D=:local_variables
- 1D=0
- C=:local_variables_end
- 8C=D
-
- ; reset stack_end
- D=:stack_end
- 4D=0
-
- ; go read the next line
- !:read_line
-
-:function_prologue
- ; sub rsp, 8
- x48
- x81
- xec
- x08
- x00
- x00
- x00
- ; mov [rsp], rbp
- x48
- x89
- x2c
- x24
- ; mov rbp, rsp
- R=S
- ; total length: 7 + 4 + 3 = 14 bytes
-
-:function_epilogue
- ; mov rsp, rbp
- S=R
- ; mov rbp, [rsp]
- x48
- x8b
- x2c
- x24
- ; add rsp, 8
- x48
- x81
- xc4
- x08
- x00
- x00
- x00
- ; ret
- return
- ; total length = 15 bytes
-
-:handle_label_definition
- I=:line
- I+=d1
- call :add_label
- !:read_line
-
-align
-:label_name
- reserve d8
-; add the label in rsi to the label list (with the current pc address)
-:add_label
- ; ignore if this is the second pass
- C=:second_pass
- C=1C
- ?C!0:return_0
-
- C=:label_name
- 8C=I
-
- ; make sure label only has identifier characters
- :label_checking_loop
- C=1I
- D=xa
- ?C=D:label_checking_loop_end
- I+=d1
- B=C
- call :isident
- D=A
- ?D!0:label_checking_loop
- !:bad_label
- :label_checking_loop_end
-
- C=:label_name
- I=8C
- J=:labels
- call :ident_lookup
- C=A
- ?C!0:label_redefinition
-
- J=:labels_end
- J=8J
- C=:label_name
- I=8C
- call :ident_copy
- R=J
-
- ; figure out where in the file we are (using lseek)
- J=d4
- I=d0
- D=d1
- syscall x8
- C=A
- C+=x400000
- J=R
- ; store address
- 4J=C
- J+=d4
-
- ; update labels_end
- C=:labels_end
- 8C=J
-
- return
-
-:handle_goto
- J=d4
- I=:jmp_prefix
- D=d1
- syscall x1
- I=:line
- ; 5 = length of "goto "
- I+=d5
- call :emit_label_jump_address
- !:read_line
-:jmp_prefix
- xe9
-
-:handle_if
- I=:line
- I+=d3
- ; skip term 1
- call :go_to_space
- I+=d1
- ; skip operator
- call :go_to_space
- I+=d1
- ; put second operand in rsi
- call :set_rax_to_term
- call :set_rsi_to_rax
-
-
- I=:line
- ; length of "if "
- I+=d3
- ; put first operand in rax
- call :set_rax_to_term
- ; put second operand in rbx
- call :set_rbx_to_rsi
- ; emit cmp rax, rbx
- J=d4
- I=:cmp_rax_rbx
- D=d3
- syscall x1
-
- I=:line
- I+=d3
- call :go_to_space
- I+=d1
- R=I
- C=x20
-
- I=R
- J=:"=="
- call :string=
- I=A
- ?I!0:write_je
-
- I=R
- J=:"!="
- call :string=
- I=A
- ?I!0:write_jne
-
- I=R
- J=:">"
- call :string=
- I=A
- ?I!0:write_jg
-
- I=R
- J=:"<"
- call :string=
- I=A
- ?I!0:write_jl
-
- I=R
- J=:">="
- call :string=
- I=A
- ?I!0:write_jge
-
- I=R
- J=:"<="
- call :string=
- I=A
- ?I!0:write_jle
-
- I=R
- J=:"]"
- call :string=
- I=A
- ?I!0:write_ja
-
- I=R
- J=:"["
- call :string=
- I=A
- ?I!0:write_jb
-
- I=R
- J=:"]="
- call :string=
- I=A
- ?I!0:write_jae
-
- I=R
- J=:"[="
- call :string=
- I=A
- ?I!0:write_jbe
-
- !:bad_jump
-
- :write_je
- J=d4
- I=:je_prefix
- D=d2
- syscall x1
- !:if_continue
-
- :write_jne
- J=d4
- I=:jne_prefix
- D=d2
- syscall x1
- !:if_continue
-
- :write_jl
- J=d4
- I=:jl_prefix
- D=d2
- syscall x1
- !:if_continue
-
- :write_jg
- J=d4
- I=:jg_prefix
- D=d2
- syscall x1
- !:if_continue
-
- :write_jle
- J=d4
- I=:jle_prefix
- D=d2
- syscall x1
- !:if_continue
-
- :write_jge
- J=d4
- I=:jge_prefix
- D=d2
- syscall x1
- !:if_continue
-
- :write_jb
- J=d4
- I=:jb_prefix
- D=d2
- syscall x1
- !:if_continue
-
- :write_ja
- J=d4
- I=:ja_prefix
- D=d2
- syscall x1
- !:if_continue
-
- :write_jbe
- J=d4
- I=:jbe_prefix
- D=d2
- syscall x1
- !:if_continue
-
- :write_jae
- J=d4
- I=:jae_prefix
- D=d2
- syscall x1
- !:if_continue
-
-:if_continue
- I=:line
- I+=d3
- ; skip term 1
- call :go_to_space
- I+=d1
- ; skip operator
- call :go_to_space
- I+=d1
- ; skip term 2
- call :go_to_space
- I+=d1
- J=:"goto"
- C=x20
- call :string=
- C=A
- ; make sure word after term 2 is "goto"
- ?C=0:bad_jump
- I+=d1
- call :emit_label_jump_address
- !:read_line
-
-:je_prefix
- x0f
- x84
-:jne_prefix
- x0f
- x85
-:jl_prefix
- x0f
- x8c
-:jg_prefix
- x0f
- x8f
-:jle_prefix
- x0f
- x8e
-:jge_prefix
- x0f
- x8d
-:jb_prefix
- x0f
- x82
-:ja_prefix
- x0f
- x87
-:jbe_prefix
- x0f
- x86
-:jae_prefix
- x0f
- x83
-
-:cmp_rax_rbx
- x48
- x39
- xd8
-
-align
-:reladdr
- reserve d4
-
-; emit relative address (for jumping) of label in rsi
-:emit_label_jump_address
- ; address doesn't matter for first pass
- C=:second_pass
- C=1C
- ?C=0:jump_ignore_address
- ; look up label; store address in rbp
- J=:labels
- call :ident_lookup
- C=A
- ?C=0:bad_label
- R=4C
-:jump_ignore_address
-
- ; first, figure out current address
- J=d4
- I=d0
- D=d1
- syscall x8
- C=A
- ; add an additional 4 because the relative address is 4 bytes long
- C+=x400004
-
- ; compute relative address
- D=d0
- D-=C
- D+=R
- ; store in :reladdr
- C=:reladdr
- 4C=D
- ; output
- J=d4
- I=:reladdr
- D=d4
- syscall x1
- return
-
-align
-:assignment_type
- reserve d8
-:handle_assignment
- I-=d1
- C=:assignment_type
- 8C=I
-
- I+=d2
- C=1I
- D=x20
- ; check for space after =
- ?C!D:bad_assignment
- I+=d1
-
- ; set rdi to right-hand side of assignment
- call :set_rax_to_rvalue
- call :set_rdi_to_rax
-
- J=:assignment_type
- J=8J
- C=1J
- ; put newline after lvalue to make parsing easier
- D=xa
- 1J=D
- D=x20
- ?C=D:handle_assignment_cont
- J-=d1
- D=xa
- 1J=D
- :handle_assignment_cont
- D=x20
- ?C=D:handle_plain_assignment
- D='+
- ?C=D:handle_+=
- D='-
- ?C=D:handle_-=
- D='*
- ?C=D:handle_*=
- D='/
- ?C=D:handle_/=
- D='%
- ?C=D:handle_%=
- D='&
- ?C=D:handle_&=
- D='|
- ?C=D:handle_|=
- D='^
- ?C=D:handle_^=
- D='<
- ?C=D:handle_<=
- D='>
- ?C=D:handle_>=
-
- !:bad_assignment
-
-:handle_plain_assignment
- I=:line
- call :set_lvalue_to_rax
- !:read_line
-
-:handle_+=
- I=:line
- call :set_rax_to_rvalue
- call :set_rbx_to_rdi
- call :emit_add_rax_rbx
- I=:line
- call :set_lvalue_to_rax
- !:read_line
-
-:handle_-=
- I=:line
- call :set_rax_to_rvalue
- call :set_rbx_to_rdi
- call :emit_sub_rax_rbx
- I=:line
- call :set_lvalue_to_rax
- !:read_line
-
-:handle_*=
- I=:line
- call :set_rax_to_rvalue
- call :set_rbx_to_rdi
- call :emit_imul_rbx
- I=:line
- call :set_lvalue_to_rax
- !:read_line
-
-:handle_/=
- I=:line
- call :set_rax_to_rvalue
- call :set_rbx_to_rdi
- call :emit_zero_rdx_idiv_rbx
- I=:line
- call :set_lvalue_to_rax
- !:read_line
-
-:handle_%=
- I=:line
- call :set_rax_to_rvalue
- call :set_rbx_to_rdi
- call :emit_zero_rdx_idiv_rbx
- call :set_rax_to_rdx
- I=:line
- call :set_lvalue_to_rax
- !:read_line
-
-:handle_&=
- I=:line
- call :set_rax_to_rvalue
- call :set_rbx_to_rdi
- call :emit_and_rax_rbx
- I=:line
- call :set_lvalue_to_rax
- !:read_line
-
-:handle_|=
- I=:line
- call :set_rax_to_rvalue
- call :set_rbx_to_rdi
- call :emit_or_rax_rbx
- I=:line
- call :set_lvalue_to_rax
- !:read_line
-
-:handle_^=
- I=:line
- call :set_rax_to_rvalue
- call :set_rbx_to_rdi
- call :emit_xor_rax_rbx
- I=:line
- call :set_lvalue_to_rax
- !:read_line
-
-:handle_<=
- I=:line
- call :set_rax_to_rvalue
- call :set_rcx_to_rdi
- call :emit_shl_rax_cl
- I=:line
- call :set_lvalue_to_rax
- !:read_line
-
-:handle_>=
- I=:line
- call :set_rax_to_rvalue
- call :set_rcx_to_rdi
- call :emit_shr_rax_cl
- I=:line
- call :set_lvalue_to_rax
- !:read_line
-
-align
-:lvalue
- reserve d8
-
-; set the lvalue in rsi to <rax>
-:set_lvalue_to_rax
- C=:lvalue
- 8C=I
-
- ; first, store away <rax> value in <rdi>
- R=I
- call :set_rdi_to_rax
- I=R
-
- C=:lvalue
- I=8C
- C=1I
- D='*
-
- ?C=D:lvalue_deref
- ; not a dereference; just a variable
- C=:lvalue
- I=8C
- call :set_rax_to_address_of_variable
- call :set_rbx_to_rax
- call :set_rax_to_rdi
- call :set_[rbx]_to_rax
- return
- :lvalue_deref
- C=:lvalue
- I=8C
- I+=d2
- call :set_rax_to_address_of_variable
- call :set_rbx_to_rax
- call :set_rax_to_[rbx]
- call :set_rbx_to_rax
- call :set_rax_to_rdi
-
- C=:lvalue
- I=8C
- I+=d1
- C=1I
-
- D='1
- ?C=D:lvalue_deref1
- D='2
- ?C=D:lvalue_deref2
- D='4
- ?C=D:lvalue_deref4
- D='8
- ?C=D:lvalue_deref8
- !:bad_assignment
- :lvalue_deref1
- !:set_[rbx]_to_al
- :lvalue_deref2
- !:set_[rbx]_to_ax
- :lvalue_deref4
- !:set_[rbx]_to_eax
- :lvalue_deref8
- !:set_[rbx]_to_rax
-
-:handle_return
- I=:line
- ; skip "return"
- I+=d6
- C=1I
- D=xa
- ?C=D:no_return_value
-
- ; skip ' ' after return
- I+=d1
-
- call :set_rax_to_rvalue
-
- :no_return_value
- J=d4
- I=:function_epilogue
- D=d15
- syscall x1
-
- ; go read the next line
- !:read_line
-
-:mov_rsp_rbp
- S=R
-
-:ret
- return
-
-; copy the newline-terminated identifier from rsi to rdi
-:ident_copy
- C=1I
- B=C
- call :isident
- D=A
- ?D=0:bad_identifier
-
- :ident_loop
- C=1I
- 1J=C
- I+=d1
- J+=d1
- D=xa
- ?C=D:ident_loop_end
- B=C
- call :isident
- D=A
- ?D=0:bad_identifier
- !:ident_loop
- :ident_loop_end
- return
-
-align
-:ident_lookup_i
- reserve d8
-
-; look up identifier rsi in list rdi
-; returns address of whatever's right after the identifier in the list, or 0 if not found
-:ident_lookup
- C=:ident_lookup_i
- 8C=I
-
- :ident_lookup_loop
- ; check if reached the end of the table
- C=1J
- ?C=0:return_0
- I=:ident_lookup_i
- I=8I
- call :ident=
- C=A
- ; move past terminator of identifier in table
- :ident_finish_loop
- D=1J
- J+=d1
- A=xa
- ?D!A:ident_finish_loop
- ; check if this was it
- ?C!0:return_J
- ; nope. keep going
- ; skip over address:
- J+=d4
- !:ident_lookup_loop
-
-; can the character in rbx appear in an identifier?
-:isident
- A='0
- ?B<A:return_0
- ; note: 58 = '9' + 1
- A=d58
- ?B<A:return_1
- A='A
- ?B<A:return_0
- ; note: 91 = 'z' + 1
- A=d91
- ?B<A:return_1
- A='z
- ?B>A:return_0
- ; 96 = 'a' - 1
- A=d96
- ?B>A:return_1
- A='_
- ?B=A:return_1
- !:return_0
-
-; set <rax> to the term in rsi
-:set_rax_to_term
- R=I
-
- C=1I
- D=''
- ?C=D:term_number
- D='.
- ?C=D:term_label
- D=d58
- ?C<D:term_number
- ; (fallthrough)
-; set <rax> to the variable in rsi
-:set_rax_to_variable
- ; variable
- call :set_rax_to_address_of_variable
- call :set_rbx_to_rax
- call :set_rax_to_[rbx]
- return
-
-:term_label
- C=:second_pass
- C=1C
- ; skip looking up label on first pass; just use whatever's in rsi
- ?C=0:set_rax_to_immediate
- ; move past .
- I+=d1
- J=:labels
- call :ident_lookup
- C=A
- ?C=0:bad_label
- ; set rax to label value
- I=4C
- !:set_rax_to_immediate
-
-align
-:rvalue
- reserve d8
-
-; set <rax> to the rvalue in rsi
-:set_rax_to_rvalue
- ; store pointer to rvalue
- C=:rvalue
- 8C=I
-
- C=1I
- D='&
- ?C=D:rvalue_addressof
-
- D='~
- ?C=D:rvalue_bitwise_not
-
- D='*
- ?C=D:rvalue_dereference
-
- J=I
- :rvalue_loop
- C=1J
- D='(
- ?C=D:rvalue_function_call
- D=x20
- ?C=D:rvalue_binary_op
- D=xa
- ; no space or opening bracket; this must be a term
- ?C=D:set_rax_to_term
- J+=d1
- !:rvalue_loop
-
-align
-:rvalue_function_arg
- reserve d8
-:rvalue_function_arg_offset
- reserve d4
-
-:rvalue_function_call
- I=J
- I+=d1
- C=1I
- D=')
- ?C=D:function_call_no_arguments
-
- C=:rvalue_function_arg_offset
- ; set arg offset to -16 (to skip over stack space for return address and rbp)
- D=xfffffffffffffff0
- 4C=D
-
- :rvalue_function_loop
- C=:rvalue_function_arg
- 8C=I
- ; set <rax> to argument
- call :set_rax_to_term
- ; set <[rsp-arg_offset]> to rax
- ; first, output prefix
- J=d4
- I=:mov_[rsp_offset]_rax_prefix
- D=d4
- syscall x1
- ; now decrement offset, and output it
- I=:rvalue_function_arg_offset
- C=4I
- C-=d8
- 4I=C
- J=d4
- D=d4
- syscall x1
-
- C=:rvalue_function_arg
- I=8C
- ; skip over argument
- :rvalue_function_arg_loop
- C=1I
- D=',
- ?C=D:rvalue_function_next_arg
- D=')
- ?C=D:rvalue_function_loop_end
- D=xa
- ; no closing bracket
- ?C=D:bad_call
- I+=d1
- !:rvalue_function_arg_loop
- :rvalue_function_next_arg
- ; skip comma
- I+=d1
- C=1I
- D=x20
- ; make sure there's a space after the comma
- ?C!D:bad_call
- ; skip space
- I+=d1
-
- ; handle the next argument
- !:rvalue_function_loop
- :rvalue_function_loop_end
- :function_call_no_arguments
-
- I+=d1
- C=1I
- D=xa
- ; make sure there's nothing after the closing bracket
- ?C!D:bad_term
-
- C=:second_pass
- C=1C
- ?C=0:ignore_function_address
- ; look up function name
- I=:rvalue
- I=8I
- J=:labels
- call :ident_lookup
- C=A
- ?C=0:bad_function
- ; read address
- I=4C
- :ignore_function_address
- call :set_rax_to_immediate
- ; write call rax
- J=d4
- I=:call_rax
- D=d2
- syscall x1
- ; we're done!
-
- return
-
-:mov_[rsp_offset]_rax_prefix
- x48
- x89
- x84
- x24
-
-:call_rax
- xff
- xd0
-
-:binary_op
- reserve d1
-:rvalue_binary_op
- ; move past ' '
- J+=d1
- ; store binary op
- D=1J
- C=:binary_op
- 1C=D
-
- ; make sure space follows operator
- J+=d1
- C=1J
- D=x20
- ?C!D:bad_term
- ; set rsi to second operand
- J+=d1
- I=J
- call :set_rax_to_term
- call :set_rsi_to_rax
-
- ; now set rax to first operand
- I=:rvalue
- I=8I
- call :set_rax_to_term
-
- ; and combine
- C=:binary_op
- C=1C
-
- D='+
- ?C=D:rvalue_add
-
- D='-
- ?C=D:rvalue_sub
-
- D='*
- ?C=D:rvalue_mul
-
- D='/
- ?C=D:rvalue_div
-
- D='%
- ?C=D:rvalue_rem
-
- D='&
- ?C=D:rvalue_and
-
- D='|
- ?C=D:rvalue_or
-
- D='^
- ?C=D:rvalue_xor
-
- D='<
- ?C=D:rvalue_shl
-
- D='>
- ?C=D:rvalue_shr
-
- !:bad_term
-
-:rvalue_add
- call :set_rbx_to_rsi
- !:emit_add_rax_rbx
-
-:rvalue_sub
- call :set_rbx_to_rsi
- !:emit_sub_rax_rbx
-
-:rvalue_mul
- call :set_rbx_to_rsi
- !:emit_imul_rbx
-
-:rvalue_div
- call :set_rbx_to_rsi
- !:emit_zero_rdx_idiv_rbx
-
-:rvalue_rem
- call :set_rbx_to_rsi
- call :emit_zero_rdx_idiv_rbx
- call :set_rax_to_rdx
- return
-
-:rvalue_and
- call :set_rbx_to_rsi
- !:emit_and_rax_rbx
-
-:rvalue_or
- call :set_rbx_to_rsi
- !:emit_or_rax_rbx
-
-:rvalue_xor
- call :set_rbx_to_rsi
- !:emit_xor_rax_rbx
-
-:rvalue_shl
- call :set_rcx_to_rsi
- !:emit_shl_rax_cl
-
-:rvalue_shr
- call :set_rcx_to_rsi
- !:emit_shr_rax_cl
-
-:rvalue_addressof
- I+=d1
- !:set_rax_to_address_of_variable
-
-:rvalue_bitwise_not
- I+=d1
- call :set_rax_to_term
- J=d4
- I=:not_rax
- D=d3
- syscall x1
- return
-:not_rax
- x48
- xf7
- xd0
-
-:rvalue_dereference_size
- reserve d1
-
-:rvalue_dereference
- I+=d1
- D=1I
- C=:rvalue_dereference_size
- 1C=D
- I+=d1
- call :set_rax_to_variable
- call :set_rbx_to_rax
- call :zero_rax
- C=:rvalue_dereference_size
- C=1C
-
- D='1
- ?C=D:set_al_to_[rbx]
- D='2
- ?C=D:set_ax_to_[rbx]
- D='4
- ?C=D:set_eax_to_[rbx]
- D='8
- ?C=D:set_rax_to_[rbx]
-
- !:bad_term
-
-
-; set <rax> to address of variable in rsi
-:set_rax_to_address_of_variable
- J=:local_variables
- call :ident_lookup
- C=A
- ?C=0:try_global
- ; it's a local variable
- ; read the offset from <rbp>
- D=4C
- ; put negated offset in rbp
- R=d0
- R-=D
-
- ; lea rax, [rbp+
- J=d4
- I=:lea_rax_rbp_offset_prefix
- D=d3
- syscall x1
-
- ; offset]
- J=d4
- I=:imm64
- 4I=R
- D=d4
- syscall x1
-
- return
- :try_global
- J=:global_variables
- call :ident_lookup
- C=A
- ?C=0:bad_variable
- ; it's a global variable
- ; get its address
- C=4C
-
- ; put address in rax
- I=C
- !:set_rax_to_immediate
-
-:number_is_negative
- reserve d1
-
-:term_number
- call :read_number
- I=A
- !:set_rax_to_immediate
-
-; set rax to the number in the string at rsi
-:read_number
- C=1I
- D=''
- ?C=D:read_char
- D='-
- ; set rdx to 0 if number is positive, 1 if negative
- ?C=D:read_number_negative
- D=d0
- !:read_number_cont
- :read_number_negative
- D=d1
- I+=d1
- :read_number_cont
- ; store away negativity
- C=:number_is_negative
- 1C=D
- ; check if number starts with 0-9
- C=1I
- D='9
- ?C>D:bad_number
- D='0
- ?C<D:bad_number
- ?C=D:number_starting_with0
- ; it's a decimal number
- ; rbp will store the number
- R=d0
- :decimal_number_loop
- C=1I
- D='9
- ?C>D:decimal_number_loop_end
- D='0
- ?C<D:decimal_number_loop_end
- C-=D
- ; multiply by 10
- B=d10
- A=R
- mul
- R=A
- ; add this digit
- R+=C
-
- I+=d1
- !:decimal_number_loop
- :decimal_number_loop_end
- !:read_number_output
-
-:read_char
- I+=d1
- R=1I
- I+=d1
- !:read_number_output
-
-:number_starting_with0
- I+=d1
- C=1I
- D='x
- ?C=D:read_hex_number
- ; otherwise, it should just be 0
- R=d0
- !:read_number_output
-
-:read_hex_number
- I+=d1
- ; rbp will store the number
- R=d0
- :hex_number_loop
- C=1I
- D='0
- ?C<D:hex_number_loop_end
- D=d58
- ?C<D:hex_number_0123456789
- D='a
- ?C<D:hex_number_loop_end
- D='f
- ?C>D:hex_number_loop_end
- ; one of the digits a-f
- D=xffffffffffffffa9
- !:hex_number_digit
- :hex_number_0123456789
- D=xffffffffffffffd0
- :hex_number_digit
- C+=D
- ; shift left by 4
- R<=d4
- ; add digit
- R+=C
- I+=d1
- !:hex_number_loop
- :hex_number_loop_end
- !:read_number_output
-
-:read_number_output
- ; first, make sure number is followed by space/newline/appropriate punctuation
- C=1I
- D=x20
- ?C=D:read_number_valid
- D=',
- ?C=D:read_number_valid
- D=')
- ?C=D:read_number_valid
- D=xa
- ?C=D:read_number_valid
- !:bad_number
-:read_number_valid
- ; we now have the *unsigned* number in rbp. take the sign into consideration
- C=:number_is_negative
- D=1C
- ?D=0:number_not_negative
- ; R = -R
- C=R
- R=d0
- R-=C
- :number_not_negative
- ; finally, return
- A=R
- return
-
-
-
-; set <rax> to the immediate in rsi.
-:set_rax_to_immediate
- C=:imm64
- 8C=I
-
- ; write prefix
- J=d4
- D=d2
- I=:mov_rax_imm64_prefix
- syscall x1
-
- ; write immediate
- J=d4
- D=d8
- I=:imm64
- syscall x1
- return
-
-:zero_rax
- J=d4
- I=:xor_eax_eax
- D=d2
- syscall x1
- return
-:xor_eax_eax
- x31
- xc0
-
-:zero_rdx
- J=d4
- I=:xor_edx_edx
- D=d2
- syscall x1
- return
-:xor_edx_edx
- x31
- xd2
-
-:set_rbx_to_rax
- J=d4
- I=:mov_rbx_rax
- D=d3
- syscall x1
- return
-:mov_rbx_rax
- B=A
-
-:set_rbx_to_rsi
- J=d4
- I=:mov_rbx_rsi
- D=d3
- syscall x1
- return
-:mov_rbx_rsi
- B=I
-
-:set_rbx_to_rdi
- J=d4
- I=:mov_rbx_rdi
- D=d3
- syscall x1
- return
-:mov_rbx_rdi
- B=J
-
-:set_rcx_to_rsi
- J=d4
- I=:mov_rcx_rsi
- D=d3
- syscall x1
- return
-:mov_rcx_rsi
- C=I
-
-:set_rcx_to_rdi
- J=d4
- I=:mov_rcx_rdi
- D=d3
- syscall x1
- return
-:mov_rcx_rdi
- C=J
-
-:set_rax_to_rdx
- J=d4
- I=:mov_rax_rdx
- D=d3
- syscall x1
- return
-:mov_rax_rdx
- A=D
-
-:set_rax_to_rdi
- J=d4
- I=:mov_rax_rdi
- D=d3
- syscall x1
- return
-:mov_rax_rdi
- A=J
-
-:set_rsi_to_rax
- J=d4
- I=:mov_rsi_rax
- D=d3
- syscall x1
- return
-:mov_rsi_rax
- I=A
-
-:set_rdi_to_rax
- J=d4
- I=:mov_rdi_rax
- D=d3
- syscall x1
- return
-:mov_rdi_rax
- J=A
-
-:set_rax_to_[rbx]
- J=d4
- I=:mov_rax_[rbx]
- D=d3
- syscall x1
- return
-:mov_rax_[rbx]
- x48
- x8b
- x03
-
-:set_eax_to_[rbx]
- J=d4
- I=:mov_eax_[rbx]
- D=d2
- syscall x1
- return
-:mov_eax_[rbx]
- x8b
- x03
-
-:set_ax_to_[rbx]
- J=d4
- I=:mov_ax_[rbx]
- D=d3
- syscall x1
- return
-:mov_ax_[rbx]
- x66
- x8b
- x03
-
-:set_al_to_[rbx]
- J=d4
- I=:mov_al_[rbx]
- D=d2
- syscall x1
- return
-:mov_al_[rbx]
- x8a
- x03
-
-
-:set_[rbx]_to_rax
- J=d4
- I=:mov_[rbx]_rax
- D=d3
- syscall x1
- return
-:mov_[rbx]_rax
- x48
- x89
- x03
-
-:set_[rbx]_to_eax
- J=d4
- I=:mov_[rbx]_eax
- D=d2
- syscall x1
- return
-:mov_[rbx]_eax
- x89
- x03
-
-:set_[rbx]_to_ax
- J=d4
- I=:mov_[rbx]_ax
- D=d3
- syscall x1
- return
-:mov_[rbx]_ax
- x66
- x89
- x03
-
-:set_[rbx]_to_al
- J=d4
- I=:mov_[rbx]_al
- D=d2
- syscall x1
- return
-:mov_[rbx]_al
- x88
- x03
-
-
-:mov_rax_imm64_prefix
- x48
- xb8
-
-:emit_add_rax_rbx
- J=d4
- I=:add_rax_rbx
- D=d3
- syscall x1
- return
-:add_rax_rbx
- x48
- x01
- xd8
-
-:emit_sub_rax_rbx
- J=d4
- I=:sub_rax_rbx
- D=d3
- syscall x1
- return
-:sub_rax_rbx
- x48
- x29
- xd8
-
-:emit_and_rax_rbx
- J=d4
- I=:and_rax_rbx
- D=d3
- syscall x1
- return
-:and_rax_rbx
- x48
- x21
- xd8
-
-:emit_or_rax_rbx
- J=d4
- I=:or_rax_rbx
- D=d3
- syscall x1
- return
-:or_rax_rbx
- x48
- x09
- xd8
-
-:emit_xor_rax_rbx
- J=d4
- I=:xor_rax_rbx
- D=d3
- syscall x1
- return
-:xor_rax_rbx
- x48
- x31
- xd8
-
-:emit_shl_rax_cl
- J=d4
- I=:shl_rax_cl
- D=d3
- syscall x1
- return
-:shl_rax_cl
- x48
- xd3
- xe0
-
-:emit_shr_rax_cl
- J=d4
- I=:shr_rax_cl
- D=d3
- syscall x1
- return
-:shr_rax_cl
- x48
- xd3
- xe8
-
-:emit_imul_rbx
- J=d4
- I=:imul_rbx
- D=d3
- syscall x1
- return
-:imul_rbx
- x48
- xf7
- xeb
-
-:emit_zero_rdx_idiv_rbx
- call :zero_rdx
- J=d4
- I=:idiv_rbx
- D=d3
- syscall x1
- return
-:idiv_rbx
- x48
- xf7
- xfb
-
-align
-:imm64
- reserve d8
-
-; prefix for lea rax, [rbp+IMM32]
-:lea_rax_rbp_offset_prefix
- x48
- x8d
- x85
-
-:input_filename
- str in04b
- x0
-
-:output_filename
- str out04b
- x0
-
-:input_file_error
- B=:input_file_error_message
- !:general_error
-
-:input_file_error_message
- str Couldn't open input file.
- xa
- x0
-
-:output_file_error
- B=:output_file_error_message
- !:general_error
-
-:output_file_error_message
- str Couldn't open output file.
- xa
- x0
-
-:bad_identifier
- B=:bad_identifier_error_message
- !:program_error
-
-:bad_identifier_error_message
- str Bad identifier.
- xa
- x0
-
-:bad_label
- B=:bad_label_error_message
- !:program_error
-
-:bad_label_error_message
- str Bad label.
- xa
- x0
-
-:bad_variable
- B=:bad_variable_error_message
- !:program_error
-
-:bad_variable_error_message
- str No such variable.
- xa
- x0
-
-:bad_function
- B=:bad_function_error_message
- !:program_error
-
-:bad_function_error_message
- str No such function.
- xa
- x0
-
-:bad_byte
- B=:bad_byte_error_message
- !:program_error
-
-:bad_byte_error_message
- str Byte not in range 0-255.
- xa
- x0
-
-:bad_number
- B=:bad_number_error_message
- !:program_error
-
-:bad_number_error_message
- str Bad number.
- xa
- x0
-
-:bad_assignment
- B=:bad_assignment_error_message
- !:program_error
-
-:bad_assignment_error_message
- str Bad assignment.
- xa
- x0
-
-:bad_term
- B=:bad_term_error_message
- !:program_error
-
-:bad_term_error_message
- str Bad term.
- xa
- x0
-
-:bad_statement
- B=:bad_statement_error_message
- !:program_error
-
-:bad_statement_error_message
- str Bad statement.
- xa
- x0
-
-:bad_jump
- B=:bad_jump_error_message
- !:program_error
-
-:bad_jump_error_message
- str Bad jump.
- xa
- x0
-
-:bad_call
- B=:bad_call_error_message
- !:program_error
-
-:bad_call_error_message
- str Bad function call.
- xa
- x0
-
-:label_redefinition
- B=:label_redefinition_error_message
- !:program_error
-
-:label_redefinition_error_message
- str Label redefinition.
- xa
- x0
-
-:global_redeclaration
- B=:global_redeclaration_error_message
- !:program_error
-
-:global_redeclaration_error_message
- str Global variable declared twice.
- xa
- x0
-
-:local_redeclaration
- B=:local_redeclaration_error_message
- !:program_error
-
-:local_redeclaration_error_message
- str Local variable declared twice.
- xa
- x0
-
-:general_error
- call :eputs
- J=d1
- syscall x3c
-
-:program_error
- R=B
-
- B=:"Line"
- call :eputs
-
- D=:line_number
- D=8D
- B=D
- call :eputn
-
- B=:line_number_separator
- call :eputs
-
- B=R
- call :eputs
- J=d1
- syscall x3c
-
-:"Line"
- str Line
- x20
- x0
-
-:line_number_separator
- str :
- x20
- x0
-
-:strlen
- I=B
- D=B
- :strlen_loop
- C=1I
- ?C=0:strlen_ret
- I+=d1
- !:strlen_loop
- :strlen_ret
- I-=D
- A=I
- return
-
-; check if strings in rdi and rsi are equal, up to terminator in rcx
-:string=
- D=1I
- A=1J
- ?D!A:return_0
- ?D=C:return_1
- I+=d1
- J+=d1
- !:string=
-
-; check if strings in rdi and rsi are equal, up to the first non-identifier character
-:ident=
- D=1I
- B=D
- call :isident
- ; I ended
- ?A=0:ident=_I_end
-
- D=1J
- B=D
- call :isident
- ; J ended, but I didn't
- ?A=0:return_0
-
- ; we haven't reached the end of either
- D=1I
- A=1J
- ?D!A:return_0
- I+=d1
- J+=d1
- !:ident=
-:ident=_I_end
- D=1J
- B=D
- call :isident
- ; check if J also ended
- ?A=0:return_1
- ; J didn't end
- !:return_0
-
-:return_0
- A=d0
- return
-:return_1
- A=d1
- return
-:return_2
- A=d2
- return
-:return_3
- A=d3
- return
-:return_4
- A=d4
- return
-:return_5
- A=d5
- return
-:return_6
- A=d6
- return
-:return_7
- A=d7
- return
-:return_8
- A=d8
- return
-:return_J
- A=J
- return
-
-; write the character in rbx to the file in rdi.
-:fputc
- C=B
- I=S
- I-=d1
- 1I=C
- D=d1
- syscall x1
- return
-
-; write the string in rbx to stderr
-:eputs
- J=B
- call :strlen
- D=A
- I=J
- J=d2
- syscall x1
- return
-
-; write rbx in decimal to stderr
-:eputn
- I=B
- J=S
- J-=d1
- :eputn_loop
- D=d0
- ; divide by 10
- B=d10
- A=I
- div
- ; quotient is new number
- I=A
- ; add remainder to string
- D+='0
- 1J=D
- J-=d1
- ?I!0:eputn_loop
- J+=d1
- D=S
- D-=J
- I=J
- J=d2
- syscall x1
- return
-
-; copy rdx bytes from rsi to rdi.
-; this copies from the left: if you're doing an overlapped copy, rsi should be greater than rdi
-:memcpy
- ?D=0:return_0
- A=1I
- 1J=A
- I+=d1
- J+=d1
- D-=d1
- !:memcpy
-
-; copy from rdi to rsi, until byte cl is reached
-:memccpy
- D=1I
- 1J=D
- I+=d1
- J+=d1
- ?D!C:memccpy
- return
-
-; advance rsi to the next space or newline character
-:go_to_space
- C=1I
- D=xa
- ?C=D:return_0
- D=x20
- ?C=D:return_0
- I+=d1
- !:go_to_space
-
-:"global"
- str global
- x20
-:"argument"
- str argument
- x20
-:"local"
- str local
- x20
-:"return"
- str return
- x20
-:"return\n"
- str return
- xa
-:"byte"
- str byte
- x20
-:"string"
- str string
- x20
-:"goto"
- str goto
- x20
-:"if"
- str if
- x20
-:"function"
- str function
- x20
-:"=="
- str ==
- x20
-:"!="
- str !=
- x20
-:">"
- str >
- x20
-:"<"
- str <
- x20
-:"<="
- str <=
- x20
-:">="
- str >=
- x20
-:"["
- str [
- x20
-:"]"
- str ]
- x20
-:"[="
- str [=
- x20
-:"]="
- str ]=
- x20
-
-:zero
- x0
-
-; put a 0 byte before the line (this is important for removing whitespace at the end of the line,
-; specifically, we don't want this to be a space character)
-x0
-:line
- reserve d1000
-
-align
-:global_variables_end
- reserve d8
-:static_memory_end
- reserve d8
-:local_variables_end
- reserve d8
-:stack_end
- reserve d8
-:labels_end
- reserve d8
-:line_number
- reserve d8
-:global_variables
- reserve d50000
-:local_variables
- reserve d20000
-:labels
- reserve d200000
-:second_pass
- reserve d1
-
-:ELF_header
-x7f
-x45
-x4c
-x46
-x02
-x01
-x01
-
-reserve d9
-
-x02
-x00
-
-x3e
-x00
-
-x01
-x00
-x00
-x00
-
-x78
-x00
-x40
-x00
-x00
-x00
-x00
-x00
-
-x40
-x00
-x00
-x00
-x00
-x00
-x00
-x00
-
-reserve d12
-
-x40
-x00
-x38
-x00
-x01
-x00
-x00
-x00
-x00
-x00
-x00
-x00
-
-x01
-x00
-x00
-x00
-
-x07
-x00
-x00
-x00
-
-x78
-x00
-x00
-x00
-x00
-x00
-x00
-x00
-
-x78
-x00
-x40
-x00
-x00
-x00
-x00
-x00
-
-reserve d8
-
-x00
-x00
-x20
-x00
-x00
-x00
-x00
-x00
-
-x00
-x00
-x20
-x00
-x00
-x00
-x00
-x00
-
-x00
-x10
-x00
-x00
-x00
-x00
-x00
-x00
-
-; NOTE: we shouldn't end the file with a reserve; we don't handle that properly