X-Git-Url: http://nitlanguage.org

diff --git a/lib/standard/string.nit b/lib/standard/string.nit
index 489654e..aa757b7 100644
--- a/lib/standard/string.nit
+++ b/lib/standard/string.nit
@@ -60,7 +60,7 @@ abstract class Text
 	fun substring(from: Int, count: Int): SELFTYPE is abstract
 
 	# Iterates on the substrings of self if any
-	fun substrings: Iterator[Text] is abstract
+	fun substrings: Iterator[FlatText] is abstract
 
 	# Is the current Text empty (== "")
 	#
@@ -345,7 +345,7 @@ abstract class Text
 		end
 		return true
 	end
-			
+
 	# Removes the whitespaces at the beginning of self
 	#
 	#     assert " \n\thello \n\t".l_trim == "hello \n\t"
@@ -531,6 +531,14 @@ abstract class Text
 	#
 	#     assert "abAB12<>&".escape_to_c         == "abAB12<>&"
 	#     assert "\n\"'\\".escape_to_c         == "\\n\\\"\\'\\\\"
+	#
+	# Most non-printable characters (bellow ASCII 32) are escaped to an octal form `\nnn`.
+	# Three digits are always used to avoid following digits to be interpreted as an element
+	# of the octal sequence.
+	#
+	#     assert "{0.ascii}{1.ascii}{8.ascii}{31.ascii}{32.ascii}".escape_to_c == "\\000\\001\\010\\037 "
+	#
+	# The exceptions are the common `\t` and `\n`.
 	fun escape_to_c: String
 	do
 		var b = new FlatBuffer
@@ -538,8 +546,10 @@ abstract class Text
 			var c = chars[i]
 			if c == '\n' then
 				b.append("\\n")
+			else if c == '\t' then
+				b.append("\\t")
 			else if c == '\0' then
-				b.append("\\0")
+				b.append("\\000")
 			else if c == '"' then
 				b.append("\\\"")
 			else if c == '\'' then
@@ -547,7 +557,17 @@ abstract class Text
 			else if c == '\\' then
 				b.append("\\\\")
 			else if c.ascii < 32 then
-				b.append("\\{c.ascii.to_base(8, false)}")
+				b.add('\\')
+				var oct = c.ascii.to_base(8, false)
+				# Force 3 octal digits since it is the
+				# maximum allowed in the C specification
+				if oct.length == 1 then
+					b.add('0')
+					b.add('0')
+				else if oct.length == 2 then
+					b.add('0')
+				end
+				b.append(oct)
 			else
 				b.add(c)
 			end
@@ -829,6 +849,60 @@ abstract class Text
 		return hash_cache.as(not null)
 	end
 
+	# Gives the formatted string back as a Nit string with `args` in place
+	#
+	#    assert "This %1 is a %2.".format("String", "formatted String") == "This String is a formatted String."
+	#    assert "\\%1 This string".format("String") == "\\%1 This string"
+	fun format(args: Object...): String do
+		var s = new Array[Text]
+		var curr_st = 0
+		var i = 0
+		while i < length do
+			# Skip escaped characters
+			if self[i] == '\\' then
+				i += 1
+			# In case of format
+			else if self[i] == '%' then
+				var fmt_st = i
+				i += 1
+				var ciph_st = i
+				while i < length and self[i].is_numeric do
+					i += 1
+				end
+				i -= 1
+				var fmt_end = i
+				var ciph_len = fmt_end - ciph_st + 1
+				s.push substring(curr_st, fmt_st - curr_st)
+				s.push args[substring(ciph_st, ciph_len).to_i - 1].to_s
+				curr_st = i + 1
+			end
+			i += 1
+		end
+		s.push substring(curr_st, length - curr_st)
+		return s.to_s
+	end
+
+	# Copies `n` bytes from `self` at `src_offset` into `dest` starting at `dest_offset`
+	#
+	# Basically a high-level synonym of NativeString::copy_to
+	#
+	# REQUIRE: `n` must be large enough to contain `len` bytes
+	#
+	# 	var ns = new NativeString(8)
+	# 	"Text is String".copy_to_native(ns, 8, 2, 0)
+	#	assert ns.to_s_with_length(8) == "xt is St"
+	#
+	fun copy_to_native(dest: NativeString, n, src_offset, dest_offset: Int) do
+		var mypos = src_offset
+		var itspos = dest_offset
+		while n > 0 do
+			dest[itspos] = self.chars[mypos]
+			itspos += 1
+			mypos += 1
+			n -= 1
+		end
+	end
+
 end
 
 # All kinds of array-based text representations.
@@ -844,6 +918,23 @@ abstract class FlatText
 	# Real items, used as cache for to_cstring is called
 	private var real_items: nullable NativeString = null
 
