janis/from-scratch
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: janis:e79af0192535d7f2a9513bd2f700c873f6e57f6f
Branches Tags
janis:main
..
compare: janis:56354237c63066ef40ecfc5606e0ac5266e55eeb
Branches Tags
janis:main

No commits in common. "e79af0192535d7f2a9513bd2f700c873f6e57f6f" and "56354237c63066ef40ecfc5606e0ac5266e55eeb" have entirely different histories.
e79af01925 ... 56354237c6

3 changed files with 166 additions and 393 deletions
Show stats Expand all files Collapse all files

509
lang/src/ast.asm
View file

@ -68,7 +68,6 @@ global parse_statement
global parse_block global parse_block
global ast_build_symtable global ast_build_symtable
global ast_walk_for_each global ast_walk_for_each
global ast_resolve_var_refs
;; start very simple, with only functions and addition ;; start very simple, with only functions and addition
;; ```rust ;; ```rust
@ -83,7 +82,6 @@ global ast_resolve_var_refs
;; kind: u8, ;; kind: u8,
;; data: *const (), ;; data: *const (),
;; extra: usize, ;; extra: usize,
;; span: u64,
;; } ;; }
;; ;;
;; struct AstArgument { ;; struct AstArgument {
@ -103,7 +101,6 @@ global ast_resolve_var_refs
parse_func: parse_func:
push rbp push rbp
mov rbp, rsp mov rbp, rsp
sub rsp, 8 ; span
push rdi push rdi
; start-structs ; start-structs
@ -117,21 +114,17 @@ parse_func:
; } ; }
; end-structs ; end-structs
; span: u64 [64..72]
; ast: *mut Ast [56..64]
; body: u64 [48..56]
; return_type: Type [32..48]
; args_len: usize [24..32]
; args_ptr: *const u64 [16..24]
; name_len: usize [8..16]
; name: *const u8 [0..8]
sub rsp, 56 sub rsp, 56
; name: *const u8 [0..8]
; name_len: usize [8..16]
; args_ptr: *const u64 [16..24]
; args_len: usize [24..32]
; return_type: Type [32..48]
; body: u64 [48..56]
; ast: *mut Ast [56..64]
mov qword [rsp + 16], 8 ; <*u64>::dangling() mov qword [rsp + 16], 8 ; <*u64>::dangling()
mov qword [rsp + 24], 0 ; args_len mov qword [rsp + 24], 0 ; args_len
call tokeniser_get_cursor
mov [rsp + 64], rax ; span
mov dil, TOKEN_FN mov dil, TOKEN_FN
call unwrap_token call unwrap_token
mov dil, TOKEN_IDENT mov dil, TOKEN_IDENT
@ -168,11 +161,9 @@ parse_func:
mov rdx, 56 ; size_of::<AstFunction> mov rdx, 56 ; size_of::<AstFunction>
call memcpy call memcpy
mov byte [rsp], AST_FUNCTION ; AstNode.kind mov byte [rsp], AST_FUNCTION ; kind
mov [rsp + 8], rdi ; AstNode.data mov [rsp + 8], rdi ; data
mov qword [rsp + 16], 0 ; AstNode.extra mov qword [rsp + 16], 0 ; extra
mov rdi, [rsp + 64] ; span
mov [rsp + 24], rdi ; AstNode.span
mov rdi, [rsp + 56] ; Ast mov rdi, [rsp + 56] ; Ast
lea rsi, [rsp] ; &AstNode lea rsi, [rsp] ; &AstNode
call vec_push call vec_push
@ -181,7 +172,6 @@ parse_func:
dec rax dec rax
add rsp, 56 add rsp, 56
pop rdi pop rdi
add rsp, 8
pop rbp pop rbp
ret ret
@ -199,7 +189,6 @@ parse_func:
parse_args: parse_args:
push rbp push rbp
mov rbp, rsp mov rbp, rsp
; span: u64 [80..88]
; vec: [40..80] ; vec: [40..80]
; argument: AstArgument { [8..40] ; argument: AstArgument { [8..40]
; name: *const u8 [8..16] ; name: *const u8 [8..16]
@ -207,7 +196,7 @@ parse_args:
; arg_type: Type [24..40] ; arg_type: Type [24..40]
; } ; }
; ast [0..8] ; ast [0..8]
sub rsp, 88 sub rsp, 80
mov [rsp], rdi ; Ast mov [rsp], rdi ; Ast
lea rdi, [rsp + 40] ; vec lea rdi, [rsp + 40] ; vec
@ -221,10 +210,6 @@ parse_args:
call expect_token call expect_token
test rax, rax test rax, rax
jnz .done_args jnz .done_args
call tokeniser_get_cursor
mov [rsp + 80], rax ; span
mov dil, TOKEN_IDENT mov dil, TOKEN_IDENT
call unwrap_token call unwrap_token
mov [rsp + 8], rax ; AstArgument.name mov [rsp + 8], rax ; AstArgument.name
@ -247,8 +232,6 @@ parse_args:
mov qword [rsp + 8], AST_ARG ; AstNode.kind mov qword [rsp + 8], AST_ARG ; AstNode.kind
mov [rsp + 16], rdi ; AstNode.data mov [rsp + 16], rdi ; AstNode.data
mov qword [rsp + 24], 0 ; AstNode.extra mov qword [rsp + 24], 0 ; AstNode.extra
mov rdi, [rsp + 80] ; span
mov [rsp + 32], rdi ; AstNode.span
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
lea rsi, [rsp + 8] ; &AstNode lea rsi, [rsp + 8] ; &AstNode
@ -273,7 +256,7 @@ parse_args:
.done_args: .done_args:
mov rax, [rsp + 40] ; args_ptr mov rax, [rsp + 40] ; args_ptr
mov rdx, [rsp + 48] ; args_len mov rdx, [rsp + 48] ; args_len
add rsp, 88 add rsp, 80
pop rbp pop rbp
ret ret
@ -334,7 +317,7 @@ parse_number:
parse_primary_expr: parse_primary_expr:
push rbp push rbp
mov rbp, rsp mov rbp, rsp
sub rsp, 40 sub rsp, 32
mov [rsp], rdi ; Ast mov [rsp], rdi ; Ast
; start-structs ; start-structs
@ -345,9 +328,6 @@ parse_primary_expr:
; } ; }
; end-structs ; end-structs
call tokeniser_get_cursor
mov [rsp + 32], rax ; span
mov dil, TOKEN_NUMBER mov dil, TOKEN_NUMBER
call expect_token call expect_token
test rax, rax test rax, rax
@ -362,7 +342,7 @@ parse_primary_expr:
jnz .var_ref jnz .var_ref
jmp .panic jmp .panic
.var_ref: .var_ref:
mov qword [rsp + 8], -1 ; AstVarRef.resolved mov qword [rsp + 8], 0 ; AstVarRef.resolved
mov [rsp + 16], rax ; AstVarRef.name mov [rsp + 16], rax ; AstVarRef.name
mov [rsp + 24], rdx ; AstVarRef.name_len mov [rsp + 24], rdx ; AstVarRef.name_len
@ -377,7 +357,6 @@ parse_primary_expr:
mov qword [rsp + 8], AST_VAR_REF ; AstNode.kind mov qword [rsp + 8], AST_VAR_REF ; AstNode.kind
mov [rsp + 16], rdi ; AstNode.data mov [rsp + 16], rdi ; AstNode.data
mov qword [rsp + 24], 0 ; AstNode.extra mov qword [rsp + 24], 0 ; AstNode.extra
; mov [rsp + 32], span ; AstNode.span
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
lea rsi, [rsp + 8] ; &AstNode lea rsi, [rsp + 8] ; &AstNode
call vec_push call vec_push
@ -391,10 +370,9 @@ parse_primary_expr:
mov rsi, rdx ; lexeme len mov rsi, rdx ; lexeme len
call parse_number call parse_number
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
mov byte [rsp + 8], AST_NUMBER ; AstNode.kind mov byte [rsp + 8], AST_NUMBER ; kind
mov [rsp + 16], rax ; AstNode.data mov [rsp + 16], rax ; data
mov qword [rsp + 24], 0 ; AstNode.extra mov qword [rsp + 24], 0 ; extra
; mov [rsp + 32], [rsp + 32] ; AstNode.span
lea rsi, [rsp + 8] ; &AstNode lea rsi, [rsp + 8] ; &AstNode
call vec_push call vec_push
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
@ -410,7 +388,7 @@ parse_primary_expr:
call unwrap_token call unwrap_token
mov rax, [rsp + 8] ; expr mov rax, [rsp + 8] ; expr
.epilogue: .epilogue:
add rsp, 40 add rsp, 32
pop rbp pop rbp
ret ret
.panic: .panic:
@ -434,8 +412,6 @@ parse_binary_expr:
; end-structs ; end-structs
sub rsp, 64 sub rsp, 64
; span: u64 [56..64]
; AstNode [32..64]
; lexeme: Lexeme [32..56] ; lexeme: Lexeme [32..56]
; right: u64 [24..32] ; right: u64 [24..32]
; right_placeness: u8 [20..21] ; right_placeness: u8 [20..21]
@ -450,9 +426,6 @@ parse_binary_expr:
mov byte [rsp + 17], sil ; upper_precedence mov byte [rsp + 17], sil ; upper_precedence
mov byte [rsp + 16], 0 mov byte [rsp + 16], 0
call tokeniser_get_cursor
mov [rsp + 56], rax ; span
call parse_prefix_expr call parse_prefix_expr
mov [rsp + 8], rax ; left mov [rsp + 8], rax ; left
mov [rsp + 19], dl ; left_placeness mov [rsp + 19], dl ; left_placeness
@ -537,7 +510,6 @@ parse_binary_expr:
mov byte [rsp + 32], AST_BINARY_OP ; AstNode.kind mov byte [rsp + 32], AST_BINARY_OP ; AstNode.kind
mov [rsp + 40], rax ; AstNode.data mov [rsp + 40], rax ; AstNode.data
mov qword [rsp + 48], 0 ; AstNode.extra mov qword [rsp + 48], 0 ; AstNode.extra
; mov [rsp + 56], [rsp + 56] ; AstNode.span
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
lea rsi, [rsp + 32] ; &AstNode lea rsi, [rsp + 32] ; &AstNode
call vec_push call vec_push
@ -575,13 +547,10 @@ parse_statement:
push rbp push rbp
mov rbp, rsp mov rbp, rsp
; AstNode [8..40] ; Ast [24..32]
; Ast [0..8] ; AstNode [0..24]
sub rsp, 40 sub rsp, 32
mov [rsp], rdi ; Ast mov [rsp + 24], rdi ; Ast
call tokeniser_get_cursor
mov [rsp + 32], rax ; AstNode.span
mov dil, TOKEN_RETURN mov dil, TOKEN_RETURN
call expect_token call expect_token
@ -594,21 +563,21 @@ parse_statement:
jmp .panic jmp .panic
.let: .let:
mov rdi, [rsp] ; Ast mov rdi, [rsp + 24] ; Ast
call ast_parse_let call ast_parse_let
mov [rsp], rax ; statement mov [rsp], rax ; statement
jmp .semi jmp .semi
.return: .return:
mov rdi, [rsp] ; Ast mov rdi, [rsp + 24] ; Ast
call parse_expr call parse_expr
mov byte [rsp + 8], AST_RETURN_STATEMENT ; AstNode.kind mov byte [rsp], AST_RETURN_STATEMENT ; kind
mov [rsp + 16], rax ; AstNode.data mov [rsp + 8], rax ; data
mov qword [rsp + 24], 0 ; AstNode.extra mov qword [rsp + 16], 0 ; extra
mov rdi, [rsp] ; Ast mov rdi, [rsp + 24] ; Ast
lea rsi, [rsp + 8] ; &AstNode lea rsi, [rsp] ; &AstNode
call vec_push call vec_push
mov rdi, [rsp] ; Ast mov rdi, [rsp + 24] ; Ast
mov rax, [rdi + 8] ; Ast.nodes.len() mov rax, [rdi + 8] ; Ast.nodes.len()
dec rax dec rax
mov [rsp], rax mov [rsp], rax
@ -617,7 +586,7 @@ parse_statement:
mov dil, TOKEN_SEMI mov dil, TOKEN_SEMI
call unwrap_token call unwrap_token
mov rax, [rsp] ; expression mov rax, [rsp] ; expression
add rsp, 40 add rsp, 32
pop rbp pop rbp
ret ret
.panic: .panic:
@ -629,16 +598,12 @@ parse_block:
push rbp push rbp
mov rbp, rsp mov rbp, rsp
; span: u64 [64..72]
; Ast: *mut Ast [56..64] ; Ast: *mut Ast [56..64]
; statements: Vec<Statement> [8..56] ; statements: Vec<Statement> [8..56]
; statement: u64 [0..8] ; statement: u64 [0..8]
sub rsp, 72 sub rsp, 64
mov [rsp + 56], rdi ; Ast mov [rsp + 56], rdi ; Ast
call tokeniser_get_cursor
mov [rsp + 64], rax ; span
mov dil, TOKEN_LBRACE mov dil, TOKEN_LBRACE
call unwrap_token call unwrap_token
@ -667,15 +632,13 @@ parse_block:
jmp .loop jmp .loop
.done: .done:
mov rdi, [rsp + 56] ; Ast mov rdi, [rsp + 56] ; Ast
mov qword [rsp], AST_BLOCK ; AstNode.kind mov qword [rsp], AST_BLOCK ; kind
mov rsi, [rsp + 64] ; span
mov [rsp + 24], rsi ; AstNode.span
lea rsi, [rsp] ; &AstNode lea rsi, [rsp] ; &AstNode
call vec_push call vec_push
mov rdi, [rsp + 56] ; Ast mov rdi, [rsp + 56] ; Ast
mov rax, [rdi + 8] ; Ast.nodes.len() mov rax, [rdi + 8] ; Ast.nodes.len()
dec rax dec rax
add rsp, 72 add rsp, 64
pop rbp pop rbp
ret ret
@ -744,13 +707,10 @@ parse_prefix_expr:
push rbp push rbp
mov rbp, rsp mov rbp, rsp
; AstNode [8..40]
; ast [0..8] ; ast [0..8]
sub rsp, 40 sub rsp, 32
mov [rsp], rdi ; Ast
call tokeniser_get_cursor mov [rsp], rdi ; Ast
mov [rsp + 32], rax ; AstNode.span
mov dil, TOKEN_STAR mov dil, TOKEN_STAR
call expect_token call expect_token
@ -803,7 +763,7 @@ parse_prefix_expr:
jmp .done jmp .done
.done: .done:
add rsp, 40 add rsp, 32
pop rbp pop rbp
ret ret
@ -813,17 +773,13 @@ parse_assignment_expr:
push rbp push rbp
mov rbp, rsp mov rbp, rsp
; span: u64 [32..40]
; source [24..32] ; source [24..32]
; dest [16..24] ; dest [16..24]
; dest_placeness [8..9] ; dest_placeness [8..9]
; ast [0..8] ; ast [0..8]
sub rsp, 40 sub rsp, 32
mov [rsp], rdi ; Ast mov [rsp], rdi ; Ast
call tokeniser_get_cursor
mov [rsp + 32], rax ; span
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
call parse_binary_expr call parse_binary_expr
mov [rsp + 16], rax ; dest mov [rsp + 16], rax ; dest
@ -840,7 +796,7 @@ parse_assignment_expr:
mov rsi, [rsp + 16] ; dest mov rsi, [rsp + 16] ; dest
movzx rdx, byte [rsp + 8] ; placeness movzx rdx, byte [rsp + 8] ; placeness
call ast_value_to_place call ast_value_to_place
mov [rsp + 16], rax ; dest mov [rsp + 16], rax ; source
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
call parse_expr call parse_expr
@ -864,7 +820,7 @@ parse_assignment_expr:
.done: .done:
mov rax, [rsp + 16] ; dest mov rax, [rsp + 16] ; dest
movzx rdx, byte [rsp + 8] ; placeness movzx rdx, byte [rsp + 8] ; placeness
add rsp, 40 add rsp, 32
pop rbp pop rbp
ret ret
@ -887,17 +843,12 @@ ast_parse_let:
; } ; }
; end-structs ; end-structs
; expr: u64 [48..56] ; AstNode [8..32]
; *AstVarDecl [40..48]
; AstNode [8..40]
; AstVarDecl [8..40] ; AstVarDecl [8..40]
; Ast [0..8] ; Ast [0..8]
sub rsp, 56 sub rsp, 48
mov [rsp], rdi ; Ast mov [rsp], rdi ; Ast
call tokeniser_get_cursor
mov [rsp + 40], rax ; span
; skipped in parse_statement ; skipped in parse_statement
; mov dil, TOKEN_LET ; mov dil, TOKEN_LET
; call unwrap_token ; call unwrap_token
@ -923,9 +874,21 @@ ast_parse_let:
mov rdx, 32 ; size_of::<AstVarDecl> mov rdx, 32 ; size_of::<AstVarDecl>
call memcpy call memcpy
mov [rsp + 40], rdi ; AstVarDecl ptr mov qword [rsp + 8], AST_VAR_DECL ; AstNode.kind
mov [rsp + 16], rdi ; AstNode.data
mov qword [rsp + 24], 0 ; AstNode.extra
mov rdi, [rsp] ; Ast
lea rsi, [rsp + 8] ; &AstNode
call vec_push
; variable is already a place
mov rdi, [rsp] ; Ast
mov rax, [rdi + 8] ; Ast.nodes.len()
dec rax
mov qword [rsp + 8], AST_ASSIGNMENT ; AstNode.kind
mov [rsp + 16], rax ; AstNode.data (variable index)
; parse the expression
mov dil, TOKEN_EQUALS mov dil, TOKEN_EQUALS
call unwrap_token call unwrap_token
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
@ -933,33 +896,10 @@ ast_parse_let:
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
mov rsi, rax ; expr mov rsi, rax ; expr
; mov rdx, rdx ; placeness ; mov rdx, rdx ; is_placeness
call ast_place_to_value call ast_place_to_value
mov [rsp + 48], rax ; expr index
; variable is defined at this point so that the expression cannot reference it
call tokeniser_get_cursor
mov rdi, [rsp + 40] ; AstVarDecl ptr
mov qword [rsp + 8], AST_VAR_DECL ; AstNode.kind
mov [rsp + 16], rdi ; AstNode.data
mov qword [rsp + 24], 0 ; AstNode.extra
mov [rsp + 32], rax ; AstNode.span
mov rdi, [rsp] ; Ast
lea rsi, [rsp + 8] ; &AstNode
call vec_push
; variables are places
mov rdi, [rsp] ; Ast
mov rax, [rdi + 8] ; Ast.nodes.len()
dec rax
mov qword [rsp + 8], AST_ASSIGNMENT ; AstNode.kind
mov [rsp + 16], rax ; AstNode.data (variable index)
mov rax, [rsp + 48] ; expr index
mov [rsp + 24], rax ; AstNode.extra (expr index) mov [rsp + 24], rax ; AstNode.extra (expr index)
; reuse span from variable declaration
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
lea rsi, [rsp + 8] ; &AstNode lea rsi, [rsp + 8] ; &AstNode
call vec_push call vec_push
@ -967,7 +907,7 @@ ast_parse_let:
mov rax, [rdi + 8] ; Ast.nodes.len() mov rax, [rdi + 8] ; Ast.nodes.len()
dec rax dec rax
add rsp, 56 add rsp, 48
xor rdx, rdx ; placeness = false xor rdx, rdx ; placeness = false
pop rbp pop rbp
ret ret
@ -984,26 +924,17 @@ ast_value_to_place:
mov rax, rsi mov rax, rsi
je .done je .done
; create new AST node ; create new AST node
sub rsp, 40 sub rsp, 32
mov [rsp], rdi ; Ast mov [rsp], rdi
mov [rsp + 8], rsi ; node_index mov byte [rsp + 8], AST_VALUE_TO_PLACE ; kind
mov [rsp + 16], rsi ; data
; load original node's span mov qword [rsp + 24], 0 ; extra
call vec_get
mov rdi, [rax + 24] ; AstNode.span
mov [rsp + 32], rdi ; AstNode.span
mov rsi, [rsp + 8] ; node_index
mov byte [rsp + 8], AST_VALUE_TO_PLACE ; AstNode.kind
mov [rsp + 16], rsi ; AstNode.data
mov qword [rsp + 24], 0 ; AstNode.extra
lea rsi, [rsp + 8] ; &AstNode lea rsi, [rsp + 8] ; &AstNode
mov rdi, [rsp] ; Ast
call vec_push call vec_push
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
mov rax, [rdi + 8] ; Ast.nodes.len() mov rax, [rdi + 8] ; Ast.nodes.len()
dec rax dec rax
add rsp, 40 add rsp, 32
.done: .done:
pop rbp pop rbp
ret ret
@ -1020,26 +951,17 @@ ast_place_to_value:
mov rax, rsi mov rax, rsi
je .done je .done
; create new AST node ; create new AST node
sub rsp, 40 sub rsp, 32
mov [rsp], rdi ; Ast mov [rsp], rdi
mov [rsp + 8], rsi ; node_index mov byte [rsp + 8], AST_PLACE_TO_VALUE ; kind
mov [rsp + 16], rsi ; data
; load original node's span mov qword [rsp + 24], 0 ; extra
call vec_get
mov rdi, [rax + 24] ; AstNode.span
mov [rsp + 32], rdi ; AstNode.span
mov rsi, [rsp + 8] ; node_index
mov byte [rsp + 8], AST_PLACE_TO_VALUE ; AstNode.kind
mov [rsp + 16], rsi ; AstNode.data
mov qword [rsp + 24], 0 ; AstNode.extra
lea rsi, [rsp + 8] ; &AstNode lea rsi, [rsp + 8] ; &AstNode
mov rdi, [rsp] ; Ast
call vec_push call vec_push
mov rdi, [rsp] ; Ast mov rdi, [rsp] ; Ast
mov rax, [rdi + 8] ; Ast.nodes.len() mov rax, [rdi + 8] ; Ast.nodes.len()
dec rax dec rax
add rsp, 40 add rsp, 32
.done: .done:
pop rbp pop rbp
ret ret
@ -1054,21 +976,21 @@ symkey_cmp:
mov rbp, rsp mov rbp, rsp
push rbx push rbx
sub rsp, 16
mov [rsp], rsi
mov [rsp + 8], rdx
mov al, byte [rsi] ; a.kind mov al, byte [rsi] ; a.kind
mov bl, byte [rdx] ; b.kind mov bl, byte [rdx] ; b.kind
cmp al, bl cmp al, bl
jl .a_less jl .a_less
jg .a_greater jg .a_greater
mov rax, [rsi + 8] ; a.scope_index mov rax, [rsi + 8] ; a.scope_index
mov rbx, [rdx + 8] ; b.scope_index mov rbx, [rdx + 8] ; b.scope_index
cmp rax, rbx cmp rax, rbx
jl .a_less jl .a_less
jg .a_greater jg .a_greater
mov rax, [rsi + 16] ; a.span
mov rbx, [rdx + 16] ; b.span
cmp rax, rbx
jl .a_less
jg .a_greater
mov rdi, [rsi + 24] ; a.ident mov rdi, [rsi + 24] ; a.ident
mov rsi, [rsi + 32] ; a.ident_len mov rsi, [rsi + 32] ; a.ident_len
@ -1078,15 +1000,6 @@ symkey_cmp:
cmp rax, 0 cmp rax, 0
jl .a_less jl .a_less
jg .a_greater jg .a_greater
mov rsi, [rsp]
mov rdx, [rsp + 8]
mov rax, [rsi + 16] ; a.span
mov rbx, [rdx + 16] ; b.span
cmp rax, rbx
jl .a_less
jg .a_greater
xor rax, rax xor rax, rax
jmp .epilogue jmp .epilogue
.a_less: .a_less:
@ -1095,7 +1008,6 @@ symkey_cmp:
.a_greater: .a_greater:
mov rax, 1 mov rax, 1
.epilogue: .epilogue:
add rsp, 16
pop rbx pop rbx
pop rbp pop rbp
ret ret
@ -1121,17 +1033,23 @@ ast_build_symtable:
push rbp push rbp
mov rbp, rsp mov rbp, rsp
; BuildSymtableCtx [24..64] ; BuildSymtableCtx [24..104]
; *SymbolTable [16..24] ; *SymbolTable [16..24]
; root_index [8..16] ; root_index [8..16]
; Ast [0..8] ; Ast [0..8]
sub rsp, 64 sub rsp, 104
mov [rsp], rdi ; Ast mov [rsp], rdi ; Ast
mov [rsp + 8], rsi ; root_index mov [rsp + 8], rsi ; root_index
mov [rsp + 16], rdx ; *SymbolTable mov [rsp + 16], rdx ; *SymbolTable
; initialise scope_stack and symtable vecs ; initialise scope_stack and symtable vecs
lea rdi, [rsp + 24] ; &BuildSymtableCtx.symtable lea rdi, [rsp + 24] ; &BuildSymtableCtx.scope_stack
mov rsi, 8 ; size of u64
mov rdx, 0 ; drop = None
mov rcx, 128 ; capacity
call vec_init_with
lea rdi, [rsp + 24 + 40] ; &BuildSymtableCtx.symtable
mov rsi, 56 ; size_of::<SymEntry> mov rsi, 56 ; size_of::<SymEntry>
mov rdx, 0 ; drop = None mov rdx, 0 ; drop = None
mov rcx, 128 ; capacity mov rcx, 128 ; capacity
@ -1146,11 +1064,11 @@ ast_build_symtable:
; memcpy symtable out ; memcpy symtable out
mov rdi, [rsp + 16] ; *SymbolTable mov rdi, [rsp + 16] ; *SymbolTable
lea rsi, [rsp + 24] ; &BuildSymtableCtx.symtable lea rsi, [rsp + 24 + 40] ; &BuildSymtableCtx.symtable
mov rdx, 40 ; size_of::<Vec<SymEntry>> mov rdx, 40 ; size_of::<Vec<SymEntry>>
call memcpy call memcpy
add rsp, 64 add rsp, 104
pop rbp pop rbp
ret ret
@ -1200,6 +1118,7 @@ ast_build_symtable:
;; ;;
;; #start-structs ;; #start-structs
;; struct BuildSymtableCtx { ;; struct BuildSymtableCtx {
;; scope_stack: Vec<u64>,
;; symtable: Vec<SymEntry>, ;; symtable: Vec<SymEntry>,
;; } ;; }
;; #end-structs ;; #end-structs
@ -1210,24 +1129,21 @@ ast_build_symtable:
;; rdi: Ctx ;; rdi: Ctx
;; rsi: Ast ;; rsi: Ast
;; rdx: index ;; rdx: index
;; rcx: scope
ast_build_symtable_for_each: ast_build_symtable_for_each:
push rbp push rbp
mov rbp, rsp mov rbp, rsp
push rbx push rbx
; scope: u64 [88..96]
; SymEntry [32..88] ; SymEntry [32..88]
; SymKey [32..72] ; SymKey [32..72]
; *AstNode [24..32] ; *AstNode [24..32]
; index [16..24] ; index [16..24]
; ctx [8..16] ; ctx [8..16]
; ast [0..8] ; ast [0..8]
sub rsp, 96 sub rsp, 88
mov [rsp], rsi ; Ast mov [rsp], rsi ; Ast
mov [rsp + 8], rdi ; Ctx mov [rsp + 8], rdi ; Ctx
mov [rsp + 16], rdx ; index mov [rsp + 16], rdx ; index
mov [rsp + 88], rcx ; scope
mov rdi, rsi ; Ast mov rdi, rsi ; Ast
mov rsi, rdx ; index mov rsi, rdx ; index
@ -1248,49 +1164,40 @@ ast_build_symtable_for_each:
mov byte [rsp + 32], SYM_KEY_SCOPE ; SymKey.kind mov byte [rsp + 32], SYM_KEY_SCOPE ; SymKey.kind
mov rdx, [rsp + 16] ; index mov rdx, [rsp + 16] ; index
mov qword [rsp + 40], rdx ; SymKey.scope_index mov qword [rsp + 40], rdx ; SymKey.scope_index
mov rdx, [rax + 24] ; AstNode.span
mov qword [rsp + 48], rdx ; SymKey.span
mov qword [rsp + 56], 1 ; SymKey.ident
mov qword [rsp + 64], 0 ; SymKey.ident_len
mov rbx, [rax + 8] ; AstNode.data
mov rdx, [rbx + 0] ; Func.name
mov rcx, [rbx + 8] ; Func.name_len
mov [rsp + 72], rdx ; SymEntry.index
mov [rsp + 80], rcx ; SymEntry.extra
mov rdi, [rsp + 8] ; Ctx.symtable
lea rsi, [rsp + 32] ; &SymEntry
mov rcx, 0 ; cmp_ctx
mov rdx, symkey_cmp ; cmp
call vec_insert_sorted
; add parent scope
mov byte [rsp + 32], SYM_KEY_PARENT_SCOPE ; SymKey.kind
mov rdx, [rsp + 16] ; index
mov qword [rsp + 40], rdx ; SymKey.scope_index
mov qword [rsp + 48], 0 ; SymKey.span mov qword [rsp + 48], 0 ; SymKey.span
mov qword [rsp + 56], 1 ; SymKey.ident mov qword [rsp + 56], 1 ; SymKey.ident
mov qword [rsp + 64], 0 ; SymKey.ident_len mov qword [rsp + 64], 0 ; SymKey.ident_len
mov rdx, [rsp + 88] ; parent scope ; mov rbx, [rax + 16] ; AstNode.data
mov [rsp + 72], rdx ; SymEntry.index ; mov rdx, [rbx + 8] ; Func.name
mov qword [rsp + 80], 0 ; SymEntry.extra ; mov rcx, [rbx + 16] ; Func.name_len
mov rbx, [rax + 8] ; AstNode.data
mov rdx, [rbx + 0] ; Func.name
mov rcx, [rbx + 8] ; Func.name_len
mov qword [rsp + 72], rdx ; SymEntry.index
mov qword [rsp + 80], rcx ; SymEntry.extra
mov rdi, [rsp + 8] ; *Ctx mov rdi, [rsp + 8] ; *Ctx
lea rdi, [rdi + 40] ; Ctx.symtable
lea rsi, [rsp + 32] ; &SymEntry lea rsi, [rsp + 32] ; &SymEntry
mov rcx, 0 ; cmp_ctx mov rcx, 0 ; cmp_ctx
mov rdx, symkey_cmp ; cmp mov rdx, symkey_cmp ; cmp
call vec_insert_sorted call vec_insert_sorted
; push scope index onto scope_stack
mov rdi, [rsp + 8] ; *Ctx
lea rdi, [rdi + 0] ; Ctx.scope_stack
lea rsi, [rsp + 16] ; &index
call vec_push
jmp .done jmp .done
.var_decl: .var_decl:
; insert variable entry ; insert variable entry
mov byte [rsp + 32], SYM_KEY_VAR ; SymKey.kind mov byte [rsp + 32], SYM_KEY_VAR ; SymKey.kind
mov rdx, [rax + 24] ; AstNode.span ; TODO: set span correctly
mov qword [rsp + 48], rdx ; SymKey.span mov qword [rsp + 48], 0 ; SymKey.span
mov rbx, [rsp + 24] ; AstNode.data mov rbx, [rsp + 24] ; AstNode.data
mov rbx, [rbx + 8] ; AstNode.data mov rbx, [rbx + 8] ; AstNode.data
@ -1304,10 +1211,17 @@ ast_build_symtable_for_each:
mov [rsp + 72], rdx ; SymEntry.index mov [rsp + 72], rdx ; SymEntry.index
mov qword [rsp + 80], 0 ; SymEntry.extra mov qword [rsp + 80], 0 ; SymEntry.extra
mov rdx, [rsp + 88] ; current scope mov qword [rsp + 40], 0 ; SymKey.scope_index = default
mov [rsp + 40], rdx ; SymKey.scope_index = default lea rdx, [rsp + 40]
mov rdi, [rsp + 8] ; *Ctx
mov rsi, [rdi + 8] ; Ctx.scope_stack.len()
dec rsi
call vec_get_or
mov rax, [rax] ; current scope index
mov [rsp + 40], rax ; SymKey.scope_index = scope_stack.last_or(0)
mov rdi, [rsp + 8] ; *Ctx mov rdi, [rsp + 8] ; *Ctx
lea rdi, [rdi + 40] ; Ctx.symtable
lea rsi, [rsp + 32] ; &SymEntry lea rsi, [rsp + 32] ; &SymEntry
mov rcx, 0 ; cmp_ctx mov rcx, 0 ; cmp_ctx
mov rdx, symkey_cmp ; cmp mov rdx, symkey_cmp ; cmp
@ -1318,8 +1232,8 @@ ast_build_symtable_for_each:
; insert variable entry ; insert variable entry
mov byte [rsp + 32], SYM_KEY_ARG ; SymKey.kind mov byte [rsp + 32], SYM_KEY_ARG ; SymKey.kind
mov rdx, [rax + 24] ; AstNode.span ; TODO: set span correctly
mov qword [rsp + 48], rdx ; SymKey.span mov qword [rsp + 48], 0 ; SymKey.span
mov rbx, [rsp + 24] ; *AstNode mov rbx, [rsp + 24] ; *AstNode
mov rbx, [rbx + 8] ; AstNode.data mov rbx, [rbx + 8] ; AstNode.data
@ -1333,18 +1247,24 @@ ast_build_symtable_for_each:
mov [rsp + 72], rdx ; SymEntry.index mov [rsp + 72], rdx ; SymEntry.index
mov qword [rsp + 80], 0 ; SymEntry.extra mov qword [rsp + 80], 0 ; SymEntry.extra
mov rdx, [rsp + 88] ; current scope mov qword [rsp + 40], 0 ; SymKey.scope_index = default
mov [rsp + 40], rdx ; SymKey.scope_index = default lea rdx, [rsp + 40]
mov rdi, [rsp + 8] ; *Ctx
mov rsi, [rdi + 8] ; Ctx.scope_stack.len()
dec rsi
call vec_get_or
mov rax, [rax] ; current scope index
mov [rsp + 40], rax ; SymKey.scope_index = scope_stack.last_or(0)
mov rdi, [rsp + 8] ; *Ctx mov rdi, [rsp + 8] ; *Ctx
lea rdi, [rdi + 40] ; Ctx.symtable
lea rsi, [rsp + 32] ; &SymEntry lea rsi, [rsp + 32] ; &SymEntry
mov rcx, 0 ; cmp_ctx mov rcx, 0 ; cmp_ctx
mov rdx, symkey_cmp ; cmp mov rdx, symkey_cmp ; cmp
call vec_insert_sorted call vec_insert_sorted
jmp .done
.done: .done:
add rsp, 96 add rsp, 88
pop rbx pop rbx
pop rbp pop rbp
ret ret
@ -1353,39 +1273,26 @@ ast_build_symtable_for_each:
;; rsi: start_index ;; rsi: start_index
;; rdx: ctx ;; rdx: ctx
;; rcx: for_each ;; rcx: for_each
;; define-fn: fn ast_walk_for_each(ast: *mut Ast, start_index: u64, ctx: *mut (), for_each: unsafe extern "C" fn(ctx: *mut (), *mut Ast, node_index: u64, scope: u64)) ;; define-fn: fn ast_walk_for_each(ast: *mut Ast, start_index: u64, ctx: *mut (), for_each: unsafe extern "C" fn(ctx: *mut (), *mut Ast, node_index: u64))
ast_walk_for_each: ast_walk_for_each:
push rbp push rbp
push r15 push r15
push r14 push r14
push rbx push rbx
; INVALID_SCOPE [48..56] ; current_index [24..32]
; current_index [40..48]
; *current_scope [32..40]
; current_node_ptr [24..32]
; for_each [16..24] ; for_each [16..24]
; ctx [8..16] ; ctx [8..16]
; ast [0..8] ; ast [0..8]
sub rsp, 56 sub rsp, 32
mov [rsp], rdi ; Ast mov [rsp], rdi ; Ast
mov [rsp + 8], rdx ; ctx mov [rsp + 8], rdx ; ctx
mov [rsp + 16], rcx ; for_each mov [rsp + 16], rcx ; for_each
mov qword [rsp + 24], 0 ; current_node_ptr mov [rsp + 24], rsi ; current_node_ptr
lea rdi, [rsp + 48] ; &INVALID_SCOPE
mov [rsp + 32], rdi ; current_scope
mov [rsp + 40], rsi ; current_index
mov qword [rsp + 48], -1 ; INVALID_SCOPE
mov rbp, rsp mov rbp, rsp
push rsi push rsi
; `current_scope` points to the index of the current scope on the stack.
; When we enter a new scope, we push `current_scope` onto the stack, then
; update it to point to the new scope index.
; When `rsp` is equal to `current_scope`, we need to additionally pop into
; `current_scope` after popping the current index.
.loop: .loop:
cmp rsp, rbp cmp rsp, rbp
jge .done jge .done
@ -1393,8 +1300,6 @@ ast_walk_for_each:
mov rdi, [rbp + 8] ; ctx mov rdi, [rbp + 8] ; ctx
mov rsi, [rbp] ; Ast mov rsi, [rbp] ; Ast
mov rdx, [rsp] ; current_index mov rdx, [rsp] ; current_index
mov rcx, [rbp + 32] ; current_scope
mov rcx, [rcx] ; current_scope value
mov rax, [rbp + 16] ; for_each mov rax, [rbp + 16] ; for_each
; align stack to 16 bytes before call ; align stack to 16 bytes before call
@ -1408,8 +1313,6 @@ ast_walk_for_each:
; get current_node_ptr ; get current_node_ptr
mov rdi, [rbp] ; Ast mov rdi, [rbp] ; Ast
pop rsi ; current_index pop rsi ; current_index
mov [rbp + 40], rsi ; update current_index
call vec_get call vec_get
mov [rbp + 24], rax ; current_node_ptr mov [rbp + 24], rax ; current_node_ptr
mov bl, byte [rax] ; AstNode.kind mov bl, byte [rax] ; AstNode.kind
@ -1431,14 +1334,9 @@ ast_walk_for_each:
je .address_of je .address_of
cmp bl, AST_RETURN_STATEMENT cmp bl, AST_RETURN_STATEMENT
je .return_statement je .return_statement
jmp .check_scope jmp .loop
.func: .func:
; push scope
push qword [rbp + 32] ; scope-ptr
push qword [rbp + 40] ; current_index
mov [rbp + 32], rsp ; update current_scope
; push child indices to stack ; push child indices to stack
mov rbx, [rax + 8] ; AstNode.data mov rbx, [rax + 8] ; AstNode.data
@ -1456,7 +1354,7 @@ ast_walk_for_each:
inc r14 inc r14
jmp .arg_loop jmp .arg_loop
.arg_loop_done: .arg_loop_done:
jmp .check_scope jmp .loop
.block: .block:
mov rbx, [rax + 8] ; AstNode.data mov rbx, [rax + 8] ; AstNode.data
@ -1470,7 +1368,7 @@ ast_walk_for_each:
push rdx ; push statement index push rdx ; push statement index
jmp .stmt_loop jmp .stmt_loop
.stmt_loop_done: .stmt_loop_done:
jmp .check_scope jmp .loop
.binary_op: .binary_op:
mov rbx, [rax + 8] ; AstNode.data mov rbx, [rax + 8] ; AstNode.data
@ -1478,14 +1376,14 @@ ast_walk_for_each:
push rdx ; push right index push rdx ; push right index
mov rdx, [rbx + 0] ; left index mov rdx, [rbx + 0] ; left index
push rdx ; push left index push rdx ; push left index
jmp .check_scope jmp .loop
.assignment: .assignment:
mov rbx, [rax + 8] ; AstNode.data = dest mov rbx, [rax + 8] ; AstNode.data = dest
mov rdx, [rax + 16] ; AstNode.extra = source mov rdx, [rax + 16] ; AstNode.extra = source
push rdx ; push source index push rdx ; push source index
push rbx ; push dest index push rbx ; push dest index
jmp .check_scope jmp .loop
.value_to_place: .value_to_place:
.place_to_value: .place_to_value:
@ -1494,145 +1392,30 @@ ast_walk_for_each:
.return_statement: .return_statement:
mov rbx, [rax + 8] ; AstNode.data mov rbx, [rax + 8] ; AstNode.data
push rbx ; push inner expr index push rbx ; push inner expr index
jmp .check_scope
.check_scope:
cmp rsp, [rbp + 32] ; current_scope
je .pop_scope
jmp .loop jmp .loop
.pop_scope: ; weird alloca thing
; pop current_scope
; the stack may look something like this:
; current_scope---+
; == stack == ^ | points here
; scope-ptr[0]-+ |
; scope: func0 <-----+
; stmt0 | |
; stmt1 | |
; scope-ptr[1] ------+
; scope: block0 <-+
; stmt2
; stmt3
; ...
pop rax ; scope
pop rax ; scope_ptr
mov [rbp + 32], rax ; update current_scope pointer
jmp .check_scope
.done: .done:
add rsp, 56 add rsp, 32
pop rbx pop rbx
pop r14 pop r14
pop r15 pop r15
pop rbp pop rbp
ret ret
;; rdi: *mut SymbolTable
;; rsi: *mut Ast
;; rdx: node_index
;; rcx: scope
ast_resolve_var_refs_for_each:
push rbp
mov rbp, rsp
push rbx
; lower_bound [88..96]
; scope: u64 [80..88]
; SymEntry [24..80]
; *AstNode [16..24]
; *BuildSymtableCtx [8..16]
; *Ast [0..8]
sub rsp, 96
mov [rsp], rsi ; Ast
mov [rsp + 8], rdi ; Ctx
mov [rsp + 80], rcx ; SymKey.scope_index
mov rdi, rsi ; Ast
mov rsi, rdx ; node_index
call vec_get
mov [rsp + 16], rax ; *AstNode
mov bl, byte [rax] ; AstNode.kind
cmp bl, AST_VAR_REF
jne .epilogue
; lookup variable in symbol table
; binary search lower bound
mov byte [rsp + 24 + 0], SYM_KEY_START_LOCALS ; SymKey.kind
mov qword [rsp + 24 + 8], 0 ; SymKey.scope_index
mov qword [rsp + 24 + 16], 0 ; SymKey.span
mov qword [rsp + 24 + 24], 1 ; SymKey.name
mov qword [rsp + 24 + 32], 0 ; SymKey.name_len
; binary search in symbol table
mov rdi, [rsp + 8] ; *Ctx
lea rsi, [rsp + 24] ; &SymKey
mov rdx, symkey_cmp ; cmp
mov rcx, 0 ; cmp_ctx
call vec_binary_search_by
mov [rsp + 88], rax ; lower_bound
; construct key
mov byte [rsp + 24 + 0], SYM_KEY_VAR ; SymKey.kind
mov rax, [rsp + 80] ; scope
mov [rsp + 24 + 8], rax ; SymKey.scope_index
mov rax, [rsp + 16] ; *AstNode
mov rbx, [rax + 24] ; AstNode.span
mov [rsp + 24 + 16], rbx ; SymKey.span
mov rbx, [rax + 8] ; AstNode.data
mov rax, [rbx + 8] ; AstVarRef.name
mov rbx, [rbx + 16] ; AstVarRef.name_len
mov [rsp + 24 + 24], rax ; SymKey.ident
mov [rsp + 24 + 32], rbx ; SymKey.ident_len
; binary search in symbol table
mov rdi, [rsp + 8] ; *Ctx
lea rsi, [rsp + 24] ; &SymKey
mov rdx, symkey_cmp ; cmp
mov rcx, 0 ; cmp_ctx
call vec_binary_search_by
test rdx, rdx
jz .fixup
dec rax
.fixup:
cmp rax, [rsp + 88] ; lower_bound
jl .panic
mov rdi, [rsp + 8] ; *Ctx
mov rsi, rax ; index
call vec_get
mov rax, [rax + 40] ; SymEntry.index
mov rdx, [rsp + 16] ; *AstNode
mov rdx, [rdx + 8] ; AstNode.data
mov [rdx + 0], rax ; AstVarRef.resolved_index
.epilogue:
add rsp, 96
pop rbx
pop rbp
ret
.panic:
call panic
;; rdi: Ast ;; rdi: Ast
;; rsi: *mut SymbolTable ;; define-fn: fn ast_resolve_var_refs(ast: *mut Ast)
;; rdx: root_index
;; define-fn: fn ast_resolve_var_refs(ast: *mut Ast, ctx: *mut SymbolTable, root_index: u64)
ast_resolve_var_refs: ast_resolve_var_refs:
push rbp push rbp
mov rbp, rsp mov rbp, rsp
push r15
xchg rsi, rdx push r14
mov rcx, ast_resolve_var_refs_for_each push rbx
call ast_walk_for_each
.epilogue: .epilogue:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp pop rbp
ret ret

