mt-lang 0.2.21 → 0.2.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e599b2192dada4fb02cbcefc522482028adce79482a53965f2715895ced1c744
-  data.tar.gz: 2a4b8540ee7050b98707aee9cdd15b6f18504c8f401f9590c03720a49d88de78
+  metadata.gz: a2ffe49a95d73789f46660b0bf1ccdd0e8cca26846d19a33352751c93371531a
+  data.tar.gz: 75be2b9035d9271b691849b98769073d875f3a81aeb656feafab63b5998ca371
 SHA512:
-  metadata.gz: a308513fd5d5aac4ab32c9707b1bb066851b103b4c3ff9521e880f0bdaf7501968329da6fa6a98487077f532189b0931bb4e715e2a495f359e383320ecc1b212
-  data.tar.gz: d6f99733d6bc1be8eff2d4002b7b2e7d8aa8b1b6a48fe7ca26631a0ffc3780bafadcee2003c73afa473c457d59c736845d3e34f96e0a13ea1b3a48920b294b2c
+  metadata.gz: a52f4fe111b80f9ea19dd24b1df46356a1450134a3bd01fce0abd50d482e4b670ad9462d4884384a09447ab1483f6c49e37175191da86abb8143fc7446109f5a
+  data.tar.gz: 75be516db3258f9c705fcf6d9f4d3a84995e2fb2c91dddbc8899cf7ac3f79fdc1054b7068567654aef88c29637e5dff136894b1ceed50b4436354525e3298d53

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.2.21"
+  VERSION = "0.2.22"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/std/asset_pack.mt

@@ -50,18 +50,18 @@ public function open(path: str) -> Result[Reader, Error]:
         stdio.file_close(file)
         return Result[Reader, Error].failure(error= Error.invalid_magic)
 
-    let version = decode_u16_le(unsafe: header_ptr + 4)
+    let version = decode_ushort_le(unsafe: header_ptr + 4)
     if version != VERSION:
         stdio.file_close(file)
         return Result[Reader, Error].failure(error= Error.unsupported_version)
 
-    let header_bits = decode_u16_le(unsafe: header_ptr + 6)
+    let header_bits = decode_ushort_le(unsafe: header_ptr + 6)
     if header_bits != HEADER_FLAGS:
         stdio.file_close(file)
         return Result[Reader, Error].failure(error= Error.unsupported_flags)
 
-    let entry_count = decode_u32_le(unsafe: header_ptr + 8)
-    let index_size_result = decode_u64_le(unsafe: header_ptr + 12)
+    let entry_count = decode_uint_le(unsafe: header_ptr + 8)
+    let index_size_result = decode_ulong_le(unsafe: header_ptr + 12)
     var index_size: ptr_uint
     match index_size_result:
         Result.failure as payload:
@@ -70,7 +70,7 @@ public function open(path: str) -> Result[Reader, Error]:
         Result.success as index_payload:
             index_size = index_payload.value
 
-    let data_offset_result = decode_u64_le(unsafe: header_ptr + 20)
+    let data_offset_result = decode_ulong_le(unsafe: header_ptr + 20)
     var data_offset: ptr_uint
     match data_offset_result:
         Result.failure as payload:
@@ -147,12 +147,12 @@ function read_entry_metadata(file: stdio.File?) -> Result[EntryMetadata, Error]:
     if not read_exact(file, prefix_ptr, ENTRY_PREFIX_SIZE_BYTES):
         return Result[EntryMetadata, Error].failure(error= Error.malformed_index)
 
-    let path_length = ptr_uint<-decode_u32_le(prefix_ptr)
+    let path_length = ptr_uint<-decode_uint_le(prefix_ptr)
     if path_length == 0:
         return Result[EntryMetadata, Error].failure(error= Error.malformed_index)
 
-    let entry_bits = decode_u32_le(unsafe: prefix_ptr + 4)
-    let data_offset_result = decode_u64_le(unsafe: prefix_ptr + 8)
+    let entry_bits = decode_uint_le(unsafe: prefix_ptr + 4)
+    let data_offset_result = decode_ulong_le(unsafe: prefix_ptr + 8)
     var data_offset: ptr_uint
     match data_offset_result:
         Result.failure as payload:
@@ -160,7 +160,7 @@ function read_entry_metadata(file: stdio.File?) -> Result[EntryMetadata, Error]:
         Result.success as data_offset_payload:
             data_offset = data_offset_payload.value
 