+	# Returns a char* starting at position `index_from`
+	#
+	# WARNING: If you choose to use this service, be careful of the following.
+	#
+	# Strings and NativeString are *ideally* always allocated through a Garbage Collector.
+	# Since the GC tracks the use of the pointer for the beginning of the char*, it may be
+	# deallocated at any moment, rendering the pointer returned by this function invalid.
+	# Any access to freed memory may very likely cause undefined behaviour or a crash.
+	# (Failure to do so will most certainly result in long and painful debugging hours)
+	#
+	# The only safe use of this pointer is if it is ephemeral (e.g. read in a C function
+	# then immediately return).
+	#
+	# As always, do not modify the content of the String in C code, if this is what you want
+	# copy locally the char* as Nit Strings are immutable.
+	private fun fast_cstring: NativeString is abstract
+
 	redef var length: Int = 0
 
 	redef fun output
@@ -856,6 +947,10 @@ abstract class FlatText
 	end
 
 	redef fun flatten do return self
+
+	redef fun copy_to_native(dest, n, src_offset, dest_offset) do
+		items.copy_to(dest, n, src_offset, dest_offset)
+	end
 end
 
 # Abstract class for the SequenceRead compatible
@@ -916,7 +1011,7 @@ abstract class String
 	#     assert "helloworld".insert_at(" ", 5)	== "hello world"
 	fun insert_at(s: String, pos: Int): SELFTYPE is abstract
 
-	redef fun substrings: Iterator[String] is abstract
+	redef fun substrings is abstract
 
 	# Returns a reversed version of self
 	#
@@ -935,41 +1030,61 @@ abstract class String
 	#     assert "Hello World!".to_lower     == "hello world!"
 	fun to_lower : SELFTYPE is abstract
 
-	# Takes a camel case `self` and converts it to snake case 
+	# 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
+	# The rules are the following:
 	#
-	#     assert "RANDOM_METHOD_ID".to_snake_case == "RANDOM_METHOD_ID"
+	# An uppercase is always converted to a lowercase
 	#
-	# If the identifier is prefixed by an underscore, the underscore is ignored
+	#     assert "HELLO_WORLD".to_snake_case == "hello_world"
+	#
+	# An uppercase that follows a lowercase is prefixed with an underscore
+	#
+	#     assert "HelloTheWORLD".to_snake_case == "hello_the_world"
 	#
-	#     assert "_privateField".to_snake_case == "_private_field"
+	# An uppercase that follows an uppercase and is followed by a lowercase, is prefixed with an underscore
+	#
+	#     assert "HelloTHEWorld".to_snake_case == "hello_the_world"
+	#
+	# All other characters are kept as is; `self` does not need to be a proper CamelCased string.
+	#
+	#     assert "=-_H3ll0Th3W0rld_-=".to_snake_case == "=-_h3ll0th3w0rld_-="
 	fun to_snake_case: SELFTYPE
 	do
-		if self.is_upper then return self
+		if self.is_lower then return self
 
 		var new_str = new FlatBuffer.with_capacity(self.length)
-		var is_first_char = true
+		var prev_is_lower = false
+		var prev_is_upper = false
 
 		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
+			if char.is_lower then
+				new_str.add(char)
+				prev_is_lower = true
+				prev_is_upper = false
 			else if char.is_upper then
-				new_str.add('_')
+				if prev_is_lower then
+					new_str.add('_')
+				else if prev_is_upper and i+1 < length and chars[i+1].is_lower then
+					new_str.add('_')
+				end
 				new_str.add(char.to_lower)
+				prev_is_lower = false
+				prev_is_upper = true
 			else
 				new_str.add(char)
+				prev_is_lower = false
+				prev_is_upper = false
 			end
 		end
-		
+
 		return new_str.to_s
 	end
 
-	# Takes a snake case `self` and converts it to camel case 
+	# Takes a snake case `self` and converts it to camel case
 	#
 	#     assert "random_method_id".to_camel_case == "randomMethodId"
 	#
@@ -1069,7 +1184,7 @@ class FlatString
 	# Indes in _items of the last item of the string
 	private var index_to: Int is noinit
 
-	redef var chars: SequenceRead[Char] = new FlatStringCharView(self)
+	redef var chars: SequenceRead[Char] = new FlatStringCharView(self) is lazy
 
 	redef fun [](index)
 	do
@@ -1099,6 +1214,8 @@ class FlatString
 		return native.to_s_with_length(self.length)
 	end
 
+	redef fun fast_cstring do return items.fast_cstring(index_from)
+
 	redef fun substring(from, count)
 	do
 		assert count >= 0
@@ -1180,10 +1297,14 @@ class FlatString
 	#              String Specific Methods           #
 	##################################################
 
-	private init with_infos(items: NativeString, len: Int, from: Int, to: Int)
+	# Low-level creation of a new string with given data.
+	#
+	# `items` will be used as is, without copy, to retrieve the characters of the string.
+	# Aliasing issues is the responsibility of the caller.
+	private init with_infos(items: NativeString, length: Int, from: Int, to: Int)
 	do
 		self.items = items
