mt-lang 0.2.0 → 0.2.1

data/std/ordered_set.mt

@@ -0,0 +1,348 @@
+import std.mem.heap as heap
+
+struct Node[T]:
+    value: T
+    left: ptr[Node[T]]?
+    right: ptr[Node[T]]?
+    parent: ptr[Node[T]]?
+    height: int
+
+struct SearchResult[T]:
+    node: ptr[Node[T]]?
+    parent: ptr[Node[T]]?
+    compare: int
+    found: bool
+
+public struct Iter[T]:
+    node: ptr[Node[T]]?
+
+public struct OrderedSet[T]:
+    root: ptr[Node[T]]?
+    len: ptr_uint
+
+
+extending OrderedSet[T]:
+    public static function create() -> OrderedSet[T]:
+        return OrderedSet[T](root = null, len = 0)
+
+
+    static function height(node: ptr[Node[T]]?) -> int:
+        if node == null:
+            return 0
+
+        unsafe:
+            return read(ptr[Node[T]]<-node).height
+
+
+    static function update_height(node: ptr[Node[T]]) -> void:
+        let left_height = unsafe: OrderedSet[T].height(read(node).left)
+        let right_height = unsafe: OrderedSet[T].height(read(node).right)
+        var next_height = left_height
+        if right_height > next_height:
+            next_height = right_height
+
+        unsafe:
+            read(node).height = next_height + 1
+
+
+    static function balance_factor(node: ptr[Node[T]]?) -> int:
+        if node == null:
+            return 0
+
+        unsafe:
+            return OrderedSet[T].height(read(ptr[Node[T]]<-node).left) - OrderedSet[T].height(read(ptr[Node[T]]<-node).right)
+
+
+    static function minimum(node: ptr[Node[T]]?) -> ptr[Node[T]]?:
+        var current = node
+        while current != null:
+            let left = unsafe: read(ptr[Node[T]]<-current).left else:
+                return current
+
+            current = left
+
+        return null
+
+
+    static function successor(node: ptr[Node[T]]?) -> ptr[Node[T]]?:
+        if node == null:
+            return null
+
+        let current = unsafe: ptr[Node[T]]<-node
+        let right = unsafe: read(current).right
+        if right != null:
+            return OrderedSet[T].minimum(right)
+
+        var child = node
+        var parent = unsafe: read(current).parent
+        while parent != null:
+            let parent_ptr = unsafe: ptr[Node[T]]<-parent
+            if unsafe: read(parent_ptr).left == child:
+                return parent
+
+            child = parent
+            parent = unsafe: read(parent_ptr).parent
+
+        return null
+
+
+    static function replace_child(
+        current: ref[OrderedSet[T]],
+        parent: ptr[Node[T]]?,
+        previous: ptr[Node[T]],
+        replacement: ptr[Node[T]]?
+    ) -> void:
+        if parent == null:
+            current.root = replacement
+        else:
+            unsafe:
+                let parent_ptr = ptr[Node[T]]<-parent
+                if read(parent_ptr).left == previous:
+                    read(parent_ptr).left = replacement
+                else if read(parent_ptr).right == previous:
+                    read(parent_ptr).right = replacement
+                else:
+                    fatal(c"ordered_set.OrderedSet.replace_child missing previous child")
+
+        if replacement != null:
+            unsafe:
+                read(ptr[Node[T]]<-replacement).parent = parent
+
+
+    static function rotate_left(current: ref[OrderedSet[T]], node: ptr[Node[T]]) -> ptr[Node[T]]:
+        let pivot = unsafe: read(node).right else:
+            fatal(c"ordered_set.OrderedSet.rotate_left missing pivot")
+
+        let pivot_ptr = unsafe: ptr[Node[T]]<-pivot
+        let parent = unsafe: read(node).parent
+        let pivot_left = unsafe: read(pivot_ptr).left
+
+        unsafe:
+            read(node).right = pivot_left
+        if pivot_left != null:
+            unsafe:
+                read(ptr[Node[T]]<-pivot_left).parent = node
+
+        OrderedSet[T].replace_child(current, parent, node, pivot)
+
+        unsafe:
+            read(pivot_ptr).left = node
+            read(node).parent = pivot
+
+        OrderedSet[T].update_height(node)
+        OrderedSet[T].update_height(pivot_ptr)
+        return pivot_ptr
+
+
+    static function rotate_right(current: ref[OrderedSet[T]], node: ptr[Node[T]]) -> ptr[Node[T]]:
+        let pivot = unsafe: read(node).left else:
+            fatal(c"ordered_set.OrderedSet.rotate_right missing pivot")
+
+        let pivot_ptr = unsafe: ptr[Node[T]]<-pivot
+        let parent = unsafe: read(node).parent
+        let pivot_right = unsafe: read(pivot_ptr).right
+
+        unsafe:
+            read(node).left = pivot_right
+        if pivot_right != null:
+            unsafe:
+                read(ptr[Node[T]]<-pivot_right).parent = node
+
+        OrderedSet[T].replace_child(current, parent, node, pivot)
+
+        unsafe:
+            read(pivot_ptr).right = node
+            read(node).parent = pivot
+
+        OrderedSet[T].update_height(node)
+        OrderedSet[T].update_height(pivot_ptr)
+        return pivot_ptr
+
+
+    static function rebalance(current: ref[OrderedSet[T]], node: ptr[Node[T]]?) -> void:
+        var cursor = node
+        while cursor != null:
+            let cursor_ptr = unsafe: ptr[Node[T]]<-cursor
+            OrderedSet[T].update_height(cursor_ptr)
+
+            let balance = OrderedSet[T].balance_factor(cursor)
+            if balance > 1:
+                let left = unsafe: read(cursor_ptr).left
+                if OrderedSet[T].balance_factor(left) < 0:
+                    if left == null:
+                        fatal(c"ordered_set.OrderedSet.rebalance missing left child")
+                    OrderedSet[T].rotate_left(current, unsafe: ptr[Node[T]]<-left)
+
+                let rotated = OrderedSet[T].rotate_right(current, cursor_ptr)
+                cursor = unsafe: read(rotated).parent
+            else if balance < -1:
+                let right = unsafe: read(cursor_ptr).right
+                if OrderedSet[T].balance_factor(right) > 0:
+                    if right == null:
+                        fatal(c"ordered_set.OrderedSet.rebalance missing right child")
+                    OrderedSet[T].rotate_right(current, unsafe: ptr[Node[T]]<-right)
+
+                let rotated = OrderedSet[T].rotate_left(current, cursor_ptr)
+                cursor = unsafe: read(rotated).parent
+            else:
+                cursor = unsafe: read(cursor_ptr).parent
+
+
+    static function locate(current: OrderedSet[T], value: T) -> SearchResult[T]:
+        var parent: ptr[Node[T]]? = null
+        var node = current.root
+        var compare = 0
+        while node != null:
+            let node_ptr = unsafe: ptr[Node[T]]<-node
+            let stored = unsafe: const_ptr_of(read(node_ptr).value)
+            compare = order[T](value, stored)
+            if compare < 0:
+                parent = node
+                unsafe:
+                    node = read(node_ptr).left
+            else if compare > 0:
+                parent = node
+                unsafe:
+                    node = read(node_ptr).right
+            else:
+                return SearchResult[T](node = node, parent = parent, compare = 0, found = true)
+
+        return SearchResult[T](node = null, parent = parent, compare = compare, found = false)
+
+
+    static function release_subtree(node: ptr[Node[T]]?) -> void:
+        if node == null:
+            return
+
+        let node_ptr = unsafe: ptr[Node[T]]<-node
+        let left = unsafe: read(node_ptr).left
+        let right = unsafe: read(node_ptr).right
+        OrderedSet[T].release_subtree(left)
+        OrderedSet[T].release_subtree(right)
+        heap.release(node)
+
+
+    static function detach_node(current: ref[OrderedSet[T]], node: ptr[Node[T]]) -> ptr[Node[T]]?:
+        let left = unsafe: read(node).left
+        let right = unsafe: read(node).right
+        if left != null and right != null:
+            let successor = OrderedSet[T].minimum(right) else:
+                fatal(c"ordered_set.OrderedSet.detach_node missing successor")
+
+            unsafe:
+                read(node).value = read(ptr[Node[T]]<-successor).value
+
+            return OrderedSet[T].detach_node(current, unsafe: ptr[Node[T]]<-successor)
+
+        var child = left
+        if child == null:
+            child = right
+
+        let parent = unsafe: read(node).parent
+        OrderedSet[T].replace_child(current, parent, node, child)
+        heap.release(node)
+
+        if parent != null:
+            return parent
+
+        return child
+
+
+    public function len() -> ptr_uint:
+        return this.len
+
+
+    public function is_empty() -> bool:
+        return this.len == 0
+
+
+    public function get(value: T) -> const_ptr[T]?:
+        let location = OrderedSet[T].locate(this, value)
+        if not location.found:
+            return null
+
+        let candidate = location.node else:
+            fatal(c"ordered_set.OrderedSet.get missing node")
+
+        unsafe:
+            return const_ptr_of(read(ptr[Node[T]]<-candidate).value)
+
+
+    public function at(value: T) -> Option[T]:
+        let p = this.get(value) else:
+            return Option[T].none
+
+        unsafe:
+            return Option[T].some(value = read(ptr[T]<-p))
+
+
+    public function contains(value: T) -> bool:
+        return this.get(value) != null
+
+
+    public function iter() -> Iter[T]:
+        return Iter[T](node = OrderedSet[T].minimum(this.root))
+
+
+    public editable function clear() -> void:
+        OrderedSet[T].release_subtree(this.root)
+        this.root = null
+        this.len = 0
+
+
+    public editable function release() -> void:
+        this.clear()
+
+
+    public editable function insert(value: T) -> bool:
+        let location = OrderedSet[T].locate(this, value)
+        if location.found:
+            return false
+
+        let node = heap.must_alloc[Node[T]](1)
+        unsafe:
+            read(node) = Node[T](value = value, left = null, right = null, parent = location.parent, height = 1)
+
+        let parent = location.parent
+        if parent == null:
+            this.root = node
+        else:
+            unsafe:
+                let parent_ptr = ptr[Node[T]]<-parent
+                if location.compare < 0:
+                    read(parent_ptr).left = node
+                else:
+                    read(parent_ptr).right = node
+
+        this.len += 1
+        OrderedSet[T].rebalance(this, parent)
+        return true
+
+
+    public editable function remove(value: T) -> bool:
+        let location = OrderedSet[T].locate(this, value)
+        if not location.found:
+            return false
+
+        let node = location.node else:
+            fatal(c"ordered_set.OrderedSet.remove missing node")
+
+        let rebalance_from = OrderedSet[T].detach_node(this, unsafe: ptr[Node[T]]<-node)
+        this.len -= 1
+        OrderedSet[T].rebalance(this, rebalance_from)
+        return true
+
+
+extending Iter[T]:
+    public function iter() -> Iter[T]:
+        return this
+
+
+    public editable function next() -> const_ptr[T]?:
+        let current = this.node else:
+            return null
+
+        this.node = OrderedSet[T].successor(current)
+
+        unsafe:
+            return const_ptr_of(read(ptr[Node[T]]<-current).value)

