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

diff --git a/lib/standard/kernel.nit b/lib/standard/kernel.nit
index 3f32a62..c7f0751 100644
--- a/lib/standard/kernel.nit
+++ b/lib/standard/kernel.nit
@@ -5,7 +5,7 @@
 #
 # This file is free software, which comes along with NIT.  This software is
 # distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-# without  even  the implied warranty of  MERCHANTABILITY or  FITNESS FOR A 
+# without  even  the implied warranty of  MERCHANTABILITY or  FITNESS FOR A
 # PARTICULAR PURPOSE.  You can modify it is you want,  provided this header
 # is kept unaltered, and a notification of the changes is added.
 # You  are  allowed  to  redistribute it and sell it, alone or is a part of
@@ -17,6 +17,11 @@ module kernel
 
 import end # Mark this module is a top level one. (must be only one)
 
+in "C" `{
+	#include <stdlib.h>
+	#include <errno.h>
+`}
+
 ###############################################################################
 # System Classes                                                              #
 ###############################################################################
@@ -63,7 +68,7 @@ interface Object
 
 	# Have `self` and `other` the same value?
 	#
-	# The exact meaning of "same value" is let to the subclasses.
+	# The exact meaning of "same value" is left to the subclasses.
 	# Implicitly, the default implementation, is `is_same_instance`
 	fun ==(other: nullable Object): Bool do return self.is_same_instance(other)
 
@@ -85,7 +90,7 @@ interface Object
 	# Display class name on stdout (debug only).
 	# This method MUST not be used by programs, it is here for debugging
 	# only and can be removed without any notice
-	fun output_class_name is intern	
+	fun output_class_name is intern
 
 	# The hash code of the object.
 	# Assuming that a == b -> a.hash == b.hash
@@ -107,7 +112,7 @@ class Sys
 	fun run do main
 
 	# Number of the last error
-	fun errno: Int is extern "sys_errno"
+	fun errno: Int `{ return errno; `}
 end
 
 # Quit the program with a specific return code
@@ -128,7 +133,7 @@ interface Comparable
 	type OTHER: Comparable
 
 	# Is `self` lesser than `other`?
-	fun <(other: OTHER): Bool is abstract 
+	fun <(other: OTHER): Bool is abstract
 
 	# not `other` < `self`
 	# Note, the implementation must ensure that: `(x<=y) == (x<y or x==y)`
@@ -223,11 +228,11 @@ end
 # Something that can be cloned
 #
 # This interface introduces the `clone` method used to duplicate an instance
-# Its specific semantic is let to the subclasses.
+# Its specific semantic is left to the subclasses.
 interface Cloneable
 	# Duplicate `self`
 	#
-	# The specific semantic of this method is let to the subclasses;
+	# The specific semantic of this method is left to the subclasses;
 	# Especially, if (and how) attributes are cloned (depth vs. shallow).
 	#
 	# As a rule of thumb, the principle of least astonishment should
@@ -275,6 +280,12 @@ interface Numeric
 	#     assert 5.to_f         != 5 # Float and Int are not equals
 	fun to_f: Float is abstract
 
+	# The byte equivalent of `self`
+	#
+	#     assert (-1).to_b == 0xFF.to_b
+	#     assert (1.9).to_b == 1.to_b
+	fun to_b: Byte is abstract
+
 	# Is this the value of zero in its domain?
 	fun is_zero: Bool do return self == zero
 
@@ -331,10 +342,10 @@ universal Float
 	redef fun !=(i) is intern
 	redef fun output is intern
 
-	redef fun <=(i): Bool is intern
-	redef fun <(i): Bool is intern
-	redef fun >=(i): Bool is intern
-	redef fun >(i): Bool is intern
+	redef fun <=(i) is intern
+	redef fun <(i) is intern
+	redef fun >=(i) is intern
+	redef fun >(i) is intern
 
 	redef fun +(i) is intern
 	redef fun - is intern
@@ -344,6 +355,7 @@ universal Float
 
 	redef fun to_i is intern
 	redef fun to_f do return self
+	redef fun to_b is intern
 
 	redef fun zero do return 0.0
 	redef fun value_of(val) do return val.to_f
@@ -402,6 +414,110 @@ universal Float
 	end
 end
 