-		length = len
+		self.length = length
 		index_from = from
 		index_to = to
 	end
@@ -1539,10 +1660,12 @@ class FlatBuffer
 	super FlatText
 	super Buffer
 
-	redef var chars: Sequence[Char] = new FlatBufferCharView(self)
+	redef var chars: Sequence[Char] = new FlatBufferCharView(self) is lazy
 
 	private var capacity: Int = 0
 
+	redef fun fast_cstring do return items.fast_cstring(0)
+
 	redef fun substrings do return new FlatSubstringsIter(self)
 
 	# Re-copies the `NativeString` into a new one and sets it as the new `Buffer`
@@ -1627,6 +1750,20 @@ class FlatBuffer
 	# Create a new empty string.
 	init do end
 
+	# Low-level creation a new buffer with given data.
+	#
+	# `items` will be used as is, without copy, to store the characters of the buffer.
+	# Aliasing issues is the responsibility of the caller.
+	#
+	# If `items` is shared, `written` should be set to true after the creation
+	# so that a modification will do a copy-on-write.
+	private init with_infos(items: NativeString, capacity, length: Int)
+	do
+		self.items = items
+		self.length = length
+		self.capacity = capacity
+	end
+
 	# Create a new string copied from `s`.
 	init from(s: Text)
 	do
@@ -1651,7 +1788,6 @@ class FlatBuffer
 	init with_capacity(cap: Int)
 	do
 		assert cap >= 0
-		# _items = new NativeString.calloc(cap)
 		items = new NativeString(cap+1)
 		capacity = cap
 		length = 0
@@ -1695,11 +1831,10 @@ class FlatBuffer
 		if from < 0 then from = 0
 		if count > length then count = length
 		if from < count then
-			var r = new FlatBuffer.with_capacity(count - from)
-			while from < count do
-				r.chars.push(items[from])
-				from += 1
-			end
+			var len = count - from
+			var r_items = new NativeString(len)
+			items.copy_to(r_items, len, from, 0)
+			var r = new FlatBuffer.with_infos(r_items, len, len)
 			return r
 		else
 			return new FlatBuffer
@@ -1895,9 +2030,7 @@ end
 redef class Int
 
 	# Wrapper of strerror C function
-	private fun strerror_ext: NativeString is extern `{
-		return strerror(recv);
-	`}
+	private fun strerror_ext: NativeString is extern "strerror"
 
 	# Returns a string describing error number
 	fun strerror: String do return strerror_ext.to_s
@@ -1937,6 +2070,10 @@ redef class Int
 	#     assert 1.to_s            == "1"
 	#     assert (-123).to_s       == "-123"
 	redef fun to_s do
+		# Fast case for common numbers
+		if self == 0 then return "0"
+		if self == 1 then return "1"
+
 		var nslen = int_to_s_len
 		var ns = new NativeString(nslen + 1)
 		ns[nslen] = '\0'
@@ -2083,6 +2220,12 @@ redef class Collection[E]
 	# Concatenate elements.
 	redef fun to_s
 	do
+		return plain_to_s
+	end
+
+	# Concatenate element without separators
+	fun plain_to_s: String
+	do
 		var s = new FlatBuffer
 		for e in self do if e != null then s.append(e.to_s)
 		return s.to_s
@@ -2118,7 +2261,7 @@ end
 redef class Array[E]
 
 	# Fast implementation
-	redef fun to_s
+	redef fun plain_to_s
 	do
 		var l = length
 		if l == 0 then return ""
@@ -2164,6 +2307,48 @@ redef class Array[E]
 	end
 end
 
+redef class NativeArray[E]
+	# Join all the elements using `to_s`
+	#
+	# REQUIRE: `self isa NativeArray[String]`
+	# REQUIRE: all elements are initialized
+	fun native_to_s: String
+	do
+		assert self isa NativeArray[String]
+		var l = length
+		var na = self
+		var i = 0
+		var sl = 0
+		var mypos = 0
+		while i < l do
+			sl += na[i].length
+			i += 1
+			mypos += 1
+		end
+		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
+
 redef class Map[K,V]
 	# Concatenate couple of 'key value'.
 	# key and value are separated by `couple_sep`.
@@ -2207,6 +2392,12 @@ extern class NativeString `{ char* `}
 	# Creates a new NativeString with a capacity of `length`
 	new(length: Int) is intern
 
+	# Returns a char* starting at `index`.
+	#
+	# WARNING: Unsafe for extern code, use only for temporary
+	# pointer manipulation purposes (e.g. write to file or such)
+	fun fast_cstring(index: Int): NativeString is intern
+
 	# Get char at `index`.
 	fun [](index: Int): Char is intern