data/std/path.mt

@@ -0,0 +1,368 @@
+import std.str as text_ops
+import std.string as string
+import std.vec as vec
+
+struct Segment:
+    start: ptr_uint
+    len: ptr_uint
+
+
+public function is_absolute(path: str) -> bool:
+    return root_length(path) != 0
+
+
+public function normalize_separators(path: str) -> string.String:
+    var result = string.String.with_capacity(path.len)
+
+    var index: ptr_uint = 0
+    while index < path.len:
+        let value = path.byte_at(index)
+        if value == 92:
+            result.push_byte(47)
+        else:
+            result.push_byte(value)
+        index += 1
+
+    return result
+
+
+public function join(left: str, right: str) -> string.String:
+    if left.len == 0:
+        return string.String.from_str(right)
+
+    if right.len == 0:
+        return string.String.from_str(left)
+
+    if is_absolute(right):
+        return string.String.from_str(right)
+
+    var result = string.String.from_str(left)
+    let last = result.as_str().byte_at(result.len() - 1)
+    if not is_separator(last):
+        result.append("/")
+
+    var start: ptr_uint = 0
+    while start < right.len and is_separator(right.byte_at(start)):
+        start += 1
+
+    if start == right.len:
+        return result
+
+    result.append(right.slice(start, right.len - start))
+    return result
+
+
+public function relative_path(path: str, base: str) -> Option[string.String]:
+    var normalized_path = normalize_separators(path)
+    defer normalized_path.release()
+    var normalized_base = normalize_separators(base)
+    defer normalized_base.release()
+
+    let path_text = normalized_path.as_str()
+    let base_text = normalized_base.as_str()
+    let path_root = root_length(path_text)
+    let base_root = root_length(base_text)
+    if not roots_compatible(path_text, path_root, base_text, base_root):
+        return Option[string.String].none
+
+    var path_segments = vec.Vec[Segment].create()
+    defer path_segments.release()
+    collect_normalized_segments(path_text, path_root, ref_of(path_segments))
+
+    var base_segments = vec.Vec[Segment].create()
+    defer base_segments.release()
+    collect_normalized_segments(base_text, base_root, ref_of(base_segments))
+
+    var common: ptr_uint = 0
+    let shared_len = min_ptr_uint(path_segments.len(), base_segments.len())
+    while common < shared_len:
+        let path_segment_ptr = path_segments.get(common) else:
+            fatal(c"path.relative_path missing path segment")
+        let base_segment_ptr = base_segments.get(common) else:
+            fatal(c"path.relative_path missing base segment")
+
+        unsafe:
+            if not segments_equal(path_text, read(path_segment_ptr), base_text, read(base_segment_ptr)):
+                break
+
+        common += 1
+
+    var result = string.String.with_capacity(path_text.len + base_text.len)
+    var index: ptr_uint = common
+    while index < base_segments.len():
+        append_relative_segment(ref_of(result), "..")
+        index += 1
+
+    index = common
+    while index < path_segments.len():
+        let path_segment_ptr = path_segments.get(index) else:
+            fatal(c"path.relative_path missing path segment for append")
+
+        unsafe:
+            append_relative_segment(ref_of(result), segment_text(path_text, read(path_segment_ptr)))
+
+        index += 1
+
+    if result.is_empty():
+        result.append(".")
+
+    return Option[string.String].some(value= result)
+
+
+public function is_within_root(path: str, root: str) -> bool:
+    var normalized_path = normalize_separators(path)
+    defer normalized_path.release()
+    var normalized_root = normalize_separators(root)
+    defer normalized_root.release()
+
+    let path_text = normalized_path.as_str()
+    let root_text = normalized_root.as_str()
+    let path_root = root_length(path_text)
+    let root_root = root_length(root_text)
+    if not roots_compatible(path_text, path_root, root_text, root_root):
+        return false
+
+    var path_segments = vec.Vec[Segment].create()
+    defer path_segments.release()
+    collect_normalized_segments(path_text, path_root, ref_of(path_segments))
+
+    var root_segments = vec.Vec[Segment].create()
+    defer root_segments.release()
+    collect_normalized_segments(root_text, root_root, ref_of(root_segments))
+
+    if path_segments.len() < root_segments.len():
+        return false
+
+    var index: ptr_uint = 0
+    while index < root_segments.len():
+        let path_segment_ptr = path_segments.get(index) else:
+            fatal(c"path.is_within_root missing path segment")
+        let root_segment_ptr = root_segments.get(index) else:
+            fatal(c"path.is_within_root missing root segment")
+
+        unsafe:
+            if not segments_equal(path_text, read(path_segment_ptr), root_text, read(root_segment_ptr)):
+                return false
+
+        index += 1
+
+    return true
+
+
+public function basename(path: str) -> str:
+    if path.len == 0:
+        return "."
+
+    let root = root_length(path)
+    let stop = trim_trailing_separators(path, root)
+    if stop == root:
+        if root == 0:
+            return "."
+
+        return path.slice(0, root)
+
+    var index = stop
+    while index > root:
+        if is_separator(path.byte_at(index - 1)):
+            return path.slice(index, stop - index)
+        index -= 1
+
+    if root != 0:
+        return path.slice(root, stop - root)
+
+    return path.slice(0, stop)
+
+
+public function dirname(path: str) -> str:
+    if path.len == 0:
+        return "."
+
+    let root = root_length(path)
+    let stop = trim_trailing_separators(path, root)
+    if stop == root:
+        if root == 0:
+            return "."
+
+        return path.slice(0, root)
+
+    var index = stop
+    while index > root:
+        if is_separator(path.byte_at(index - 1)):
+            var dir_stop = index - 1
+            while dir_stop > root and is_separator(path.byte_at(dir_stop - 1)):
+                dir_stop -= 1
+
+            if dir_stop == 0:
+                return "."
+
+            return path.slice(0, dir_stop)
+        index -= 1
+
+    if root != 0:
+        return path.slice(0, root)
+
+    return "."
+
+
+public function extension(path: str) -> Option[str]:
+    let name = basename(path)
+    match extension_dot(name):
+        Option.some as payload:
+            return Option[str].some(value= name.slice(payload.value, name.len - payload.value))
+        Option.none:
+            return Option[str].none
+
+
+public function stem(path: str) -> str:
+    let name = basename(path)
+    return name.slice(0, extension_dot(name).unwrap_or(name.len))
+
+
+function root_length(path: str) -> ptr_uint:
+    if path.len == 0:
+        return 0
+
+    if is_separator(path.byte_at(0)):
+        return 1
+
+    if path.len >= 3 and is_ascii_letter(path.byte_at(0)) and path.byte_at(1) == 58 and is_separator(path.byte_at(2)):
+        return 3
+
+    return 0
+
+
+function roots_compatible(left: str, left_root: ptr_uint, right: str, right_root: ptr_uint) -> bool:
+    if left_root != right_root:
+        return false
+
+    if left_root == 0:
+        return true
+
+    if left_root == 1:
+        return true
+
+    if left_root == 3 and left.byte_at(1) == 58 and right.byte_at(1) == 58:
+        return ascii_fold(left.byte_at(0)) == ascii_fold(right.byte_at(0))
+
+    var index: ptr_uint = 0
+    while index < left_root:
+        if left.byte_at(index) != right.byte_at(index):
+            return false
+
+        index += 1
+
+    return true
+
+
+function ascii_fold(value: ubyte) -> ubyte:
+    if value >= 65 and value <= 90:
+        return value + 32
+
+    return value
+
+
+function collect_normalized_segments(path: str, root: ptr_uint, output: ref[vec.Vec[Segment]]) -> void:
+    var index = root
+    while index < path.len:
+        while index < path.len and is_separator(path.byte_at(index)):
+            index += 1
+
+        if index == path.len:
+            return
+
+        let segment_start = index
+        while index < path.len and not is_separator(path.byte_at(index)):
+            index += 1
+
+        let segment_len = index - segment_start
+        if segment_is_current_directory(path, segment_start, segment_len):
+            continue
+
+        if segment_is_parent_directory(path, segment_start, segment_len):
+            let last_segment_ptr = output.last()
+            if last_segment_ptr != null:
+                unsafe:
+                    let last_segment = read(last_segment_ptr)
+                    if not segment_is_parent_directory(path, last_segment.start, last_segment.len):
+                        match output.pop():
+                            Option.some:
+                                pass
+                            Option.none:
+                                fatal(c"path.collect_normalized_segments failed to pop segment")
+                        continue
+
+            if root == 0:
+                output.push(Segment(start = segment_start, len = segment_len))
+
+            continue
+
+        output.push(Segment(start = segment_start, len = segment_len))
+
+
+function segment_is_current_directory(path: str, start: ptr_uint, len: ptr_uint) -> bool:
+    return len == 1 and path.byte_at(start) == 46
+
+
+function segment_is_parent_directory(path: str, start: ptr_uint, len: ptr_uint) -> bool:
+    return len == 2 and path.byte_at(start) == 46 and path.byte_at(start + 1) == 46
+
+
+function segments_equal(left: str, left_segment: Segment, right: str, right_segment: Segment) -> bool:
+    if left_segment.len != right_segment.len:
+        return false
+
+    var index: ptr_uint = 0
+    while index < left_segment.len:
+        if left.byte_at(left_segment.start + index) != right.byte_at(right_segment.start + index):
+            return false
+
+        index += 1
+
+    return true
+
+
+function segment_text(path: str, segment: Segment) -> str:
+    return path.slice(segment.start, segment.len)
+
+
+function append_relative_segment(output: ref[string.String], segment: str) -> void:
+    if not output.is_empty():
+        output.append("/")
+
+    output.append(segment)
+
+
+function min_ptr_uint(left: ptr_uint, right: ptr_uint) -> ptr_uint:
+    if left < right:
+        return left
+
+    return right
+
+
+function trim_trailing_separators(path: str, minimum: ptr_uint) -> ptr_uint:
+    var stop = path.len
+    while stop > minimum and is_separator(path.byte_at(stop - 1)):
+        stop -= 1
+
+    return stop
+
+
+function extension_dot(name: str) -> Option[ptr_uint]:
+    var index = name.len
+    while index > 0:
+        index -= 1
+        if name.byte_at(index) == 46:
+            if index == 0:
+                return Option[ptr_uint].none
+
+            return Option[ptr_uint].some(value= index)
+
+    return Option[ptr_uint].none
+
+
+function is_separator(value: ubyte) -> bool:
+    return value == 47 or value == 92
+
+
+function is_ascii_letter(value: ubyte) -> bool:
+    return (value >= 65 and value <= 90) or (value >= 97 and value <= 122)