-    let stored_size_result = decode_u64_le(unsafe: prefix_ptr + 16)
+    let stored_size_result = decode_ulong_le(unsafe: prefix_ptr + 16)
     var stored_size: ptr_uint
     match stored_size_result:
         Result.failure as payload:
@@ -168,7 +168,7 @@ function read_entry_metadata(file: stdio.File?) -> Result[EntryMetadata, Error]:
         Result.success as stored_size_payload:
             stored_size = stored_size_payload.value
 
-    let unpacked_size_result = decode_u64_le(unsafe: prefix_ptr + 24)
+    let unpacked_size_result = decode_ulong_le(unsafe: prefix_ptr + 24)
     var unpacked_size: ptr_uint
     match unpacked_size_result:
         Result.failure as payload:
@@ -228,12 +228,12 @@ function bytes_equal_str(left: ptr[ubyte], left_len: ptr_uint, right: str) -> bo
     return true
 
 
-function decode_u16_le(bytes: ptr[ubyte]) -> uint:
+function decode_ushort_le(bytes: ptr[ubyte]) -> uint:
     unsafe:
         return uint<-read(bytes + 0) | (uint<-read(bytes + 1) << 8)
 
 
-function decode_u32_le(bytes: ptr[ubyte]) -> uint:
+function decode_uint_le(bytes: ptr[ubyte]) -> uint:
     unsafe:
         return (
             uint<-read(bytes + 0) |
@@ -243,7 +243,7 @@ function decode_u32_le(bytes: ptr[ubyte]) -> uint:
         )
 
 
-function decode_u64_le(bytes: ptr[ubyte]) -> Result[ptr_uint, Error]:
+function decode_ulong_le(bytes: ptr[ubyte]) -> Result[ptr_uint, Error]:
     if size_of(ptr[void]) < 8:
         var upper_index: ptr_uint = 4
         while upper_index < 8:

data/std/binary.mt

@@ -114,7 +114,7 @@ extending Writer:
     public editable function write_uint_at(position: ptr_uint, value: uint) -> void:
         let buffer_span = this.buffer.as_span()
         if position + 4 > buffer_span.len:
-            fatal(c"binary.write_u32_at position out of bounds")
+            fatal(c"binary.write_uint_at position out of bounds")
         unsafe:
             read(buffer_span.data + position) = ubyte<-(value & 0xFF)
             read(buffer_span.data + position + 1) = ubyte<-((value >> 8) & 0xFF)

data/std/hash.mt

@@ -189,7 +189,7 @@ extending char:
 #  hash mixes the value's bytes (FNV-1a); equal/order use native operators.
 # ---------------------------------------------------------------------------
 
-function hash_u32(value: uint) -> uint:
+function hash_uint(value: uint) -> uint:
     let fnv: uint = 0x811C9DC5
     let prime: uint = 0x01000193
     var h = fnv
@@ -200,14 +200,14 @@ function hash_u32(value: uint) -> uint:
     return h
 
 
-function hash_u64(value: ulong) -> uint:
-    return hash_u32(uint<-((value >> uint<-(32)) ^ value))
+function hash_ulong(value: ulong) -> uint:
+    return hash_uint(uint<-((value >> uint<-(32)) ^ value))
 
 
 extending byte:
     public static function hash(value: const_ptr[byte]) -> uint:
         unsafe:
-            return hash_u32(uint<-(int<-read(ptr[byte]<-value)))
+            return hash_uint(uint<-(int<-read(ptr[byte]<-value)))
 
 
     public static function equal(a: const_ptr[byte], b: const_ptr[byte]) -> bool:
@@ -229,7 +229,7 @@ extending byte:
 extending ubyte:
     public static function hash(value: const_ptr[ubyte]) -> uint:
         unsafe:
-            return hash_u32(uint<-read(ptr[ubyte]<-value))
+            return hash_uint(uint<-read(ptr[ubyte]<-value))
 
 
     public static function equal(a: const_ptr[ubyte], b: const_ptr[ubyte]) -> bool:
@@ -251,7 +251,7 @@ extending ubyte:
 extending short:
     public static function hash(value: const_ptr[short]) -> uint:
         unsafe:
-            return hash_u32(uint<-(int<-read(ptr[short]<-value)))
+            return hash_uint(uint<-(int<-read(ptr[short]<-value)))
 
 
     public static function equal(a: const_ptr[short], b: const_ptr[short]) -> bool:
