# `i` bits shift fo the left
#
# assert 5u8 << 1 == 10u8
- fun <<(i: Int): Byte `{ return self << i; `}
+ fun <<(i: Int): Byte is intern `{ return self << i; `}
# `i` bits shift fo the right
#
# assert 5u8 >> 1 == 2u8
- fun >>(i: Int): Byte `{ return self >> i; `}
+ fun >>(i: Int): Byte is intern `{ return self >> i; `}
+
+ # Returns the character equivalent of `self`
+ #
+ # REQUIRE: `self <= 127u8`
+ fun ascii: Char is intern `{ return (uint32_t)self; `}
redef fun to_i is intern
redef fun to_f is intern
return self
end
end
+
+ # Is `self` an ASCII whitespace ?
+ fun is_whitespace: Bool do return self == 0x7Fu8 or self <= 0x20u8
end
# Native integer numbers.
# `i` bits shift fo the left
#
# assert 5 << 1 == 10
- fun <<(i: Int): Int `{ return self << i; `}
+ fun <<(i: Int): Int is intern `{ return self << i; `}
# `i` bits shift fo the right
#
# assert 5 >> 1 == 2
- fun >>(i: Int): Int `{ return self >> i; `}
+ fun >>(i: Int): Int is intern `{ return self >> i; `}
redef fun to_i do return self
redef fun to_f is intern
end
end
- # The character whose ASCII value is `self`.
+ # The character which code point (unicode-wise) is `self`
#
- # assert 65.ascii == 'A'
- # assert 10.ascii == '\n'
- fun ascii: Char is intern
+ # assert 65.code_point == 'A'
+ # assert 10.code_point == '\n'
+ # assert 0x220B.code_point == '∋'
+ fun code_point: Char is intern `{ return (uint32_t)self; `}
# Number of digits of an integer in base `b` (plus one if negative)
#
do
assert self >= 0 and self <= 36 # TODO plan for this
if self < 10 then
- return (self + '0'.ascii).ascii
+ return (self + '0'.code_point).code_point
else
- return (self + ('a'.ascii - 10)).ascii
+ return (self - 10 + 'a'.code_point).code_point
end
end
# assert (-10).abs == 10
# assert 10.abs == 10
# assert 0.abs == 0
- fun abs: Int
- do
- if self >= 0
- then
- return self
- else
- return -1 * self
- end
- end
+ fun abs: Int do return if self >= 0 then self else -self
end
# Native characters.
printf("%c", self);
}
`}
- redef fun hash do return ascii
+ redef fun hash do return code_point
redef fun ==(o) is intern
redef fun !=(o) is intern
redef fun distance(c)
do
- var d = self.ascii - c.ascii
+ var d = self.code_point - c.code_point
if d >= 0 then
return d
else
if self == '-' then
return -1
else if is_digit then
- return self.ascii - '0'.ascii
+ return self.code_point - '0'.code_point
else
- return self.to_lower.ascii - 'a'.ascii + 10
+ return self.to_lower.code_point - 'a'.code_point + 10
end
end
- # the ascii value of self
+ # The ascii value of `self`
+ #
+ # assert 'a'.ascii == 97u8
+ # assert '\n'.ascii == 10u8
+ #
+ # REQUIRE: `is_ascii`
+ fun ascii: Byte do return code_point.to_b
+
+ # The unicode code point value of `self`
#
- # assert 'a'.ascii == 97
- # assert '\n'.ascii == 10
- fun ascii: Int is intern
+ # assert 'A'.code_point == 65
+ # assert '\n'.code_point == 10
+ # assert '∋'.code_point == 0x220B
+ fun code_point: Int is intern `{ return (long)self; `}
+
+ # Is `self` an ASCII character ?
+ #
+ # assert 'x'.is_ascii
+ # assert not 'ま'.is_ascii
+ fun is_ascii: Bool do return code_point <= 127
# Return the lower case version of self.
# If self is not a letter, then return self
fun to_lower: Char
do
if is_upper then
- return (ascii + ('a'.distance('A'))).ascii
+ return (code_point + ('a'.distance('A'))).code_point
else
return self
end
fun to_upper: Char
do
if is_lower then
- return (ascii - ('a'.distance('A'))).ascii
+ return (code_point - ('a'.distance('A'))).code_point
else
return self
end
# assert '\t'.is_whitespace == true
fun is_whitespace: Bool
do
- var i = ascii
+ var i = code_point
return i <= 0x20 or i == 0x7F
end
end
# Free the memory pointed by this pointer
fun free `{ free(self); `}
end
+
+# Task with a `main` method to be implemented by subclasses
+#
+# This class is provided for compatibility between different parallelization systems.
+# It can be used to run a fragment of code on a different thread and
+# to register a reaction to UI events.
+interface Task
+
+ # Main method of this task
+ fun main do end
+end
nitlanguage / nit.git / blobdiff