From 2ec32dac56b544bc4851a3efddf75ee5fd9314ed Mon Sep 17 00:00:00 2001
From: Kyle Gunger <kgunger12@gmail.com>
Date: Sat, 17 Dec 2022 10:56:18 -0500
Subject: Change charp to uint8 + Change charp to uint8 + Start value
abstraction
---
tnslc/compile/compile.tnsl | 158 ++++++++++++++++-----------------------------
tnslc/compile/isa_x86.tnsl | 48 +++++++-------
tnslc/compile/value.tnsl | 148 ++++++++++++++++++++++++++++++++++++++++++
3 files changed, 229 insertions(+), 125 deletions(-)
create mode 100644 tnslc/compile/value.tnsl
(limited to 'tnslc/compile')
diff --git a/tnslc/compile/compile.tnsl b/tnslc/compile/compile.tnsl
index 14916b5..b8c6cd3 100644
--- a/tnslc/compile/compile.tnsl
+++ b/tnslc/compile/compile.tnsl
@@ -15,7 +15,7 @@
#/
-;{}{}charp COMMON_ASM = {
+;{}{}uint8 COMMON_ASM = {
"\tret\n"
}
@@ -26,14 +26,14 @@
int
ptr,
- {}charp name,
+ {}uint8 name,
{}VType sub_types,
- {}{}charp sub_names
+ {}{}uint8 sub_names
}
/; method VType
- /; get_sub_type({}charp name) [VType]
+ /; get_sub_type({}uint8 name) [VType]
/; loop (int i = 0; i < len (self.sub_types)) [i++]
/; if (string_equate(~name, ~(self.sub_names{i})))
;return self.sub_types{i}
@@ -42,7 +42,7 @@
;return NT
;/
- /; get_offset({}charp name) [int]
+ /; get_offset({}uint8 name) [int]
;int out = 0
/; loop (int i = 0; i < len (self.on_stack)) [i++]
/; if (string_equate(~name, ~(self.sub_types{i*2 + 1})))
@@ -67,7 +67,7 @@
# Tracks defined variables in a block
;struct VTrack {
- {}{}charp
+ {}{}uint8
sym_names,
{}bool
@@ -79,7 +79,7 @@
/; method VTrack
# returns true if the value is allocated to the stack
- /; add_track({}charp name, VType _type) [int]
+ /; add_track({}uint8 name, VType _type) [int]
;bool to_stack = is_struct(_type)
;int count = 0
@@ -105,7 +105,7 @@
;/
# Returns true if the variable is being tracked
- /; in_vtrack({}charp name) [bool]
+ /; in_vtrack({}uint8 name) [bool]
/; loop (int i = 0; i < len (self.on_stack)) [i++]
/; if (string_equate(~name, ~(self.sym_names{i})))
;return true
@@ -126,7 +126,7 @@
;/
# returns the type of the named variable
- /; get_vtype ({}charp name) [VType]
+ /; get_vtype ({}uint8 name) [VType]
/; loop (int i = 0; i < len (self.on_stack)) [i++]
/; if (string_equate(name, self.sym_names{i}))
;return (self.sym_types{i})
@@ -158,44 +158,23 @@
;VType NT = {0, 0, "null", {}, {}}
# Returns an index in the vtrack for a given variable name
-/; name_to_index ({}charp name, ~VTrack tab) [int]
+/; name_to_index ({}uint8 name, ~VTrack tab) [int]
/; loop (int i = 0; i < len (tab`.sym_names)) [i++]
/; if (string_equate(tab`.sym_names{i}, name))
;return i
;/
;/
-
+
;tnsl.io.print("Failed to find vairable ")
;tnsl.io.println(name)
;return -1
;/
-# The commonly used registers in order
-/; reg_by_num(int r) [{}charp]
- /; if (r == 0)
- ;return "ax"
- ;; if (r == 1)
- ;return "bx"
- ;; if (r == 2)
- ;return "cx"
- ;; if (r == 3)
- ;return "dx"
- ;; if (r == 4)
- ;return "si"
- ;; if (r == 5)
- ;return "di"
- ;; if (r == 6)
- ;return "bp"
- ;; if (r == 7)
- ;/
- ;return string_from_int(r)
-;/
-
# Given an index in the vtrack, returns a string representation of the
# register or memory where that variable is
-/; index_to_loc (int index, ~VTrack tab) [{}charp]
- ;{}charp out = ""
+/; index_to_loc (int index, ~VTrack tab) [{}uint8]
+ ;{}uint8 out = ""
;int stack_bytes = 0
;int reg = 0
;int i = 0
@@ -232,29 +211,9 @@
;return true
;/
-# Using the type name and member name, create a label of form "_type.member"
-/; construct_offset_label ({}charp t, {}charp n) [{}charp]
- ;{}charp out = "_"
- ;add_strings(~out, ~t)
- ;out.append('.')
- ;add_strings(~out, ~n)
- ;return out
-;/
-
-# For use when constructing module labels
-/; construct_path_label({}{}charp path)
- ;{}charp out = "_."
- /; loop (int i = 0; i < len path) [i++]
- ;add_strings(~out, ~(path{i}))
- ;out.append('.')
- ;/
- ;out{len out - 1} = ':'
- ;return out
-;/
-
# Using the given offset (in bytes), return an asm value of form ".quad <offset>"
-/; construct_value (int size, int offset) [{}charp]
- ;{}charp out = ".byte "
+/; construct_value (int size, int offset) [{}uint8]
+ ;{}uint8 out = ".byte "
/; if (size == 2)
;out = ".word "
;; if (size == 4)
@@ -262,28 +221,25 @@
;; if (size == 8)
;out = ".quad "
;/
- ;{}charp tmp = string_from_int(offset)
+ ;{}uint8 tmp = string_from_int(offset)
;add_strings(~out, ~tmp)
;return out
;/
-/; construct_text_value ({}charp t) [{}charp]
- ;{}charp tmp = unquote_string(t)
- ;{}charp out = construct_value(1, len tmp)
- ;{}charp tmp = "\n\t.ascii "
- ;add_strings(~out, ~tmp)
- ;add_strings(~out, ~t)
- ;return out
+/; construct_text_value ({}uint8 t) [{}uint8]
+ ;{}uint8 tmp = "\n\t.ascii "
+ ;add_strings(~tmp, ~t)
+ ;return tmp
;/
-/; construct_mov_literal({}charp value, reg) [{}charp]
- ;{}charp tmp = "$"
+/; construct_mov_literal({}uint8 value, reg) [{}uint8]
+ ;{}uint8 tmp = "$"
;add_strings(~tmp, ~value)
;return mov_asm(tmp, reg)
;/
# Parse a struct and add it to the table
-/; def_struct (~int cur, ~{}Token data, ~{}charp dsec) [VType]
+/; def_struct (~int cur, ~{}Token data, ~{}uint8 dsec) [VType]
;VType out = {0, 0, "", {}, {}}
;cur`++
@@ -333,7 +289,7 @@
;/
# Checks if the current token's data member is equal to a given string
-/; token_is(~int cur, ~{}Token data, {}charp str) [bool]
+/; token_is(~int cur, ~{}Token data, {}uint8 str) [bool]
;return string_equate(data`{cur`}.data`, str)
;/
@@ -350,7 +306,7 @@
;/
# Searches the type table for a type
-/; vtype_by_name ({}charp name) [VType]
+/; vtype_by_name ({}uint8 name) [VType]
/; loop (int i = 0; i < len type_table) [i++]
;VType tmp = tnslc.type_table{i}
/; if (string_equate(name, tmp.name))
@@ -408,7 +364,7 @@
;/
# Mostly deals with structs and enums
-/; compile_global (~int cur, ~{}Token data, ~VTrack gsc, ~{}charp hsec, csec, dsec)
+/; compile_global (~int cur, ~{}Token data, ~VTrack gsc, ~{}uint8 hsec, csec, dsec)
;cur`++
/; if (token_is(cur, data, "struct"))
;def_struct(cur, data, dsec)
@@ -416,7 +372,7 @@
;/
# Evaluate a value and return it to the register pointed at by reg
-/; eval_value (~int cur, ~{}Token data, ~VTrack tab, gsc, ~{}charp hsec, csec, dsec, int reg)
+/; eval_value (~int cur, ~{}Token data, ~VTrack tab, gsc, ~{}uint8 hsec, csec, dsec, int reg)
/; if (token_is(cur, data, ";/"))
;return
;/
@@ -432,7 +388,7 @@
# Char literal
;; else
# int literal
- ;{}charp tmp = construct_mov_literal(data`{cur`}.data`, get_reg(8, reg_by_num(val_layer)))
+ ;{}uint8 tmp = construct_mov_literal(data`{cur`}.data`, get_reg(8, reg_by_num(val_layer)))
;add_strings(csec, ~tmp)
;val_layer++
;cur`++
@@ -446,12 +402,12 @@
;/
;/
-/; get_function_label(~int cur, ~{}Token data) [{}charp]
+/; get_function_label(~int cur, ~{}Token data) [{}uint8]
/; if (string_equate(data`{cur` + 1}.data`, "("))
;return data`{cur`}.data`
;/
- ;{}{}charp func_path = {}
+ ;{}{}uint8 func_path = {}
/; loop (cur` < len data`) [cur`++]
/; if (token_is(cur, data, "("))
@@ -460,17 +416,17 @@
;func_path.append(data`{cur`}.data`)
;/
;/
- ;{}charp out = "_."
- ;{}charp jn_tmp = join(func_path, '.')
+ ;{}uint8 out = "_."
+ ;{}uint8 jn_tmp = join(func_path, '.')
;add_strings(~out, ~jn_tmp)
;return out
;/
# Sets up a call and reports back where the return value is stored
-/; eval_call (~int cur, ~{}Token data, ~VTrack tab, gsc, ~{}charp hsec, csec, dsec) [{}charp]
+/; eval_call (~int cur, ~{}Token data, ~VTrack tab, gsc, ~{}uint8 hsec, csec, dsec) [{}uint8]
# Store the name of the function we are calling
- ;{}charp to_call = get_function_label(cur, data)
+ ;{}uint8 to_call = get_function_label(cur, data)
;tnsl.io.println(to_call)
# Set read head to first parameter
;cur`++
@@ -490,29 +446,29 @@
;/
;cur`++
- ;{}charp call_ist = call_asm(to_call)
+ ;{}uint8 call_ist = call_asm(to_call)
;add_strings(csec, ~call_ist)
;return "ax"
;/
-/; set_struct_value (~{}charp csec)
+/; set_struct_value (~{}uint8 csec)
;/
-/; copy_struct ({}charp from, to, VType t) [{}charp]
- ;{}charp out = ""
- ;{}charp init = ""
+/; copy_struct ({}uint8 from, to, VType t) [{}uint8]
+ ;{}uint8 out = ""
+ ;{}uint8 init = ""
;/
-/; set_value ({}charp from, to, int size, ~{}charp csec)
+/; set_value ({}uint8 from, to, int size, ~{}uint8 csec)
/; if (is_common_reg(from))
;from = get_reg(size, from)
;; if (is_common_reg(to))
;to = get_reg(size, to)
;/
- ;{}charp tmp = "\tmov"
+ ;{}uint8 tmp = "\tmov"
/; if (size == 1)
;mov.append('b')
;; else if (size == 2)
@@ -544,13 +500,13 @@
;/
# Compile a statement in a function
-/; compile_statement (~int cur, ~{}Token data, ~VTrack tab, gsc, ~{}charp hsec, csec, dsec) [bool]
+/; compile_statement (~int cur, ~{}Token data, ~VTrack tab, gsc, ~{}uint8 hsec, csec, dsec) [bool]
;cur`++
;bool r = false
/; if (cur` < len data`)
/; if (token_is(cur, data, "asm"))
;cur`++
- ;{}charp raw_asm = unquote_string(data`{cur`}.data`)
+ ;{}uint8 raw_asm = unquote_string(data`{cur`}.data`)
;raw_asm.append('\n')
;csec`.append('\t')
;add_strings(csec, ~raw_asm)
@@ -570,7 +526,7 @@
;; else if (name_to_index(data`{cur`}.data`, tab) !< 0)
# set value
;int i = name_to_index(data`{cur`}.data`, tab)
- ;{}charp tmp = index_to_loc(i)
+ ;{}uint8 tmp = index_to_loc(i)
;eval_value(cur, data, tab, gsc, hsec, csec, dsec, 0)
;tmp = mov_asm(get_reg(tab`.sym_types{i}._size, "ax"), tmp)
;add_strings(csec, ~tmp)
@@ -585,7 +541,7 @@
/; if (token_is(cur, data, ","))
;cur`++
;; else if (token_is(cur, data, "="))
- ;{}charp loc = index_to_loc(len tab`.sym_names - 1, tab)
+ ;{}uint8 loc = index_to_loc(len tab`.sym_names - 1, tab)
;eval_value(cur, data, tab, gsc, hsec, csec, dsec, loc)
/; if (token_is(cur, data, ","))
;cur`++
@@ -606,10 +562,10 @@
-/; compile_block (~int cur, ~{}Token data, ~VTrack gsc, ~{}charp hsec, csec, dsec, {}{}charp mod_path, Path rel)
+/; compile_block (~int cur, ~{}Token data, ~VTrack gsc, ~{}uint8 hsec, csec, dsec, {}{}uint8 mod_path, Path rel)
;VTrack tab = { {}, {}, {} }
;VType out_type = tnslc.type_table{14}
- ;{}charp name = ""
+ ;{}uint8 name = ""
;bool r = false
/; loop (cur`++; cur` < len data`) [cur`++]
@@ -621,8 +577,8 @@
/; if (data`{cur`}.token_type == TOKEN_TYPE.DEFWORD && len name == 0)
;name = data`{cur`}.data`
/; if (len mod_path > 0)
- ;{}charp frs = "_."
- ;{}charp jn = join(mod_path, '.')
+ ;{}uint8 frs = "_."
+ ;{}uint8 jn = join(mod_path, '.')
;add_strings(~frs, ~jn)
;add_strings(csec, ~frs)
;csec`.append('.')
@@ -684,13 +640,13 @@
;csec`.append('\n')
;/
-/; compile_include (Path file_path, ~VTrack global, ~{}charp hsec, csec, dsec, {}{}charp mod_path)
+/; compile_include (Path file_path, ~VTrack global, ~{}uint8 hsec, csec, dsec, {}{}uint8 mod_path)
# Autocomplete in the case of module syntax
;bool d = file_path.extension_is("tnsl")
/; if (!d)
;file_path.dirs.append(file_path.file)
- ;{}charp ftmp = file_path.file
- ;{}charp tmp = ".tnsl"
+ ;{}uint8 ftmp = file_path.file
+ ;{}uint8 tmp = ".tnsl"
;add_strings(~ftmp, ~tmp)
;file_path.file = ftmp
;/
@@ -708,7 +664,7 @@
;compile_file(file_path, data, global, hsec, csec, dsec, mod_path)
;/
-/; compile_file (Path rel, ~{}Token data, ~VTrack global, ~{}charp hsec, csec, dsec, {}{}charp mod_path)
+/; compile_file (Path rel, ~{}Token data, ~VTrack global, ~{}uint8 hsec, csec, dsec, {}{}uint8 mod_path)
;int j = len data`
@@ -728,10 +684,10 @@
;/
-/; do_compile ({}charp file_out, Path rel)
- ;{}charp hsec = ".global main\n"
- ;{}charp csec = ".text\n"
- ;{}charp dsec = ".data\n"
+/; do_compile ({}uint8 file_out, Path rel)
+ ;{}uint8 hsec = ".global main\n"
+ ;{}uint8 csec = ".text\n"
+ ;{}uint8 dsec = ".data\n"
;VTrack global_scope = {{}, {}}
diff --git a/tnslc/compile/isa_x86.tnsl b/tnslc/compile/isa_x86.tnsl
index ee5bf27..02ba899 100644
--- a/tnslc/compile/isa_x86.tnsl
+++ b/tnslc/compile/isa_x86.tnsl
@@ -14,7 +14,7 @@
EXPRESS OR IMPLIED
#/
-/; construct_statement({}charp base, {}{}charp args) [{}charp]
+/; construct_statement({}uint8 base, {}{}uint8 args) [{}uint8]
/; loop (int i = 0; i < len args) [i++]
;add_strings(~base, ~(args{i}))
/; if (i < len args - 1)
@@ -26,59 +26,59 @@
;return base
;/
-/; literal_num ({}charp num) [{}charp]
- ;{}charp out = "$"
+/; literal_num ({}uint8 num) [{}uint8]
+ ;{}uint8 out = "$"
;add_strings(~out, ~num)
;return out
;/
-/; add_asm ({}charp from, to) [{}charp]
+/; add_asm ({}uint8 from, to) [{}uint8]
;return construct_statement("\tadd ", {from, to})
;/
-/; sub_asm({}charp from, to) [{}charp]
+/; sub_asm({}uint8 from, to) [{}uint8]
;return construct_statement("\tsub ", {from, to})
;/
-/; push_asm ({}charp reg) [{}charp]
+/; push_asm ({}uint8 reg) [{}uint8]
;return construct_statement("\tpush ", {reg})
;/
-/; pop_asm ({}charp reg) [{}charp]
+/; pop_asm ({}uint8 reg) [{}uint8]
;return construct_statement("\tpop ", {reg})
;/
-/; cmp_asm ({}charp a, b) [{}charp]
+/; cmp_asm ({}uint8 a, b) [{}uint8]
;return construct_statement("\tcmp ", {a, b})
;/
-/; mov_asm ({}charp a, b) [{}charp]
+/; mov_asm ({}uint8 a, b) [{}uint8]
;return construct_statement("\tmov ", {a, b})
;/
-/; jmp_asm ({}charp pos) [{}charp]
+/; jmp_asm ({}uint8 pos) [{}uint8]
;return construct_statement("\tjmp ", {pos})
;/
-/; call_asm ({}charp pos) [{}charp]
+/; call_asm ({}uint8 pos) [{}uint8]
;return construct_statement("\tcall ", {pos})
;/
-/; cjmp_asm ({}charp suffix, pos) [{}charp]
- ;{}charp p = "\tj"
+/; cjmp_asm ({}uint8 suffix, pos) [{}uint8]
+ ;{}uint8 p = "\tj"
;add_strings(~p, ~suffix)
;p.append(' ')
;return construct_statement(p, {pos})
;/
-/; mem_offset ({}charp pos, offset, scale) [{}charp]
- ;{}charp tmp = construct_statement("(", {pos, offset, scale})
+/; mem_offset ({}uint8 pos, offset, scale) [{}uint8]
+ ;{}uint8 tmp = construct_statement("(", {pos, offset, scale})
;tmp{len tmp - 1} = ')'
;return tmp
;/
-/; header_guard (~{}charp csec) [{}charp]
- ;{}charp out = "", tmp = ""
+/; header_guard (~{}uint8 csec) [{}uint8]
+ ;{}uint8 out = "", tmp = ""
;tmp = push_asm("%r8")
;add_strings(~out, ~tmp)
;tmp = push_asm("%r9")
@@ -98,8 +98,8 @@
;add_strings(csec, ~out)
;/
-/; tail_guard (~{}charp csec) [{}charp]
- ;{}charp out = "", tmp = ""
+/; tail_guard (~{}uint8 csec) [{}uint8]
+ ;{}uint8 out = "", tmp = ""
;tmp = pop_asm("%r15")
;add_strings(~out, ~tmp)
;tmp = pop_asm("%r14")
@@ -119,7 +119,7 @@
;add_strings(csec, ~out)
;/
-/; is_common_reg ({}charp n) [bool]
+/; is_common_reg ({}uint8 n) [bool]
;return string_equate(n, "ax") || string_equate(n, "bx") || string_equate(n, "cx") || string_equate(n, "dx")
|| string_equate(n, "sp") || string_equate(n, "bp") || string_equate(n, "si") || string_equate(n, "di")
|| string_equate(n, "8") || string_equate(n, "9") || string_equate(n, "10") || string_equate(n, "11")
@@ -137,8 +137,8 @@
# - di
# - 8-15
#/
-/; get_reg (uint size, {}charp common) [{}charp]
- ;{}charp out = "%"
+/; get_reg (uint size, {}uint8 common) [{}uint8]
+ ;{}uint8 out = "%"
/; if (string_equate(common, "ax") || string_equate(common, "bx") || string_equate(common, "cx") || string_equate(common, "dx"))
@@ -166,7 +166,7 @@
;; else
- ;{}charp out = "r"
+ ;{}uint8 out = "r"
;add_strings(~out, ~common)
/; if (size == 1)
;out.append('b')
@@ -181,7 +181,7 @@
;return out
;/
-/; make_label ({}charp func_name, func_place, ~{}charp csec)
+/; make_label ({}uint8 func_name, func_place, ~{}uint8 csec)
;func_name.append("_")
;add_strings(~func_name, ~func_place)
;func_name.append(':')
diff --git a/tnslc/compile/value.tnsl b/tnslc/compile/value.tnsl
new file mode 100644
index 0000000..701d4b9
--- /dev/null
+++ b/tnslc/compile/value.tnsl
@@ -0,0 +1,148 @@
+;struct Value {
+ bool
+ on_stack,
+ temp,
+ literal,
+
+ int
+ loc,
+ val,
+
+ VType
+ _type
+}
+
+;Value NV = {false, false, false, 0, 0, 0, {0, 0, "null", {}, {}}}
+
+/; setup_stack_offset (int offset) [{}uint8]
+ ;{}uint8 out = "$"
+ ;{}uint8 tmp = string_from_int(offset)
+ ;add_strings(~out, ~tmp)
+ ;return mov_asm(out, "%rax")
+;/
+
+;{}charp general_stack_offset = "(%rsp, %rax, 1)"
+
+
+# The temp registers in order
+/; reg_by_num(int r) [{}uint8]
+ /; if (r == 0)
+ ;return "ax"
+ ;; if (r == 1)
+ ;return "bx"
+ ;; if (r == 2)
+ ;return "cx"
+ ;; if (r == 3)
+ ;return "dx"
+ ;; if (r == 4)
+ ;return "si"
+ ;; if (r == 5)
+ ;return "di"
+ ;; if (r == 6)
+ ;return "bp"
+ ;/
+ ;return string_from_int(r)
+;/
+
+
+/; method Value
+
+ /; get_norm_loc [{}uint8]
+ /; if (self.on_stack)
+ ;return general_stack_offset
+ ;/
+
+ /; if (self.temp)
+ ;return get_reg(self._type._size, reg_by_num(self.loc))
+ ;; else
+ ;return get_reg(self._type._size, reg_by_num(self.loc + 8))
+ ;/
+
+ ;return ""
+ ;/
+
+ /; add_literal (int i) [{}uint8]
+ /; if (self.literal)
+ ;self.val = self.val + i
+ ;return ""
+ ;; else if (!self.on_stack)
+ ;{}uint8 reg = self.get_norm_loc()
+ ;{}uint8 out = "\tadd $"
+ ;{}uint8 tmp = string_from_int(i)
+ ;add_strings(~out, ~tmp)
+ ;out.append(',')
+ ;out.append(' ')
+ ;add_strings(~out, ~reg)
+ ;return out
+ ;/
+
+ ;/
+
+ /; add_value (Value v) [{}uint8]
+ /; if (self.literal)
+ ;self.val = self.val + v.val
+ ;return ""
+ ;; else if (!self.on_stack)
+ ;{}uint8 tmp = self.get_norm_loc()
+ ;{}uint8 out = "\tadd "
+ ;add_strings(~out, ~tmp)
+ ;out.append(',')
+ ;out.append(' ')
+ ;tmp = v.get_norm_loc()
+ ;add_strings(~out, ~tmp)
+ ;return out
+ ;/
+ ;/
+
+ /; sub_value (Value v) [{}uint8]
+ /; if (self.literal)
+ ;self.val = self.val - v.val
+ ;return ""
+ ;/
+ ;/
+
+ /; mul_literal (int i) [{}uint8]
+ /; if (self.literal)
+ ;return ""
+ ;/
+ ;/
+
+ /; div_literal (int i) [{}uint8]
+
+ ;/
+
+ /; mul_value (Value v) [{}uint8]
+
+ ;/
+
+ /; div_value (int i) [{}uint8]
+
+ ;/
+
+ /; deref_value [Value]
+ /; if (self._type.ptr == 0)
+
+ ;/
+ ;/
+
+ /; arr_value (int i) [Value]
+ /; if (self._type.ptr == 0)
+
+ ;/
+ ;/
+
+ /; copy_from_value (Value v)
+
+ ;/
+
+ /; get_member_value ({}uint8 name) [Value]
+ ;Value out = self
+ ;/
+
+ /; update_loc(int offset)
+ /; if (self.on_stack)
+ ;self.loc = self.loc + offset
+ ;/
+ ;/
+
+;/
\ No newline at end of file
--
cgit v1.2.3