import end # Mark this module is a top level one. (must be only one)
+`{
+#include <errno.h>
+`}
+
###############################################################################
# System Classes #
###############################################################################
# Unless specific code, you should not use this method.
fun is_same_type(other: Object): Bool is intern
+ # Return true if `self` and `other` are the same instance.
+ # Unless specific code, you should use `==` instead.
+ fun is_same_instance(other: nullable Object): Bool is intern
+
# Have `self` and `other` the same value?
##
# The exact meaning of "same value" is let to the subclasses.
- # Implicitly, the default implementation, is `is`
- fun ==(other: nullable Object): Bool do return self is other
+ # Implicitly, the default implementation, is `is_same_instance`
+ fun ==(other: nullable Object): Bool do return self.is_same_instance(other)
# Have `self` and `other` different values?
##
# only and can be removed without any notice
fun output_class_name is intern
- # Quit the program with a specific return code
- protected fun exit(exit_value: Int) is intern
-
- # Return the global sys object, the only instance of the `Sys` class.
- protected fun sys: Sys is intern
-
# The hash code of the object.
# Assuming that a == b -> a.hash == b.hash
##
class Sys
# Instructions outside classes implicitly redefine this method.
fun main do end
+
+ # The entry point for the execution of the whole program.
+ # Its job is to call `main` but some modules may want to refine it
+ # and inject specific work before or after the main part.
+ fun run do main
+
+ # Number of the last error
+ fun errno: Int is extern `{
+ return errno;
+ `}
end
+# Quit the program with a specific return code
+fun exit(exit_value: Int) is intern
+
+# Return the global sys object, the only instance of the `Sys` class.
+fun sys: Sys is intern
+
+
###############################################################################
# Abstract Classes #
###############################################################################
redef type OTHER: Discrete
# The next element.
- fun succ: OTHER do return self + 1
+ fun successor(i: Int): OTHER is abstract
# The previous element.
- fun prec: OTHER do return self - 1
-
- # The `i`-th successor element.
- fun +(i: Int): OTHER is abstract
-
- # The `i`-th previous element.
- fun -(i: Int): OTHER is abstract
+ fun predecessor(i: Int): OTHER is abstract
# The distance between self and d.
#
var nb = 0
while cursor < stop do
- cursor = cursor.succ
+ cursor = cursor.successor(1)
nb += 1
end
return nb
end
end
+# A numeric value supporting mathematical operations
+interface Numeric
+ super Comparable
+
+ redef type OTHER: Numeric
+
+ # Addition of `self` with `i`
+ fun +(i: OTHER): OTHER is abstract
+
+ # Substraction of `i` from `self`
+ fun -(i: OTHER): OTHER is abstract
+
+ # Inverse of `self`
+ fun -: OTHER is abstract
+
+ # Multiplication of `self` with `i`
+ fun *(i: OTHER): OTHER is abstract
+
+ # Division of `self` with `i`
+ fun /(i: OTHER): OTHER is abstract
+
+ # The integer part of `self`.
+ #
+ # assert (0.0).to_i == 0
+ # assert (0.9).to_i == 0
+ # assert (-0.9).to_i == 0
+ # assert (9.9).to_i == 9
+ # assert (-9.9).to_i == -9
+ fun to_i: Int is abstract
+
+ # The float equivalent of `self`
+ #
+ # assert 5.to_f == 5.0
+ # assert 5.to_f != 5 # Float and Int are not equals
+ fun to_f: Float is abstract
+
+ # Is this the value of zero in its domain?
+ fun is_zero: Bool do return self == zero
+
+ # The value of zero in the domain of `self`
+ fun zero: OTHER is abstract
+
+ # The value of `val` in the domain of `self`
+ #
+ # assert 1.0.value_of(2) == 2.0
+ # assert 1.0.value_of(2.0) == 2.0
+ # assert 1.value_of(2) == 2
+ # assert 1.value_of(2.0) == 2
+ fun value_of(val: Numeric): OTHER is abstract
+end
+
###############################################################################
# Native classes #
###############################################################################
redef fun ==(b) is intern
redef fun !=(b) is intern
redef fun output is intern
- redef fun hash
+ redef fun hash do return to_i
+
+ # 1 if true and 0 if false
+ fun to_i: Int
do
if self then
return 1
# Native floating point numbers.
# Corresponds to C float.
universal Float
+ super Numeric
+
+ redef type OTHER: Float
+
redef fun object_id is intern
+ redef fun ==(i) is intern
+ redef fun !=(i) is intern
redef fun output is intern
- fun <=(i: Float): Bool is intern
- fun <(i: Float): Bool is intern
- fun >=(i: Float): Bool is intern
- fun >(i: Float): Bool is intern
- fun +(i: Float): Float is intern
- fun -: Float is intern
- fun -(i: Float): Float is intern
- fun *(i: Float): Float is intern
- fun /(i: Float): Float 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
- # The integer part of `self`.
+ redef fun +(i) is intern
+ redef fun - is intern
+ redef fun -(i) is intern
+ redef fun *(i) is intern
+ redef fun /(i) is intern
+
+ redef fun to_i is intern
+ redef fun to_f do return self
+
+ redef fun zero do return 0.0
+ redef fun value_of(val) do return val.to_f
+
+ 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
+
+ # Compare float numbers with a given precision.
#
- # assert (0.0).to_i == 0
- # assert (0.9).to_i == 0
- # assert (-0.9).to_i == 0
- # assert (9.9).to_i == 9
- # assert (-9.9).to_i == -9
- fun to_i: Int is intern
+ # Because of the loss of precision in floating numbers,
+ # the `==` method is often not the best way to compare them.
+ #
+ # ~~~
+ # assert 0.01.is_approx(0.02, 0.1) == true
+ # assert 0.01.is_approx(0.02, 0.001) == false
+ # ~~~
+ fun is_approx(other, precision: Float): Bool
+ do
+ assert precision >= 0.0
+ return self <= other + precision and self >= other - precision
+ 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
super Discrete
+ super Numeric
+
redef type OTHER: Int
+ redef fun successor(i) do return self + i
+ redef fun predecessor(i) do return self - i
+
redef fun object_id is intern
redef fun hash do return self
redef fun ==(i) is intern
redef fun >=(i) is intern
redef fun >(i) is intern
redef fun +(i) is intern
- fun -: Int is intern
+
+ redef fun - is intern
redef fun -(i) is intern
- fun *(i: Int): Int is intern
- fun /(i: Int): Int is intern
+ redef fun *(i) is intern
+ redef fun /(i) is intern
fun %(i: Int): Int is intern
+ redef fun zero do return 0
+ redef fun value_of(val) do return val.to_i
+
# `i` bits shift fo the left (aka <<)
#
# assert 5.lshift(1) == 10
# assert 5.rshift(1) == 2
fun rshift(i: Int): Int is intern
- # The float equivalent of `self`
- #
- # assert 5.to_f == 5.0
- # assert 5.to_f != 5 # Float and Int are not equals
- fun to_f: Float is intern
+ redef fun to_i do return self
+ redef fun to_f is intern
- redef fun succ is intern
- redef fun prec is intern
redef fun distance(i)
do
var d = self - i
end
end
- # Execute 'each' for each integer in [self..last]
- fun enumerate_to(last: Int)
- !each(i: Int)
- do
- var cur = self
- while cur <= last do
- each(cur)
- cur += 1
- end
- end
-
- # Execute 'each' for each integer in [self..after[
- fun enumerate_before(after: Int)
- !each(i: Int)
- do
- var cur = self
- while cur < after do
- each(cur)
- cur += 1
- end
- end
-
# The absolute value of self
#
# assert (-10).abs == 10
redef fun >=(i) is intern
redef fun >(i) is intern
- redef fun succ is intern
- redef fun prec is intern
+ redef fun successor(i) is intern
+ redef fun predecessor(i) is intern
redef fun distance(c)
do
else if is_digit then
return self.ascii - '0'.ascii
else
- return self.to_lower.ascii - ('a'.ascii + 10)
+ return self.to_lower.ascii - 'a'.ascii + 10
end
end
# assert '\n'.ascii == 10
fun ascii: Int is intern
- redef fun +(i) is intern
- redef fun -(i) is intern
-
# Return the lower case version of self.
# If self is not a letter, then return self
#
end
# Pointer classes are used to manipulate extern C structures.
-extern Pointer
+extern class Pointer
# Is the address behind this Object at NULL?
- fun address_is_null: Bool `{ return recv == NULL; `}
+ fun address_is_null: Bool is extern "address_is_null"
+
+ # Free the memory pointed by this pointer
+ fun free `{ free(recv); `}
end
nitlanguage / nit.git / blobdiff