module string
import math
-intrude import collection # FIXME should be collection::array
+import collection
+intrude import collection::array
`{
#include <stdio.h>
# High-level abstraction for all text representations
abstract class Text
super Comparable
- super StringCapable
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
- var hash_cache: nullable Int = null
-
# 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.
# 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
#
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
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
#
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
#
# 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
# 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.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
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
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
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
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
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
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
# assert "\na\nb\tc\t".trim == "a\nb\tc"
fun trim: SELFTYPE do return (self.l_trim).r_trim
- # Mangle a string to be a unique string only made of alphanumeric characters
+ # 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.
+ # * 0.0 for left-justified (no space at the left)
+ # * 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 "
+ #
+ # If `length` is not enough, `self` is returned as is.
+ #
+ # assert "hello".justify(2, 0.0) == "hello"
+ #
+ # REQUIRE: `left >= 0.0 and left <= 1.0`
+ # ENSURE: `self.length <= length implies result.length == length`
+ # ENSURE: `self.length >= length implies result == self`
+ fun justify(length: Int, left: Float): SELFTYPE
+ do
+ var diff = length - self.length
+ if diff <= 0 then return self
+ assert left >= 0.0 and left <= 1.0
+ var before = (diff.to_f * left).to_i
+ return " " * before + self + " " * (diff-before)
+ end
+
+ # 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 c in self.chars do
+ 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
underscore = false
end
end
+ if underscore then
+ res.append('_'.ascii.to_s)
+ res.add('d')
+ end
return res.to_s
end
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
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
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("\{\}")
+ # 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.
#
- # 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
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 characters `<`, `>`, `&`, `"`, `'` and `/` as HTML/XML entity references.
+ #
+ # assert "a&b-<>\"x\"/'".html_escape == "a&b-<>"x"/'"
+ #
+ # SEE: <https://www.owasp.org/index.php/XSS_%28Cross_Site_Scripting%29_Prevention_Cheat_Sheet#RULE_.231_-_HTML_Escape_Before_Inserting_Untrusted_Data_into_HTML_Element_Content>
+ 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 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
return self.chars == o.chars
end
- redef fun <(o)
+ # Lexicographical comparaison
+ #
+ # assert "abc" < "xy"
+ # assert "ABC" < "abc"
+ redef fun <(other)
+ do
+ 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 self.chars < o.chars
+ 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
- var i = length - 1
- for char in self.chars do
- h = (h * 32) + h + char.ascii
- i -= 1
+ for i in [0..length[ do
+ var char = chars[i]
+ h = h.lshift(5) + h + char.ascii
end
hash_cache = h
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
-
- init do end
+ redef var length: Int = 0
redef fun output
do
# 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)
- do
- target = tgt
- end
+ var target: SELFTYPE
redef fun is_empty do return target.is_empty
redef fun iterator: IndexedIterator[Char] do return self.iterator_from(0)
- # Gets a new Iterator starting at position `pos`
+ 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
+
+# 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
+
+ redef type SELFTYPE: String
+
+ redef fun to_s do return self
+
+ # Concatenates `o` to `self`
#
- # Ex :
- # var iter = "abcd".iterator_from(2)
- # while iter.is_ok do
- # printn iter.item
- # iter.next
- # end
+ # assert "hello" + "world" == "helloworld"
+ # assert "" + "hello" + "" == "hello"
+ fun +(o: Text): SELFTYPE is abstract
+
+ # Concatenates self `i` times
#
- # Outputs : cd
- fun iterator_from(pos: Int): IndexedIterator[Char] is abstract
+ # assert "abc" * 4 == "abcabcabcabc"
+ # assert "abc" * 1 == "abc"
+ # assert "abc" * 0 == ""
+ fun *(i: Int): SELFTYPE is abstract
- # Gets an iterator starting at the end and going backwards
+ # Insert `s` at `pos`.
#
- # Ex :
- # var reviter = "now step live...".reverse_iterator
- # while reviter.is_ok do
- # printn reviter.item
- # reviter.next
- # end
+ # 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
#
- # 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]
+private class FlatSubstringsIter
+ super Iterator[FlatText]
- redef type SELFTYPE: Buffer
-
-end
-
-abstract class String
- super Text
+ var tgt: nullable FlatText
- 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.
super FlatText
super String
- redef type SELFTYPE: FlatString
-
# 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 native = new NativeString(self.length + 1)
+ 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
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
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
index_to = to
end
- # Return a null terminated char *
redef fun to_cstring: NativeString
do
- if real_items != null then return real_items.as(not null)
- if index_from > 0 or index_to != items.cstring_length - 1 then
- var newItems = calloc_string(length + 1)
+ if real_items != null then
+ return real_items.as(not null)
+ else
+ var newItems = new NativeString(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)
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
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
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
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
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
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'
redef fun hash
do
if hash_cache == null then
- # djb2 hash algorythm
+ # djb2 hash algorithm
var h = 5381
- var i = length - 1
+ var i = index_from
var myitems = items
- var strStart = index_from
-
- i += strStart
- while i >= strStart do
- h = (h * 32) + h + self.items[i].ascii
- i -= 1
+ while i <= index_to do
+ h = h.lshift(5) + h + myitems[i].ascii
+ i += 1
end
hash_cache = h
return hash_cache.as(not null)
end
+
+ redef fun substrings do return new FlatSubstringsIter(self)
end
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]
# 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
end
+# A mutable sequence of characters.
abstract class Buffer
super Text
- redef type SELFVIEW: BufferCharView
redef type SELFTYPE: Buffer
- var is_dirty = true
+ # 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`
#
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 = 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.
redef type SELFTYPE: FlatBuffer
- redef var chars: SELFVIEW = new FlatBufferCharView(self)
+ redef var chars: Sequence[Char] = new FlatBufferCharView(self)
- var capacity: Int
+ 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
+
+ redef fun [](index)
+ do
+ assert index >= 0
+ assert index < length
+ return items[index]
+ end
redef fun []=(index, item)
do
add(item)
return
end
+ if written then reset
assert index >= 0 and index < length
items[index] = item
end
redef fun clear do
is_dirty = true
+ if written then reset
length = 0
end
redef fun enlarge(cap)
do
- is_dirty = true
var c = capacity
if cap <= c then return
while c <= cap do c = c * 2 + 2
- var a = calloc_string(c+1)
- items.copy_to(a, length, 0, 0)
+ # The COW flag can be set at false here, since
+ # it does a copy of the current `Buffer`
+ written = false
+ var a = new NativeString(c+1)
+ 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
- return to_cstring.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
if is_dirty then
- var new_native = calloc_string(length + 1)
+ var new_native = new NativeString(length + 1)
new_native[length] = '\0'
- items.copy_to(new_native, length, 0, 0)
+ if length > 0 then items.copy_to(new_native, length, 0, 0)
real_items = new_native
is_dirty = false
end
end
# Create a new empty string.
- init do with_capacity(5)
+ 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
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
do
assert cap >= 0
# _items = new NativeString.calloc(cap)
- items = calloc_string(cap+1)
+ items = new NativeString(cap+1)
capacity = cap
length = 0
end
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)
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
end
end
- redef fun reversed
+ redef fun reverse
+ do
+ written = false
+ var ns = new NativeString(capacity)
+ var si = length - 1
+ var ni = 0
+ var it = items
+ while si >= 0 do
+ ns[ni] = it[si]
+ ni += 1
+ si -= 1
+ end
+ items = ns
+ end
+
+ redef fun times(repeats)
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
+ var x = new FlatString.with_infos(items, length, 0, length - 1)
+ for i in [1..repeats[ do
+ append(x)
end
- return new_buf
end
- redef fun +(other)
+ redef fun upper
do
- var new_buf = new FlatBuffer.with_capacity(self.length + other.length)
- new_buf.append(self)
- new_buf.append(other)
- return new_buf
+ 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
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
private class FlatBufferCharView
super BufferCharView
- super StringCapable
redef type SELFTYPE: FlatBuffer
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
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
# 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`.
do
return "{class_name}:#{object_id.to_hex}"
end
-
- protected fun args: Sequence[String]
- do
- return sys.args
- end
end
redef class Bool
# 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
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
end
redef class Float
- # Pretty print self, print needoed decimals up to a max of 3.
+ # Pretty representation of `self`, with decimals as needed from 1 to a maximum of 3
+ #
+ # assert 12.34.to_s == "12.34"
+ # assert (-0120.030).to_s == "-120.03"
+ #
+ # see `to_precision` for a custom precision.
redef fun to_s do
var str = to_precision( 3 )
if is_inf != 0 or is_nan then return str
return str
end
- # `self` representation with `nb` digits after the '.'.
- fun to_precision(nb: Int): String
+ # `String` representation of `self` with the given number of `decimals`
+ #
+ # assert 12.345.to_precision(0) == "12"
+ # assert 12.345.to_precision(3) == "12.345"
+ # assert (-12.345).to_precision(3) == "-12.345"
+ # assert (-0.123).to_precision(3) == "-0.123"
+ # assert 0.999.to_precision(2) == "1.00"
+ # assert 0.999.to_precision(4) == "0.9990"
+ fun to_precision(decimals: Int): String
do
if is_nan then return "nan"
return "-inf"
end
- if nb == 0 then return self.to_i.to_s
+ if decimals == 0 then return self.to_i.to_s
var f = self
- for i in [0..nb[ do f = f * 10.0
+ for i in [0..decimals[ do f = f * 10.0
if self > 0.0 then
f = f + 0.5
else
f = f - 0.5
end
var i = f.to_i
- if i == 0 then return "0.0"
- var s = i.to_s
+ if i == 0 then return "0." + "0"*decimals
+
+ # Prepare both parts of the float, before and after the "."
+ var s = i.abs.to_s
var sl = s.length
- if sl > nb then
- var p1 = s.substring(0, s.length-nb)
- var p2 = s.substring(s.length-nb, nb)
- return p1 + "." + p2
+ var p1
+ var p2
+ if sl > decimals then
+ # Has something before the "."
+ p1 = s.substring(0, sl-decimals)
+ p2 = s.substring(sl-decimals, decimals)
else
- return "0." + ("0"*(nb-sl)) + s
+ p1 = "0"
+ p2 = "0"*(decimals-sl) + s
end
+
+ if i < 0 then p1 = "-" + p1
+
+ return p1 + "." + p2
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;
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
#
# 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 ""
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
###############################################################################
# Native strings are simple C char *
-class NativeString
- super StringCapable
+extern class NativeString `{ char* `}
+ # 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.
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
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
- return new FlatString.with_infos(self, length, 0, length - 1)
+ var str = new FlatString.with_infos(self, length, 0, length - 1)
+ 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)
- 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
-interface StringCapable
- protected fun calloc_string(size: Int): NativeString is intern
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)
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
#
# Note: it caching is not usefull, see `alpha_comparator`
class CachedAlphaComparator
- super Comparator[Object]
+ super Comparator
+ redef type COMPARED: Object
private var cache = new HashMap[Object, String]
# see `alpha_comparator`
private class AlphaComparator
- super Comparator[Object]
+ super Comparator
redef fun compare(a, b) do return a.to_s <=> b.to_s
end
# var a = [1, 2, 3, 10, 20]
# alpha_comparator.sort(a)
# assert a == [1, 10, 2, 20, 3]
-fun alpha_comparator: Comparator[Object] do return once new AlphaComparator
+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
nitlanguage / nit.git / blobdiff