Basic AST

stdlib/ast.krak

@@ -0,0 +1,209 @@
+import tree:*
+import type:*
+import vec:*
+import set:*
+import util:*
+import str:*
+import mem:*
+
+adt ast {
+    _translation_unit: str,
+    _import: set<str>,
+    _identifier: pair<str, *type>,
+    _binding: pair<str, *tree<ast>>,
+    _type_def: str,
+    _adt_def: str,
+    _function: pair<str, *type>,
+    _template: pair<str, set<str>>,
+    _declaration,
+    _assignment,
+    _block,
+    _if,
+    _match,
+    _case,
+    _while,
+    _for,
+    _return,
+    _break,
+    _continue,
+    _defer,
+    _call,
+    _compiler_intrinsic: pair<str, vec<*type>>,
+    _cast: *type,
+    _value: pair<str, *type>
+}
+fun to_string(a: ref ast): str {
+    match(a) {
+        ast::_translation_unit()    return str("_translation_unit")
+        ast::_import()              return str("_import")
+        ast::_identifier()          return str("_identifier")
+        ast::_binding()             return str("_binding")
+        ast::_type_def()            return str("_type_def")
+        ast::_adt_def()             return str("_adt_def")
+        ast::_function()            return str("_function")
+        ast::_template()            return str("_template")
+        ast::_declaration()         return str("_declaration")
+        ast::_assignment()          return str("_assignment")
+        ast::_block()               return str("_block")
+        ast::_if()                  return str("_if")
+        ast::_match()               return str("_match")
+        ast::_case()                return str("_case")
+        ast::_while()               return str("_while")
+        ast::_for()                 return str("_for")
+        ast::_return()              return str("_return")
+        ast::_break()               return str("_break")
+        ast::_continue()            return str("_continue")
+        ast::_defer()               return str("_defer")
+        ast::_call()                return str("_call")
+        ast::_compiler_intrinsic()  return str("_compiler_intrinsic")
+        ast::_cast()                return str("_cast")
+        ast::_value()               return str("_value")
+    }
+}
+fun _translation_unit(p: str): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_translation_unit(p))
+}
+fun _import(p: set<str>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_import(p))
+}
+fun _type_def(p: str): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_type_def(p))
+}
+fun _adt_def(p: str): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_adt_def(p))
+}
+fun _cast(p: *type): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_cast(p))
+}
+fun _identifier(p1: str, p2: *type): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_identifier(make_pair(p1, p2)))
+}
+fun _binding(p1: str, p2: *tree<ast>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_binding(make_pair(p1, p2)))
+}
+fun _function(p1: str, p2: *type): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_function(make_pair(p1, p2)))
+}
+fun _template(p1: str, p2: set<str>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_template(make_pair(p1, p2)))
+}
+fun _compiler_intrinsic(p1: str, p2: vec<*type>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_compiler_intrinsic(make_pair(p1, p2)))
+}
+fun _value(p1: str, p2: *type): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_value(make_pair(p1, p2)))
+}
+fun _declaration(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_declaration())
+}
+fun _assignment(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_assignment())
+}
+fun _block(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_block())
+}
+fun _if(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_if())
+}
+fun _match(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_match())
+}
+fun _case(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_case())
+}
+fun _while(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_while())
+}
+fun _for(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_for())
+}
+fun _return(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_return())
+}
+fun _break(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_break())
+}
+fun _continue(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_continue())
+}
+fun _defer(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_defer())
+}
+fun _call(): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_call())
+}
+
+
+
+fun _translation_unit(p: str, c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_translation_unit(p), c)
+}
+fun _import(p: set<str>, c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_import(p), c)
+}
+fun _type_def(p: str, c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_type_def(p), c)
+}
+fun _adt_def(p: str, c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_adt_def(p), c)
+}
+fun _cast(p: *type, c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_cast(p), c)
+}
+fun _identifier(p1: str, p2: *type, c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_identifier(make_pair(p1, p2)), c)
+}
+fun _binding(p1: str, p2: *tree<ast>, c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_binding(make_pair(p1, p2)), c)
+}
+fun _function(p1: str, p2: *type, c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_function(make_pair(p1, p2)), c)
+}
+fun _template(p1: str, p2: set<str>, c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_template(make_pair(p1, p2)), c)
+}
+fun _compiler_intrinsic(p1: str, p2: vec<*type>, c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_compiler_intrinsic(make_pair(p1, p2)), c)
+}
+fun _value(p1: str, p2: *type, c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_value(make_pair(p1, p2)), c)
+}
+fun _declaration(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_declaration(), c)
+}
+fun _assignment(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_assignment(), c)
+}
+fun _block(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_block(), c)
+}
+fun _if(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_if(), c)
+}
+fun _match(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_match(), c)
+}
+fun _case(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_case(), c)
+}
+fun _while(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_while(), c)
+}
+fun _for(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_for(), c)
+}
+fun _return(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_return(), c)
+}
+fun _break(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_break(), c)
+}
+fun _continue(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_continue(), c)
+}
+fun _defer(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_defer(), c)
+}
+fun _call(c: ref vec<*tree<ast>>): *tree<ast> {
+    return new<tree<ast>>()->construct(ast::_call(), c)
+}

stdlib/simple.krak

@@ -0,0 +1,3 @@
+fun main(argc: int, argv: **char): int {
+    return 0
+}

stdlib/str.krak

@@ -88,6 +88,15 @@ fun operator+(first: *char, second: ref str): str {
 fun operator+(first: int, second: ref str): str {
     return to_string(first) + second
 }
+fun operator*(first: *char, second: int): str {
+    return str(first) * second
+}
+fun operator*(first: int, second: *char): str {
+    return str(second) * first
+}
+fun operator*(first: int, second: ref str): str {
+    return second * first
+}
 
 fun str(in:*char):str {
     var out.construct(in):str
@@ -191,6 +200,13 @@ obj str (Object, Serializable, Hashable) {
         return *this == str
     }
 
+    fun operator*(n: int): str {
+        var to_ret.construct(): str
+        while (n-- > 0)
+            to_ret += *this
+        return to_ret
+    }
+
     fun operator+(c: char): str {
         var to_ret = *this
         to_ret += c

stdlib/symbol.krak

@@ -39,6 +39,9 @@ fun symbol(nameIn: ref str::str, terminalIn: bool, dataIn: ref str::str, positio
     return toRet
 }
 
+fun to_string(s: ref symbol): str::str {
+    return s.to_string()
+}
 obj symbol (Object, Serializable) {
     var data: str::str
     var name: str::str

stdlib/tree.krak

@@ -9,6 +9,11 @@ obj tree<T> (Object) {
         children.construct()
         return this
     }
+    fun construct(dataIn: T, c: ref vec::vec<*tree<T>>): *tree<T> {
+        mem::maybe_copy_construct(&data, &dataIn)
+        children.copy_construct(&c)
+        return this
+    }
     // Some of these don't really make much sense considering this tree is all about
     // heap allocated pointers. Best to have it for saftey, though
     fun copy_construct(old: *tree<T>) {