+# Native bytes.
+# Same as a C `unsigned char`
+universal Byte
+	super Discrete
+	super Numeric
+
+	redef type OTHER: Byte
+
+	redef fun successor(i) do return self + i.to_b
+	redef fun predecessor(i) do return self - i.to_b
+
+	redef fun object_id is intern
+	redef fun hash do return self.to_i
+	redef fun ==(i) is intern
+	redef fun !=(i) is intern
+	redef fun output is intern
+
+	redef fun <=(i) is intern
+	redef fun <(i) is intern
+	redef fun >=(i) is intern
+	redef fun >(i) is intern
+	redef fun +(i) is intern
+
+	# On an Byte, unary minus will return `(256 - self) % 256`
+	#
+	#     assert -(1.to_b) == 0xFF.to_b
+	#     assert -(0.to_b) == 0x00.to_b
+	redef fun - is intern
+	redef fun -(i) is intern
+	redef fun *(i) is intern
+	redef fun /(i) is intern
+
+	# Modulo of `self` with `i`.
+	#
+	# Finds the remainder of division of `self` by `i`.
+	#
+	#     assert 5.to_b % 2.to_b		== 1.to_b
+	#     assert 10.to_b % 2.to_b		== 0.to_b
+	fun %(i: Byte): Byte is intern
+
+	redef fun zero do return 0.to_b
+	redef fun value_of(val) do return val.to_b
+
+	# `i` bits shift fo the left (aka <<)
+	#
+	#     assert 5.to_b.lshift(1)    == 10.to_b
+	fun lshift(i: Int): Byte is intern
+
+	# alias of `lshift`
+	fun <<(i: Int): Byte do return lshift(i)
+
+	# `i` bits shift fo the right (aka >>)
+	#
+	#     assert 5.to_b.rshift(1)    == 2.to_b
+	fun rshift(i: Int): Byte is intern
+
+	# alias of `rshift`
+	fun >>(i: Int): Byte do return rshift(i)
+
+	redef fun to_i is intern
+	redef fun to_f is intern
+	redef fun to_b do return self
+
+	redef fun distance(i) do return (self - i).to_i
+
+	redef fun <=>(other)
+	do
+		if self < other then
+			return -1
+		else if other < self then
+			return 1
+		else
+			return 0
+		end
+	end
+
+	redef fun is_between(c, d)
+	do
+		if self < c or d < self then
+			return false
+		else
+			return true
+		end
+	end
+
+	redef fun max(other)
+	do
+		if self < other then
+			return other
+		else
+			return self
+		end
+	end
+
+	redef fun min(c)
+	do
+		if c < self then
+			return c
+		else
+			return self
+		end
+	end
+end
+
 # Native integer numbers.
 # Correspond to C int.
 universal Int
@@ -459,6 +575,7 @@ universal Int
 
 	redef fun to_i do return self
 	redef fun to_f is intern
+	redef fun to_b is intern
 
 	redef fun distance(i)
 	do
@@ -483,9 +600,9 @@ universal Int
 
 	redef fun is_between(c, d)
 	do
-		if self < c or d < self then 
+		if self < c or d < self then
 			return false
-		else 
+		else
 			return true
 		end
 	end
@@ -536,7 +653,7 @@ universal Int
 		# count digits
 		while n > 0 do
 			d += 1
-			n = n / b  	# euclidian division /
+			n = n / b	# euclidian division /
 		end
 		return d
 	end
@@ -602,10 +719,23 @@ universal Char
 	redef type OTHER: Char
 
 	redef fun object_id is intern
+	redef fun output `{
+		if(self < 128){
+			printf("%c", self);
+		}else if(self < 2048){
+			printf("%c%c", 0xC0 | ((0x7C0 & self) >> 6), 0x80 | (0x3F & self));
+		}else if(self < 65536){
+			printf("%c%c%c", 0xE0 | ((0xF000 & self) >> 12), 0x80 | ((0xFC0 & self) >> 6) ,0x80 | (0x3F & self));
+		}else if(self < 2097152){
+			printf("%c%c%c%c", 0xF0 | ((0x1C0000 & self) >> 18), 0x80 | ((0x3F000 & self) >> 12), 0x80 | ((0xFC0 & self) >> 6), 0x80 | (0x3F & self));
+		}else{
+			// Bad char
+			printf("%c", self);
+		}
+	`}
 	redef fun hash do return ascii
 	redef fun ==(o) is intern
 	redef fun !=(o) is intern
-	redef fun output is intern
 
 	redef fun <=(i) is intern
 	redef fun <(i) is intern
@@ -739,8 +869,8 @@ end
 # Pointer classes are used to manipulate extern C structures.
 extern class Pointer
 	# Is the address behind this Object at NULL?
-	fun address_is_null: Bool is extern "address_is_null"
+	fun address_is_null: Bool `{ return self == NULL; `}
 
 	# Free the memory pointed by this pointer
-	fun free is extern "free"
+	fun free `{ free(self); `}
 end