X-Git-Url: http://nitlanguage.org diff --git a/lib/standard/string.nit b/lib/standard/string.nit index e5a1581..2c46179 100644 --- a/lib/standard/string.nit +++ b/lib/standard/string.nit @@ -30,7 +30,6 @@ intrude import collection::array # High-level abstraction for all text representations abstract class Text super Comparable - super StringCapable redef type OTHER: Text @@ -181,8 +180,25 @@ abstract class Text # # assert "abcd".has_substring("bc",1) == true # assert "abcd".has_substring("bc",2) == false + # + # Returns true iff all characters of `str` are presents + # at the expected index in `self.` + # The first character of `str` being at `pos`, the second + # character being at `pos+1` and so on... + # + # This means that all characters of `str` need to be inside `self`. + # + # assert "abcd".has_substring("xab", -1) == false + # assert "abcd".has_substring("cdx", 2) == false + # + # And that the empty string is always a valid substring. + # + # assert "abcd".has_substring("", 2) == true + # assert "abcd".has_substring("", 200) == true fun has_substring(str: String, pos: Int): Bool do + if str.is_empty then return true + if pos < 0 or pos + str.length > length then return false var myiter = self.chars.iterator_from(pos) var itsiter = str.chars.iterator while myiter.is_ok and itsiter.is_ok do @@ -369,6 +385,40 @@ abstract class Text # assert "\na\nb\tc\t".trim == "a\nb\tc" fun trim: SELFTYPE do return (self.l_trim).r_trim + # Returns `self` removed from its last line terminator (if any). + # + # assert "Hello\n".chomp == "Hello" + # assert "Hello".chomp == "Hello" + # + # assert "\n".chomp == "" + # assert "".chomp == "" + # + # Line terminators are `"\n"`, `"\r\n"` and `"\r"`. + # A single line terminator, the last one, is removed. + # + # assert "\r\n".chomp == "" + # assert "\r\n\n".chomp == "\r\n" + # assert "\r\n\r\n".chomp == "\r\n" + # assert "\r\n\r".chomp == "\r\n" + # + # Note: unlike with most IO methods like `IStream::read_line`, + # a single `\r` is considered here to be a line terminator and will be removed. + fun chomp: SELFTYPE + do + var len = length + if len == 0 then return self + var l = self.chars.last + if l == '\r' then + return substring(0, len-1) + else if l != '\n' then + return self + else if len > 1 and self.chars[len-2] == '\r' then + return substring(0, len-2) + else + return substring(0, len-1) + end + end + # Justify a self in a space of `length` # # `left` is the space ratio on the left side. @@ -376,6 +426,8 @@ abstract class Text # * 1.0 for right-justified (all spaces at the left) # * 0.5 for centered (half the spaces at the left) # + # Examples + # # assert "hello".justify(10, 0.0) == "hello " # assert "hello".justify(10, 1.0) == " hello" # assert "hello".justify(10, 0.5) == " hello " @@ -384,9 +436,9 @@ abstract class Text # # assert "hello".justify(2, 0.0) == "hello" # - # REQUIRE: left >= 0.0 and left <= 1.0 + # REQUIRE: `left >= 0.0 and left <= 1.0` # ENSURE: `self.length <= length implies result.length == length` - # ENSURE: `self.length >= length implies result == self + # ENSURE: `self.length >= length implies result == self` fun justify(length: Int, left: Float): SELFTYPE do var diff = length - self.length @@ -396,13 +448,39 @@ abstract class Text return " " * before + self + " " * (diff-before) end - # Mangle a string to be a unique string only made of alphanumeric characters + # Mangle a string to be a unique string only made of alphanumeric characters and underscores. + # + # This method is injective (two different inputs never produce the same + # output) and the returned string always respect the following rules: + # + # * Contains only US-ASCII letters, digits and underscores. + # * Never starts with a digit. + # * Never ends with an underscore. + # * Never contains two contiguous underscores. + # + # assert "42_is/The answer!".to_cmangle == "_52d2_is_47dThe_32danswer_33d" + # assert "__".to_cmangle == "_95d_95d" + # assert "__d".to_cmangle == "_95d_d" + # assert "_d_".to_cmangle == "_d_95d" + # assert "_42".to_cmangle == "_95d42" + # assert "foo".to_cmangle == "foo" + # assert "".to_cmangle == "" fun to_cmangle: String do + if is_empty then return "" var res = new FlatBuffer var underscore = false - for i in [0..length[ do - var c = chars[i] + var start = 0 + var c = chars[0] + + if c >= '0' and c <= '9' then + res.add('_') + res.append(c.ascii.to_s) + res.add('d') + start = 1 + end + for i in [start..length[ do + c = chars[i] if (c >= 'a' and c <= 'z') or (c >='A' and c <= 'Z') then res.add(c) underscore = false @@ -425,6 +503,10 @@ abstract class Text underscore = false end end + if underscore then + res.append('_'.ascii.to_s) + res.add('d') + end return res.to_s end @@ -477,6 +559,50 @@ abstract class Text # assert "\n\"'\\\{\}".escape_to_nit == "\\n\\\"\\'\\\\\\\{\\\}" fun escape_to_nit: String do return escape_more_to_c("\{\}") + # Escape to POSIX Shell (sh). + # + # Abort if the text contains a null byte. + # + # assert "\n\"'\\\{\}0".escape_to_sh == "'\n\"'\\''\\\{\}0'" + fun escape_to_sh: String do + var b = new FlatBuffer + b.chars.add '\'' + for i in [0..length[ do + var c = chars[i] + if c == '\'' then + b.append("'\\''") + else + assert without_null_byte: c != '\0' + b.add(c) + end + end + b.chars.add '\'' + return b.to_s + end + + # Escape to include in a Makefile + # + # Unfortunately, some characters are not escapable in Makefile. + # These characters are `;`, `|`, `\`, and the non-printable ones. + # They will be rendered as `"?{hex}"`. + fun escape_to_mk: String do + var b = new FlatBuffer + for i in [0..length[ do + var c = chars[i] + if c == '$' then + b.append("$$") + else if c == ':' or c == ' ' or c == '#' then + b.add('\\') + b.add(c) + else if c.ascii < 32 or c == ';' or c == '|' or c == '\\' or c == '=' then + b.append("?{c.ascii.to_base(16, false)}") + else + b.add(c) + end + end + return b.to_s + end + # Return a string where Nit escape sequences are transformed. # # var s = "\\n" @@ -580,9 +706,11 @@ abstract class Text return buf.to_s end - # Escape the four characters `<`, `>`, `&`, and `"` with their html counterpart + # Escape the characters `<`, `>`, `&`, `"`, `'` and `/` as HTML/XML entity references. # - # assert "a&b->\"x\"".html_escape == "a&b->"x"" + # assert "a&b-<>\"x\"/'".html_escape == "a&b-<>"x"/'" + # + # SEE: fun html_escape: SELFTYPE do var buf = new FlatBuffer @@ -596,7 +724,11 @@ abstract class Text else if c == '>' then buf.append ">" else if c == '"' then - buf.append """ + buf.append """ + else if c == '\'' then + buf.append "'" + else if c == '/' then + buf.append "/" else buf.add c end @@ -697,8 +829,6 @@ abstract class FlatText redef var length: Int = 0 - init do end - redef fun output do var i = 0 @@ -718,12 +848,7 @@ private abstract class StringCharView type SELFTYPE: Text - private var target: SELFTYPE - - private init(tgt: SELFTYPE) - do - target = tgt - end + var target: SELFTYPE redef fun is_empty do return target.is_empty @@ -744,6 +869,11 @@ private abstract class BufferCharView end +# A `String` holds and manipulates an arbitrary sequence of characters. +# +# String objects may be created using literals. +# +# assert "Hello World!" isa String abstract class String super Text @@ -764,8 +894,13 @@ abstract class String # 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: Iterator[String] is abstract + # Returns a reversed version of self # # assert "hello".reversed == "olleh" @@ -865,9 +1000,9 @@ abstract class String # # 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 "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 @@ -896,8 +1031,6 @@ private class FlatSubstringsIter var tgt: nullable FlatText - init(tgt: FlatText) do self.tgt = tgt - redef fun item do assert is_ok return tgt.as(not null) @@ -936,7 +1069,7 @@ class FlatString redef fun reversed do - var native = calloc_string(self.length + 1) + var native = new NativeString(self.length + 1) var length = self.length var items = self.items var pos = 0 @@ -959,22 +1092,26 @@ class FlatString from = 0 end - var realFrom = index_from + from + var new_from = index_from + from - if (realFrom + count) > index_to then return new FlatString.with_infos(items, index_to - realFrom + 1, realFrom, index_to) + if (new_from + count) > index_to then + var new_len = index_to - new_from + 1 + if new_len <= 0 then return empty + return new FlatString.with_infos(items, new_len, new_from, index_to) + end - if count == 0 then return empty + if count <= 0 then return empty - var to = realFrom + count - 1 + var to = new_from + count - 1 - return new FlatString.with_infos(items, to - realFrom + 1, realFrom, to) + return new FlatString.with_infos(items, to - new_from + 1, new_from, to) end redef fun empty do return "".as(FlatString) redef fun to_upper do - var outstr = calloc_string(self.length + 1) + var outstr = new NativeString(self.length + 1) var out_index = 0 var myitems = self.items @@ -994,7 +1131,7 @@ class FlatString redef fun to_lower do - var outstr = calloc_string(self.length + 1) + var outstr = new NativeString(self.length + 1) var out_index = 0 var myitems = self.items @@ -1039,7 +1176,7 @@ class FlatString if real_items != null then return real_items.as(not null) else - var newItems = calloc_string(length + 1) + var newItems = new NativeString(length + 1) self.items.copy_to(newItems, length, index_from, 0) newItems[length] = '\0' self.real_items = newItems @@ -1117,7 +1254,7 @@ class FlatString var total_length = my_length + its_length - var target_string = calloc_string(my_length + its_length + 1) + var target_string = new NativeString(my_length + its_length + 1) self.items.copy_to(target_string, my_length, index_from, 0) if s isa FlatString then @@ -1148,7 +1285,7 @@ class FlatString var my_items = self.items - var target_string = calloc_string((final_length) + 1) + var target_string = new NativeString(final_length + 1) target_string[final_length] = '\0' @@ -1258,6 +1395,7 @@ private class FlatStringCharView end +# A mutable sequence of characters. abstract class Buffer super Text @@ -1343,20 +1481,20 @@ abstract class Buffer # # 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" + # 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 + var prev = c for i in [1 .. length[ do prev = c c = self[i] @@ -1446,7 +1584,7 @@ class FlatBuffer # 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) + var a = new NativeString(c+1) if length > 0 then items.copy_to(a, length, 0, 0) items = a capacity = c @@ -1462,7 +1600,7 @@ class FlatBuffer redef fun to_cstring do if is_dirty then - var new_native = calloc_string(length + 1) + var new_native = new NativeString(length + 1) new_native[length] = '\0' if length > 0 then items.copy_to(new_native, length, 0, 0) real_items = new_native @@ -1474,11 +1612,12 @@ class FlatBuffer # Create a new empty string. init do end + # Create a new string copied from `s`. init from(s: Text) do capacity = s.length + 1 length = s.length - items = calloc_string(capacity) + items = new NativeString(capacity) if s isa FlatString then s.items.copy_to(items, length, s.index_from, 0) else if s isa FlatBuffer then @@ -1498,7 +1637,7 @@ class FlatBuffer do assert cap >= 0 # _items = new NativeString.calloc(cap) - items = calloc_string(cap+1) + items = new NativeString(cap+1) capacity = cap length = 0 end @@ -1555,7 +1694,7 @@ class FlatBuffer redef fun reverse do written = false - var ns = calloc_string(capacity) + var ns = new NativeString(capacity) var si = length - 1 var ni = 0 var it = items @@ -1626,7 +1765,6 @@ end private class FlatBufferCharView super BufferCharView - super StringCapable redef type SELFTYPE: FlatBuffer @@ -1659,7 +1797,6 @@ private class FlatBufferCharView redef fun append(s) do - var my_items = target.items var s_length = s.length if target.capacity < s.length then enlarge(s_length + target.length) end @@ -1709,7 +1846,7 @@ redef class Object # The class name of the object. # - # assert 5.class_name == "Int" + # assert 5.class_name == "Int" fun class_name: String do return native_class_name.to_s # Developer readable representation of `self`. @@ -1904,10 +2041,10 @@ redef class Char # 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 + # assert '0'.is_numeric + # assert '9'.is_numeric + # assert not 'a'.is_numeric + # assert not '?'.is_numeric fun is_numeric: Bool do return self >= '0' and self <= '9' @@ -1915,10 +2052,10 @@ redef class Char # 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 + # assert 'a'.is_alpha + # assert 'Z'.is_alpha + # assert not '0'.is_alpha + # assert not '?'.is_alpha fun is_alpha: Bool do return (self >= 'a' and self <= 'z') or (self >= 'A' and self <= 'Z') @@ -1926,11 +2063,11 @@ redef class Char # 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 + # 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 return self.is_numeric or self.is_alpha @@ -2041,7 +2178,7 @@ redef class Map[K,V] var i = iterator var k = i.key var e = i.item - s.append("{k}{couple_sep}{e or else ""}") + s.append("{k or else ""}{couple_sep}{e or else ""}") # Concat other items i.next @@ -2049,7 +2186,7 @@ redef class Map[K,V] s.append(sep) k = i.key e = i.item - s.append("{k}{couple_sep}{e or else ""}") + s.append("{k or else ""}{couple_sep}{e or else ""}") i.next end return s.to_s @@ -2062,11 +2199,16 @@ end # Native strings are simple C char * extern class NativeString `{ char* `} - super StringCapable # Creates a new NativeString with a capacity of `length` new(length: Int) is intern + + # Get char at `index`. fun [](index: Int): Char is intern + + # Set char `item` at index. fun []=(index: Int, item: Char) is intern + + # Copy `self` to `dest`. fun copy_to(dest: NativeString, length: Int, from: Int, to: Int) is intern # Position of the first nul character. @@ -2076,7 +2218,11 @@ extern class NativeString `{ char* `} while self[l] != '\0' do l += 1 return l end + + # Parse `self` as an Int. fun atoi: Int is intern + + # Parse `self` as a Float. fun atof: Float is extern "atof" redef fun to_s @@ -2084,30 +2230,27 @@ extern class NativeString `{ char* `} return to_s_with_length(cstring_length) end + # Returns `self` as a String of `length`. fun to_s_with_length(length: Int): FlatString do assert length >= 0 var str = new FlatString.with_infos(self, length, 0, length - 1) - str.real_items = self return str end + # Returns `self` as a new String. fun to_s_with_copy: FlatString do var length = cstring_length - var new_self = calloc_string(length + 1) + var new_self = new NativeString(length + 1) copy_to(new_self, length, 0, 0) var str = new FlatString.with_infos(new_self, length, 0, length - 1) - str.real_items = self + new_self[length] = '\0' + str.real_items = new_self return str end end -# StringCapable objects can create native strings -interface StringCapable - protected fun calloc_string(size: Int): NativeString is intern -end - redef class Sys private var args_cache: nullable Sequence[String]