# assert "\na\nb\tc\t".trim == "a\nb\tc"
fun trim: SELFTYPE do return (self.l_trim).r_trim
+ # 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)
+ #
+ # 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
fun to_cmangle: String
do
# 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"
private var target: SELFTYPE
- private init(tgt: SELFTYPE)
- do
- target = tgt
- end
-
redef fun is_empty do return target.is_empty
redef fun length do return target.length
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"
var tgt: nullable FlatText
- init(tgt: FlatText) do self.tgt = tgt
-
redef fun item do
assert is_ok
return tgt.as(not null)
do
assert length >= 0
var str = new FlatString.with_infos(self, length, 0, length - 1)
- str.real_items = self
return str
end
var new_self = calloc_string(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