rbs 3.10.0.pre.1 → 3.10.0

data/src/string.c

@@ -1,59 +1,10 @@
 #include "rbs/string.h"
-#include "rbs/defines.h"
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <ctype.h>
 
-unsigned int rbs_utf8_string_to_codepoint(const rbs_string_t string) {
-    unsigned int codepoint = 0;
-    int remaining_bytes = 0;
-
-    const char *s = string.start;
-    const char *end = string.end;
-
-    if (s >= end) return 0; // End of string
-
-    if (RBS_LIKELY((*s & 0x80) == 0)) {
-        // Single byte character (0xxxxxxx)
-        return *s;
-    } else if ((*s & 0xE0) == 0xC0) {
-        // Two byte character (110xxxxx 10xxxxxx)
-        codepoint = *s & 0x1F;
-        remaining_bytes = 1;
-    } else if ((*s & 0xF0) == 0xE0) {
-        // Three byte character (1110xxxx 10xxxxxx 10xxxxxx)
-        codepoint = *s & 0x0F;
-        remaining_bytes = 2;
-    } else if ((*s & 0xF8) == 0xF0) {
-        // Four byte character (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
-        codepoint = *s & 0x07;
-        remaining_bytes = 3;
-    } else {
-        // Invalid UTF-8 sequence
-        return 0xFFFD; // Unicode replacement character
-    }
-
-    s++;
-    while (remaining_bytes > 0 && s < end) {
-        if ((*s & 0xC0) != 0x80) {
-            // Invalid continuation byte
-            return 0xFFFD;
-        }
-        codepoint = (codepoint << 6) | (*s & 0x3F);
-        s++;
-        remaining_bytes--;
-    }
-
-    if (remaining_bytes > 0) {
-        // Incomplete sequence
-        return 0xFFFD;
-    }
-
-    return codepoint;
-}
-
 rbs_string_t rbs_string_new(const char *start, const char *end) {
     return (rbs_string_t) {
         .start = start,

data/src/util/rbs_allocator.c

@@ -57,7 +57,7 @@ static size_t get_system_page_size(void) {
 static rbs_allocator_page_t *rbs_allocator_page_new(size_t payload_size) {
     const size_t page_header_size = sizeof(rbs_allocator_page_t);
 
-    rbs_allocator_page_t *page = malloc(page_header_size + payload_size);
+    rbs_allocator_page_t *page = (rbs_allocator_page_t *) malloc(page_header_size + payload_size);
     page->size = payload_size;
     page->used = 0;
 
@@ -65,7 +65,7 @@ static rbs_allocator_page_t *rbs_allocator_page_new(size_t payload_size) {
 }
 
 rbs_allocator_t *rbs_allocator_init(void) {
-    rbs_allocator_t *allocator = malloc(sizeof(rbs_allocator_t));
+    rbs_allocator_t *allocator = (rbs_allocator_t *) malloc(sizeof(rbs_allocator_t));
 
     const size_t system_page_size = get_system_page_size();
 

data/src/util/rbs_assert.c

@@ -6,8 +6,6 @@
 #include <stdbool.h>
 
 void rbs_assert_impl(bool condition, const char *fmt, ...) {
-    printf("RBS_ASSERT called\n");
-
     if (condition) {
         return;
     }

data/src/util/rbs_constant_pool.c

@@ -57,8 +57,8 @@ rbs_constant_pool_resize(rbs_constant_pool_t *pool) {
     void *next = calloc(next_capacity, element_size);
     if (next == NULL) return false;
 
-    rbs_constant_pool_bucket_t *next_buckets = next;
-    rbs_constant_t *next_constants = (void *) (((char *) next) + next_capacity * sizeof(rbs_constant_pool_bucket_t));
+    rbs_constant_pool_bucket_t *next_buckets = (rbs_constant_pool_bucket_t *) next;
+    rbs_constant_t *next_constants = (rbs_constant_t *) (((char *) next) + next_capacity * sizeof(rbs_constant_pool_bucket_t));
 
     // For each bucket in the current constant pool, find the index in the
     // next constant pool, and insert it.
@@ -111,8 +111,8 @@ bool rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity) {
     void *memory = calloc(capacity, element_size);
     if (memory == NULL) return false;
 
-    pool->buckets = memory;
-    pool->constants = (void *) (((char *) memory) + capacity * sizeof(rbs_constant_pool_bucket_t));
+    pool->buckets = (rbs_constant_pool_bucket_t *) memory;
+    pool->constants = (rbs_constant_t *) (((char *) memory) + capacity * sizeof(rbs_constant_pool_bucket_t));
     pool->size = 0;
     pool->capacity = capacity;
     return true;

data/src/util/rbs_unescape.c

@@ -1,4 +1,5 @@
 #include "rbs/util/rbs_unescape.h"
+#include "rbs/util/rbs_encoding.h"
 #include <string.h>
 #include <stdlib.h>
 #include <ctype.h>
@@ -42,20 +43,44 @@ static int octal_to_int(const char *octal, int length) {
     return result;
 }
 
-int rbs_utf8_codelen(unsigned int c) {
-    if (c <= 0x7F) return 1;
-    if (c <= 0x7FF) return 2;
-    if (c <= 0xFFFF) return 3;
-    if (c <= 0x10FFFF) return 4;
-    return 1; // Invalid Unicode codepoint, treat as 1 byte
+// Fills buf starting at index 'start' with the UTF-8 encoding of 'codepoint'.
+// Returns the number of bytes written, or 0 when the output is not changed.
+//
+size_t rbs_utf8_fill_codepoint(char *buf, size_t start, size_t end, unsigned int codepoint) {
+    if (start + 4 > end) {
+        return 0;
+    }
+
+    if (codepoint <= 0x7F) {
+        buf[start] = codepoint & 0x7F;
+        return 1;
+    } else if (codepoint <= 0x7FF) {
+        buf[start + 0] = 0xC0 | ((codepoint >> 6) & 0x1F);
+        buf[start + 1] = 0x80 | (codepoint & 0x3F);
+        return 2;
+    } else if (codepoint <= 0xFFFF) {
+        buf[start + 0] = 0xE0 | ((codepoint >> 12) & 0x0F);
+        buf[start + 1] = 0x80 | ((codepoint >> 6) & 0x3F);
+        buf[start + 2] = 0x80 | (codepoint & 0x3F);
+        return 3;
+    } else if (codepoint <= 0x10FFFF) {
+        buf[start + 0] = 0xF0 | ((codepoint >> 18) & 0x07);
+        buf[start + 1] = 0x80 | ((codepoint >> 12) & 0x3F);
+        buf[start + 2] = 0x80 | ((codepoint >> 6) & 0x3F);
+        buf[start + 3] = 0x80 | (codepoint & 0x3F);
+        return 4;
+    } else {
+        return 0;
+    }
 }
 
-rbs_string_t unescape_string(rbs_allocator_t *allocator, const rbs_string_t string, bool is_double_quote) {
+rbs_string_t unescape_string(rbs_allocator_t *allocator, const rbs_string_t string, bool is_double_quote, bool is_unicode) {
     if (!string.start) return RBS_STRING_NULL;
 
     size_t len = string.end - string.start;
     const char *input = string.start;
 
+    // The output cannot be longer than the input even after unescaping.
     char *output = rbs_allocator_alloc_many(allocator, len + 1, char);
     if (!output) return RBS_STRING_NULL;
 
@@ -79,9 +104,21 @@ rbs_string_t unescape_string(rbs_allocator_t *allocator, const rbs_string_t stri
                     i += hex_len + 2;
                 } else if (input[i + 1] == 'u' && i + 5 < len) {
                     // Unicode escape
-                    int value = hex_to_int(input + i + 2, 4);
-                    output[j++] = (char) value;
-                    i += 6;
+
+                    if (is_unicode) {
+                        // The UTF-8 representation is at most 4 bytes, shorter than the input length.
+                        int value = hex_to_int(input + i + 2, 4);
+                        j += rbs_utf8_fill_codepoint(output, j, len + 1, value);
+                        i += 6;
+                    } else {
+                        // Copy the escape sequence as-is
+                        output[j++] = input[i++];
+                        output[j++] = input[i++];
+                        output[j++] = input[i++];
+                        output[j++] = input[i++];
+                        output[j++] = input[i++];
+                        output[j++] = input[i++];
+                    }
                 } else {
                     // Other escapes
                     int found = 0;
@@ -114,18 +151,17 @@ rbs_string_t unescape_string(rbs_allocator_t *allocator, const rbs_string_t stri
     return rbs_string_new(output, output + j);
 }
 
-rbs_string_t rbs_unquote_string(rbs_allocator_t *allocator, rbs_string_t input) {
-    unsigned int first_char = rbs_utf8_string_to_codepoint(input);
-    size_t byte_length = rbs_string_len(input);
+rbs_string_t rbs_unquote_string(rbs_allocator_t *allocator, rbs_string_t input, const rbs_encoding_t *encoding) {
+    unsigned int first_char = input.start[0];
+
+    const char *new_start = input.start;
+    const char *new_end = input.end;
 
-    ptrdiff_t start_offset = 0;
     if (first_char == '"' || first_char == '\'' || first_char == '`') {
-        int bs = rbs_utf8_codelen(first_char);
-        start_offset += bs;
-        byte_length -= 2 * bs;
+        new_start += 1;
+        new_end -= 1;
     }
 
-    const char *new_start = input.start + start_offset;
-    rbs_string_t string = rbs_string_new(new_start, new_start + byte_length);
-    return unescape_string(allocator, string, first_char == '"');
+    rbs_string_t string = rbs_string_new(new_start, new_end);
+    return unescape_string(allocator, string, first_char == '"', encoding == RBS_ENCODING_UTF_8_ENTRY);
 }

data/stdlib/bigdecimal/0/big_decimal.rbs

@@ -609,7 +609,7 @@ class BigDecimal < Numeric
   # The quotient q is (a/b).floor, and the modulus is the amount that must be
   # added to q * b to get a.
   #
-  def divmod: (Numeric) -> [ BigDecimal, BigDecimal ]
+  def divmod: (Numeric) -> [ Integer, BigDecimal ]
 
   # <!--
   #   rdoc-file=ext/bigdecimal/bigdecimal.c
@@ -783,20 +783,6 @@ class BigDecimal < Numeric
   #
   def power: (Numeric n, int prec) -> BigDecimal
 
-  # <!--
-  #   rdoc-file=ext/bigdecimal/bigdecimal.c
-  #   - precs -> array
-  # -->
-  # Returns an Array of two Integer values that represent platform-dependent
-  # internal storage properties.
-  #
-  # This method is deprecated and will be removed in the future. Instead, use
-  # BigDecimal#n_significant_digits for obtaining the number of significant digits
-  # in scientific notation, and BigDecimal#precision for obtaining the number of
-  # digits in decimal notation.
-  #
-  def precs: () -> [ Integer, Integer ]
-
   # <!--
   #   rdoc-file=ext/bigdecimal/bigdecimal.c
   #   - quo(value)  -> bigdecimal
@@ -1274,33 +1260,35 @@ class Integer
 
   # <!--
   #   rdoc-file=numeric.c
-  #   - self / numeric -> numeric_result
+  #   - self / other -> numeric
   # -->
-  # Performs division; for integer `numeric`, truncates the result to an integer:
+  # Returns the quotient of `self` and `other`.
+  #
+  # For integer `other`, truncates the result to an integer:
   #
-  #      4 / 3              # => 1
-  #      4 / -3             # => -2
-  #      -4 / 3             # => -2
-  #      -4 / -3            # => 1
+  #     4 / 3              # => 1
+  #     4 / -3             # => -2
+  #     -4 / 3             # => -2
+  #     -4 / -3            # => 1
   #
-  #     For other +numeric+, returns non-integer result:
+  # For non-integer `other`, returns a non-integer result:
   #
-  #      4 / 3.0            # => 1.3333333333333333
-  #      4 / Rational(3, 1) # => (4/3)
-  #      4 / Complex(3, 0)  # => ((4/3)+0i)
+  #     4 / 3.0            # => 1.3333333333333333
+  #     4 / Rational(3, 1) # => (4/3)
+  #     4 / Complex(3, 0)  # => ((4/3)+0i)
   #
   def /: (BigDecimal) -> BigDecimal
     | ...
 
   # <!--
   #   rdoc-file=numeric.c
-  #   - self * numeric -> numeric_result
+  #   - self * other -> numeric
   # -->
-  # Performs multiplication:
+  # Returns the numeric product of `self` and `other`:
   #
   #     4 * 2              # => 8
-  #     4 * -2             # => -8
   #     -4 * 2             # => -8
+  #     4 * -2             # => -8
   #     4 * 2.0            # => 8.0
   #     4 * Rational(1, 3) # => (4/3)
   #     4 * Complex(2, 0)  # => (8+0i)
@@ -1310,25 +1298,29 @@ class Integer
 
   # <!--
   #   rdoc-file=numeric.c
-  #   - self + numeric -> numeric_result
+  #   - self + other -> numeric
   # -->
-  # Performs addition:
+  # Returns the sum of `self` and `other`:
+  #
+  #     1 + 1               # => 2
+  #     1 + -1             # => 0
+  #     1 + 0              # => 1
+  #     1 + -2             # => -1
+  #     1 + Complex(1, 0)  # => (2+0i)
+  #     1 + Rational(1, 1) # => (2/1)
   #
-  #     2 + 2              # => 4
-  #     -2 + 2             # => 0
-  #     -2 + -2            # => -4
-  #     2 + 2.0            # => 4.0
-  #     2 + Rational(2, 1) # => (4/1)
-  #     2 + Complex(2, 0)  # => (4+0i)
+  # For a computation involving Floats, the result may be inexact (see Float#+):
+  #
+  #     1 + 3.14           # => 4.140000000000001
   #
   def +: (BigDecimal) -> BigDecimal
     | ...
 
   # <!--
   #   rdoc-file=numeric.c
-  #   - self - numeric -> numeric_result
+  #   - self - other -> numeric
   # -->
-  # Performs subtraction:
+  # Returns the difference of `self` and `other`:
   #
   #     4 - 2              # => 2
   #     -4 - 2             # => -6
@@ -1368,7 +1360,7 @@ class Float
   #   rdoc-file=numeric.c
   #   - self / other -> numeric
   # -->
-  # Returns a new Float which is the result of dividing `self` by `other`:
+  # Returns the quotient of `self` and `other`:
   #
   #     f = 3.14
   #     f / 2              # => 1.57
@@ -1383,7 +1375,7 @@ class Float
   #   rdoc-file=numeric.c
   #   - self * other -> numeric
   # -->
-  # Returns a new Float which is the product of `self` and `other`:
+  # Returns the numeric product of `self` and `other`:
   #
   #     f = 3.14
   #     f * 2              # => 6.28
@@ -1396,15 +1388,20 @@ class Float
 
   # <!--
   #   rdoc-file=numeric.c
-  #   - self + other -> numeric
+  #   - self + other -> float or complex
   # -->
-  # Returns a new Float which is the sum of `self` and `other`:
+  # Returns the sum of `self` and `other`; the result may be inexact (see Float):
   #
-  #     f = 3.14
-  #     f + 1                 # => 4.140000000000001
-  #     f + 1.0               # => 4.140000000000001
-  #     f + Rational(1, 1)    # => 4.140000000000001
-  #     f + Complex(1, 0)     # => (4.140000000000001+0i)
+  #     3.14 + 0              # => 3.14
+  #     3.14 + 1              # => 4.140000000000001
+  #     -3.14 + 0             # => -3.14
+  #     -3.14 + 1             # => -2.14
+  #
+  #     3.14 + -3.14          # => 0.0
+  #     -3.14 + -3.14         # => -6.28
+  #
+  #     3.14 + Complex(1, 0)   # => (4.140000000000001+0i)
+  #     3.14 + Rational(1, 1)  # => 4.140000000000001
   #
   def +: (BigDecimal) -> BigDecimal
     | ...
@@ -1413,7 +1410,7 @@ class Float
   #   rdoc-file=numeric.c
   #   - self - other -> numeric
   # -->
-  # Returns a new Float which is the difference of `self` and `other`:
+  # Returns the difference of `self` and `other`:
   #
   #     f = 3.14
   #     f - 1                 # => 2.14
@@ -1468,10 +1465,9 @@ class Rational
 
   # <!--
   #   rdoc-file=rational.c
-  #   - rat / numeric     ->  numeric
-  #   - rat.quo(numeric)  ->  numeric
+  #   - self / other -> numeric
   # -->
-  # Performs division.
+  # Returns the quotient of `self` and `other`:
   #
   #     Rational(2, 3)  / Rational(2, 3)   #=> (1/1)
   #     Rational(900)   / Rational(1)      #=> (900/1)
@@ -1484,39 +1480,50 @@ class Rational
 
   # <!--
   #   rdoc-file=rational.c
-  #   - rat * numeric  ->  numeric
+  #   - self * other -> numeric
   # -->
-  # Performs multiplication.
+  # Returns the numeric product of `self` and `other`:
   #
-  #     Rational(2, 3)  * Rational(2, 3)   #=> (4/9)
-  #     Rational(900)   * Rational(1)      #=> (900/1)
-  #     Rational(-2, 9) * Rational(-9, 2)  #=> (1/1)
-  #     Rational(9, 8)  * 4                #=> (9/2)
-  #     Rational(20, 9) * 9.8              #=> 21.77777777777778
+  #     Rational(9, 8)  * 4               #=> (9/2)
+  #     Rational(20, 9) * 9.8             #=> 21.77777777777778
+  #     Rational(9, 8)  * Complex(1, 2)   # => ((9/8)+(9/4)*i)
+  #     Rational(2, 3)  * Rational(2, 3)  #=> (4/9)
+  #     Rational(900)   * Rational(1)     #=> (900/1)
+  #     Rational(-2, 9) * Rational(-9, 2) #=> (1/1)
   #
   def *: (BigDecimal) -> BigDecimal
     | ...
 
   # <!--
   #   rdoc-file=rational.c
-  #   - rat + numeric  ->  numeric
+  #   - self + other -> numeric
   # -->
-  # Performs addition.
+  # Returns the sum of `self` and `other`:
+  #
+  #     Rational(2, 3) + 0  # => (2/3)
+  #     Rational(2, 3) + 1  # => (5/3)
+  #     Rational(2, 3) + -1 # => (-1/3)
+  #
+  #     Rational(2, 3) + Complex(1, 0)     # => ((5/3)+0i)
   #
-  #     Rational(2, 3)  + Rational(2, 3)   #=> (4/3)
-  #     Rational(900)   + Rational(1)      #=> (901/1)
-  #     Rational(-2, 9) + Rational(-9, 2)  #=> (-85/18)
-  #     Rational(9, 8)  + 4                #=> (41/8)
-  #     Rational(20, 9) + 9.8              #=> 12.022222222222222
+  #     Rational(2, 3) + Rational(1, 1)     # => (5/3)
+  #     Rational(2, 3) + Rational(3, 2)     # => (13/6)
+  #     Rational(2, 3) + Rational(3.0, 2.0) # => (13/6)
+  #     Rational(2, 3) + Rational(3.1, 2.1) # => (30399297484750849/14186338826217063)
+  #
+  # For a computation involving Floats, the result may be inexact (see Float#+):
+  #
+  #     Rational(2, 3) + 1.0 # => 1.6666666666666665
+  #     Rational(2, 3) + Complex(1.0, 0.0) # => (1.6666666666666665+0.0i)
   #
   def +: (BigDecimal) -> BigDecimal
     | ...
 
   # <!--
   #   rdoc-file=rational.c
-  #   - rat - numeric  ->  numeric
+  #   - self - other -> numeric
   # -->
-  # Performs subtraction.
+  # Returns the difference of `self` and `other`:
   #
   #     Rational(2, 3)  - Rational(2, 3)   #=> (0/1)
   #     Rational(900)   - Rational(1)      #=> (899/1)
@@ -1553,9 +1560,9 @@ class Complex
 
   # <!--
   #   rdoc-file=complex.c
-  #   - complex / numeric -> new_complex
+  #   - self / other -> complex
   # -->
-  # Returns the quotient of `self` and `numeric`:
+  # Returns the quotient of `self` and `other`:
   #
   #     Complex.rect(2, 3)  / Complex.rect(2, 3)  # => (1+0i)
   #     Complex.rect(900)   / Complex.rect(1)     # => (900+0i)
@@ -1568,39 +1575,50 @@ class Complex
 
   # <!--
   #   rdoc-file=complex.c
-  #   - complex * numeric -> new_complex
+  #   - self * other -> numeric
   # -->
-  # Returns the product of `self` and `numeric`:
+  # Returns the numeric product of `self` and `other`:
   #
+  #     Complex.rect(9, 8)  * 4                   # => (36+32i)
+  #     Complex.rect(20, 9) * 9.8                 # => (196.0+88.2i)
   #     Complex.rect(2, 3)  * Complex.rect(2, 3)  # => (-5+12i)
   #     Complex.rect(900)   * Complex.rect(1)     # => (900+0i)
   #     Complex.rect(-2, 9) * Complex.rect(-9, 2) # => (0-85i)
-  #     Complex.rect(9, 8)  * 4                   # => (36+32i)
-  #     Complex.rect(20, 9) * 9.8                 # => (196.0+88.2i)
+  #     Complex.rect(9, 8)  * Rational(2, 3)      # => ((6/1)+(16/3)*i)
   #
   def *: (BigDecimal) -> Complex
     | ...
 
   # <!--
   #   rdoc-file=complex.c
-  #   - complex + numeric -> new_complex
+  #   - self + other -> numeric
   # -->
-  # Returns the sum of `self` and `numeric`:
+  # Returns the sum of `self` and `other`:
+  #
+  #     Complex(1, 2) + 0  # => (1+2i)
+  #     Complex(1, 2) + 1  # => (2+2i)
+  #     Complex(1, 2) + -1 # => (0+2i)
+  #
+  #     Complex(1, 2) + 1.0  # => (2.0+2i)
+  #
+  #     Complex(1, 2) + Complex(2, 1)     # => (3+3i)
+  #     Complex(1, 2) + Complex(2.0, 1.0) # => (3.0+3.0i)
+  #
+  #     Complex(1, 2) + Rational(1, 1) # => ((2/1)+2i)
+  #     Complex(1, 2) + Rational(1, 2) # => ((3/2)+2i)
+  #
+  # For a computation involving Floats, the result may be inexact (see Float#+):
   #
-  #     Complex.rect(2, 3)  + Complex.rect(2, 3)  # => (4+6i)
-  #     Complex.rect(900)   + Complex.rect(1)     # => (901+0i)
-  #     Complex.rect(-2, 9) + Complex.rect(-9, 2) # => (-11+11i)
-  #     Complex.rect(9, 8)  + 4                   # => (13+8i)
-  #     Complex.rect(20, 9) + 9.8                 # => (29.8+9i)
+  #     Complex(1, 2) + 3.14 # => (4.140000000000001+2i)
   #
   def +: (BigDecimal) -> Complex
     | ...
 
   # <!--
   #   rdoc-file=complex.c
-  #   - complex - numeric -> new_complex
+  #   - self - other -> complex
   # -->
-  # Returns the difference of `self` and `numeric`:
+  # Returns the difference of `self` and `other`:
   #
   #     Complex.rect(2, 3)  - Complex.rect(2, 3)  # => (0+0i)
   #     Complex.rect(900)   - Complex.rect(1)     # => (899+0i)