X-Git-Url: http://nitlanguage.org diff --git a/lib/standard/string.nit b/lib/standard/string.nit index 11dece3..b20ed23 100644 --- a/lib/standard/string.nit +++ b/lib/standard/string.nit @@ -15,10 +15,12 @@ module string import math -intrude import collection # FIXME should be collection::array +import collection +intrude import collection::array `{ #include +#include `} ############################################################################### @@ -32,16 +34,18 @@ abstract class Text redef type OTHER: Text - # Type of the view on self (.chars) - type SELFVIEW: StringCharView - # Type of self (used for factorization of several methods, ex : substring_from, empty...) type SELFTYPE: Text # Gets a view on the chars of the Text object - fun chars: SELFVIEW is abstract + # + # assert "hello".chars.to_a == ['h', 'e', 'l', 'l', 'o'] + fun chars: SequenceRead[Char] is abstract # Number of characters contained in self. + # + # assert "12345".length == 5 + # assert "".length == 0 fun length: Int is abstract # Create a substring. @@ -56,19 +60,20 @@ abstract class Text # In this case, `from += count` and `count -= from`. fun substring(from: Int, count: Int): SELFTYPE is abstract - # Concatenates `o` to `self` - fun +(o: Text): SELFTYPE is abstract - - # Auto-concatenates self `i` times - fun *(i: Int): SELFTYPE is abstract + # Iterates on the substrings of self if any + fun substrings: Iterator[Text] is abstract # Is the current Text empty (== "") - # assert "".is_empty - # assert not "foo".is_empty + # + # assert "".is_empty + # assert not "foo".is_empty fun is_empty: Bool do return self.length == 0 # Returns an empty Text of the right type - fun empty: SELFTYPE is abstract + # + # This method is used internally to get the right + # implementation of an empty string. + protected fun empty: SELFTYPE is abstract # Gets the first char of the Text # @@ -107,6 +112,7 @@ abstract class Text var iter = self.chars.iterator_from(pos) while iter.is_ok do if iter.item == c then return iter.index + iter.next end return -1 end @@ -125,9 +131,10 @@ abstract class Text fun to_cstring: NativeString do return flatten.to_cstring # The index of the last occurrence of an element starting from pos (in reverse order). - # Example : - # assert "/etc/bin/test/test.nit".last_index_of_from('/', length-1) == 13 - # assert "/etc/bin/test/test.nit".last_index_of_from('/', 12) == 8 + # + # var s = "/etc/bin/test/test.nit" + # assert s.last_index_of_from('/', s.length-1) == 13 + # assert s.last_index_of_from('/', 12) == 8 # # Returns -1 if not found # @@ -150,13 +157,6 @@ abstract class Text return self.chars.iterator end - # Is 'c' contained in self ? - # - # DEPRECATED : Use self.chars.has instead - fun has(c: Char): Bool - do - return self.chars.has(c) - end # Gets an Array containing the chars of self # @@ -172,14 +172,11 @@ abstract class Text # As with substring, a `from` index < 0 will be replaced by 0 fun substring_from(from: Int): SELFTYPE do - if from > self.length then return empty + if from >= self.length then return empty if from < 0 then from = 0 return substring(from, length - from) end - # Returns a reversed version of self - fun reversed: SELFTYPE is abstract - # Does self have a substring `str` starting from position `pos`? # # assert "abcd".has_substring("bc",1) == true @@ -187,7 +184,7 @@ abstract class Text fun has_substring(str: String, pos: Int): Bool do var myiter = self.chars.iterator_from(pos) - var itsiter = str.iterator + var itsiter = str.chars.iterator while myiter.is_ok and itsiter.is_ok do if myiter.item != itsiter.item then return false myiter.next @@ -232,6 +229,8 @@ abstract class Text end # If `self` contains only digits and alpha <= 'f', return the corresponding integer. + # + # assert "ff".to_hex == 255 fun to_hex: Int do return a_to(16) # If `self` contains only digits and letters, return the corresponding integer in a given base @@ -242,8 +241,8 @@ abstract class Text var i = 0 var neg = false - for c in self.chars - do + for j in [0..length[ do + var c = chars[j] var v = c.to_i if v > base then if neg then @@ -273,12 +272,10 @@ abstract class Text fun is_numeric: Bool do var has_point_or_comma = false - for i in self.chars - do - if not i.is_numeric - then - if (i == '.' or i == ',') and not has_point_or_comma - then + for i in [0..length[ do + var c = chars[i] + if not c.is_numeric then + if (c == '.' or c == ',') and not has_point_or_comma then has_point_or_comma = true else return false @@ -288,17 +285,56 @@ abstract class Text return true end - # A upper case version of `self` + # Returns `true` if the string contains only Hex chars # - # assert "Hello World!".to_upper == "HELLO WORLD!" - fun to_upper: SELFTYPE is abstract + # assert "048bf".is_hex == true + # assert "ABCDEF".is_hex == true + # assert "0G".is_hex == false + fun is_hex: Bool + do + for i in [0..length[ do + var c = chars[i] + if not (c >= 'a' and c <= 'f') and + not (c >= 'A' and c <= 'F') and + not (c >= '0' and c <= '9') then return false + end + return true + end - # A lower case version of `self` + # Are all letters in `self` upper-case ? # - # assert "Hello World!".to_lower == "hello world!" - fun to_lower : SELFTYPE is abstract + # assert "HELLO WORLD".is_upper == true + # assert "%$&%!".is_upper == true + # assert "hello world".is_upper == false + # assert "Hello World".is_upper == false + fun is_upper: Bool + do + for i in [0..length[ do + var char = chars[i] + if char.is_lower then return false + end + return true + end + # Are all letters in `self` lower-case ? + # + # assert "hello world".is_lower == true + # assert "%$&%!".is_lower == true + # assert "Hello World".is_lower == false + fun is_lower: Bool + do + for i in [0..length[ do + var char = chars[i] + if char.is_upper then return false + end + return true + end + # Removes the whitespaces at the beginning of self + # + # assert " \n\thello \n\t".l_trim == "hello \n\t" + # + # A whitespace is defined as any character which ascii value is less than or equal to 32 fun l_trim: SELFTYPE do var iter = self.chars.iterator @@ -311,6 +347,10 @@ abstract class Text end # Removes the whitespaces at the end of self + # + # assert " \n\thello \n\t".r_trim == " \n\thello" + # + # A whitespace is defined as any character which ascii value is less than or equal to 32 fun r_trim: SELFTYPE do var iter = self.chars.reverse_iterator @@ -318,7 +358,7 @@ abstract class Text if iter.item.ascii > 32 then break iter.next end - if iter.index == length then return self.empty + if iter.index < 0 then return self.empty return self.substring(0, iter.index + 1) end @@ -334,7 +374,8 @@ abstract class Text do var res = new FlatBuffer var underscore = false - for c in self.chars do + for i in [0..length[ do + var c = chars[i] if (c >= 'a' and c <= 'z') or (c >='A' and c <= 'Z') then res.add(c) underscore = false @@ -367,7 +408,8 @@ abstract class Text fun escape_to_c: String do var b = new FlatBuffer - for c in self.chars do + for i in [0..length[ do + var c = chars[i] if c == '\n' then b.append("\\n") else if c == '\0' then @@ -394,7 +436,7 @@ abstract class Text fun escape_more_to_c(chars: String): String do var b = new FlatBuffer - for c in escape_to_c do + for c in escape_to_c.chars do if chars.chars.has(c) then b.add('\\') end @@ -403,24 +445,24 @@ abstract class Text return b.to_s end - # Escape to c plus braces + # Escape to C plus braces # # assert "\n\"'\\\{\}".escape_to_nit == "\\n\\\"\\'\\\\\\\{\\\}" fun escape_to_nit: String do return escape_more_to_c("\{\}") # Return a string where Nit escape sequences are transformed. # - # Example: # var s = "\\n" # assert s.length == 2 # var u = s.unescape_nit # assert u.length == 1 - # assert u[0].ascii == 10 # (the ASCII value of the "new line" character) + # assert u.chars[0].ascii == 10 # (the ASCII value of the "new line" character) fun unescape_nit: String do var res = new FlatBuffer.with_capacity(self.length) var was_slash = false - for c in self do + for i in [0..length[ do + var c = chars[i] if not was_slash then if c == '\\' then was_slash = true @@ -445,6 +487,111 @@ abstract class Text return res.to_s end + # Encode `self` to percent (or URL) encoding + # + # assert "aBc09-._~".to_percent_encoding == "aBc09-._~" + # assert "%()< >".to_percent_encoding == "%25%28%29%3c%20%3e" + # assert ".com/post?e=asdf&f=123".to_percent_encoding == ".com%2fpost%3fe%3dasdf%26f%3d123" + fun to_percent_encoding: String + do + var buf = new FlatBuffer + + for i in [0..length[ do + var c = chars[i] + if (c >= '0' and c <= '9') or + (c >= 'a' and c <= 'z') or + (c >= 'A' and c <= 'Z') or + c == '-' or c == '.' or + c == '_' or c == '~' + then + buf.add c + else buf.append "%{c.ascii.to_hex}" + end + + return buf.to_s + end + + # Decode `self` from percent (or URL) encoding to a clear string + # + # Replace invalid use of '%' with '?'. + # + # assert "aBc09-._~".from_percent_encoding == "aBc09-._~" + # assert "%25%28%29%3c%20%3e".from_percent_encoding == "%()< >" + # assert ".com%2fpost%3fe%3dasdf%26f%3d123".from_percent_encoding == ".com/post?e=asdf&f=123" + # assert "%25%28%29%3C%20%3E".from_percent_encoding == "%()< >" + # assert "incomplete %".from_percent_encoding == "incomplete ?" + # assert "invalid % usage".from_percent_encoding == "invalid ? usage" + fun from_percent_encoding: String + do + var buf = new FlatBuffer + + var i = 0 + while i < length do + var c = chars[i] + if c == '%' then + if i + 2 >= length then + # What follows % has been cut off + buf.add '?' + else + i += 1 + var hex_s = substring(i, 2) + if hex_s.is_hex then + var hex_i = hex_s.to_hex + buf.add hex_i.ascii + i += 1 + else + # What follows a % is not Hex + buf.add '?' + i -= 1 + end + end + else buf.add c + + i += 1 + end + + return buf.to_s + end + + # Escape the four characters `<`, `>`, `&`, and `"` with their html counterpart + # + # assert "a&b->\"x\"".html_escape == "a&b->"x"" + fun html_escape: SELFTYPE + do + var buf = new FlatBuffer + + for i in [0..length[ do + var c = chars[i] + if c == '&' then + buf.append "&" + else if c == '<' then + buf.append "<" + else if c == '>' then + buf.append ">" + else if c == '"' then + buf.append """ + else buf.add c + end + + return buf.to_s + end + + # Equality of text + # Two pieces of text are equals if thez have the same characters in the same order. + # + # assert "hello" == "hello" + # assert "hello" != "HELLO" + # assert "hello" == "hel"+"lo" + # + # Things that are not Text are not equal. + # + # assert "9" != '9' + # assert "9" != ['9'] + # assert "9" != 9 + # + # assert "9".chars.first == '9' # equality of Char + # assert "9".chars == ['9'] # equality of Sequence + # assert "9".to_i == 9 # equality of Int redef fun ==(o) do if o == null then return false @@ -454,23 +601,74 @@ abstract class Text return self.chars == o.chars end - redef fun <(o) + # Lexicographical comparaison + # + # assert "abc" < "xy" + # assert "ABC" < "abc" + redef fun <(other) do - return self.chars < o.chars + var self_chars = self.chars.iterator + var other_chars = other.chars.iterator + + while self_chars.is_ok and other_chars.is_ok do + if self_chars.item < other_chars.item then return true + if self_chars.item > other_chars.item then return false + self_chars.next + other_chars.next + end + + if self_chars.is_ok then + return false + else + return true + end + end + + # Escape string used in labels for graphviz + # + # assert ">><<".escape_to_dot == "\\>\\>\\<\\<" + fun escape_to_dot: String + do + return escape_more_to_c("|\{\}<>") end # Flat representation of self fun flatten: FlatText is abstract + private var hash_cache: nullable Int = null + + redef fun hash + do + if hash_cache == null then + # djb2 hash algorithm + var h = 5381 + + for i in [0..length[ do + var char = chars[i] + h = h.lshift(5) + h + char.ascii + end + + hash_cache = h + end + return hash_cache.as(not null) + end + end # All kinds of array-based text representations. abstract class FlatText super Text - private var items: NativeString + # Underlying C-String (`char*`) + # + # Warning : Might be void in some subclasses, be sure to check + # if set before using it. + private var items: NativeString is noinit + + # Real items, used as cache for to_cstring is called + private var real_items: nullable NativeString = null - redef var length: Int + redef var length: Int = 0 init do end @@ -488,14 +686,11 @@ end # Abstract class for the SequenceRead compatible # views on String and Buffer objects -abstract class StringCharView +private abstract class StringCharView super SequenceRead[Char] - super Comparable type SELFTYPE: Text - redef type OTHER: StringCharView - private var target: SELFTYPE private init(tgt: SELFTYPE) @@ -509,99 +704,183 @@ abstract class StringCharView redef fun iterator: IndexedIterator[Char] do return self.iterator_from(0) - # Gets a new Iterator starting at position `pos` - # - # Ex : - # var iter = "abcd".iterator_from(2) - # while iter.is_ok do - # printn iter.item - # iter.next - # end + redef fun reverse_iterator do return self.reverse_iterator_from(self.length - 1) +end + +# View on Buffer objects, extends Sequence +# for mutation operations +private abstract class BufferCharView + super StringCharView + super Sequence[Char] + + redef type SELFTYPE: Buffer + +end + +abstract class String + super Text + + redef type SELFTYPE: String + + redef fun to_s do return self + + # Concatenates `o` to `self` # - # Outputs : cd - fun iterator_from(pos: Int): IndexedIterator[Char] is abstract + # assert "hello" + "world" == "helloworld" + # assert "" + "hello" + "" == "hello" + fun +(o: Text): SELFTYPE is abstract - # Gets an iterator starting at the end and going backwards + # Concatenates self `i` times # - # Ex : - # var reviter = "now step live...".reverse_iterator - # while reviter.is_ok do - # printn reviter.item - # reviter.next - # end + # assert "abc" * 4 == "abcabcabcabc" + # assert "abc" * 1 == "abc" + # assert "abc" * 0 == "" + fun *(i: Int): SELFTYPE is abstract + + fun insert_at(s: String, pos: Int): SELFTYPE is abstract + + redef fun substrings: Iterator[String] is abstract + + # Returns a reversed version of self # - # Outputs : ...evil pets won - fun reverse_iterator: IndexedIterator[Char] do return self.reverse_iterator_from(self.length - 1) + # assert "hello".reversed == "olleh" + # assert "bob".reversed == "bob" + # assert "".reversed == "" + fun reversed: SELFTYPE is abstract - # Gets an iterator on the chars of self starting from `pos` + # A upper case version of `self` # - # Ex : - # var iter = "abcd".reverse_iterator_from(1) - # while iter.is_ok do - # printn iter.item - # iter.next - # end + # assert "Hello World!".to_upper == "HELLO WORLD!" + fun to_upper: SELFTYPE is abstract + + # A lower case version of `self` # - # Outputs : ba - fun reverse_iterator_from(pos: Int): IndexedIterator[Char] is abstract + # assert "Hello World!".to_lower == "hello world!" + fun to_lower : SELFTYPE is abstract - redef fun has(c: Char): Bool - do - for i in self do - if i == c then return true + # Takes a camel case `self` and converts it to snake case + # + # assert "randomMethodId".to_snake_case == "random_method_id" + # + # If `self` is upper, it is returned unchanged + # + # assert "RANDOM_METHOD_ID".to_snake_case == "RANDOM_METHOD_ID" + # + # If the identifier is prefixed by an underscore, the underscore is ignored + # + # assert "_privateField".to_snake_case == "_private_field" + fun to_snake_case: SELFTYPE + do + if self.is_upper then return self + + var new_str = new FlatBuffer.with_capacity(self.length) + var is_first_char = true + + for i in [0..length[ do + var char = chars[i] + if is_first_char then + new_str.add(char.to_lower) + is_first_char = false + else if char.is_upper then + new_str.add('_') + new_str.add(char.to_lower) + else + new_str.add(char) + end end - return false + + return new_str.to_s end - redef fun ==(other) - do - if other == null then return false - if not other isa StringCharView then return false - var other_chars = other.iterator - for i in self do - if i != other_chars.item then return false - other_chars.next + # 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 + if self.is_upper then return self + + var new_str = new FlatBuffer + 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 - return true - end - redef fun <(other) - do - var self_chars = self.iterator - var other_chars = other.iterator + return new_str.to_s + end - while self_chars.is_ok and other_chars.is_ok do - if self_chars.item < other_chars.item then return true - if self_chars.item > other_chars.item then return false - self_chars.next - other_chars.next + # 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 FlatBuffer.with_capacity(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 - if self_chars.is_ok then - return false - else - return true - end + return buf.to_s end end -# View on Buffer objects, extends Sequence -# for mutation operations -abstract class BufferCharView - super StringCharView - super Sequence[Char] - - redef type SELFTYPE: Buffer +private class FlatSubstringsIter + super Iterator[FlatText] -end + var tgt: nullable FlatText -abstract class String - super Text + init(tgt: FlatText) do self.tgt = tgt - redef type SELFTYPE: String + redef fun item do + assert is_ok + return tgt.as(not null) + end - redef fun to_s do return self + redef fun is_ok do return tgt != null + redef fun next do tgt = null end # Immutable strings of characters. @@ -609,38 +888,38 @@ class FlatString super FlatText super String - redef type SELFTYPE: FlatString - redef type SELFVIEW: FlatStringCharView - # Index in _items of the start of the string - private var index_from: Int + private var index_from: Int is noinit # Indes in _items of the last item of the string - private var index_to: Int + private var index_to: Int is noinit - redef var chars: SELFVIEW = new FlatStringCharView(self) + redef var chars: SequenceRead[Char] = new FlatStringCharView(self) - ################################################ - # AbstractString specific methods # - ################################################ - - redef fun [](index) do - assert index >= 0 + redef fun [](index) + do # Check that the index (+ index_from) is not larger than indexTo # In other terms, if the index is valid + assert index >= 0 assert (index + index_from) <= index_to return items[index + index_from] end + ################################################ + # AbstractString specific methods # + ################################################ + redef fun reversed do var native = calloc_string(self.length + 1) - var reviter = chars.reverse_iterator + var length = self.length + var items = self.items var pos = 0 - while reviter.is_ok do - native[pos] = reviter.item + var ipos = length-1 + while pos < length do + native[pos] = items[ipos] pos += 1 - reviter.next + ipos -= 1 end return native.to_s_with_length(self.length) end @@ -730,16 +1009,17 @@ class FlatString index_to = to end - # Return a null terminated char * redef fun to_cstring: NativeString do - if index_from > 0 or index_to != items.cstring_length - 1 then + if real_items != null then + return real_items.as(not null) + else var newItems = calloc_string(length + 1) self.items.copy_to(newItems, length, index_from, 0) newItems[length] = '\0' + self.real_items = newItems return newItems end - return items end redef fun ==(other) @@ -769,9 +1049,6 @@ class FlatString return true end - # The comparison between two strings is done on a lexicographical basis - # - # assert ("aa" < "b") == true redef fun <(other) do if not other isa FlatString then return super @@ -808,9 +1085,6 @@ class FlatString return my_length < its_length end - # The concatenation of `self` with `s` - # - # assert "hello " + "world!" == "hello world!" redef fun +(s) do var my_length = self.length @@ -827,8 +1101,9 @@ class FlatString s.items.copy_to(target_string, its_length, 0, my_length) else var curr_pos = my_length - for i in s.chars do - target_string[curr_pos] = i + for i in [0..s.length[ do + var c = s.chars[i] + target_string[curr_pos] = c curr_pos += 1 end end @@ -838,9 +1113,6 @@ class FlatString return target_string.to_s_with_length(total_length) end - # assert "abc"*3 == "abcabcabc" - # assert "abc"*1 == "abc" - # assert "abc"*0 == "" redef fun *(i) do assert i >= 0 @@ -867,22 +1139,25 @@ class FlatString redef fun hash do - # djb2 hash algorythm - var h = 5381 - var i = length - 1 + if hash_cache == null then + # djb2 hash algorithm + var h = 5381 + var i = index_from - var myitems = items - var strStart = index_from + var myitems = items - i += strStart + while i <= index_to do + h = h.lshift(5) + h + myitems[i].ascii + i += 1 + end - while i >= strStart do - h = (h * 32) + h + self.items[i].ascii - i -= 1 + hash_cache = h end - return h + return hash_cache.as(not null) end + + redef fun substrings do return new FlatSubstringsIter(self) end private class FlatStringReverseIterator @@ -901,7 +1176,7 @@ private class FlatStringReverseIterator curr_pos = pos + tgt.index_from end - redef fun is_ok do return curr_pos >= 0 + redef fun is_ok do return curr_pos >= target.index_from redef fun item do return target_items[curr_pos] @@ -947,6 +1222,7 @@ private class FlatStringCharView # Check that the index (+ index_from) is not larger than indexTo # In other terms, if the index is valid assert index >= 0 + var target = self.target assert (index + target.index_from) <= target.index_to return target.items[index + target.index_from] end @@ -960,9 +1236,19 @@ end abstract class Buffer super Text - redef type SELFVIEW: BufferCharView redef type SELFTYPE: Buffer + # Specific implementations MUST set this to `true` in order to invalidate caches + protected var is_dirty = true + + # Copy-On-Write flag + # + # If the `Buffer` was to_s'd, the next in-place altering + # operation will cause the current `Buffer` to be re-allocated. + # + # The flag will then be set at `false`. + protected var written = false + # Modifies the char contained at pos `index` # # DEPRECATED : Use self.chars.[]= instead @@ -974,14 +1260,98 @@ abstract class Buffer fun add(c: Char) is abstract # Clears the buffer + # + # var b = new FlatBuffer + # b.append "hello" + # assert not b.is_empty + # b.clear + # assert b.is_empty fun clear is abstract # Enlarges the subsequent array containing the chars of self fun enlarge(cap: Int) is abstract # Adds the content of text `s` at the end of self + # + # var b = new FlatBuffer + # b.append "hello" + # b.append "world" + # assert b == "helloworld" fun append(s: Text) is abstract + # `self` is appended in such a way that `self` is repeated `r` times + # + # var b = new FlatBuffer + # b.append "hello" + # b.times 3 + # assert b == "hellohellohello" + fun times(r: Int) is abstract + + # Reverses itself in-place + # + # var b = new FlatBuffer + # b.append("hello") + # b.reverse + # assert b == "olleh" + fun reverse is abstract + + # Changes each lower-case char in `self` by its upper-case variant + # + # var b = new FlatBuffer + # b.append("Hello World!") + # b.upper + # assert b == "HELLO WORLD!" + fun upper is abstract + + # Changes each upper-case char in `self` by its lower-case variant + # + # var b = new FlatBuffer + # b.append("Hello World!") + # b.lower + # assert b == "hello world!" + fun lower is abstract + + # Capitalizes each word in `self` + # + # Letters that follow a letter are lowercased + # Letters that follow a non-letter are upcased. + # + # SEE: `Char::is_letter` for the definition of a letter. + # + # var b = new FlatBuffer.from("jAVAsCriPt")" + # b.capitalize + # assert b == "Javascript" + # b = new FlatBuffer.from("i am root") + # b.capitalize + # assert b == "I Am Root" + # b = new FlatBuffer.from("ab_c -ab0c ab\nc") + # b.capitalize + # assert b == "Ab_C -Ab0C Ab\nC" + fun capitalize do + if length == 0 then return + var c = self[0].to_upper + self[0] = c + var prev: Char = c + for i in [1 .. length[ do + prev = c + c = self[i] + if prev.is_letter then + self[i] = c.to_lower + 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 end # Mutable strings of characters. @@ -989,31 +1359,57 @@ class FlatBuffer super FlatText super Buffer - redef type SELFVIEW: FlatBufferCharView redef type SELFTYPE: FlatBuffer - redef var chars: SELFVIEW = new FlatBufferCharView(self) + redef var chars: Sequence[Char] = new FlatBufferCharView(self) + + private var capacity: Int = 0 + + redef fun substrings do return new FlatSubstringsIter(self) + + # Re-copies the `NativeString` into a new one and sets it as the new `Buffer` + # + # This happens when an operation modifies the current `Buffer` and + # the Copy-On-Write flag `written` is set at true. + private fun reset do + var nns = new NativeString(capacity) + items.copy_to(nns, length, 0, 0) + items = nns + written = false + end - var capacity: Int + redef fun [](index) + do + assert index >= 0 + assert index < length + return items[index] + end redef fun []=(index, item) do + is_dirty = true if index == length then add(item) return end + if written then reset assert index >= 0 and index < length items[index] = item end redef fun add(c) do + is_dirty = true if capacity <= length then enlarge(length + 5) items[length] = c length += 1 end - redef fun clear do length = 0 + redef fun clear do + is_dirty = true + if written then reset + length = 0 + end redef fun empty do return new FlatBuffer @@ -1022,38 +1418,36 @@ class FlatBuffer var c = capacity if cap <= c then return while c <= cap do c = c * 2 + 2 + # The COW flag can be set at false here, since + # it does a copy of the current `Buffer` + written = false var a = calloc_string(c+1) - items.copy_to(a, length, 0, 0) + if length > 0 then items.copy_to(a, length, 0, 0) items = a capacity = c - items.copy_to(a, length, 0, 0) end redef fun to_s: String do - var l = length - var a = calloc_string(l+1) - items.copy_to(a, l, 0, 0) - - # Ensure the afterlast byte is '\0' to nul-terminated char * - a[length] = '\0' - - return a.to_s_with_length(length) + written = true + if length == 0 then items = new NativeString(1) + return new FlatString.with_infos(items, length, 0, length - 1) end redef fun to_cstring do - var new_native = calloc_string(length + 1) - new_native[length] = '\0' - items.copy_to(new_native, length, 0, 0) - return new_native + if is_dirty then + var new_native = calloc_string(length + 1) + new_native[length] = '\0' + if length > 0 then items.copy_to(new_native, length, 0, 0) + real_items = new_native + is_dirty = false + end + return real_items.as(not null) end # Create a new empty string. - init - do - with_capacity(5) - end + init do end init from(s: Text) do @@ -1066,8 +1460,9 @@ class FlatBuffer s.items.copy_to(items, length, 0, 0) else var curr_pos = 0 - for i in s.chars do - items[curr_pos] = i + for i in [0..s.length[ do + var c = s.chars[i] + items[curr_pos] = c curr_pos += 1 end end @@ -1085,6 +1480,8 @@ class FlatBuffer redef fun append(s) do + if s.is_empty then return + is_dirty = true var sl = s.length if capacity < length + sl then enlarge(length + sl) if s isa FlatString then @@ -1093,8 +1490,9 @@ class FlatBuffer s.items.copy_to(items, sl, 0, length) else var curr_pos = self.length - for i in s.chars do - items[curr_pos] = i + for i in [0..s.length[ do + var c = s.chars[i] + items[curr_pos] = c curr_pos += 1 end end @@ -1129,32 +1527,49 @@ class FlatBuffer end end - redef fun reversed + redef fun reverse do - var new_buf = new FlatBuffer.with_capacity(self.length) - var reviter = self.chars.reverse_iterator - while reviter.is_ok do - new_buf.add(reviter.item) - reviter.next + written = false + var ns = calloc_string(capacity) + var si = length - 1 + var ni = 0 + var it = items + while si >= 0 do + ns[ni] = it[si] + ni += 1 + si -= 1 end - return new_buf + items = ns end - redef fun +(other) + redef fun times(repeats) do - var new_buf = new FlatBuffer.with_capacity(self.length + other.length) - new_buf.append(self) - new_buf.append(other) - return new_buf + var x = new FlatString.with_infos(items, length, 0, length - 1) + for i in [1..repeats[ do + append(x) + end + end + + redef fun upper + do + if written then reset + var it = items + var id = length - 1 + while id >= 0 do + it[id] = it[id].to_upper + id -= 1 + end end - redef fun *(repeats) + redef fun lower do - var new_buf = new FlatBuffer.with_capacity(self.length * repeats) - for i in [0..repeats[ do - new_buf.append(self) + if written then reset + var it = items + var id = length - 1 + while id >= 0 do + it[id] = it[id].to_lower + id -= 1 end - return new_buf end end @@ -1170,7 +1585,7 @@ private class FlatBufferReverseIterator init with_pos(tgt: FlatBuffer, pos: Int) do target = tgt - target_items = tgt.items + if tgt.length > 0 then target_items = tgt.items curr_pos = pos end @@ -1242,7 +1657,7 @@ private class FlatBufferIterator init with_pos(tgt: FlatBuffer, pos: Int) do target = tgt - target_items = tgt.items + if tgt.length > 0 then target_items = tgt.items curr_pos = pos end @@ -1285,11 +1700,6 @@ redef class Object do return "{class_name}:#{object_id.to_hex}" end - - protected fun args: Sequence[String] - do - return sys.args - end end redef class Bool @@ -1306,9 +1716,18 @@ redef class Bool end redef class Int + + # Wrapper of strerror C function + private fun strerror_ext: NativeString is extern `{ + return strerror(recv); + `} + + # Returns a string describing error number + fun strerror: String do return strerror_ext.to_s + # Fill `s` with the digits in base `base` of `self` (and with the '-' sign if 'signed' and negative). # assume < to_c max const of char - fun fill_buffer(s: Buffer, base: Int, signed: Bool) + private fun fill_buffer(s: Buffer, base: Int, signed: Bool) do var n: Int # Sign @@ -1331,18 +1750,20 @@ redef class Int end # C function to convert an nit Int to a NativeString (char*) - private fun native_int_to_s(len: Int): NativeString is extern "native_int_to_s" + private fun native_int_to_s: NativeString is extern "native_int_to_s" # return displayable int in base 10 and signed # # assert 1.to_s == "1" # assert (-123).to_s == "-123" redef fun to_s do - var len = digit_count(10) - return native_int_to_s(len).to_s_with_length(len) + return native_int_to_s.to_s end - # return displayable int in hexadecimal (unsigned (not now)) + # return displayable int in hexadecimal + # + # assert 1.to_hex == "1" + # assert (-255).to_hex == "-ff" fun to_hex: String do return to_base(16,false) # return displayable int in base base and signed @@ -1357,6 +1778,11 @@ end redef class Float # Pretty print self, print needoed decimals up to a max of 3. + # + # assert 12.34.to_s == "12.34" + # assert (-0120.03450).to_s == "-120.035" + # + # see `to_precision` for a different precision. redef fun to_s do var str = to_precision( 3 ) if is_inf != 0 or is_nan then return str @@ -1376,6 +1802,11 @@ redef class Float end # `self` representation with `nb` digits after the '.'. + # + # assert 12.345.to_precision(1) == "12.3" + # assert 12.345.to_precision(2) == "12.35" + # assert 12.345.to_precision(3) == "12.345" + # assert 12.345.to_precision(4) == "12.3450" fun to_precision(nb: Int): String do if is_nan then return "nan" @@ -1408,6 +1839,12 @@ redef class Float end end + # `self` representation with `nb` digits after the '.'. + # + # assert 12.345.to_precision_native(1) == "12.3" + # assert 12.345.to_precision_native(2) == "12.35" + # assert 12.345.to_precision_native(3) == "12.345" + # assert 12.345.to_precision_native(4) == "12.3450" fun to_precision_native(nb: Int): String import NativeString.to_s `{ int size; char *str; @@ -1430,27 +1867,37 @@ redef class Char end # Returns true if the char is a numerical digit + # + # assert '0'.is_numeric + # assert '9'.is_numeric + # assert not 'a'.is_numeric + # assert not '?'.is_numeric fun is_numeric: Bool do - if self >= '0' and self <= '9' - then - return true - end - return false + return self >= '0' and self <= '9' end # Returns true if the char is an alpha digit + # + # assert 'a'.is_alpha + # assert 'Z'.is_alpha + # assert not '0'.is_alpha + # assert not '?'.is_alpha fun is_alpha: Bool do - if (self >= 'a' and self <= 'z') or (self >= 'A' and self <= 'Z') then return true - return false + return (self >= 'a' and self <= 'z') or (self >= 'A' and self <= 'Z') end # Returns true if the char is an alpha or a numeric digit + # + # assert 'a'.is_alphanumeric + # assert 'Z'.is_alphanumeric + # assert '0'.is_alphanumeric + # assert '9'.is_alphanumeric + # assert not '?'.is_alphanumeric fun is_alphanumeric: Bool do - if self.is_numeric or self.is_alpha then return true - return false + return self.is_numeric or self.is_alpha end end @@ -1467,7 +1914,7 @@ redef class Collection[E] # # assert [1, 2, 3].join(":") == "1:2:3" # assert [1..3].join(":") == "1:2:3" - fun join(sep: String): String + fun join(sep: Text): String do if is_empty then return "" @@ -1491,18 +1938,51 @@ redef class Collection[E] end redef class Array[E] + # Fast implementation redef fun to_s do - var s = new FlatBuffer - var i = 0 var l = length + if l == 0 then return "" + if l == 1 then if self[0] == null then return "" else return self[0].to_s + var its = _items + var na = new NativeArray[String](l) + var i = 0 + var sl = 0 + var mypos = 0 while i < l do - var e = self[i] - if e != null then s.append(e.to_s) + var itsi = its[i] + if itsi == null then + i += 1 + continue + end + var tmp = itsi.to_s + sl += tmp.length + na[mypos] = tmp i += 1 + mypos += 1 end - return s.to_s + var ns = new NativeString(sl + 1) + ns[sl] = '\0' + i = 0 + var off = 0 + while i < mypos do + var tmp = na[i] + var tpl = tmp.length + if tmp isa FlatString then + tmp.items.copy_to(ns, tpl, tmp.index_from, off) + off += tpl + else + for j in tmp.substrings do + var s = j.as(FlatString) + var slen = s.length + s.items.copy_to(ns, slen, s.index_from, off) + off += slen + end + end + i += 1 + end + return ns.to_s_with_length(sl) end end @@ -1545,9 +2025,10 @@ end ############################################################################### # Native strings are simple C char * -class NativeString +extern class NativeString `{ char* `} super StringCapable - + # Creates a new NativeString with a capacity of `length` + new(length: Int) is intern fun [](index: Int): Char is intern fun []=(index: Int, item: Char) is intern fun copy_to(dest: NativeString, length: Int, from: Int, to: Int) is intern @@ -1570,7 +2051,8 @@ class NativeString fun to_s_with_length(length: Int): FlatString do assert length >= 0 - return new FlatString.with_infos(self, length, 0, length - 1) + var str = new FlatString.with_infos(self, length, 0, length - 1) + return str end fun to_s_with_copy: FlatString @@ -1578,9 +2060,11 @@ class NativeString var length = cstring_length var new_self = calloc_string(length + 1) copy_to(new_self, length, 0, 0) - return new FlatString.with_infos(new_self, length, 0, length - 1) + var str = new FlatString.with_infos(new_self, length, 0, length - 1) + new_self[length] = '\0' + str.real_items = new_self + return str end - end # StringCapable objects can create native strings @@ -1589,9 +2073,10 @@ interface StringCapable end redef class Sys - var _args_cache: nullable Sequence[String] + private var args_cache: nullable Sequence[String] - redef fun args: Sequence[String] + # The arguments of the program as given by the OS + fun program_args: Sequence[String] do if _args_cache == null then init_args return _args_cache.as(not null) @@ -1603,7 +2088,7 @@ redef class Sys return native_argv(0).to_s end - # Initialize `args` with the contents of `native_argc` and `native_argv`. + # Initialize `program_args` with the contents of `native_argc` and `native_argv`. private fun init_args do var argc = native_argc @@ -1623,3 +2108,54 @@ redef class Sys private fun native_argv(i: Int): NativeString is intern end +# Comparator that efficienlty use `to_s` to compare things +# +# The comparaison call `to_s` on object and use the result to order things. +# +# var a = [1, 2, 3, 10, 20] +# (new CachedAlphaComparator).sort(a) +# assert a == [1, 10, 2, 20, 3] +# +# Internally the result of `to_s` is cached in a HashMap to counter +# uneficient implementation of `to_s`. +# +# Note: it caching is not usefull, see `alpha_comparator` +class CachedAlphaComparator + super Comparator + redef type COMPARED: Object + + private var cache = new HashMap[Object, String] + + private fun do_to_s(a: Object): String do + if cache.has_key(a) then return cache[a] + var res = a.to_s + cache[a] = res + return res + end + + redef fun compare(a, b) do + return do_to_s(a) <=> do_to_s(b) + end +end + +# see `alpha_comparator` +private class AlphaComparator + super Comparator + redef fun compare(a, b) do return a.to_s <=> b.to_s +end + +# Stateless comparator that naively use `to_s` to compare things. +# +# Note: the result of `to_s` is not cached, thus can be invoked a lot +# on a single instace. See `CachedAlphaComparator` as an alternative. +# +# var a = [1, 2, 3, 10, 20] +# alpha_comparator.sort(a) +# assert a == [1, 10, 2, 20, 3] +fun alpha_comparator: Comparator do return once new AlphaComparator + +# The arguments of the program as given by the OS +fun args: Sequence[String] +do + return sys.program_args +end