X-Git-Url: http://nitlanguage.org diff --git a/lib/core/text/abstract_text.nit b/lib/core/text/abstract_text.nit index d7dfa48..71021ab 100644 --- a/lib/core/text/abstract_text.nit +++ b/lib/core/text/abstract_text.nit @@ -25,6 +25,7 @@ in "C" `{ # High-level abstraction for all text representations abstract class Text super Comparable + super Cloneable redef type OTHER: Text @@ -50,9 +51,9 @@ abstract class Text # Number of bytes in `self` # - # assert "12345".bytelen == 5 - # assert "あいうえお".bytelen == 15 - fun bytelen: Int is abstract + # assert "12345".byte_length == 5 + # assert "あいうえお".byte_length == 15 + fun byte_length: Int is abstract # Create a substring. # @@ -82,6 +83,9 @@ abstract class Text # implementation of an empty string. protected fun empty: SELFTYPE is abstract + # Returns a copy of `self` as a Buffer + fun to_buffer: Buffer is abstract + # Gets the first char of the Text # # DEPRECATED : Use self.chars.first instead @@ -135,7 +139,7 @@ abstract class Text end # Return a null terminated char * - fun to_cstring: NativeString is abstract + fun to_cstring: CString is abstract # The index of the last occurrence of an element starting from pos (in reverse order). # @@ -148,6 +152,12 @@ abstract class Text # DEPRECATED : Use self.chars.last_index_of_from instead fun last_index_of_from(item: Char, pos: Int): Int do return chars.last_index_of_from(item, pos) + # Concatenates `o` to `self` + # + # assert "hello" + "world" == "helloworld" + # assert "" + "hello" + "" == "hello" + fun +(o: Text): SELFTYPE is abstract + # Gets an iterator on the chars of self # # DEPRECATED : Use self.chars.iterator instead @@ -551,7 +561,7 @@ abstract class Text var res = new Buffer var underscore = false var start = 0 - var c = chars[0] + var c = self[0] if c >= '0' and c <= '9' then res.add('_') @@ -560,7 +570,7 @@ abstract class Text start = 1 end for i in [start..length[ do - c = chars[i] + c = self[i] if (c >= 'a' and c <= 'z') or (c >='A' and c <= 'Z') then res.add(c) underscore = false @@ -590,10 +600,13 @@ abstract class Text return res.to_s end - # Escape " \ ' and non printable characters using the rules of literal C strings and characters + # Escape `"` `\` `'`, trigraphs and non printable characters using the rules of literal C strings and characters # - # assert "abAB12<>&".escape_to_c == "abAB12<>&" + # assert "abAB12<>&".escape_to_c == "abAB12<>&" # assert "\n\"'\\".escape_to_c == "\\n\\\"\\'\\\\" + # assert "allo???!".escape_to_c == "allo??\\?!" + # assert "??=??/??'??(??)".escape_to_c == "?\\?=?\\?/??\\'?\\?(?\\?)" + # assert "??!????-".escape_to_c == "?\\?!?\\??\\?-" # # Most non-printable characters (bellow ASCII 32) are escaped to an octal form `\nnn`. # Three digits are always used to avoid following digits to be interpreted as an element @@ -617,6 +630,24 @@ abstract class Text b.append("\\\'") else if c == '\\' then b.append("\\\\") + else if c == '?' then + # Escape if it is the last question mark of a ANSI C trigraph. + var j = i + 1 + if j < length then + var next = chars[j] + # We ignore `??'` because it will be escaped as `??\'`. + if + next == '!' or + next == '(' or + next == ')' or + next == '-' or + next == '/' or + next == '<' or + next == '=' or + next == '>' + then b.add('\\') + end + b.add('?') else if c.code_point < 32 then b.add('\\') var oct = c.code_point.to_base(8) @@ -640,6 +671,7 @@ abstract class Text # The result might no be legal in C but be used in other languages # # assert "ab|\{\}".escape_more_to_c("|\{\}") == "ab\\|\\\{\\\}" + # assert "allo???!".escape_more_to_c("") == "allo??\\?!" fun escape_more_to_c(chars: String): String do var b = new Buffer @@ -822,7 +854,7 @@ abstract class Text # assert "%c3%a9%e3%81%82%e3%81%84%e3%81%86".from_percent_encoding == "éあいう" fun from_percent_encoding: String do - var len = bytelen + var len = byte_length var has_percent = false for c in chars do if c == '%' then @@ -834,7 +866,7 @@ abstract class Text # If no transformation is needed, return self as a string if not has_percent then return to_s - var buf = new NativeString(len) + var buf = new CString(len) var i = 0 var l = 0 while i < length do @@ -1076,15 +1108,15 @@ abstract class Text # Copies `n` bytes from `self` at `src_offset` into `dest` starting at `dest_offset` # - # Basically a high-level synonym of NativeString::copy_to + # Basically a high-level synonym of CString::copy_to # # REQUIRE: `n` must be large enough to contain `len` bytes # - # var ns = new NativeString(8) + # var ns = new CString(8) # "Text is String".copy_to_native(ns, 8, 2, 0) # assert ns.to_s_unsafe(8) == "xt is St" # - fun copy_to_native(dest: NativeString, n, src_offset, dest_offset: Int) do + fun copy_to_native(dest: CString, n, src_offset, dest_offset: Int) do var mypos = src_offset var itspos = dest_offset while n > 0 do @@ -1128,6 +1160,108 @@ abstract class Text end return retarr.reversed end + + # Concatenates self `i` times + # + #~~~nit + # assert "abc" * 4 == "abcabcabcabc" + # assert "abc" * 1 == "abc" + # assert "abc" * 0 == "" + # var b = new Buffer + # b.append("天地") + # b = b * 4 + # assert b == "天地天地天地天地" + #~~~ + fun *(i: Int): SELFTYPE is abstract + + # Insert `s` at `pos`. + # + #~~~nit + # assert "helloworld".insert_at(" ", 5) == "hello world" + # var b = new Buffer + # b.append("Hello世界") + # b = b.insert_at(" beautiful ", 5) + # assert b == "Hello beautiful 世界" + #~~~ + fun insert_at(s: String, pos: Int): SELFTYPE is abstract + + # Returns a reversed version of self + # + # assert "hello".reversed == "olleh" + # assert "bob".reversed == "bob" + # assert "".reversed == "" + fun reversed: SELFTYPE is abstract + + # A upper case version of `self` + # + # assert "Hello World!".to_upper == "HELLO WORLD!" + fun to_upper: SELFTYPE is abstract + + # A lower case version of `self` + # + # assert "Hello World!".to_lower == "hello world!" + fun to_lower : SELFTYPE is abstract + + # Takes a camel case `self` and converts it to snake case + # + # assert "randomMethodId".to_snake_case == "random_method_id" + # + # The rules are the following: + # + # An uppercase is always converted to a lowercase + # + # assert "HELLO_WORLD".to_snake_case == "hello_world" + # + # An uppercase that follows a lowercase is prefixed with an underscore + # + # assert "HelloTheWORLD".to_snake_case == "hello_the_world" + # + # An uppercase that follows an uppercase and is followed by a lowercase, is prefixed with an underscore + # + # assert "HelloTHEWorld".to_snake_case == "hello_the_world" + # + # All other characters are kept as is; `self` does not need to be a proper CamelCased string. + # + # assert "=-_H3ll0Th3W0rld_-=".to_snake_case == "=-_h3ll0th3w0rld_-=" + fun to_snake_case: SELFTYPE is abstract + + # Takes a snake case `self` and converts it to camel case + # + # assert "random_method_id".to_camel_case == "randomMethodId" + # + # If the identifier is prefixed by an underscore, the underscore is ignored + # + # assert "_private_field".to_camel_case == "_privateField" + # + # If `self` is upper, it is returned unchanged + # + # assert "RANDOM_ID".to_camel_case == "RANDOM_ID" + # + # If there are several consecutive underscores, they are considered as a single one + # + # assert "random__method_id".to_camel_case == "randomMethodId" + fun to_camel_case: SELFTYPE is abstract + + # Returns a capitalized `self` + # + # Letters that follow a letter are lowercased + # Letters that follow a non-letter are upcased. + # + # If `keep_upper = true`, already uppercase letters are not lowercased. + # + # SEE : `Char::is_letter` for the definition of letter. + # + # assert "jAVASCRIPT".capitalized == "Javascript" + # assert "i am root".capitalized == "I Am Root" + # assert "ab_c -ab0c ab\nc".capitalized == "Ab_C -Ab0C Ab\nC" + # assert "preserve my ACRONYMS".capitalized(keep_upper=true) == "Preserve My ACRONYMS" + fun capitalized(keep_upper: nullable Bool): SELFTYPE do + if length == 0 then return self + + var buf = new Buffer.with_cap(length) + buf.capitalize(keep_upper=keep_upper, src=self) + return buf.to_s + end end # All kinds of array-based text representations. @@ -1138,13 +1272,13 @@ abstract class FlatText # # Warning : Might be void in some subclasses, be sure to check # if set before using it. - var items: NativeString is noinit + var items: CString is noinit # Returns a char* starting at position `first_byte` # # WARNING: If you choose to use this service, be careful of the following. # - # Strings and NativeString are *ideally* always allocated through a Garbage Collector. + # Strings and CString are *ideally* always allocated through a Garbage Collector. # Since the GC tracks the use of the pointer for the beginning of the char*, it may be # deallocated at any moment, rendering the pointer returned by this function invalid. # Any access to freed memory may very likely cause undefined behaviour or a crash. @@ -1155,11 +1289,11 @@ abstract class FlatText # # As always, do not modify the content of the String in C code, if this is what you want # copy locally the char* as Nit Strings are immutable. - fun fast_cstring: NativeString is abstract + fun fast_cstring: CString is abstract redef var length = 0 - redef var bytelen = 0 + redef var byte_length = 0 redef fun output do @@ -1204,11 +1338,11 @@ private abstract class StringByteView redef fun is_empty do return target.is_empty - redef fun length do return target.bytelen + redef fun length do return target.byte_length redef fun iterator do return self.iterator_from(0) - redef fun reverse_iterator do return self.reverse_iterator_from(target.bytelen - 1) + redef fun reverse_iterator do return self.reverse_iterator_from(target.byte_length - 1) end # Immutable sequence of characters. @@ -1223,168 +1357,26 @@ abstract class String redef fun to_s do return self - # Concatenates `o` to `self` - # - # assert "hello" + "world" == "helloworld" - # assert "" + "hello" + "" == "hello" - fun +(o: Text): SELFTYPE is abstract - - # Concatenates self `i` times - # - # assert "abc" * 4 == "abcabcabcabc" - # assert "abc" * 1 == "abc" - # assert "abc" * 0 == "" - fun *(i: Int): SELFTYPE is abstract - - # Insert `s` at `pos`. - # - # assert "helloworld".insert_at(" ", 5) == "hello world" - fun insert_at(s: String, pos: Int): SELFTYPE is abstract - - redef fun substrings is abstract - - # Returns a reversed version of self - # - # assert "hello".reversed == "olleh" - # assert "bob".reversed == "bob" - # assert "".reversed == "" - fun reversed: SELFTYPE is abstract - - # A upper case version of `self` - # - # assert "Hello World!".to_upper == "HELLO WORLD!" - fun to_upper: SELFTYPE is abstract - - # A lower case version of `self` - # - # assert "Hello World!".to_lower == "hello world!" - fun to_lower : SELFTYPE is abstract - - # Takes a camel case `self` and converts it to snake case - # - # assert "randomMethodId".to_snake_case == "random_method_id" - # - # The rules are the following: - # - # An uppercase is always converted to a lowercase - # - # assert "HELLO_WORLD".to_snake_case == "hello_world" - # - # An uppercase that follows a lowercase is prefixed with an underscore - # - # assert "HelloTheWORLD".to_snake_case == "hello_the_world" - # - # An uppercase that follows an uppercase and is followed by a lowercase, is prefixed with an underscore - # - # assert "HelloTHEWorld".to_snake_case == "hello_the_world" - # - # All other characters are kept as is; `self` does not need to be a proper CamelCased string. - # - # assert "=-_H3ll0Th3W0rld_-=".to_snake_case == "=-_h3ll0th3w0rld_-=" - fun to_snake_case: SELFTYPE - do - if self.is_lower then return self - - var new_str = new Buffer.with_cap(self.length) - var prev_is_lower = false - var prev_is_upper = false - - for i in [0..length[ do - var char = chars[i] - if char.is_lower then - new_str.add(char) - prev_is_lower = true - prev_is_upper = false - else if char.is_upper then - if prev_is_lower then - new_str.add('_') - else if prev_is_upper and i+1 < length and chars[i+1].is_lower then - new_str.add('_') - end - new_str.add(char.to_lower) - prev_is_lower = false - prev_is_upper = true - else - new_str.add(char) - prev_is_lower = false - prev_is_upper = false - end - end + redef fun clone do return self - return new_str.to_s - end + redef fun to_buffer do return new Buffer.from_text(self) - # Takes a snake case `self` and converts it to camel case - # - # assert "random_method_id".to_camel_case == "randomMethodId" - # - # If the identifier is prefixed by an underscore, the underscore is ignored - # - # assert "_private_field".to_camel_case == "_privateField" - # - # If `self` is upper, it is returned unchanged - # - # assert "RANDOM_ID".to_camel_case == "RANDOM_ID" - # - # If there are several consecutive underscores, they are considered as a single one - # - # assert "random__method_id".to_camel_case == "randomMethodId" - fun to_camel_case: SELFTYPE - do + redef fun to_camel_case do if self.is_upper then return self - var new_str = new Buffer - var is_first_char = true - var follows_us = false - - for i in [0..length[ do - var char = chars[i] - if is_first_char then - new_str.add(char) - is_first_char = false - else if char == '_' then - follows_us = true - else if follows_us then - new_str.add(char.to_upper) - follows_us = false - else - new_str.add(char) - end - end - + var new_str = new Buffer.with_cap(length) + new_str.append self + new_str.camel_case return new_str.to_s end - # Returns a capitalized `self` - # - # Letters that follow a letter are lowercased - # Letters that follow a non-letter are upcased. - # - # SEE : `Char::is_letter` for the definition of letter. - # - # assert "jAVASCRIPT".capitalized == "Javascript" - # assert "i am root".capitalized == "I Am Root" - # assert "ab_c -ab0c ab\nc".capitalized == "Ab_C -Ab0C Ab\nC" - fun capitalized: SELFTYPE do - if length == 0 then return self - - var buf = new Buffer.with_cap(length) - - var curr = chars[0].to_upper - var prev = curr - buf[0] = curr - - for i in [1 .. length[ do - prev = curr - curr = self[i] - if prev.is_letter then - buf[i] = curr.to_lower - else - buf[i] = curr.to_upper - end - end + redef fun to_snake_case do + if self.is_lower then return self - return buf.to_s + var new_str = new Buffer.with_cap(self.length) + new_str.append self + new_str.snake_case + return new_str.to_s end end @@ -1398,10 +1390,14 @@ abstract class Buffer # Returns an instance of a subclass of `Buffer` with `i` base capacity new with_cap(i: Int) is abstract - redef type SELFTYPE: Buffer is fixed + # Returns an instance of a subclass of `Buffer` with `t` as content + new from_text(t: Text) do + var ret = new Buffer.with_cap(t.byte_length) + ret.append t + return ret + end - # Specific implementations MUST set this to `true` in order to invalidate caches - protected var is_dirty = true + redef type SELFTYPE: Buffer is fixed # Copy-On-Write flag # @@ -1416,6 +1412,20 @@ abstract class Buffer # DEPRECATED : Use self.chars.[]= instead fun []=(index: Int, item: Char) is abstract + redef fun to_buffer do return clone + + #~~~nit + # var b = new Buffer + # b.append("Buffer!") + # var c = b.clone + # assert b == c + #~~~ + redef fun clone do + var cln = new Buffer.with_cap(byte_length) + cln.append self + return cln + end + # Adds a char `c` at the end of self # # DEPRECATED : Use self.chars.add instead @@ -1478,6 +1488,13 @@ abstract class Buffer # Letters that follow a letter are lowercased # Letters that follow a non-letter are upcased. # + # If `keep_upper = true`, uppercase letters are not lowercased. + # + # When `src` is specified, this method reads from `src` instead of `self` + # but it still writes the result to the beginning of `self`. + # This requires `self` to have the capacity to receive all of the + # capitalized content of `src`. + # # SEE: `Char::is_letter` for the definition of a letter. # # var b = new FlatBuffer.from("jAVAsCriPt") @@ -1489,28 +1506,38 @@ abstract class Buffer # b = new FlatBuffer.from("ab_c -ab0c ab\nc") # b.capitalize # assert b == "Ab_C -Ab0C Ab\nC" - fun capitalize do + # + # b = new FlatBuffer.from("12345") + # b.capitalize(src="foo") + # assert b == "Foo45" + # + # b = new FlatBuffer.from("preserve my ACRONYMS") + # b.capitalize(keep_upper=true) + # assert b == "Preserve My ACRONYMS" + fun capitalize(keep_upper: nullable Bool, src: nullable Text) do + src = src or else self + var length = src.length if length == 0 then return - var c = self[0].to_upper + keep_upper = keep_upper or else false + + var c = src[0].to_upper self[0] = c var prev = c for i in [1 .. length[ do prev = c - c = self[i] + c = src[i] if prev.is_letter then - self[i] = c.to_lower + if keep_upper then + self[i] = c + else + self[i] = c.to_lower + end else self[i] = c.to_upper end end end - redef fun hash - do - if is_dirty then hash_cache = null - return super - end - # In Buffers, the internal sequence of character is mutable # Thus, `chars` can be used to modify the buffer. redef fun chars: Sequence[Char] is abstract @@ -1544,11 +1571,152 @@ abstract class Buffer # NOTE: Use only if sure about `from` and `length`, no checks # or bound recalculation is done fun append_substring_impl(s: Text, from, length: Int) do - var pos = from - for i in [0 .. length[ do - self.add s[pos] + var max = from + length + for i in [from .. max[ do add s[i] + end + + redef fun *(i) do + var ret = new Buffer.with_cap(byte_length * i) + for its in [0 .. i[ do ret.append self + return ret + end + + redef fun insert_at(s, pos) do + var obuf = new Buffer.with_cap(byte_length + s.byte_length) + obuf.append_substring(self, 0, pos) + obuf.append s + obuf.append_substring(self, pos, length - pos) + return obuf + end + + # Inserts `s` at position `pos` + # + #~~~nit + # var b = new Buffer + # b.append "美しい世界" + # b.insert(" nit ", 3) + # assert b == "美しい nit 世界" + #~~~ + fun insert(s: Text, pos: Int) is abstract + + # Inserts `c` at position `pos` + # + #~~~nit + # var b = new Buffer + # b.append "美しい世界" + # b.insert_char(' ', 3) + # assert b == "美しい 世界" + #~~~ + fun insert_char(c: Char, pos: Int) is abstract + + # Removes a substring from `self` at position `pos` + # + # NOTE: `length` defaults to 1, expressed in chars + # + #~~~nit + # var b = new Buffer + # b.append("美しい 世界") + # b.remove_at(3) + # assert b == "美しい世界" + # b.remove_at(1, 2) + # assert b == "美世界" + #~~~ + fun remove_at(pos: Int, length: nullable Int) is abstract + + redef fun reversed do + var ret = clone + ret.reverse + return ret + end + + redef fun to_upper do + var ret = clone + ret.upper + return ret + end + + redef fun to_lower do + var ret = clone + ret.lower + return ret + end + + redef fun to_snake_case do + var ret = clone + ret.snake_case + return ret + end + + # Takes a camel case `self` and converts it to snake case + # + # SEE: `to_snake_case` + fun snake_case do + if self.is_lower then return + var prev_is_lower = false + var prev_is_upper = false + + var i = 0 + while i < length do + var char = chars[i] + if char.is_lower then + prev_is_lower = true + prev_is_upper = false + else if char.is_upper then + if prev_is_lower then + insert_char('_', i) + i += 1 + else if prev_is_upper and i + 1 < length and self[i + 1].is_lower then + insert_char('_', i) + i += 1 + end + self[i] = char.to_lower + prev_is_lower = false + prev_is_upper = true + else + prev_is_lower = false + prev_is_upper = false + end + i += 1 + end + end + + redef fun to_camel_case + do + var new_str = clone + new_str.camel_case + return new_str + end + + # Takes a snake case `self` and converts it to camel case + # + # SEE: `to_camel_case` + fun camel_case do + if is_upper then return + + var underscore_count = 0 + + var pos = 1 + while pos < length do + var char = self[pos] + if char == '_' then + underscore_count += 1 + else if underscore_count > 0 then + pos -= underscore_count + remove_at(pos, underscore_count) + self[pos] = char.to_upper + underscore_count = 0 + end pos += 1 end + if underscore_count > 0 then remove_at(pos - underscore_count - 1, underscore_count) + end + + redef fun capitalized(keep_upper) do + if length == 0 then return self + + var buf = new Buffer.with_cap(byte_length) + buf.capitalize(keep_upper=keep_upper, src=self) + return buf end end @@ -1574,8 +1742,8 @@ redef class Object # User readable representation of `self`. fun to_s: String do return inspect - # The class name of the object in NativeString format. - private fun native_class_name: NativeString is intern + # The class name of the object in CString format. + private fun native_class_name: CString is intern # The class name of the object. # @@ -1611,13 +1779,13 @@ redef class Bool end redef class Byte - # C function to calculate the length of the `NativeString` to receive `self` + # C function to calculate the length of the `CString` to receive `self` private fun byte_to_s_len: Int `{ return snprintf(NULL, 0, "0x%02x", self); `} - # C function to convert an nit Int to a NativeString (char*) - private fun native_byte_to_s(nstr: NativeString, strlen: Int) `{ + # C function to convert an nit Int to a CString (char*) + private fun native_byte_to_s(nstr: CString, strlen: Int) `{ snprintf(nstr, strlen, "0x%02x", self); `} @@ -1627,7 +1795,7 @@ redef class Byte # assert (-123).to_b.to_s == "0x85" redef fun to_s do var nslen = byte_to_s_len - var ns = new NativeString(nslen + 1) + var ns = new CString(nslen + 1) ns[nslen] = 0u8 native_byte_to_s(ns, nslen + 1) return ns.to_s_unsafe(nslen) @@ -1637,7 +1805,7 @@ end redef class Int # Wrapper of strerror C function - private fun strerror_ext: NativeString `{ return strerror((int)self); `} + private fun strerror_ext: CString `{ return strerror((int)self); `} # Returns a string describing error number fun strerror: String do return strerror_ext.to_s @@ -1666,13 +1834,13 @@ redef class Int end end - # C function to calculate the length of the `NativeString` to receive `self` + # C function to calculate the length of the `CString` to receive `self` private fun int_to_s_len: Int `{ return snprintf(NULL, 0, "%ld", self); `} - # C function to convert an nit Int to a NativeString (char*) - private fun native_int_to_s(nstr: NativeString, strlen: Int) `{ + # C function to convert an nit Int to a CString (char*) + private fun native_int_to_s(nstr: CString, strlen: Int) `{ snprintf(nstr, strlen, "%ld", self); `} @@ -1817,7 +1985,7 @@ redef class Char # assert 'x'.to_s == "x" redef fun to_s do var ln = u8char_len - var ns = new NativeString(ln + 1) + var ns = new CString(ln + 1) u8char_tos(ns, ln) return ns.to_s_unsafe(ln) end @@ -1862,7 +2030,7 @@ redef class Char return buf.to_s end - private fun u8char_tos(r: NativeString, len: Int) `{ + private fun u8char_tos(r: CString, len: Int) `{ r[len] = '\0'; switch(len){ case 1: @@ -2066,7 +2234,7 @@ redef class Sys private fun native_argc: Int is intern # Second argument of the main C function. - private fun native_argv(i: Int): NativeString is intern + private fun native_argv(i: Int): CString is intern end # Comparator that efficienlty use `to_s` to compare things @@ -2102,7 +2270,12 @@ end # see `alpha_comparator` private class AlphaComparator super Comparator - redef fun compare(a, b) do return a.to_s <=> b.to_s + redef fun compare(a, b) do + if a == b then return 0 + if a == null then return -1 + if b == null then return 1 + return a.to_s <=> b.to_s + end end # Stateless comparator that naively use `to_s` to compare things. @@ -2121,7 +2294,7 @@ do return sys.program_args end -redef class NativeString +redef class CString # Get a `String` from the data at `self` copied into Nit memory # # Require: `self` is a null-terminated string. @@ -2148,7 +2321,7 @@ redef class NativeString # use only when the data has already been verified as valid UTF-8. fun to_s_unsafe(length: nullable Int): String is abstract - # Get a `String` from the raw `bytelen` bytes at `self` with `unilen` Unicode characters + # Get a `String` from the raw `byte_length` bytes at `self` with `unilen` Unicode characters # # The created `String` points to the data at `self`. # This method should be used when `self` was allocated by the Nit GC, @@ -2158,13 +2331,13 @@ redef class NativeString # use only when the data has already been verified as valid UTF-8. # # SEE: `abstract_text::Text` for more info on the difference - # between `Text::bytelen` and `Text::length`. - fun to_s_full(bytelen, unilen: Int): String is abstract + # between `Text::byte_length` and `Text::length`. + fun to_s_full(byte_length, unilen: Int): String is abstract # Copies the content of `src` to `self` # - # NOTE: `self` must be large enough to withold `self.bytelen` bytes - fun fill_from(src: Text) do src.copy_to_native(self, src.bytelen, 0, 0) + # NOTE: `self` must be large enough to withold `self.byte_length` bytes + fun fill_from(src: Text) do src.copy_to_native(self, src.byte_length, 0, 0) end redef class NativeArray[E]