summaryrefslogtreecommitdiff
path: root/tnslc/compile.tnsl
diff options
context:
space:
mode:
Diffstat (limited to 'tnslc/compile.tnsl')
-rw-r--r--tnslc/compile.tnsl1503
1 files changed, 1503 insertions, 0 deletions
diff --git a/tnslc/compile.tnsl b/tnslc/compile.tnsl
new file mode 100644
index 0000000..8bad758
--- /dev/null
+++ b/tnslc/compile.tnsl
@@ -0,0 +1,1503 @@
+##
+## UTIL FUNCS
+##
+
+/; string_split ({}uint8 str, uint8 split) [{}{}uint8]
+ /; if (len str == 0)
+ ;return {}
+ ;/
+
+ ;{}{}uint8 out = {}
+
+ ;{}uint8 run = ""
+
+ /; loop (int i = 0; i < len str) [i++]
+ /; if (str{i} == split)
+ ;out.append(run)
+ ;run = ""
+ ;; else
+ ;run.append(str{i})
+ ;/
+ ;/
+
+ ;out.append(run)
+
+ ;return out
+;/
+
+/; string_join ({}{}uint8 strs, {}uint8 join) [{}uint8]
+ ;{}uint8 out = ""
+ /; loop (int i = 0; i < len strs) [i++]
+ ;out = string_add(out, strs{i})
+ /; if (i !== len strs - 1)
+ ;out = string_add(out, join)
+ ;/
+ ;/
+ ;return out
+;/
+
+/; string_add ({}uint8 base, add) [{}uint8]
+ /; loop (int i = 0; i < len add) [i++]
+ ;base.append(add{i})
+ ;/
+ ;return base
+;/
+
+/; string_equate ({}uint8 a, b) [bool]
+ /; if (len a !== len b)
+ ;return false
+ ;/
+
+ /; loop (int i = 0; i < len a) [i++]
+ /; if (a{i} !== b{i})
+ ;return false
+ ;/
+ ;/
+
+ ;return true
+;/
+
+/; string_contains ({}uint8 str, uint8 chk) [bool]
+ /; loop (int i = 0; i < len str) [i++]
+ /; if (str{i} == chk)
+ ;return true
+ ;/
+ ;/
+ ;return false
+;/
+
+/; list_contains ({}{}uint8 list, {}uint8 str) [bool]
+ /; loop (int i = 0; i < len list) [i++]
+ /; if (string_equate(list{i}, str))
+ ;return true
+ ;/
+ ;/
+ ;return false
+;/
+
+/; unqote_char ({}uint8 str) [uint8]
+ /; if (len str < 3)
+ ;return 0
+ ;/
+
+ ;uint8 cmp = str{2}
+ /; if (cmp == '\\')
+ ;return '\\'
+ ;; else if (cmp == 'n')
+ ;return '\n'
+ ;; else if (cmp == 'r')
+ ;return '\r'
+ ;/
+
+;/
+
+/; unquote_str({}uint8 str) [{}uint8]
+ /; if (str{0} !== '\'' && str{0} !== '"')
+ ;return str
+ ;/
+ ;{}uint8 out = ""
+
+ /; loop (int i = 1; i < len str - 1) [i++]
+ /; if (str{i} == '\\')
+ ;{}uint8 unq = "'\\"
+ ;unq.append(str{i + 1})
+ ;out.append(unqote_char(unq))
+ ;i++
+ ;; else
+ ;out.append(str{i})
+ ;/
+ ;/
+
+ ;return out
+;/
+
+/; int_to_string (int i) [{}uint8]
+ /; if (i == 0)
+ ;return "0"
+ ;/
+
+ ;{}uint8 out = ""
+
+ /; if (i < 0)
+ ;out.append('-')
+ ;i = -i
+ ;/
+
+ /; loop [i = i / 10; i > 0]
+ ;out.append('0' + (i % 10))
+ ;/
+
+ ;return out
+;/
+
+/; digit_from_base (uint8 ch, int base) [int]
+ /; if (ch == '-')
+ ;return 0
+ ;/
+
+ /; if (base !> 10)
+ ;return ch - '0'
+ ;; if (base == 16)
+ /; if (ch !< 'A' && ch < 'G')
+ ;return 11 + (ch - 'A')
+ ;; else if (ch !< 'a' && ch < 'g')
+ ;return 11 + (ch - 'a')
+ ;/
+ ;return ch - '0'
+ ;/
+ ;return 0
+;/
+
+/; string_to_int ({}uint8 str) [int]
+ /; if (len str < 1)
+ ;return 0
+ ;/
+ ;int i = 0
+ ;bool inv = str{0} == '-'
+ /; if (inv)
+ ;i = 1
+ ;/
+
+ ;int out = 0
+ ;int base = 10
+
+ /; if (len str !< 3 && str{i} == '0')
+ /; if (str{i + 1} == 'x')
+ ;base = 16
+ ;i = i + 2
+ ;; if (str{i + 1} == 'b')
+ ;base = 2
+ ;i = i + 2
+ ;; if (str{i + 1} == 'o')
+ ;base = 8
+ ;i = i + 2
+ ;/
+ ;/
+
+ /; loop (i < len str) [i++]
+ ;out = out * base
+ ;out = out + digit_from_base(str{i}, base)
+ ;/
+
+ /; if (inv)
+ ;out = -out
+ ;/
+ ;return out
+;/
+
+##
+## Structs
+##
+
+# The seperated string sections that make up an asm file
+;struct CompData {
+ {}uint8
+ hsec,
+ dsec,
+ csec
+}
+
+# Represents a relative file path
+;struct Path {
+ {}{}uint8 path,
+ {}uint8 name
+}
+
+/; method Path
+
+ /; relative ({}uint8 rel_path) [Path]
+ ;Path out = self
+ ;{}{}uint8 rel_split = string_split(rel_path, '/')
+
+ /; loop (int i = 0; i < len rel_split - 1)
+ ;out.path.append(rel_split{i})
+ ;/
+
+ ;out.name = rel_split{len rel_split - 1}
+
+ ;return out
+ ;/
+
+ /; full_path [{}uint8]
+ ;{}uint8 out = string_join(self.path, "/")
+ /; if (len out > 0)
+ ;out.append('/')
+ ;/
+ ;return string_add(out, self.name)
+ ;/
+
+ /; extension [{}uint8]
+ ;{}{}uint8 split_name = string_split(self.name, '.')
+
+ /; if (len split_name > 1)
+ ;return split_name{len split_name - 1}
+ ;/
+
+ ;return ""
+ ;/
+
+ /; open_read [tnsl.io.File]
+ ;return tnsl.io.readFile(self.full_path())
+ ;/
+
+ /; write ({}uint8 bytes)
+ ;tnsl.io.File out = tnsl.io.writeFile(self.full_path())
+
+ /; loop (int i = 0; i < len bytes) [i++]
+ ;out.write(bytes{i})
+ ;/
+
+ ;out.close()
+ ;/
+;/
+
+# Represents the different classes of token
+;enum TOKEN [int] {
+ SEPARATOR = 0,
+ DELIMITER = 1,
+ AUGMENT = 2,
+ KEYTYPE = 3,
+ KEYWORD = 4,
+ LITERAL = 5,
+ DEFWORD = 6
+}
+
+# Represents a single token in a TNSL file
+;struct Token {
+ int
+ tokenType,
+ line,
+
+ {}uint8 data
+}
+
+/; method Token
+
+ /; type_is (int a) [bool]
+ ;return self.tokenType == a
+ ;/
+
+ /; cmp ({}uint8 str) [bool]
+ ;return string_equate(self.data, str)
+ ;/
+
+ /; print
+ ;tnsl.io.print(self.data)
+ ;tnsl.io.print(": { type: ")
+ ;tnsl.io.print(self.tokenType)
+ ;tnsl.io.print(" line: ")
+ ;tnsl.io.print(self.line)
+ ;tnsl.io.print(" }")
+ ;/
+
+ /; sprint [{}uint8]
+ ;{}uint8 out = "{ "
+ ;out = string_add(out, self.data)
+ ;out.append(' ')
+ ;out = string_add(out, int_to_string(self.tokenType))
+ ;out.append(' ')
+ ;out.append('}')
+ ;return out
+ ;/
+;/
+
+# General defs:
+## Type defs
+## Function defs
+## Method defs
+## Module defs
+## Constant and variable defs
+
+# Module
+## General defs
+
+# Block
+## Variable defs
+## Control flow defs
+## Value defs
+
+;enum PTYPE [int] {
+ POINTER = 0,
+ REFERENCE = 1,
+ ARRAY = 2
+}
+
+# Represents a data type
+;struct Type {
+ int s,
+ {}uint8
+ name,
+ mod_name,
+ {}int
+ ptr_chain,
+ {}Variable
+ members
+}
+
+;{}{}uint8 PRIM_NAMES = {
+ "uint8", "uint16", "uint32", "uint64", "uint",
+ "int8", "int16", "int32", "int64", "int",
+ "float32", "float64", "float",
+ "bool", "void"
+}
+
+;{}int PRIM_SIZES = {
+ 1, 2, 4, 8, 8,
+ 1, 2, 4, 8, 8,
+ 4, 8, 8,
+ 1,
+ 8
+}
+
+;Type NO_TYPE = {0, "", "", {}, {}}
+
+/; is_primitive ({}uint8 t) [int]
+ ;{}{}uint8 pn = PRIM_NAMES
+ ;{}int ps = PRIM_SIZES
+ /; loop (int i = 0; i < len pn) [i++]
+ /; if (string_equate(pn{i}, t))
+ ;return ps{i}
+ ;/
+ ;/
+ ;return -1
+;/
+
+# Represents the place in memory where a variable is
+;enum LOCATION [int] {
+ REGISTER = 0,
+ STACK = 1,
+ LABEL = 2,
+ LITERAL = 3
+}
+
+# Represents a variable
+;struct Variable {
+ {}uint8
+ name,
+ Type
+ data_type,
+ int
+ location,
+ loc_type
+}
+
+# Get common register name by index
+/; 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 == -1)
+ ;return "sp"
+ ;; if (r == -2)
+ ;return "bp"
+ ;/
+ ;return int_to_string(r + 2)
+;/
+
+# Get common register by common name and size
+/; reg_by_name_size ({}uint8 common, uint sz) [{}uint8]
+ ;{}uint8 out = "%"
+
+ /; if (common{0} !< 'a')
+
+ /; if (sz == 1)
+ /; if(common{1} == 'x')
+ ;common{1} = 'l'
+ ;; else
+ ;common.append('l')
+ ;/
+ ;; else if (sz == 4)
+ ;out.append('e')
+ ;; else if (sz == 8)
+ ;out.append('r')
+ ;/
+
+ ;string_add(out, common)
+
+ ;; else
+
+ ;out.append('r')
+ ;string_add(out, common)
+ /; if (sz == 1)
+ ;out.append('b')
+ ;; else if (sz == 2)
+ ;out.append('w')
+ ;; else if (sz == 4)
+ ;out.append('d')
+ ;/
+ ;return out
+ ;/
+
+ ;return out
+;/
+
+/; get_reg (int r, sz) [{}uint8]
+ ;return reg_by_name_size(reg_by_num(r), sz)
+;/
+
+# Most methods make use of one or more temporary variables.
+# These are denoted by tr
+/; method Variable
+
+ /; norm_loc (int sz) [{}uint8]
+ /; if (self.loc_type == LOCATION.LABEL)
+ ;return ""
+ ;; else if (self.loc_type == LOCATION.REGISTER)
+ ;return get_reg(self.location, sz)
+ ;; else if (self.loc_type == LOCATION.STACK)
+ ;return string_join( { "[ rsp + ", int_to_string(self.location), " ]" } , "")
+ ;/
+ ;/
+
+ /; norm_size [int]
+ /; if (len (self.data_type.ptr_chain) > 0)
+ ;return 8
+ ;; else
+ ;return self.data_type.s
+ ;/
+ ;/
+
+ /; norm_op ({}uint8 op, {}{}uint8 args) [{}uint8]
+ ;return string_join(
+ {
+ "\t", op, " ",
+ string_join(args, ", "), "\n"
+ },
+ ""
+ )
+ ;/
+
+ # functions that do work on this variable
+ /; add (Variable v, int tr) [{}uint8]
+ /; if (self.loc_type == LOCATION.LITERAL)
+ /; if (v.loc_type !== LOCATION.LITERAL)
+ ;return v.add(self)
+ ;/
+ ;self.location = self.location + v.location
+ ;return ""
+ ;; if (self.loc_type == LOCATION.STACK && v.loc_type == LOCATION.STACK)
+ ;{}uint8 tmp = get_reg(tr, self.norm_size())
+ ;{}uint8 out = self.norm_op("mov", { tmp, v.norm_loc(self.norm_size()) })
+ ;return string_add(out, self.norm_op("add", { self.norm_loc(self.norm_size()), tmp }))
+ ;/
+ ;return self.norm_op("add", { self.norm_loc(self.norm_size()), get_reg(tr, self.norm_size()) })
+ ;/
+
+ /; sub (Variable v)
+ /; if (self.loc_type == LOCATION.LITERAL)
+ /; if (v.loc_type !== LOCATION.LITERAL)
+ ;return v.add(self)
+ ;/
+ ;self.location = self.location - v.location
+ ;return ""
+ ;; if (self.loc_type == LOCATION.STACK && v.loc_type == LOCATION.STACK)
+ ;{}uint8 tmp = get_reg(tr, self.norm_size())
+ ;{}uint8 out = self.norm_op("mov", { tmp, v.norm_loc(self.norm_size()) })
+ ;return string_add(out, self.norm_op("sub", { self.norm_loc(self.norm_size()), tmp }))
+ ;/
+ ;return self.norm_op("sub", { self.norm_loc(self.norm_size()), get_reg(tr, self.norm_size()) })
+ ;/
+
+ /; div (Variable v)
+ /; if (self.loc_type == LOCATION.LITERAL)
+ /; if (v.loc_type !== LOCATION.LITERAL)
+ ;return v.div(self)
+ ;/
+ ;self.location = self.location + v.location
+ ;return ""
+ ;; if (self.loc_type == LOCATION.STACK && v.loc_type == LOCATION.STACK)
+ ;{}uint8 out = ""
+ # TODO
+ ;return out
+ ;/
+ ;return self.norm_op("div", { self.norm_loc(self.norm_size()), v.norm_loc(self.norm_size) })
+ ;/
+
+ /; mul (Variable v)
+ /; if (self.loc_type == LOCATION.LITERAL)
+ /; if (v.loc_type !== LOCATION.LITERAL)
+ ;return v.mul(self)
+ ;/
+ ;self.location = self.location * v.location
+ ;return ""
+ ;; if (self.loc_type == LOCATION.STACK && v.loc_type == LOCATION.STACK)
+ ;{}uint8 out = ""
+ # TODO
+ ;return out
+ ;/
+ ;return self.norm_op("mul", { self.norm_loc(self.norm_size()), v.norm_loc(self.norm_size) })
+ ;/
+
+ /; set (Variable v)
+ /; if (self.loc_type == LOCATION.LITERAL)
+ /; if (v.loc_type !== LOCATION.LITERAL)
+ ;return v.set(self)
+ ;/
+ ;self.location = v.location
+ ;return ""
+ ;; if (self.loc_type == LOCATION.STACK && v.loc_type == LOCATION.STACK)
+ ;{}uint8 out = ""
+ # TODO
+ ;return out
+ ;/
+ ;return self.norm_op("mov", { self.norm_loc(self.norm_size()), v.norm_loc(self.norm_size) })
+ ;/
+
+ # functions that do work on another variable
+ /; ref (Variable out)
+ ;/
+
+ /; deref (Variable out)
+ ;/
+
+ /; member (Variable out, {}uint8 name)
+ ;/
+
+ /; index (Variable out, Variable i)
+ /;
+
+ ;/
+ ;/
+
+ /; call (Variable out, {}uint8 name)
+ ;/
+;/
+
+;struct Scope {
+ {}Variable vars
+}
+
+;struct Function {
+ {}uint8 name,
+ {}Type
+ inputs,
+ outputs
+}
+
+;struct Module {
+ # Parent module
+ ~Module parent,
+ # Export functions or not
+ bool exp,
+ # Name of module
+ {}uint8 name,
+ # Types defined in this module
+ {}Type types,
+ # Variables defined in this module
+ {}Variable defs,
+ # Functions defined in this module
+ {}Function functions,
+ # Sub modules
+ {}Module sub
+}
+
+/; method Module
+ # Internal recursive function
+ /; _find_type ({}{}uint8 artifact, int r) [~Type]
+ /; if (len artifact !> r)
+ ;return ~NO_TYPE
+ ;/
+
+ /; if (len artifact - 1 > r)
+ /; loop (int i = 0; i < len (self.sub)) [i++]
+ /; if (string_equate(artifact{r}, self.sub{i}.name))
+ ;return self._find_type(artifact, r + 1)
+ ;/
+ ;/
+ ;/
+
+ /; loop (int i = 0; i < len (self.types)) [i++]
+ /; if (string_equate(self.types{i}.name, artifact{r}))
+ ;return ~(self.types{i})
+ ;/
+ ;/
+
+ ;Type nt = {0, artifact{len artifact - 1}, "", {}, {}}
+ ;return ~nt
+ ;/
+
+ # Consumer facing function
+ /; find_type ({}{}uint8 artifact) [~Type]
+ ;int p = is_primitive(artifact{0})
+ /; if (p !< 0)
+ ;Type out = {p, artifact{0}, {}, {}, {}}
+ ;return ~out
+ ;/
+
+ ;return self._find_type(artifact, 0)
+ ;/
+
+ /; _find_def ({}{}uint8 artifact, int r) [Variable]
+ /; if (len artifact !> r)
+ ;retirn {{}, "", 0, 0, 0}
+ ;/
+
+ /; if (len artifact - 1 > r)
+ /; loop (int i = 0; i < len (self.sub)) [i++]
+ /; if (string_equate(artifact{r}, self.sub{i}.name))
+ ;return self._find_type(artifact, r + 1)
+ ;/
+ ;/
+ ;/
+
+ /; loop (int i = 0; i < len (self.defs)) [i++]
+ /; if (string_equate(self.defs{i}.name, artifact{r}))
+ ;return self.defs{i}
+ ;/
+ ;/
+
+ ;return {{}, "", 0, 0, 0}
+ ;/
+
+ /; find_def ({}{}uint8 artifact) [Variable]
+ ;return _find_def(artifact, 0)
+ ;/
+
+ /; _find_function ({}{}uint8 artifact, int r) [Variable]
+ /; if (len artifact !> r)
+ ;retirn {{}, "", 0, 0, 0}
+ ;/
+
+ /; if (len artifact - 1 > r)
+ /; loop (int i = 0; i < len (self.sub)) [i++]
+ /; if (string_equate(artifact{r}, self.sub{i}.name))
+ ;return self._find_type(artifact, r + 1)
+ ;/
+ ;/
+ ;/
+
+ /; loop (int i = 0; i < len (self.funcs)) [i++]
+ /; if (string_equate(self.funcs{i}.name, artifact{r}))
+ ;return self.funcs{i}
+ ;/
+ ;/
+
+ ;return {{}, "", 0, 0, 0}
+ ;/
+
+ /; find_function ({}{}uint8 artifact) [Variable]
+ ;return _find_function(artifact, 0)
+ ;/
+
+ /; full_path [{}uint8]
+ /; if (string_equate(self.name, ""))
+ ;return ""
+ ;/
+ ;{}uint8 out = self.parent`.full_path()
+ /; if (len out > 0)
+ ;out = string_add(out, ".")
+ ;/
+ ;out = string_add(out, self.name)
+ ;return out
+ ;/
+;/
+
+##
+## Compiler funcs
+##
+
+/; get_artifact (~{}Token tok, ~int cur) [{}{}uint8]
+ ;{}{}uint8 out = {}
+
+ ;out.append(tok`{cur`}.data)
+ ;cur`++
+
+ /; loop (cur` < len tok` && tok`{cur`}.cmp(".")) [cur`++]
+ /; if (tok`{cur` + 1}.type_is(TOKEN.DEFWORD))
+ ;out.append(tok`{cur` + 1}.data)
+ ;cur`++
+ ;/
+ ;/
+ ;return out
+;/
+
+/; get_type (~{}Token tok, ~int cur, ~Module current) [Type]
+ ;{}int ptr_chain = {}
+
+ /; loop (cur` < len tok`) [cur`++]
+ /; if (tok`{cur`}.cmp("{"))
+ ;ptr_chain.append(PTYPE.ARRAY)
+ ;cur`++
+ ;; else if (tok`{cur`}.cmp("~"))
+ ;ptr_chain.append(PTYPE.POINTER)
+ ;; else
+ ;break
+ ;/
+ ;/
+
+ ;~Type pout = current`.find_type(get_artifact(tok, cur))
+ ;Type out = pout`
+ /; if (string_equate(out.name, ""))
+ ;return out
+ ;/
+
+ ;{}Type generics = {}
+ /; if (tok`{cur`}.cmp("("))
+ ;int max = find_closing(tok, cur)
+ ;cur`++
+ /; loop (cur` < max) [cur`++]
+ ;generics.append(get_type(tok, cur, current))
+ ;/
+ ;/
+
+ # TODO: References
+
+ ;out.ptr_chain = ptr_chain
+ ;return out
+;/
+
+/; is_definition (~{}Token tok, ~int cur) [bool]
+ ;return false
+;/
+
+/; compile_file_def (~{}Token tok, ~int cur, Type t, ~Module current) [{}Variable]
+ ;return {}
+;/
+
+/; next_non_nl (~{}Token tok, int c) [int]
+ /; loop (tok`{c}.cmp("\n")) [c++] ;/
+ ;return c
+;/
+
+/; parse_param_list (~{}Token tok, ~int cur, ~Module current) [{}Variable]
+ ;{}Variable out = {}
+ ;int max = find_closing(tok, cur)
+ ;Type t = NO_TYPE
+ /; loop (cur` = next_non_nl(tok, cur` + 1); cur` < max) [cur` = next_non_nl(tok, cur` + 1)]
+ ;int nnl = next_non_nl(tok, cur` + 1)
+ /; if (tok`{nnl}.cmp(",") || nnl == max)
+ ;out.append({tok`{cur`}.data, t, 0, 0})
+ /; if (tok`{nnl}.cmp(","))
+ ;cur`++
+ ;/
+ ;; else
+ ;t = get_type(tok, cur, current)
+ ;cur` = cur` - 1
+ ;/
+ ;/
+ ;return out
+;/
+
+# Generates new type
+/; new_type (~{}Token tok, ~int cur, ~Module current)
+ ;cur`++
+ ;Type out = {0, tok`{cur`}.data, "", {}, {}}
+ ;out.mod_name = string_add(current`.full_path(), "_#")
+ ;out.mod_name = string_add(out.mod_name, out.name)
+ ;current`.sub.append({current, current`.exp, out.mod_name, {}, {}, {}, {}})
+
+ /; loop (cur` < len tok`) [cur`++]
+ /; if (tok`{cur`}.cmp("{"))
+ ;break
+ ;/
+ ;/
+
+ ;out.members = parse_param_list(tok, cur, current)
+ /; loop (int i = 0; i < len (out.members)) [i++]
+ ;tnsl.io.print(string_join({"[", out.members{i}.name, ":", out.members{i}.data_type.name, "]"}, ""))
+ ;/
+
+ ;tnsl.io.print(string_add("Generated type ", string_add(out.name, string_add(":", out.mod_name))))
+ ;current`.types.append(out)
+;/
+
+/; decompose_empty (~Module current, Type t) [{}uint8]
+ ;return ""
+;/
+
+# Used to take an array literal and make it into a label
+/; decompose_array (~{}Token tok, ~int cur, ~Module current, Type t) [{}uint8]
+ ;int max = find_closing(tok, cur)
+ ;{}uint8 arr = ""
+ ;int alen = 0
+
+ /; loop (cur`++; cur` < max) [cur`++]
+ ;alen++
+
+ /; if (tok`{cur`}.cmp("{"))
+ /; if (ptr_chain{0} == PTYPE.ARRAY)
+ ;{}int ptr = {}
+ /; loop (int i = 1; i < len (t.ptr_chain)) [i++]
+ ;ptr.append(t.ptr_chain{i})
+ ;/
+ ;t.ptr_chain = ptr
+ ;arr = string_add(arr, decompose_array(tok, cur, current, t))
+ ;cur`++
+ ;; else
+ ;decompose_struct(tok, cur, current, t)
+ ;cur`++
+ ;/
+ ;; else
+ ;arr = string_add(arr, decompose_data(tok, cur, current, t))
+ ;cur`++
+ ;/
+ ;/
+
+ ;{}uint out = string_join( { "\tdq ", int_to_string(alen), "\n", arr, "\n" }, "")
+
+ ;return out
+;/
+
+# Used to take a struct literal and make it into a label
+/; decompose_struct (~{}Token tok, ~int cur, ~Module current, Type t) [{}uint8]
+ ;int max = find_closing(tok, cur)
+ ;{}uint8 out = ""
+ ;int m = 0
+ /; loop (cur`++; cur` < max) [cur`++]
+ /; if (tok`{cur`}.cmp("}"))
+ ;break
+ ;; else if (tok`{cur`}.cmp(","))
+ ;cur`++
+ ;/
+ ;out = string_add(out, decompose_data(tok, cur, current, t.members{m}.data_type))
+ ;m++
+ ;/
+
+ /; if (m < len (t.members) - 1)
+ /; loop (m < len (t.members)) [m++]
+ ;out = string_add(out, decompose_empty(current, t.members{m}))
+ ;/
+ ;/
+
+ ;return out
+;/
+
+/; declare_size(int sz) [{}uint8]
+ ;{}uint8 out = "\tdb "
+
+ /; if (sz == 2)
+ ;out{2} = 'w'
+ ;; if (sz == 4)
+ ;out{2} = 'd'
+ ;; if (sz == 8)
+ ;out{2} = 'q'
+ ;/
+
+ ;return out
+;/
+
+# Used to take data from a literal and make it into a label
+/; decompose_data (~{}Token tok, ~int cur, ~Module current, Type t) [{}uint8]
+ /; if (tok`{cur`}.cmp("{"))
+ /; if (len (t.ptr_chain) > 0)
+ ;{}int ptr = {}
+ /; loop (int i = 1; i < len (t.ptr_chain)) [i++]
+ ;ptr.append(t.ptr_chain{i})
+ ;/
+ ;t.ptr_chain = ptr
+ ;return decompose_array(tok, cur, current, t)
+ ;; else
+ ;return decompose_struct(tok, cur, current, t)
+ ;/
+ ;; if (tok`{cur`}.type_is(TOKEN.LITERAL))
+ /; if (tok`{cur`}.data{0} == '"')
+ ;return string_join({
+ declare_size(8), int_to_string(len unquote_str(tok`{cur`}.data)), "\n",
+ declare_size(1), tok`{cur`}.data, "\n"}, "")
+ ;; else if (tok`{cur`}.data{0} == '\'')
+ ;return string_join({
+ declare_size(1), tok`{cur`}.data, "\n"}, "")
+ ;/
+ ;return string_add(string_add(declare_size(t.s), tok`{cur`}.data), "\n")
+ ;/
+
+ ;return decompose_empty(current, t)
+;/
+
+# Compiles new enum for the file
+/; compile_enum (~{}Token tok, ~int cur, ~Module current) [{}uint8]
+ ;cur`++
+ ;Type et = NO_TYPE
+ ;{}uint8 name = ""
+
+ /; if (tok`{cur`}.cmp("["))
+ ;cur`++
+ ;et = get_type(tok, cur, current)
+ ;cur`++
+ ;; if (!(tok`{cur`}.cmp("{")))
+ ;name = tok`{cur`}.data
+ ;cur`++
+ /; if (tok`{cur`}.cmp("["))
+ ;cur`++
+ ;et = get_type(tok, cur, current)
+ ;cur`++
+ ;/
+ ;/
+
+ /; if (string_equate(et.name, ""))
+ ;et = Primitives{3}
+ ;/
+
+ /; loop (!(tok`{cur`}.cmp("{"))) [cur`++] ;/
+ ;cur`++
+
+ ;Module enum_mod = {current, current`.exp, string_add("__#", name), {}, {}, {}, {}}
+
+ ;{}uint8 out = ""
+
+ /; loop (cur` < len tok`) [cur`++]
+ /; if (tok`{cur`}.cmp("}"))
+ ;break
+ ;/
+
+ /; if (tok`{cur`}.type_is(TOKEN.DEFWORD))
+ ;{}uint8 l = string_add(enum_mod.full_path(), ".")
+ ;l = string_add(l, tok`{cur`}.data)
+ ;l.append(':')
+ ;l.append('\n')
+ ;cur` = cur` + 2
+ ;l = string_add(l, decompose_data(tok, cur, current, et))
+ ;out = string_add(out, l)
+ ;/
+ ;/
+
+ ;current`.sub.append(enum_mod)
+
+ ;return out
+;/
+
+# Generates opposite closing bracket
+/; closing_for (Token d) [{}uint8]
+ /; if (d.cmp("("))
+ ;return ")"
+ ;; else if (d.cmp("["))
+ ;return "]"
+ ;; else if (d.cmp("{"))
+ ;return "}"
+ ;/
+ ;tnsl.io.println(string_add("Error, unrecognized delim: ", d))
+;/
+
+# Finds closing bracket
+/; find_closing (~{}Token tok, ~int cur) [int]
+ ;int bl = 0, p = 0, br = 0, c = 0
+ ;{}uint8 cl = closing_for(tok`{cur`})
+
+ /; loop (int i = cur` + 1; i < len tok`) [i++]
+ /; if (bl == 0 && p == 0 && br == 0 && c == 0)
+ /; if ((tok`{i}.cmp(";;") || tok`{i}.cmp(";:")) && string_equate(cl, "/;"))
+ ;return i
+ ;; else if (tok`{i}.cmp(cl))
+ ;return i
+ ;/
+ ;/
+
+ /; if (tok`{i}.cmp("("))
+ ;p++
+ ;; else if (tok`{i}.cmp("["))
+ ;br++
+ ;; else if (tok`{i}.cmp("{"))
+ ;c++
+ ;; else if (tok`{i}.cmp("/;"))
+ ;bl++
+ ;/
+
+ /; if (tok`{i}.cmp(")"))
+ ;p = p - 1
+ ;; else if (tok`{i}.cmp("]"))
+ ;br = br - 1
+ ;; else if (tok`{i}.cmp("}"))
+ ;c = c - 1
+ ;; else if (tok`{i}.cmp(";/") || tok`{i}.cmp(";:"))
+ ;bl = bl - 1
+ ;/
+ ;/
+
+ ;return len tok` - 1
+;/
+
+# Skips cur to the end of a struct
+/; skip_struct (~{}Token tok, ~int cur)
+ ;{}uint8 name = tok`{cur` + 1}.data
+ /; loop (cur` < len tok`) [cur`++]
+ /; if (tok`{cur`}.cmp("{"))
+ ;cur` = find_closing(tok, cur)
+ ;break
+ ;/
+ ;/
+;/
+
+# TODO:
+/; compile_function (~{}Token tok, ~int cur, ~CompData out, ~Module current, ~Scope scope) [Function]
+
+;/
+
+# TODO:
+/; compile_method (~{}Token tok, ~int cur, ~CompData out, ~Module current, ~Scope scope) [Function]
+
+;/
+
+# First pass on a module
+# Generates structs, enums, and submodules
+/; module_pass_one (~{}Token tok, ~int cur, ~Module current)
+
+;/
+
+# Second pass on a module
+# Generates code and calls compile_file_second_pass if an include happens
+/; module_pass_two (~{}Token tok, ~int cur, ~Module current)
+
+;/
+
+# First compiler pass on a file
+# Only creates structs, enums, and moduless
+/; compile_file_pass_one (Path f, ~Module current)
+ ;{}Token tok = tokenize(f)
+
+ ;tnsl.io.print("Number of tokens generated: ")
+ ;tnsl.io.println(len tok)
+
+ /; loop (int i = 0; i < len tok) [i++]
+ ;tnsl.io.print(".")
+ /; if (tok{i}.cmp(":"))
+ ;tnsl.io.println("INCLUDE")
+ /; if (tok{i + 2}.type_is(TOKEN.LITERAL))
+ ;CompData tmp = compile_file_pass_one(f.relative(unquote_str(tok{i + 2}.data)), current)
+ ;i = i + 2
+ ;/
+ ;continue
+ ;; else if (tok{i}.cmp("/;") || tok{i}.cmp(";;"))
+ /; if (tok{i + 1}.cmp("export") || tok{i + 1}.cmp("module"))
+ ;module_pass_one(~tok, ~i, current)
+ ;/
+ ;; else if (tok{i}.cmp("struct"))
+ ;new_type(~tok, ~i, current)
+ ;/
+ ;/
+;/
+
+/; size_struct (~Type t, ~Module m)
+ ;int s = 0
+ /; loop (int i = 0; i < len (t`.members)) [i++]
+ ;int p = is_primitive(t`.members{i}.data_type.name)
+ /; if (len (t`.members{i}.data_type.ptr_chain) > 0)
+ ;s = s + 8
+ ;; else if (p >== 0)
+ ;s = s + p
+ ;; else
+ ;~Type tp = m`.find_type(t`.members{i}.data_type.name)
+ /; if (tp`.s == 0)
+ ;size_struct(tp, m)
+ ;/
+ ;t`.members{i}.data_type = tp`
+ ;s = s + tp`.s
+ ;/
+ ;/
+ ;tnsl.io.println(string_add("Sized type ", t`.name))
+ ;t`.s = s
+;/
+
+# Regenerates struct sizes (with support for cyclical struct definitions)
+/; flush_structs (~Module m)
+
+ /; loop (int i = 0; i < len (m`.types)) [i++]
+ ;size_struct(~(m`.types{i}), m)
+ ;/
+
+ /; loop (int i = 0; i < len (m`.sub)) [i++]
+ ;flush_structs(~(m`.sub{i}))
+ ;/
+;/
+
+# Second pass of compiler
+# Does code generation, ignores structs and enums
+/; compile_file_pass_two (Path f, ~Module current) [CompData]
+ ;CompData out = {"", "", ""}
+ ;{}Token tok = tokenize(f)
+
+ /; loop (int i = 0; i < len tok) [i++]
+ ;tnsl.io.print(".")
+ /; if (tok{i}.cmp(":"))
+ ;tnsl.io.println("INCLUDE")
+ /; if (tok{i + 2}.type_is(TOKEN.LITERAL))
+ ;CompData tmp = compile_file_pass_two(f.relative(unquote_str(tok{i + 2}.data)), current)
+ ;out.hsec = string_add(out.hsec, tmp.hsec)
+ ;out.dsec = string_add(out.dsec, tmp.dsec)
+ ;out.csec = string_add(out.csec, tmp.csec)
+ ;i = i + 2
+ ;/
+ ;continue
+ ;; else if (tok{i}.cmp("/;") || tok{i}.cmp(";;"))
+ ;tnsl.io.print("block")
+ /; if (tok{i + 1}.cmp("export") || tok{i + 1}.cmp("module"))
+ ;module_pass_two(~tok, ~i, current)
+ ;/
+ ;; else if (tok{i}.cmp("struct"))
+ ;tnsl.io.print("struct")
+ ;skip_struct(~tok, ~i)
+ ;; else if (tok{i}.cmp("enum"))
+ ;tnsl.io.print("enum")
+ ;out.dsec = string_add(out.dsec, compile_enum(~tok, ~i, current))
+ ;; else if (is_definition(~tok, ~i))
+ ;tnsl.io.print("def")
+ ;Type t = get_type(~tok, ~i, current)
+ ;out.dsec = string_add(out.dsec, compile_file_def(~tok, ~i, t, current))
+ ;; else if (!(tok{i}.cmp("\n")))
+ ;tnsl.io.println("Failed to recognize file-level statement")
+ ;tok{i}.print()
+ ;break
+ ;/
+ ;/
+
+ ;tnsl.io.print("Generated code length: ")
+ ;tnsl.io.println(len (out.hsec) + len (out.dsec) + len (out.csec))
+
+ ;return out
+;/
+
+# Starts the compiler on a given path
+/; compile_start (Path f) [{}uint8]
+ ;{}uint8 out = ""
+
+ ;Module root = {0, true, {}, {}, {}, {}, {}}
+ ;compile_file_pass_one(f, ~root)
+ ;flush_structs(~root)
+ ;tnsl.io.println("First pass DONE")
+
+ ;CompData data = compile_file_pass_two(f, ~root)
+ ;tnsl.io.println("Second pass DONE")
+
+ ;out = string_join({
+ data.hsec,
+ "section .data\n",
+ data.dsec,
+ "section .text\n",
+ data.csec}, "")
+
+ ;return out
+;/
+
+##
+## Tokenizer funcs
+##
+
+
+/; is_whitespace (uint8 c) [bool]
+ ;return (c == '\n' || c == '\t' || c == ' ')
+;/
+
+;{}uint8 MULTI_PARENS = "/;:#"
+;{}uint8 PARENS = "()[]{}"
+;{}uint8 RESERVED = "`~!%^&*()-+=[]{}|;:/?<>.,"
+;{}uint8 AUGMENTS = "=~!<>&|^+-*/`."
+
+;{}{}uint8 MULTI_AUGMENTS = {
+ "~=", "`=", "%=", "^=", "&=", "*=",
+ "!=", "|=", "/=",
+
+ "==", "!==", "&&", "||", "^^", "<==", ">==", "!>", "!<",
+
+ "<<", ">>", "!&", "!|", "!^"
+}
+
+
+;{}{}uint8 KEYWORDS = {
+ "len",
+ "is",
+
+ "if",
+ "else",
+ "loop",
+ "continue",
+ "break",
+
+ "return",
+
+ "method",
+ "struct",
+ "enum",
+ "interface",
+
+ "export",
+ "module",
+
+ "const",
+ "static",
+ "volatile",
+
+ "extends",
+ "override"
+}
+
+;{}{}uint8 KEYTYPES = {
+ "uint8",
+ "uint16",
+ "uint32",
+ "uint64",
+ "uint",
+
+ "int8",
+ "int16",
+ "int32",
+ "int64",
+ "int",
+
+ "float32",
+ "float64",
+ "float",
+
+ "comp32",
+ "comp64",
+ "comp",
+
+ "vect",
+ "bool",
+
+ "type",
+ "void"
+}
+
+/; is_delimiter ({}uint8 str) [bool]
+ /; if (len str > 2 || len str < 1)
+ ;return false
+ ;/
+
+ /; if (len str == 2)
+ ;return string_contains(MULTI_PARENS, str{0}) && string_contains(MULTI_PARENS, str{1})
+ ;/
+
+ ;return string_contains(PARENS, str{0})
+;/
+
+/; is_reserved ({}uint8 str) [bool]
+ /; if (len str < 1)
+ ;return false
+ ;/
+ ;return string_contains(RESERVED, str{0})
+;/
+
+/; is_augment ({}uint8 str) [bool]
+ /; if (len str == 1)
+ ;return string_contains(AUGMENTS, str{0})
+ ;/
+
+ ;return list_contains(MULTI_AUGMENTS, str)
+;/
+
+/; is_str_literal ({}uint8 str) [bool]
+ /; if (string_equate(str, "\"") || string_equate(str, "'"))
+ ;return true
+ ;/
+
+ /; if (len str < 2)
+ ;return false
+ ;; else if (str{0} !== '\'' && str{0} !== '"')
+ ;return false
+ ;/
+
+ /; loop (int i = 1; i < len str) [i++]
+ /; if (str{i} == '\\')
+ ;i++
+ ;; else if (str{i} == str{0})
+ ;return i == len str - 1
+ ;/
+ ;/
+ ;return true
+;/
+
+/; is_num_literal ({}uint8 str) [bool]
+ /; if (len str < 1)
+ ;return false
+ ;/
+
+ ;bool dec = false
+ /; loop (int i = 0; i < len str) [i++]
+ /; if (str{i} == '.')
+ /; if (!dec)
+ ;dec = true
+ ;; else
+ ;return false
+ ;/
+ ;; else if (str{i} < '0' || str{i} > '9')
+ ;return false
+ ;/
+ ;/
+ ;return true
+;/
+
+/; is_literal({}uint8 str) [bool]
+ ;return is_str_literal(str) || is_num_literal(str)
+;/
+
+/; gen_type (Token t) [int]
+ /; if (t.cmp("\n") || t.cmp(","))
+ ;return TOKEN.SEPARATOR
+ ;/
+
+ /; if (is_literal(t.data))
+ ;return TOKEN.LITERAL
+ ;/
+
+ /; if (is_reserved(t.data))
+ /; if (is_delimiter(t.data))
+ ;return TOKEN.DELIMITER
+ ;; else if (is_augment(t.data))
+ ;return TOKEN.AUGMENT
+ ;/
+ ;; else if (list_contains(KEYWORDS, t.data))
+ ;return TOKEN.KEYWORD
+ ;; else if (list_contains(KEYTYPES, t.data))
+ ;return TOKEN.KEYTYPE
+ ;/
+
+ ;return TOKEN.DEFWORD
+;/
+
+/; break_token (Token current, uint8 to_append) [bool]
+ /; if (is_literal(current.data))
+ ;current.data.append(to_append)
+ ;return !(is_literal(current.data))
+ ;/
+
+ /; if (is_whitespace(to_append) || current.cmp("\n"))
+ ;return true
+ ;/
+
+ /; if (is_reserved(current.data))
+ /; if (is_reserved({to_append}))
+ ;current.data.append(to_append)
+ ;return gen_type(current) == TOKEN.DEFWORD
+ ;/
+ ;return true
+ ;; else if (is_reserved({to_append}))
+ ;return true
+ ;/
+
+ ;return false
+;/
+
+/; handle_comment (tnsl.io.File fd, ~Token current, ~int line) [bool]
+ ;bool block = false
+ /; if (current`.cmp("/"))
+ ;block = true
+ ;/
+
+ /; loop (int i = fd.read(); i !== -1) [i = fd.read()]
+ /; if (i == '\n')
+ ;line`++
+ /; if (!block)
+ ;return true
+ ;/
+ ;; else if (block && i == '#')
+ ;i = fd.read()
+ /; if (i == '/')
+ ;current` = {0, line, ""}
+ ;return false
+ ;; else if (i == ';' || i == ':')
+ ;current`.data.append(i)
+ ;return false
+ ;/
+
+ /; loop (i !== '\n' && i !== -1) [i = fd.read()] ;/
+
+ ;line`++
+ ;/
+ ;/
+;/
+
+/; tokenize (Path f) [{}Token]
+ ;{}Token out = {}
+
+ ;tnsl.io.File fd = f.open_read()
+
+ ;Token current = {0, 0, ""}
+ ;int line = 1
+ /; loop (int i = fd.read(); i > -1) [i = fd.read()]
+
+ /; if (i == '#' && (break_token(current, i) || gen_type(current) !== TOKEN.LITERAL))
+ ;bool ln = handle_comment(fd, ~current, ~line)
+ /; if (ln)
+ ;current.tokenType = gen_type(current)
+ /; if (!(current.cmp("")))
+ ;out.append(current)
+ ;/
+ ;out.append({TOKEN.SEPARATOR, line - 1, "\n"})
+ ;/
+ ;continue
+ ;/
+
+ /; if (i == '\n')
+ ;tnsl.io.print(".")
+ /; if (!(current.cmp("\n")))
+ ;current.tokenType = gen_type(current)
+ /; if (!(current.cmp("")))
+ ;out.append(current)
+ ;/
+ ;current = {TOKEN.SEPARATOR, line, ""}
+ ;current.data.append(i)
+ ;/
+ ;line++
+ ;; else if (break_token(current, i))
+ ;current.tokenType = gen_type(current)
+ /; if (!(current.cmp("")))
+ ;out.append(current)
+ ;/
+ ;current = {0, line, ""}
+ /; if (!(is_whitespace(i)))
+ ;current.data.append(i)
+ ;/
+ ;; else
+ ;current.data.append(i)
+ ;/
+ ;/
+ ;tnsl.io.println("OK")
+
+ /; if (!(current.cmp("")) && !(current.cmp("\n")))
+ ;current.tokenType = gen_type(current)
+ ;out.append(current)
+ ;/
+
+ ;fd.close()
+
+ ;return out
+;/
+
+##
+## Main
+##
+
+/; main ({}{}uint8 args) [int]
+ /; if (len args < 1)
+ ;tnsl.io.println("Give me something to compile!")
+ ;return 1
+ ;/
+
+ ;bool tokenize_only = len args > 1
+
+ ;{}{}uint8 fsplit = string_split(args{0}, '/')
+ ;Path p = {{}, fsplit{len fsplit - 1}}
+
+ /; loop (int i = 0; i < len fsplit - 1) [i++]
+ ;p.path.append(fsplit{i})
+ ;/
+
+ ;tnsl.io.print("Path: ")
+ ;tnsl.io.println(p.full_path())
+
+ ;{}uint8 code = ""
+ /; if (!tokenize_only)
+ ;code = compile_start(p)
+ ;; else
+ ;{}Token tok = tokenize(p)
+ /; loop(int i = 0; i < len tok) [i++]
+ ;tnsl.io.print(".")
+ ;code = string_add(code, tok{i}.sprint())
+ ;/
+ ;tnsl.io.println("OK")
+ ;/
+
+ ;p.name = string_add(p.name, ".asm")
+
+ ;p.write(code)
+
+ ;return 0
+;/
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-20 04:07:38 +0000