summaryrefslogtreecommitdiff
path: root/tnslc/compile
diff options
context:
space:
mode:
Diffstat (limited to 'tnslc/compile')
-rw-r--r--tnslc/compile/codegen.tnsl76
-rw-r--r--tnslc/compile/compbuf.tnsl6
-rw-r--r--tnslc/compile/compile.tnsl1
-rw-r--r--tnslc/compile/function.tnsl253
-rw-r--r--tnslc/compile/module.tnsl399
-rw-r--r--tnslc/compile/scope.tnsl261
-rw-r--r--tnslc/compile/struct.tnsl263
-rw-r--r--tnslc/compile/var.tnsl479
8 files changed, 1531 insertions, 207 deletions
diff --git a/tnslc/compile/codegen.tnsl b/tnslc/compile/codegen.tnsl
index 165fe12..2dfe9d5 100644
--- a/tnslc/compile/codegen.tnsl
+++ b/tnslc/compile/codegen.tnsl
@@ -1,4 +1,80 @@
+/; _indent (int idt)
+ /; loop (int i = 0; i < idt) [i++]
+ _printf(" \0")
+ ;/
+;/
/; generate (~utils.File fin, fout)
+ # Parse files into AST
+ parse.Node ast = parse.generate_ast(fin)
+ ast.update_children()
+
+ parse.print_ast(~ast)
+
+ # Create output buffer
+ CompBuf buffer
+ buffer.init()
+
+ # Transform into a module tree
+ Module mod
+ mod.init(~ast, ~buffer)
+ _gen_prims(~mod)
+ mod.update_children()
+
+ # Compile code
+ mod.compile(~buffer)
+
+ mod.print()
+
+ # Write assembly to output file
+ fout.create()
+ buffer.write_to(fout)
+ fout.close()
+
+ # Free all structs
+ mod.end()
+ buffer.end()
+ ast.end()
+;/
+
+/; _gen_prim(~Module m, int size, ~uint8 id)
+ ~Module mds = m`._create_methods(id)
+
+ Var t
+
+ Struct s
+ s.size = size
+ s.methods = NULL
+ s.members.init(len t)
+ s.name = utils.strcpy(id)
+ s._up = NULL
+
+ m`.structs.push(~s)
+;/
+
+/; _gen_prims (~Module m)
+
+ # One byte prims
+ _gen_prim(m, 1, "bool\0")
+ _gen_prim(m, 1, "uint8\0")
+ _gen_prim(m, 1, "int8\0")
+
+ # Two byte prims
+ _gen_prim(m, 2, "uint16\0")
+ _gen_prim(m, 2, "int16\0")
+
+ # Four byte prims
+ _gen_prim(m, 4, "uint32\0")
+ _gen_prim(m, 4, "int32\0")
+ _gen_prim(m, 4, "float32\0")
+
+ # Eight byte prims
+ _gen_prim(m, 8, "uint64\0")
+ _gen_prim(m, 8, "int64\0")
+ _gen_prim(m, 8, "float64\0")
+ _gen_prim(m, 8, "uint\0")
+ _gen_prim(m, 8, "int\0")
+ _gen_prim(m, 8, "float\0")
+ _gen_prim(m, 8, "void\0")
;/
diff --git a/tnslc/compile/compbuf.tnsl b/tnslc/compile/compbuf.tnsl
index b4ce261..d4bc640 100644
--- a/tnslc/compile/compbuf.tnsl
+++ b/tnslc/compile/compbuf.tnsl
@@ -26,13 +26,13 @@ struct CompBuf {
;/
/; write_to(~utils.File fout)
- fout`.write_cstr("BITS 64\0\n")
+ fout`.write_cstr("BITS 64\n\0")
fout`.write_cstr(self.sec_head.as_cstr())
- fout`.write_cstr("\nsection .data\0\n\n")
+ fout`.write_cstr("\nsection .data\n\n\0")
fout`.write_cstr(self.sec_data.as_cstr())
- fout`.write_cstr("\nsection .text\0\n\n")
+ fout`.write_cstr("\nsection .text\n\n\0")
fout`.write_cstr(self.sec_code.as_cstr())
;/
diff --git a/tnslc/compile/compile.tnsl b/tnslc/compile/compile.tnsl
index 338e28d..fbb9670 100644
--- a/tnslc/compile/compile.tnsl
+++ b/tnslc/compile/compile.tnsl
@@ -5,5 +5,6 @@
:import "function.tnsl"
:import "module.tnsl"
:import "codegen.tnsl"
+ :import "scope.tnsl"
;/
diff --git a/tnslc/compile/function.tnsl b/tnslc/compile/function.tnsl
index cf42db1..eec65ed 100644
--- a/tnslc/compile/function.tnsl
+++ b/tnslc/compile/function.tnsl
@@ -1,36 +1,237 @@
struct Function {
- ~uint8 name,
- utils.Vector
- inputs,
- outputs,
- ~parse.Node body
+ ~uint8 name,
+ utils.Vector
+ inputs,
+ outputs,
+ ~parse.Node _up,
}
/; method Function
- /; init (~uint8 name)
- self.name = name
- Var v
- self.inputs.init(len v)
- self.outputs.init(len v)
- ;/
+ /; init (~parse.Node n)
+ self.name = utils.strcpy(n`.data)
+ self._up = n
+ Var v
+ self.inputs.init(len v)
+ self.outputs.init(len v)
+ ;/
- /; end
- _delete(self.name)
- self.body`.end()
+ /; _resolve_dlist (~Module parent, ~parse.Node dl)
+ ~parse.Node tn = NULL
+ ~parse.Node n
+ int reg = 1
+ int stack_down = 0
+ /; loop (int i = 0; i < dl`.sub.count) [i++]
+ n = dl`.sub.get(i)
+ /; if (n`._type == parse.NTYPE_TYPE)
+ tn = n
+ ;; else if (n`._type == parse.NTYPE_ID)
+ /; if (tn == NULL)
+ _printf("Identifier declared in parameter list before any type was found!\n\0")
+ return
+ ;/
+ Var p
+ p.init(tn, n)
+ p._resolve_type(parent)
+ /; if (p.is_reg_passed() == true && reg < 7)
+ p.loc = reg
+ reg++
+ ;; else
+ p.loc = 0
+ p.loc = p.loc - stack_down
+ stack_down = stack_down - p.actual_size()
+ ;/
+ self.inputs.push(~p)
+ ;/
+ ;/
+ ;/
- ~Var v
- /; loop (int i = 0; i < self.inputs.count) [i++]
- v = self.inputs.get(i)
- v`.end()
- ;/
- self.inputs.end()
+ /; _resolve_tlist (~Module parent, ~parse.Node tl)
+ ~parse.Node n
+ parse.Node dummy
+ dummy.data = "### OUTPUT ###\0"
+ /; loop (int i = 0; i < tl`.sub.count) [i++]
+ n = tl`.sub.get(i)
+ /; if (n`._type == parse.NTYPE_TYPE)
+ Var r
+ r.init(n, ~dummy)
+ r._resolve_type(parent)
+ self.outputs.push(~r)
+ ;/
+ ;/
+ ;/
- /; loop (int i = 0; i < self.outputs.count) [i++]
- v = self.outputs.get(i)
- v`.end()
- ;/
- self.outputs.end()
- ;/
+ /; _resolve_type (~Module parent)
+ ~parse.Node _up = self._up
+ /; if (_up`.sub.count < 1)
+ return
+ ;/
+
+ ~parse.Node lst = _up`.sub.get(0)
+ /; if (lst`._type == parse.NTYPE_DLIST)
+ self._resolve_dlist(parent, lst)
+ /; if (_up`.sub.count > 1)
+ lst = _up`.sub.get(1)
+ ;/
+ ;/
+
+ /; if (lst`._type == parse.NTYPE_TLIST)
+ self._resolve_tlist(parent, lst)
+ ;/
+ ;/
+
+ /; _build_func(~Module parent, ~CompBuf cb) [Scope]
+ Scope out
+ out.init(parent, cb, self.name)
+ out.parent = NULL
+
+ /; if (parent`.e == true)
+ # Add to the global exports if the parent is exported
+ ~uint8 bl = out.base_label()
+ cb`.add_h("global \0")
+ cb`.add_h(bl)
+ cb`.add_h("\n\0")
+ _delete(bl)
+ ;/
+
+ # Write label and opening
+ out.place_base_label()
+ cb`.add_c(" push rbp\n\0")
+ cb`.add_c(" lea rbp, [rsp + 8]\n\0")
+ cb`.add_c(" push r10\n\0")
+ cb`.add_c(" push r11\n\0")
+ cb`.add_c(" push r12\n\0")
+ cb`.add_c(" push r13\n\0")
+ cb`.add_c(" push r14\n\0")
+ cb`.add_c(" push r15 ; scope init\n\n\0")
+
+ # Add all params to the scope
+ ~Var in
+ /; loop (int i = 0; i < self.inputs.count) [i++]
+ in = self.inputs.get(i)
+ out.mk_set_var(in)
+ ;/
+
+ return out
+ ;/
+
+ /; _end_func(~Scope scope, ~CompBuf cb)
+ cb`.add_c(" lea rsp, [rbp - 56]\n\0")
+ cb`.add_c(" pop r15\n\0")
+ cb`.add_c(" pop r14\n\0")
+ cb`.add_c(" pop r13\n\0")
+ cb`.add_c(" pop r12\n\0")
+ cb`.add_c(" pop r11\n\0")
+ cb`.add_c(" pop r10\n\0")
+ cb`.add_c(" pop rbp\n\0")
+ cb`.add_c(" ret ; scope end\n\n\n\0")
+
+ scope`.end()
+ ;/
+
+ /; _compile (~Module parent, ~CompBuf cb)
+ # Sanity check
+ ~parse.Node _up = self._up
+ /; if (_up`.sub.count < 1)
+ ~Scope s = self._build_func(parent, cb)
+ self._end_func(s, cb)
+ return
+ ;/
+
+ # Skip past parameters and outputs
+ int i = 0
+ ~parse.Node n = _up`.sub.get(i)
+ /; if (n`._type == parse.NTYPE_DLIST)
+ i++
+ /; if (_up`.sub.count > 1)
+ n = _up`.sub.get(1)
+ ;/
+ ;/
+
+ /; if (n`._type == parse.NTYPE_TLIST)
+ i++
+ ;/
+
+ # Create scope
+ Scope fscope = self._build_func(parent, cb)
+
+
+ # Compile and then end scope
+ self._compile_statements(~fscope, i)
+ self._end_func(~fscope, cb)
+ ;/
+
+ #
+ # Compiling individual statements
+ #
+
+ /; _compile_statements (~Scope s, int off)
+ ~parse.Node _up = self._up
+ ~parse.Node n = NULL
+ /; loop (off < _up`.sub.count) [off++]
+ n = _up`.sub.get(off)
+ /; if (n`._type == parse.NTYPE_FLOW_CONTROL)
+ self._compile_flow_control(s, n)
+ ;; else if (n`._type == parse.NTYPE_ASM)
+ s`.cb`.add_c(" \0")
+ s`.cb`.add_c(n`.data)
+ s`.cb`.add_c(" ; User defined asm\n\0")
+ ;/
+ ;/
+ ;/
+
+ # Should handle break, continue, and return
+ /; _compile_flow_control (~Scope s, ~parse.Node n)
+ /; if (utils.strcmp(n`.data, "return\0") == true)
+ # Compute value and return
+ self._compile_value(s, n)
+ ;/
+ ;/
+
+ # Should handle computing a value, delegate to other funcs when needed
+ /; _compile_value (~Scope s, ~parse.Node n)
+ ;/
+
+ /; _print (int idt)
+ _indent(idt)
+ _printf("{ Function : \0")
+ _printf(self.name)
+ _printf("\n\0")
+
+ _indent(idt)
+ _printf(" inputs:\n\0")
+ ~Var prtv
+ /; loop (int i = 0; i < self.inputs.count) [i++]
+ prtv = self.inputs.get(i)
+ prtv`._print(idt + 1)
+ ;/
+
+ _indent(idt)
+ _printf(" outputs:\n\0")
+ /; loop (int i = 0; i < self.outputs.count) [i++]
+ prtv = self.outputs.get(i)
+ prtv`._print(idt + 1)
+ ;/
+
+ _indent(idt)
+ _printf("}\n\0")
+ ;/
+
+ /; end
+ _delete(self.name)
+
+ ~Var v
+ /; loop (int i = 0; i < self.inputs.count) [i++]
+ v = self.inputs.get(i)
+ v`.end()
+ ;/
+ self.inputs.end()
+
+ /; loop (int i = 0; i < self.outputs.count) [i++]
+ v = self.outputs.get(i)
+ v`.end()
+ ;/
+ self.outputs.end()
+ ;/
;/
diff --git a/tnslc/compile/module.tnsl b/tnslc/compile/module.tnsl
index 6dbef6c..e46c219 100644
--- a/tnslc/compile/module.tnsl
+++ b/tnslc/compile/module.tnsl
@@ -1,68 +1,367 @@
+int SEARCH_VAR = 0
+int SEARCH_STRUCT = 1
+int SEARCH_FUNC = 2
+int SEARCH_SUB = 3
+
struct Module {
- # Text name of module
- ~uint8 name,
+ # Text name of module
+ ~uint8 name,
+
+ # Various contained elements
+ utils.Vector
+ vars,
+ structs,
+ funcs,
+ subs,
- # Various contained elements
- utils.Vector
- vars,
- structs,
- funcs,
- subs,
+ # Whether we export or not
+ bool e,
- # Whether we export or not
- bool e
+ # Parent module
+ ~Module parent
}
/; method Module
-
- /; init (~uint8 name, bool exp)
- Var v
- Struct s
- Function f
- Module m
+
+ /; _init
+ Var v
+ Struct s
+ Function f
+ Module m
+
+ self.parent = NULL
+
+ self.vars.init(len v)
+ self.structs.init(len s)
+ self.funcs.init(len f)
+ self.subs.init(len m)
+ ;/
+
+ /; init (~parse.Node mod, ~CompBuf buf)
+ self._init()
+ self.name = utils.strcpy(mod`.data)
+ self.e = mod`._type == parse.NTYPE_EXPORT
+
+ self._from_tree(mod, buf)
+ ;/
+
+ /; update_children
+ ~Module sub
+ /; loop (int i = 0; i < self.subs.count) [i++]
+ sub = self.subs.get(i)
+ sub`.update_children()
+ sub`.parent = ~self
+ ;/
+
+ ~Struct str
+ utils.Vector n
+ /; loop (int i = 0; i < self.structs.count) [i++]
+ str = self.structs.get(i)
+
+ n.from_cstr("_#\0")
+ n.push_cstr(str`.name)
+
+ sub = self._find_sub(n.as_cstr())
+ str`.methods = sub
+
+ n.end()
+ ;/
+ ;/
+
+ /; _create_methods (~uint8 name) [~Module]
+ utils.Vector n
+ n.from_cstr("_#\0")
+ n.push_cstr(name)
+
+ Module m
+ m._init()
+ m.name = n.as_cstr()
+ m.e = self.e
+ self.subs.push(~m)
+
+ int i = self.subs.count - 1
+ ~Module out = self.subs.get(i)
+ return out
+ ;/
+
+ /; _from_tree (~parse.Node mod, ~CompBuf buf)
+ ~parse.Node sub
+ /; loop (int i = 0; i < mod`.sub.count) [i++]
+ sub = mod`.sub.get(i)
+
+ # TODO: Vars, Enums, Method blocks
+
+ /; if (sub`._type == parse.NTYPE_MODULE)
+ Module m
+ m.init(sub, buf)
+ self.subs.push(~m)
+ ;; else if (sub`._type == parse.NTYPE_EXPORT)
+ Module m
+ m.init(sub, buf)
+ self.subs.push(~m)
+ ;; else if (sub`._type == parse.NTYPE_STRUCT)
+ ~Module m = self._create_methods(sub`.data)
+ Struct s
+ s.init(sub)
+ self.structs.push(~s)
+ ;; else if (sub`._type == parse.NTYPE_FUNCTION)
+ Function f
+ f.init(sub)
+ self.funcs.push(~f)
+ ;; else if (sub`._type == parse.NTYPE_DECL)
+ self._decl(sub)
+ ;; else if (sub`._type == parse.NTYPE_ASM)
+ buf`.add_h(sub`.data)
+ buf`.add_h("\n\0")
+ ;/
+ ;/
+ ;/
+
+ /; _decl (~parse.Node decl)
+ /; if (decl`.sub.count < 1)
+ return
+ ;/
+
+ ~parse.Node tn = decl`.sub.get(0)
+ /; if (tn`._type !== parse.NTYPE_TYPE)
+ # Type must be first
+ return
+ ;/
+
+ ~parse.Node id
+ /; loop (int i = 1; i < decl`.sub.count) [i++]
+ id = decl`.sub.get(i)
+ /; if (tn`._type == parse.NTYPE_ID)
+ # Add a new variable to the list
+ Var v
+ v.init(tn, id)
+ self.vars.push(~v)
+ ;/
+ ;/
+ ;/
+
+ /; compile (~CompBuf cb)
+ # First, since all the types are in place, we need to size all of them.
+ self._size_structs()
+
+ # Finally, write all functions to the code section
+ self._compile(cb)
+ ;/
+
+ /; _size_structs
+ ~Struct s
+ /; loop (int i = 0; i < self.structs.count) [i++]
+ s = self.structs.get(i)
+ /; if (s`.size == 0)
+ s`._compute_size()
+ ;/
+ ;/
+
+ ~Var v
+ /; loop (int i = 0; i < self.vars.count) [i++]
+ v = self.vars.get(i)
+ v`._resolve_type(~self)
+ ;/
+
+ ~Function f
+ /; loop (int i = 0; i < self.funcs.count) [i++]
+ f = self.funcs.get(i)
+ f`._resolve_type(~self)
+ ;/
+
+ ~Module m
+ /; loop (int i = 0; i < self.subs.count) [i++]
+ m = self.subs.get(i)
+ m`._size_structs()
+ ;/
+ ;/
+
+ /; _compile (~CompBuf cb)
+ ~Var v
+ /; loop (int i = 0; i < self.vars.count) [i++]
+ v = self.vars.get(i)
+ v`._static_compile(~self, cb)
+ ;/
+
+ ~Function f
+ /; loop (int i = 0; i < self.funcs.count) [i++]
+ f = self.funcs.get(i)
+ f`._compile(~self, cb)
+ ;/
+
+ ~Module m
+ /; loop (int i = 0; i < self.subs.count) [i++]
+ m = self.subs.get(i)
+ m`._compile(cb)
+ ;/
+ ;/
+
+ #
+ # Functions to search sub-modules
+ #
+
+ /; find (int stype, ~utils.Vector key) [~void]
+ /; if (key`.count < 1)
+ return NULL
+ ;/
+ return self._find(stype, key, 0)
+ ;/
+
+ /; _find (int stype, ~utils.Vector key, int lvl) [~void]
+
+ /; if ((lvl + 1) < key`.count)
+ ~Module m
+ ~~uint8 str = key`.get(lvl)
+
+ /; loop (int i = 0; i < self.subs.count) [i++]
+ m = self.subs.get(i)
+ /; if (utils.strcmp(str`, m`.name) == true)
+ ~void v = m._find(stype, key, lvl + 1)
+ /; if (v != NULL)
+ return v
+ ;/
+ ;/
+ ;/
+ ;; else
+ ~~uint8 str = key`.get(key`.count - 1)
+ ~void out = NULL
+ /; if (stype == SEARCH_VAR)
+ out = self._find_var(str`)
+ ;; else if (stype == SEARCH_STRUCT)
+ out = self._find_struct(str`)
+ ;; else if (stype == SEARCH_FUNC)
+ out = self._find_func(str`)
+ ;; else if (stype == SEARCH_SUB)
+ out = self._find_sub(str`)
+ ;/
+
+ /; if (out !== NULL)
+ return out
+ ;/
+ ;/
+
+ /; if (lvl == 0 && self.parent !== NULL)
+ return self.parent`._find(stype, key, 0)
+ ;/
+
+ return NULL
+ ;/
+
+ /; _find_var (~uint8 name) [~void]
+ ~Var v
+ /; loop (int i = 0; i < self.vars.count) [i++]
+ v = self.vars.get(i)
+ /; if (utils.strcmp(name, v`.name) == true)
+ return v
+ ;/
+ ;/
+ return NULL
+ ;/
+
+ /; _find_struct (~uint8 name) [~void]
+ ~Struct s
+ /; loop (int i = 0; i < self.structs.count) [i++]
+ s = self.structs.get(i)
+ /; if (utils.strcmp(name, s`.name) == true)
+ return s
+ ;/
+ ;/
+ return NULL
+ ;/
+
+ /; _find_func (~uint8 name) [~void]
+ ~Function f
+ /; loop (int i = 0; i < self.funcs.count) [i++]
+ f = self.funcs.get(i)
+ /; if (utils.strcmp(name, f`.name) == true)
+ return f
+ ;/
+ ;/
+ return NULL
+ ;/
+
+ /; _find_sub (~uint8 name) [~void]
+ ~Module m
+ /; loop (int i = 0; i < self.subs.count) [i++]
+ m = self.subs.get(i)
+ /; if (utils.strcmp(name, m`.name) == true)
+ return m
+ ;/
+ ;/
+ return NULL
+ ;/
+
+ /; print
+ self._print(0)
+ ;/
+
+ /; _print (int indent)
+
+ _indent(indent)
+ _printf("{ Module : \0")
+ _printf(self.name)
+ _printf("\n\0")
+
+ ~Var v
+ /; loop (int i = 0; i < self.vars.count) [i++]
+ v = self.vars.get(i)
+ v`._print(indent + 1)
+ ;/
+
+ ~Struct s
+ /; loop (int i = 0; i < self.structs.count) [i++]
+ s = self.structs.get(i)
+ s`._print(indent + 1)
+ ;/
- self.vars.init(len v)
- self.structs.init(len s)
- self.funcs.init(len f)
- self.subs.init(len m)
+ ~Function f
+ /; loop (int i = 0; i < self.funcs.count) [i++]
+ f = self.funcs.get(i)
+ f`._print(indent + 1)
+ ;/
- self.name = name
- self.e = exp
- ;/
+ ~Module m
+ /; loop (int i = 0; i < self.subs.count) [i++]
+ m = self.subs.get(i)
+ m`._print(indent + 1)
+ ;/
- /; end
- _delete(self.name)
+ _indent(indent)
+ _printf("}\n\0")
+ ;/
- ~Var v
- /; loop (int i = 0; i < self.vars.count) [i++]
- v = self.vars.get(i)
- v`.end()
- ;/
- self.vars.end()
+ /; end
+ _delete(self.name)
- ~Struct s
- /; loop (int i = 0; i < self.structs.count) [i++]
- s = self.structs.get(i)
- s`.end()
- ;/
- self.structs.end()
+ ~Var v
+ /; loop (int i = 0; i < self.vars.count) [i++]
+ v = self.vars.get(i)
+ v`.end()
+ ;/
+ self.vars.end()
- ~Function f
- /; loop (int i = 0; i < self.funcs.count) [i++]
- f = self.funcs.get(i)
- f`.end()
- ;/
- self.funcs.end()
+ ~Struct s
+ /; loop (int i = 0; i < self.structs.count) [i++]
+ s = self.structs.get(i)
+ s`.end()
+ ;/
+ self.structs.end()
- ~Module m
- /; loop (int i = 0; i < self.subs.count) [i++]
- m = self.subs.get(i)
- m`.end()
- ;/
- self.subs.end()
+ ~Function f
+ /; loop (int i = 0; i < self.funcs.count) [i++]
+ f = self.funcs.get(i)
+ f`.end()
+ ;/
+ self.funcs.end()
- ;/
+ ~Module m
+ /; loop (int i = 0; i < self.subs.count) [i++]
+ m = self.subs.get(i)
+ m`.end()
+ ;/
+ self.subs.end()
+ ;/
;/
diff --git a/tnslc/compile/scope.tnsl b/tnslc/compile/scope.tnsl
index 7822125..1afaeab 100644
--- a/tnslc/compile/scope.tnsl
+++ b/tnslc/compile/scope.tnsl
@@ -1,123 +1,232 @@
struct Scope {
~uint8 name,
-
- utils.Vector
- stack_vars,
- reg_vars,
+ ~Module mod,
+ ~CompBuf cb,
~Scope parent,
-
- int
- next_const,
- next_bool
-}
-/; method Scope
- /; init (~uint8 name)
- self.name = name
+ utils.Vector vars,
- Variable v
- self.stack_vars.init(len v)
- self.reg_vars.init(len v)
+ int unique
+}
+
+/; _recursive_mod_name(~Module mod, ~utils.Vector vec)
+ ~Module p = mod`.parent
+ /; if (p !== NULL)
+ _recursive_mod_name(p, vec)
+ /; if (vec`.count !== 0)
+ vec`.push_char('.')
+ ;/
+ ;/
+ vec`.push_cstr(mod`.name)
+;/
- self.next_const = 0
- self.next_bool = 0
+/; _recursive_scope_name(~Scope s, ~utils.Vector vec)
+ ~void p = s`.parent
+ /; if (p == NULL)
+ ~void m = s`.mod
+ /; if (m !== NULL)
+ _recursive_mod_name(m, vec)
+ /; if (vec`.count > 0)
+ vec`.push_char('.')
+ ;/
+ ;/
+ ;; else
+ _recursive_scope_name(p, vec)
;/
+ vec`.push_cstr(s`.name)
+;/
+/; method Scope
+ /; init (~Module mod, ~CompBuf cb, ~uint8 name)
+ self.name = utils.strcpy(name)
+ self.mod = mod
+ self.cb = cb
+ self.parent = NULL
+ self.unique = 0
+
+ Var v
+ self.vars.init(len v)
+ ;/
+
/; end
_delete(self.name)
- ~Variable v
- /; loop (int i = 0; i < self.stack_vars.count) [i++]
- v = self.stack_vars.get(i)
+ ~Var v
+ /; loop (int i = 0; i < self.vars.count) [i++]
+ v = self.vars.get(i)
v`.end()
;/
+ self.vars.end()
+ ;/
- /; loop (int i = 0; i < self.reg_vars.count) [i++]
- v = self.reg_vars.get(i)
- v`.end()
+ #
+ # Make variables
+ #
+
+ /; _next_reg_slot [uint]
+ uint out = 9
+ /; if (self.parent !== NULL)
+ out = self.parent`._next_reg_slot()
+ ;/
+
+ /; if (out == 0)
+ return out
;/
+
+ ~Var v
+ /; loop (int i = 0; i < self.vars.count) [i++]
+ v = self.vars.get(i)
+ /; if (v`.loc > 0)
+ out++
+ /; if (out > 16)
+ return 0
+ ;/
+ ;/
+ ;/
+
+ return out
;/
- /; _name_rec (~utils.Vector out)
+ /; _next_stack_slot [uint]
+ uint out = 0
/; if (self.parent !== NULL)
- self.parent`._name_rec(out)
- out`.push_cstr("#")
+ out = self.parent`._next_stack_slot()
+ ;/
+
+ ~Var v
+ /; loop (int i = 0; i < self.vars.count) [i++]
+ v = self.vars.get(i)
+ /; if (v`.loc < 0)
+ out = out - v`.actual_size()
+ ;/
+ ;/
+
+ return out
+ ;/
+
+ /; mk_set_var (~Var src)
+ Var out = src`.copy()
+
+ /; if (src`.is_reg_passed() == true)
+ out.loc = self._next_reg_slot()
+ /; if (out.loc == 0)
+ out.loc = self._next_stack_slot()
+ ;/
+ ;; else
+ out.loc = self._next_stack_slot()
+ ;/
+
+ ~int32 p = out.top_ptrc()
+ /; if (p == NULL)
+ out.set(self.cb, src)
+ ;; else if (p` == 0)
+ out.set_ref(self.cb, src)
+ ;; else
+ out.set(self.cb, src)
;/
- out`.push_cstr(self.name)
+ self.vars.push(~out)
+ ;/
+
+ #
+ # Sub scope
+ #
+
+ /; mk_sub (~uint8 name) [Scope]
+ Scope out
+ out.init(self.mod, self.cb, name)
+ out.parent = ~self
+ return out
+ ;/
+
+ # Generate a garantueed unique name for the sub scope, using
+ # the provided name as a base
+ /; gen_sub(~uint8 name) [Scope]
+ utils.Vector true_name
+ true_name.init(1)
+
+ # Append a 'unique' number
+ ~uint8 u = utils.int_to_str(self.unique)
+ true_name.push_char('#')
+ true_name.push_cstr(u)
+ true_name.push_char('#')
+ true_name.push_cstr(name)
+ _delete(u)
+
+ Scope out = self.mk_sub(true_name.as_cstr())
+ true_name.end()
+
+ # Inc for subsequent names
+ self.unique++
+
+ return out
;/
+
+ #
+ # Label generation
+ #
+
+
/; _base_label [utils.Vector]
utils.Vector out
out.init(1)
- ~uint8 mod_str = self.current.label_prefix()
- out.push_cstr(mod_str)
- _delete(mod_str)
-
- self._name_rec(~out)
+ _recursive_scope_name(~self, ~out)
return out
;/
- /; label_start [~uint8]
- utils.Vector base = self._base_label()
- base.push_cstr("#start\0")
- return base.as_cstr()
+ /; base_label [~uint8]
+ utils.Vector v = self._base_label()
+ return v.as_cstr()
;/
- /; label_rep [~uint8]
- utils.Vector base = self._base_label()
- base.push_cstr("#rep\0")
- return base.as_cstr()
+ /; place_base_label
+ ~uint8 bl = self.base_label()
+ self.cb`.add_c(bl)
+ self.cb`.add_c(":\n\0")
+ _delete(bl)
;/
- /; label_end [~uint8]
- utils.Vector base = self._base_label()
- base.push_cstr("#end\0")
- return base.as_cstr()
+ /; start_label [~uint8]
+ utils.Vector v = self._base_label()
+ v.push_cstr("#start\0")
+ return v.as_cstr()
;/
-
- /; label_next_const [~uint8]
- utils.Vector base = self._base_label()
- base.push_cstr("#const\0")
-
- ~uint8 str = utils.int_to_str(self.next_const)
- base.push_cstr(str)
- self.next_const++
- _delete(str)
- return base.as_cstr()
+ /; place_start_label
+ ~uint8 sl = self.start_label()
+ self.cb`.add_c(sl)
+ self.cb`.add_c(":\n\0")
+ _delete(sl)
;/
- /; label_bool [~uint8]
- utils.Vector base = self._base_label()
- base.push_cstr("#bool\0")
-
- ~uint8 str = utils.int_to_str(self.next_bool)
- base.push_cstr(str)
- self.next_bool++
- _delete(str)
-
- return base.as_cstr()
+ /; rep_label [~uint8]
+ utils.Vector v = self._base_label()
+ v.push_cstr("#rep\0")
+ return v.as_cstr()
;/
- /; label_bool_adv
- self.next_bool++
+ /; place_rep_label
+ ~uint8 rl = self.rep_label()
+ self.cb`.add_c(rl)
+ self.cb`.add_c(":\n\0")
+ _delete(rl)
;/
- /; subscope (~uint8 name) [Scope]
- Scope out
-
- utils.Vector str
- str.from_cstr(name)
- _delete(name)
-
- out.init(str.as_cstr(), self.current)
- out.parent = ~self
+ /; end_label [~uint8]
+ utils.Vector v = self._base_label()
+ v.push_cstr("#end\0")
+ return v.as_cstr()
+ ;/
- return out
+ /; place_end_label
+ ~uint8 el = self.end_label()
+ self.cb`.add_c(el)
+ self.cb`.add_c(":\n\0")
+ _delete(el)
;/
;/
diff --git a/tnslc/compile/struct.tnsl b/tnslc/compile/struct.tnsl
index d175aef..eba1488 100644
--- a/tnslc/compile/struct.tnsl
+++ b/tnslc/compile/struct.tnsl
@@ -3,44 +3,249 @@ struct Struct {
~uint8 name,
~Module methods,
utils.Vector members,
- int size
+ int size,
+
+ ~parse.Node _up
}
+~uint8 PRIMITIVE_1 = "bool,uint8,int8\0"
+~uint8 PRIMITIVE_2 = "uint16,int16\0"
+~uint8 PRIMITIVE_4 = "uint32,int32,float32\0"
+~uint8 PRIMITIVE_8 = "uint64,int64,float64,int,uint,float,void\0"
+
+/; is_primitive (~parse.Node tn) [int]
+ /; if (tn`.sub.count < 1)
+ return 0
+ ;/
+
+ ~parse.Node n = tn`.sub.get(0)
+
+ # Check for pointer, array
+ /; if (n`._type == parse.NTYPE_PRE_OP)
+ return 8
+ ;/
+
+ # Check for ref
+ n = tn`.sub.get(tn`.sub.count - 1)
+ /; if (n`._type == parse.NTYPE_POST_OP)
+ return 8
+ ;/
+
+ return 0
+;/
+
+/; _print_type(~parse.Node tn)
+ ~parse.Node n
+ bool seen_id = false
+ /; loop (int i = 0; i < tn`.sub.count) [i++]
+
+ n = tn`.sub.get(i)
+
+ /; if (n`._type == parse.NTYPE_ID)
+ /; if (seen_id == true)
+ _printf(".\0")
+ ;/
+ _printf(n`.data)
+ seen_id = true
+ ;; else
+ return
+ ;/
+ ;/
+;/
+
+# Might be wrong
+/; _type_is_ptr (~parse.Node n) [bool]
+ # Sanity
+ /; if (n`.sub.count < 1)
+ return false
+ ;/
+
+ ~parse.Node op = n`.sub.get(0)
+ /; if (op`._type == parse.NTYPE_PRE_OP)
+ return true
+ ;/
+
+ op = n`.sub.get(n`.sub.count - 1)
+ /; if (op`._type == parse.NTYPE_POST_OP)
+ return true
+ ;/
+
+ return false
+;/
+
/; method Struct
- /; init (~uint8 name)
- self.name = name
- Var v
- self.members.init(len v)
- ;/
+ /; init (~parse.Node node)
+ self._up = node
+ self.size = 0
+ self.methods = NULL
+ self.name = utils.strcpy(node`.data)
+ Var v
+ self.members.init(len v)
+ ;/
+
+ /; _print (int idt)
+ _indent(idt)
+ _printf("{ Struct : \0")
+ _printf(self.name)
+ _printf("\n\0")
+
+ _indent(idt)
+ _print_num(" size: %d\n\0", self.size)
+
+ _indent(idt)
+ _printf(" members:\n\0")
+
+ ~Var v
+ /; loop (int i = 0; i < self.members.count) [i++]
+ v = self.members.get(i)
+ v`._print(idt + 1)
+ ;/
+
+ _indent(idt)
+ _printf("}\n\0")
+ ;/
+
+ /; add_member(~parse.Node tn, ~parse.Node id)
+ Var v
+ v.init(tn, id)
+ v._resolve_type(self.methods)
+ self.members.push(~v)
+ ;/
+
+ /; get_member(~uint8 name) [~Var]
+ ~Var out = NULL
+
+ ~Var v
+ /; loop (int i = 0; i < self.members.count) [i++]
+ v = self.members.get(i)
+ /; if (utils.strcmp(v`.name, name) == true)
+ return v
+ ;/
+ ;/
+
+ return out
+ ;/
+
+ /; _dlist [~parse.Node]
+ ~parse.Node up = self._up
+ ~parse.Node n
+ /; loop (int i = 0; i < up`.sub.count) [i++]
+ n = up`.sub.get(i)
+ /; if (n`._type == parse.NTYPE_DLIST)
+ return n
+ ;/
+ ;/
+ return NULL
+ ;/
+
+ /; _compute_size
+ /; if (self.size !== 0)
+ return
+ ;/
+
+ self.size = self.size - 1
+
+ int total = 0
+ ~parse.Node up = self._dlist()
+ ~parse.Node tn = NULL
+ ~parse.Node n = NULL
+ int add_size = 0
+ /; loop (int i = 0; i < up`.sub.count) [i++]
+ n = up`.sub.get(i)
+
+ /; if (n`._type == parse.NTYPE_TYPE)
+ # Store for generating new variables
+ tn = n
+ add_size = self._compute_type_size(n)
+ /; if (add_size == 0)
+ return
+ ;/
+ ;; else if (n`._type == parse.NTYPE_ID)
+ /; if (tn == NULL)
+ _printf("ERROR: Unable to find type when trying to create member for struct '\0")
+ _printf(self.name)
+ _printf("\n\0")
+ return
+ ;/
+ self.add_member(tn, n)
+ total = total + add_size
+ ;/
+ ;/
+
+ self.size = total
+ ;/
+
+ /; _compute_type_size(~parse.Node tn) [int]
+ ~Struct ft = self._find_type(tn)
+
+ /; if (ft == NULL)
+ # Type not found
+ _printf("ERROR: Unable to find type '\0")
+ _print_type(tn)
+ _printf("' for use in struct '\0")
+ _printf(self.name)
+ _printf("'\n\0")
+ return 0
+ ;/
+
+ /; if (_type_is_ptr(tn) == true)
+ return 8
+ ;/
+
+ /; if (ft !== NULL && ft`.size == 0)
+ ft`._compute_size()
+ ;/
+
+ /; if (ft`.size < 0)
+ # Cyclical dependency
+ _printf("ERROR: Cyclic struct definition: '\0")
+ _printf(ft`.name)
+ _printf("' imported from '\0")
+ _printf(self.name)
+ _printf("'\n\0")
+ return 0
+ ;/
+
+ return ft`.size
+ ;/
- /; add_member(~Var v)
- self.members.push(v)
- ;/
+ /; _find_type (~parse.Node tn) [~Struct]
+
+ # Init vector of strings
+ utils.Vector sv
+ sv.init(8)
- /; get_member(~uint8 name) [~Var]
- ~Var out = NULL
+ ~uint8 str
+ ~parse.Node n
+ bool seen_id = false
- ~Var v
- /; loop (int i = 0; i < self.members.count) [i++]
- v = self.members.get(i)
- /; if (utils.strcmp(v`.name, name) == true)
- return v
- ;/
- ;/
+ /; loop (int i = 0; i < tn`.sub.count) [i++]
+ n = tn`.sub.get(i)
+ /; if (n`._type == parse.NTYPE_ID)
+ str = n`.data
+ sv.push(~str)
+ seen_id = true
+ ;; else if (seen_id == true)
+ i = tn`.sub.count
+ ;/
+ ;/
- return out
- ;/
+ # Find struct and compute its size
+ ~Struct out = self.methods`.find(SEARCH_STRUCT, ~sv)
+ sv.end()
+ return out
+ ;/
- /; end
- _delete(self.name)
- ~Var v
- /; loop (int i = 0; i < self.members.count) [i++]
- v = self.members.get(i)
- v`.end()
- ;/
- self.members.end()
- ;/
+ /; end
+ _delete(self.name)
+ ~Var v
+ /; loop (int i = 0; i < self.members.count) [i++]
+ v = self.members.get(i)
+ v`.end()
+ ;/
+ self.members.end()
+ ;/
;/
diff --git a/tnslc/compile/var.tnsl b/tnslc/compile/var.tnsl
index 9526fc6..9748ed4 100644
--- a/tnslc/compile/var.tnsl
+++ b/tnslc/compile/var.tnsl
@@ -1,33 +1,466 @@
+# Location enum
+int VLOC_STCK = 2
+int VLOC_LITL = 1
+int VLOC_DATA = 0
+
+# Should be -2
+int32 PTYPE_NONE = 2
+# Should be -1
+int32 PTYPE_PTR = 1
+int32 PTYPE_REF = 0
+# 1 Arr is ptr to arr, larger #s are static size arrs
+int32 PTYPE_ARR = 1
+
+int PRIM_NON = 0
+int PRIM_BOO = 1
+int PRIM_INT = 2
+int PRIM_FLT = 3
+
+~uint8 PRIM_CSV_BOO = "bool\0"
+~uint8 PRIM_CSV_INT = "int,int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64\0"
+~uint8 PRIM_CSV_FLT = "float,float32,float64\0"
+
+# Should dispose of this constructed string
+# 1-8 are ax, bx, cx, dx, si, di, sp, bp
+# 9-16 are r8, r9, r10, r11, r12, r13, r14, r15
+# 17-32 are xmm0, xmm1, xmm2, ..., xmm15
+/; reg_string (int r, int size) [~uint8]
+ utils.Vector out
+ out.init(1)
+ uint8 add
+
+ /; if (r < 9)
+ /; if (size == 4)
+ add = 'e'
+ out.push(~add)
+ ;; else if (size == 8)
+ add = 'r'
+ out.push(~add)
+ ;/
+
+ add = 'a'
+ /; if (r < 5)
+ add = add + r - 1
+ ;; else if (r == 5 || r == 7)
+ add = 's'
+ ;; else if (r == 6)
+ add = 'd'
+ ;; else if (r == 8)
+ add = 'b'
+ ;/
+ out.push(~add)
+
+ /; if (r == 5 || r == 6)
+ add = 'i'
+ out.push(~add)
+ ;; else if (r == 7 || r == 8)
+ add = 'p'
+ out.push(~add)
+ ;; else if (size !== 1)
+ add = 'x'
+ out.push(~add)
+ ;/
+
+ /; if (size == 1)
+ add = 'l'
+ out.push(~add)
+ ;/
+ ;; else if (r < 17)
+ add = 'r'
+ out.push(~add)
+
+ ~uint8 num = utils.int_to_str(r - 1)
+ out.push_cstr(num)
+ _delete(num)
+ /; if (size == 1)
+ add = 'b'
+ out.push(~add)
+ ;; else if (size == 2)
+ add = 'w'
+ out.push(~add)
+ ;; else if (size == 4)
+ add = 'd'
+ out.push(~add)
+ ;/
+ ;; else if (r < 33)
+ out.push_cstr("xmm\0")
+ ~uint8 num = utils.int_to_str(r - 17)
+ out.push_cstr(num)
+ _delete(num)
+ ;/
+
+ return out.as_cstr()
+;/
+
struct Var {
- ~uint8 name,
- ~Struct _type,
- utils.Vector ptrc,
- int loc
+ ~uint8 name,
+ ~Struct _type,
+ utils.Vector ptrc,
+ int loc,
+
+ ~parse.Node _tn, _id
}
/; method Var
- /; init (~uint8 name)
- self.name = name
- self.ptrc.init(4)
- ;/
+ # Initial init function, requires type node and
+ # identifier node
+ /; init (~parse.Node tn, id)
+ self.name = utils.strcpy(id`.data)
+ self.ptrc.init(4)
+ self.loc = 0
+
+ self._tn = tn
+ self._id = id
+ ;/
+
+ /; copy [Var]
+ Var out
+ out.init(self._tn, self._id)
+ out._type = self._type
+ out.loc = self.loc
+
+ /; loop (int i = 0; i < self.ptrc.count) [i++]
+ ~int32 p = self.ptrc.get(i)
+ out.ptrc.push(p)
+ ;/
+
+ return out
+ ;/
+
+ /; top_ptrc [~int32]
+ # Sanity
+ /; if (self.ptrc.count < 1)
+ return NULL
+ ;/
+ ~int32 out = self.ptrc.get(self.ptrc.count - 1)
+ return out
+ ;/
+
+ /; _print (int idt)
+ _indent(idt)
+ _printf("{ Var : \0")
+ _printf(self.name)
+ _printf("\n\0")
+
+ _indent(idt)
+ _printf(" type: \0")
+ /; if (self._type !== NULL)
+ _printf(self._type`.name)
+ ;; else
+ _printf("(nil)\0")
+ ;/
+ _printf("\n\0")
+
+ _indent(idt)
+ _printf(" ptrc: \0")
+ ~int32 istr
+ /; loop (int i = 0; i < self.ptrc.count) [i++]
+ istr = self.ptrc.get(i)
+ _print_num("%d \0", istr`)
+ ;/
+ _printf("\n\0")
+
+ _indent(idt)
+ _printf("}\n\0")
+ ;/
+
+ /; _arr_ptr(~parse.Node a)
+ int32 ptr = 1
+ /; if (a`.sub.count > 0)
+ ~parse.Node l = a`.sub.get(0)
+ ptr = utils.cstr_to_int(l`.data)
+ /; if (ptr < 2)
+ return
+ ;/
+ ;/
+ self.ptrc.push(~ptr)
+ ;/
+
+ /; is_reg_passed [bool]
+ /; if (self.ptrc.count > 0)
+ return true
+ ;/
+ return false
+ ;/
+
+ /; actual_size [uint]
+ /; if (self.ptrc.count > 0)
+ return 8
+ ;; else if (self._type == NULL)
+ return 0
+ ;/
+
+ return self._type`.size
+ ;/
+
+ /; _reverse_ptrc
+ int max = self.ptrc.count / 2
+ ~int32 l, r
+ /; loop (int i = 0; i < max) [i++]
+ l = self.ptrc.get(i)
+ r = self.ptrc.get(self.ptrc.count - (i + 1))
+ int32 tmp = l`
+ l` = r`
+ r` = tmp
+ ;/
+ ;/
+
+ # Sets up both the ptrc and the _type members, requires
+ # parent module for resolution of types
+ /; _resolve_type (~Module parent)
+ int idx = 0
+ bool running = true
+ ~parse.Node t, _tn
+ _tn = self._tn
+
+ # Pre-op pointer
+ /; loop (running == true)
+ /; if (idx !< _tn`.sub.count)
+ running = false
+ ;; else
+ t = _tn`.sub.get(idx)
+ /; if (t`._type == parse.NTYPE_PRE_OP)
+ /; if (utils.strcmp(t`.data, "~\0") == true)
+ int32 ptr = 0
+ ptr = ptr - PTYPE_PTR
+ self.ptrc.push(~ptr)
+ ;; else
+ self._arr_ptr(t)
+ ;/
+ ;; else
+ running = false
+ ;/
+ ;/
+
+ /; if (running == true)
+ idx++
+ ;/
+ ;/
+
+ self._reverse_ptrc()
+
+ # After pre-ops comes id
+ utils.Vector strv
+ strv.init(8)
+ running = true
+ /; loop (running == true)
+ /; if (idx !< _tn`.sub.count)
+ running = false
+ ;; else
+ t = _tn`.sub.get(idx)
+ /; if (t`._type == parse.NTYPE_ID)
+ ~uint8 str = t`.data
+ strv.push(~str)
+ ;; else
+ running = false
+ ;/
+ ;/
+
+ /; if (running == true)
+ idx++
+ ;/
+ ;/
+
+ # Main type resolution
+ # TODO: FUNCTION POINTER
+ self._type = parent`.find(SEARCH_STRUCT, ~strv)
+ strv.end()
+
+ # Post-op pointer
+ running = true
+ /; loop (running == true)
+ /; if (idx !< _tn`.sub.count)
+ running = false
+ ;; else
+ t = _tn`.sub.get(idx)
+ /; if (t`._type == parse.NTYPE_POST_OP)
+ int32 ptr = 0
+ self.ptrc.push(~ptr)
+ ;/
+ ;/
+
+ /; if (running == true)
+ idx++
+ ;/
+ ;/
+ ;/
+
+ /; _static_compile (~Module parent, ~CompBuf buf)
+ # TODO:
+ ;/
- /; ptr [int32]
- ~int32 i
- i = self.ptrc.get(self.ptrc.count - 1)
- return i`
- ;/
+ /; ptr [int32]
+ ~int32 i
+ i = self.ptrc.get(self.ptrc.count - 1)
+ return i`
+ ;/
- /; ptr_push (int32 p)
- self.ptrc.push(~p)
- ;/
+ /; ptr_push (int32 p)
+ self.ptrc.push(~p)
+ ;/
- /; ptr_pop
- self.ptrc.pop()
- ;/
+ /; ptr_pop
+ self.ptrc.pop()
+ ;/
- /; end
- _delete(self.name)
- self.ptrc.end()
- ;/
+ /; is_primitive [int]
+ ~uint8 tn = self`._type`.name
+
+ /; if (parse._in_csv(PRIM_CSV_BOO, tn) == true)
+ return PRIM_BOO
+ ;; else if (parse._in_csv(PRIM_CSV_INT, tn) == true)
+ return PRIM_INT
+ ;; else if (parse._in_csv(PRIM_CSV_FLT, tn) == true)
+ return PRIM_FLT
+ ;/
+
+ return PRIM_NON
+ ;/
+
+ /; end
+ _delete(self.name)
+ self.ptrc.end()
+ ;/
+
+ ###################################
+ # Variable manipulation functions #
+ ###################################
+
+ /; gen_loc [~uint8]
+ utils.Vector out
+ out.init(1)
+
+ /; if (self.in_mem() == true)
+ out.push_char('[')
+ ;/
+
+ ~uint8 str
+ /; if (self.loc < 1)
+ str = reg_string(7, 8)
+ ;; else
+ str = reg_string(self.loc, self.actual_size())
+ ;/
+ out.push_cstr(str)
+ _delete(str)
+
+
+ /; if (self.in_mem() == true)
+ /; if (self.loc < 0)
+ int stk = 0
+ stk = stk - self.loc
+ out.push_cstr(" + \0")
+ str = utils.int_to_str(stk)
+ out.push_cstr(str)
+ _delete(str)
+ ;/
+ out.push_char(']')
+ ;/
+
+ return out.as_cstr()
+ ;/
+
+ # Returns true if the variable is known to be stored in memory
+ /; in_mem [bool]
+ /; if (self.loc < 1)
+ return true
+ ;/
+
+ ~int32 ptr = self.top_ptrc()
+ /; if (ptr !== NULL)
+ /; if (ptr` == 0)
+ return true
+ ;; else if (ptr` > 1)
+ return true
+ ;/
+ ;/
+
+ return false
+ ;/
+
+ # Set this variable to the value of a literal
+ /; set_literal (~CompBuf buf, ~Var other)
+ ;/
+
+ /; _set_mem(~CompBuf buf, ~Var other)
+
+ ;/
+
+ # Set this Variable to the value of other
+ /; set (~CompBuf buf, ~Var other)
+ self.standard_op(buf, other, "mov\0")
+ ;/
+
+ # Set the address which this reference points to
+ /; set_ref(~CompBuf buf, ~Var other)
+ ;/
+
+ /; standard_op (~CompBuf buf, ~Var other, ~uint8 op_str)
+ ~uint8 from_str = other`.gen_loc()
+ ~uint8 to_str = self.gen_loc()
+
+ buf`.add_c(" \0")
+ buf`.add_c(op_str)
+ buf`.add_c(" \0")
+ buf`.add_c(to_str)
+ buf`.add_c(", \0")
+ buf`.add_c(from_str)
+ buf`.add_c("\n\0")
+
+ _delete(from_str)
+ _delete(to_str)
+ ;/
+
+ /; product_op (~CompBuf buf, ~Var other, ~uint8 op_str, int read_reg)
+
+ ;/
+
+ /; add (~CompBuf buf, ~Var other)
+ /; if (self.loc = VLOC_LITL)
+ ;/
+ self.standard_op(buf, other, "add")
+ ;/
+
+ /; sub (~CompBuf buf, ~Var other)
+ self.standard_op(buf, other, "sub")
+ ;/
+
+ /; mul (~CompBuf buf, ~Var other)
+ self.product_op(buf, other, "imul", 1)
+ ;/
+
+ /; div (~CompBuf buf, ~Var other)
+ /; if ("signed")
+ self.product_op(buf, other, "idiv", 1)
+ ;; else
+ self.product_op(buf, other, "div", 1)
+ ;/
+ ;/
+
+ /; mod (~CompBuf buf, ~Var other)
+ /; if ("signed")
+ self.product_op(buf, other, "idiv", 4)
+ ;; else
+ self.product_op(buf, other, "div", 4)
+ ;/
+ ;/
+
+ /; and (~CompBuf buf, ~Var other)
+ self.standard_op(buf, other, "and")
+ ;/
+
+ /; or (~CompBuf buf, ~Var other)
+ self.standard_op(buf, other, "or")
+ ;/
+
+ /; xor (~CompBuf buf, ~Var other)
+ self.standard_op(buf, other, "xor")
+ ;/
+
+ /; member (~CompBuf buf, ~uint8 name) [Var]
+ Var out
+ return out
+ ;/
;/
+
+
generated by cgit v1.2.3 (git 2.51.0) at 2025-12-15 03:59:56 +0000