31
lang/tests/ast.rs
View file

@ -29,31 +29,22 @@ fn main() {
eprintln!("Parsed expression ID: {}", expr_id); eprintln!("Parsed expression ID: {}", expr_id);
println!("{:#}", &ast); println!("{:#}", &ast);
// unsafe extern "C" fn visit_node( // unsafe extern "C" fn visit_node(_this: *mut (), ast: *mut Ast, node_id: u64) {
// _this: *mut (),
// ast: *mut Ast,
// node_id: u64,
// scope: u64,
// ) {
// let ast = unsafe { &*ast }; // let ast = unsafe { &*ast };
// let node = ast.nodes.get(node_id as usize).unwrap(); // let node = ast.nodes.get(node_id as usize).unwrap();
// eprintln!("{scope}: Visiting node {node_id}: {node}"); // eprintln!("Visiting node {node_id}: {node}");
// } // }
// util::defs::ast_walk_for_each(&mut ast, expr_id, core::ptr::null_mut(), visit_node); // util::defs::ast_walk_for_each(&mut ast, expr_id, core::ptr::null_mut(), visit_node);
let mut symtable = core::mem::MaybeUninit::<util::defs::SymbolTable>::uninit(); let mut symtable = core::mem::MaybeUninit::<util::defs::SymbolTable>::uninit();
util::defs::ast_build_symtable(&mut ast, expr_id, &mut symtable); util::defs::ast_build_symtable(&mut ast, expr_id, &mut symtable);
let mut symtable = symtable.assume_init(); let symtable = symtable.assume_init();
use util::DisplayedSliceExt; use util::DisplayedSliceExt;
println!( println!(
"Symbol Table: {:#?}", "Symbol Table: {:#?}",
symtable.symtable.as_slice().displayed() symtable.symtable.as_slice().displayed()
); );
util::defs::ast_resolve_var_refs(&mut ast, &mut symtable, expr_id);
println!("{:#}", &ast);
}; };
} }
@ -75,14 +66,14 @@ fn main() {
// print_ast(b"fn main() -> void { let x: u32 = 4; }", |ast| unsafe { // print_ast(b"fn main() -> void { let x: u32 = 4; }", |ast| unsafe {
// parse_func(ast) // parse_func(ast)
// }); // });
// print_ast( print_ast(
// b"fn main(a: u32) -> void { let x: u32 = a + 4; }", b"fn main(a: u32) -> void { let x: u32 = a + 4; }",
// |ast| unsafe { parse_func(ast) }, |ast| unsafe { parse_func(ast) },
// ); );
print_ast( print_ast(
b"fn main(a: u32) -> void { b"fn main(a: u32) -> void {
let y: u32 = a + 4; let x: u32 = a + 4;
let y: *u32 = &y; let y: *u32 = &x;
return *y; return *y;
}", }",
|ast| unsafe { parse_func(ast) }, |ast| unsafe { parse_func(ast) },
@ -119,7 +110,7 @@ impl std::fmt::Display for AstNode {
} }
AST_VAR_REF => { AST_VAR_REF => {
let var_ref = unsafe { self.data.cast::<util::defs::AstVarRef>().read() }; let var_ref = unsafe { self.data.cast::<util::defs::AstVarRef>().read() };
if var_ref.resolved != u64::MAX { if var_ref.resolved != 0 {
write!(f, "VarRef({})", var_ref.resolved) write!(f, "VarRef({})", var_ref.resolved)
} else { } else {
write!(f, "VarRef(name: {:?})", unsafe { write!(f, "VarRef(name: {:?})", unsafe {
@ -193,7 +184,7 @@ impl std::fmt::Display for AstNode {
AST_VALUE_TO_PLACE => { AST_VALUE_TO_PLACE => {
write!(f, "ValueToPlace(value: {})", self.data as usize) write!(f, "ValueToPlace(value: {})", self.data as usize)
} }
kind => write!(f, "UnknownNode(kind: {kind})"), _ => write!(f, "UnknownNode"),
} }
} }
} }

5
lang/tests/shared/defs.rs
View file

@ -15,8 +15,8 @@ unsafe extern "C" {
pub unsafe fn ast_parse_let(ast: *mut Ast) -> (u64, bool); pub unsafe fn ast_parse_let(ast: *mut Ast) -> (u64, bool);
pub unsafe fn symkey_cmp(a: *const SymKey, b: *const SymKey) -> i32; pub unsafe fn symkey_cmp(a: *const SymKey, b: *const SymKey) -> i32;
pub unsafe fn ast_build_symtable(ast: *mut Ast, root_index: u64, symtable: *mut core::mem::MaybeUninit<SymbolTable>); pub unsafe fn ast_build_symtable(ast: *mut Ast, root_index: u64, symtable: *mut core::mem::MaybeUninit<SymbolTable>);
pub unsafe fn ast_walk_for_each(ast: *mut Ast, start_index: u64, ctx: *mut (), for_each: unsafe extern "C" fn(ctx: *mut (), *mut Ast, node_index: u64, scope: u64)); pub unsafe fn ast_walk_for_each(ast: *mut Ast, start_index: u64, ctx: *mut (), for_each: unsafe extern "C" fn(ctx: *mut (), *mut Ast, node_index: u64));
pub unsafe fn ast_resolve_var_refs(ast: *mut Ast, ctx: *mut SymbolTable, root_index: u64); pub unsafe fn ast_resolve_var_refs(ast: *mut Ast);
} }
pub const AST_FUNCTION: u8 = 1; pub const AST_FUNCTION: u8 = 1;
@ -106,7 +106,6 @@ pub struct AstNode {
pub kind: u8, pub kind: u8,
pub data: *const (), pub data: *const (),
pub extra: usize, pub extra: usize,
pub span: u64,
} }
#[repr(C)] #[repr(C)]