@@ -273,7 +273,7 @@ extending short:
 extending ushort:
     public static function hash(value: const_ptr[ushort]) -> uint:
         unsafe:
-            return hash_u32(uint<-read(ptr[ushort]<-value))
+            return hash_uint(uint<-read(ptr[ushort]<-value))
 
 
     public static function equal(a: const_ptr[ushort], b: const_ptr[ushort]) -> bool:
@@ -295,7 +295,7 @@ extending ushort:
 extending long:
     public static function hash(value: const_ptr[long]) -> uint:
         unsafe:
-            return hash_u64(ulong<-read(ptr[long]<-value))
+            return hash_ulong(ulong<-read(ptr[long]<-value))
 
 
     public static function equal(a: const_ptr[long], b: const_ptr[long]) -> bool:
@@ -317,7 +317,7 @@ extending long:
 extending ulong:
     public static function hash(value: const_ptr[ulong]) -> uint:
         unsafe:
-            return hash_u64(read(ptr[ulong]<-value))
+            return hash_ulong(read(ptr[ulong]<-value))
 
 
     public static function equal(a: const_ptr[ulong], b: const_ptr[ulong]) -> bool:
@@ -339,7 +339,7 @@ extending ulong:
 extending ptr_int:
     public static function hash(value: const_ptr[ptr_int]) -> uint:
         unsafe:
-            return hash_u64(ulong<-read(ptr[ptr_int]<-value))
+            return hash_ulong(ulong<-read(ptr[ptr_int]<-value))
 
 
     public static function equal(a: const_ptr[ptr_int], b: const_ptr[ptr_int]) -> bool:
@@ -410,7 +410,7 @@ public function order_struct[T](a: const_ptr[T], b: const_ptr[T]) -> int:
 extending ptr_uint:
     public static function hash(value: const_ptr[ptr_uint]) -> uint:
         unsafe:
-            return hash_u64(ulong<-read(ptr[ptr_uint]<-value))
+            return hash_ulong(ulong<-read(ptr[ptr_uint]<-value))
 
 
     public static function equal(a: const_ptr[ptr_uint], b: const_ptr[ptr_uint]) -> bool:

data/std/net/session.mt

@@ -167,7 +167,7 @@ function generate_handshake_key() -> Result[ulong, net.Error]:
                     return Result[ulong, net.Error].success(value = value)
 
 
-function decode_u32_at(data: span[ubyte], offset: ptr_uint) -> uint:
+function decode_uint_at(data: span[ubyte], offset: ptr_uint) -> uint:
     unsafe:
         return uint<-read(data.data + offset) | (uint<-read(data.data + offset + 1) << 8) | (uint<-read(data.data + offset + 2) << 16) | (uint<-read(data.data + offset + 3) << 24)
 
@@ -536,7 +536,7 @@ function handle_incoming_conn(conn: ref[Connection], msg: ref[chan.Message]) ->
         conn.frame_since_last_recv = 0
         let hb_span = unsafe: span[ubyte](data = span.data + 1, len = span.len - 1)
         if hb_span.len >= 4:
-            let echoed = decode_u32_at(hb_span, 0)
+            let echoed = decode_uint_at(hb_span, 0)
             var ack = build_heartbeat_ack(echoed)
             let peer_addr_result = conn.channel.peer_address()
             match peer_addr_result:
@@ -555,7 +555,7 @@ function handle_incoming_conn(conn: ref[Connection], msg: ref[chan.Message]) ->
         conn.frame_since_last_recv = 0
         let echo_span = unsafe: span[ubyte](data = span.data + 1, len = span.len - 1)
         if echo_span.len >= 4:
-            let echoed = decode_u32_at(echo_span, 0)
+            let echoed = decode_uint_at(echo_span, 0)
             if conn.last_heartbeat_sent > echoed:
                 conn.ping_rtt_frames = conn.last_heartbeat_sent - echoed
         msg.release()
@@ -920,7 +920,7 @@ function handle_incoming_session(session: ref[Session], msg: ref[chan.HostMessag
                 update_peer_last_recv(session, peer_payload.value)
                 let hb_span = unsafe: span[ubyte](data = span.data + 1, len = span.len - 1)
                 if hb_span.len >= 4:
-                    let echoed = decode_u32_at(hb_span, 0)
+                    let echoed = decode_uint_at(hb_span, 0)
                     var ack = build_heartbeat_ack(echoed)
                     let addr_result = msg.source.copy()
                     match addr_result:
@@ -973,7 +973,7 @@ function handle_connect_request(session: ref[Session], msg: ref[chan.HostMessage
         msg.release()
         return
 
-    let client_version = decode_u32_at(req_span, 0)
+    let client_version = decode_uint_at(req_span, 0)
     if client_version != session.config.protocol_version:
         var reject = build_connect_reject(reject_reason_version)
         let addr_result = msg.source.copy()

data/std/random.mt

@@ -9,9 +9,9 @@ public struct Rng:
 
 public function from_seed(seed: ulong) -> Rng:
     var rng = Rng(state = 0ul, increment = (seed << 1ul) | 1ul)
-    rng.next_u32()
+    rng.next_uint()
     rng.state = rng.state + seed
-    rng.next_u32()
+    rng.next_uint()
     return rng
 
 
@@ -27,7 +27,7 @@ public function from_seed_str(seed_str: str) -> Rng:
 
 
 extending Rng:
-    public editable function next_u32() -> uint:
+    public editable function next_uint() -> uint:
         let oldstate = this.state
         this.state = oldstate * pcg_multiplier + this.increment
         let xorshifted = uint<-(((oldstate >> 18ul) ^ oldstate) >> 27ul)
@@ -35,67 +35,59 @@ extending Rng:
         return (xorshifted >> rot) | (xorshifted << (32u - rot))
 
 
-    public editable function next_u64() -> ulong:
-        let hi = ulong<-this.next_u32()
-        let lo = ulong<-this.next_u32()
+    public editable function next_ulong() -> ulong:
+        let hi = ulong<-this.next_uint()
+        let lo = ulong<-this.next_uint()
         return (hi << 32ul) | lo
 
 
-    public editable function next_f64() -> double:
-        let val = this.next_u32()
+    public editable function next_double() -> double:
+        let val = this.next_uint()
         return double<-val / 4294967296.0
 
 
-    public editable function next_f32() -> float:
-        let val = this.next_u32()
+    public editable function next_float() -> float:
+        let val = this.next_uint()
         return float<-val / 4294967296.0
 
 
     public editable function next_ubyte() -> ubyte:
-        let val = this.next_u32()
+        let val = this.next_uint()
         return ubyte<-(val & 0xFFu)
 
 
     public editable function next_bool() -> bool:
-        let val = this.next_u32()
+        let val = this.next_uint()
         return (val & 1u) != 0u
 
 
-    public editable function next_uint() -> uint:
-        return this.next_u32()
-
-
-    public editable function next_ulong() -> ulong:
-        return this.next_u64()
-
-
     public editable function next_uint_range(min: uint, max: uint) -> uint:
         if min >= max:
             return min
         let range = max - min
-        return min + (this.next_u32() % range)
+        return min + (this.next_uint() % range)
 
 
     public editable function next_int_range(min: int, max: int) -> int:
         if min >= max:
             return min
         let range = uint<-(max - min)
-        let offset = this.next_u32() % range
+        let offset = this.next_uint() % range
         return min + int<-offset
 
 
-    public editable function next_f64_range(min: double, max: double) -> double:
-        let t = this.next_f64()
+    public editable function next_double_range(min: double, max: double) -> double:
+        let t = this.next_double()
         return min + (max - min) * t
 
 
-    public editable function next_f32_range(min: float, max: float) -> float:
-        let t = this.next_f32()
+    public editable function next_float_range(min: float, max: float) -> float:
+        let t = this.next_float()
         return min + (max - min) * t
 
 
     public editable function chance(probability: double) -> bool:
-        return this.next_f64() < probability
+        return this.next_double() < probability
 
 
     public editable function pick_ref[T](items: span[T]) -> ptr[T]?:
@@ -130,17 +122,17 @@ extending Rng:
     public editable function skip(count: ptr_uint) -> void:
         var i: ptr_uint = 0
         while i < count:
-            this.next_u32()
+            this.next_uint()
             i += 1
 
 
     public editable function fork() -> Rng:
-        let seed = this.next_u64()
+        let seed = this.next_ulong()
         return from_seed(seed)
 
 
     public editable function seeds() -> array[ulong, 4]:
         return array[ulong, 4](
-            this.next_u64(), this.next_u64(),
-            this.next_u64(), this.next_u64()
+            this.next_ulong(), this.next_ulong(),
+            this.next_ulong(), this.next_ulong()
         )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.2.21
+  version: 0.2.22
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -586,7 +586,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.2.21 installed!
+  Milk Tea 0.2.22 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH