nitlanguage / nit.git / blob
? search:


2e9c9ae274ba6cedcf5b359de15d782b37d3659b
[nit.git] / lib / standard / kernel.nit
1 # This file is part of NIT ( http://www.nitlanguage.org ).
2 #
3 # Copyright 2004-2008 Jean Privat <jean@pryen.org>
4 # Copyright 2006-2008 Floréal Morandat <morandat@lirmm.fr>
5 #
6 # This file is free software, which comes along with NIT. This software is
7 # distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
8 # without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
9 # PARTICULAR PURPOSE. You can modify it is you want, provided this header
10 # is kept unaltered, and a notification of the changes is added.
11 # You are allowed to redistribute it and sell it, alone or is a part of
12 # another product.
13
14 # Most minimal classes and methods.
15 # This module is the root of the standard module hierarchy.
16 module kernel
17
18 import end # Mark this module is a top level one. (must be only one)
19
20 `{
21 #include <errno.h>
22 `}
23
24 ###############################################################################
25 # System Classes #
26 ###############################################################################
27
28 # The root of the class hierarchy.
29 # Each class implicitly specialize Object.
30 #
31 # Currently, Object is also used to collect all top-level methods.
32 interface Object
33 # The unique object identifier in the class.
34 # Unless specific code, you should not use this method.
35 # The identifier is used internally to provide a hash value.
36 fun object_id: Int is intern
37
38 # Return true if `self` and `other` have the same dynamic type.
39 # Unless specific code, you should not use this method.
40 fun is_same_type(other: Object): Bool is intern
41
42 # Return true if `self` and `other` are the same instance.
43 # Unless specific code, you should use `==` instead.
44 fun is_same_instance(other: nullable Object): Bool is intern
45
46 # Have `self` and `other` the same value?
47 ##
48 # The exact meaning of "same value" is let to the subclasses.
49 # Implicitly, the default implementation, is `is_same_instance`
50 fun ==(other: nullable Object): Bool do return self.is_same_instance(other)
51
52 # Have `self` and `other` different values?
53 ##
54 # != is equivalent with "not ==".
55 fun !=(other: nullable Object): Bool do return not (self == other)
56
57 # Display self on stdout (debug only).
58 # This method MUST not be used by programs, it is here for debugging
59 # only and can be removed without any notice
60 fun output
61 do
62 '<'.output
63 object_id.output
64 '>'.output
65 end
66
67 # Display class name on stdout (debug only).
68 # This method MUST not be used by programs, it is here for debugging
69 # only and can be removed without any notice
70 fun output_class_name is intern
71
72 # The hash code of the object.
73 # Assuming that a == b -> a.hash == b.hash
74 ##
75 # Without redefinition, it is based on the `object_id` of the instance.
76 fun hash: Int do return object_id / 8
77 end
78
79 # The main class of the program.
80 # `Sys` is a singleton class, its only instance is `sys` defined in `Object`.
81 # `sys` is used to invoke methods on the program on the system.
82 class Sys
83 # Instructions outside classes implicitly redefine this method.
84 fun main do end
85
86 # The entry point for the execution of the whole program.
87 # Its job is to call `main` but some modules may want to refine it
88 # and inject specific work before or after the main part.
89 fun run do main
90
91 # Number of the last error
92 fun errno: Int is extern `{
93 return errno;
94 `}
95 end
96
97 # Quit the program with a specific return code
98 fun exit(exit_value: Int) is intern
99
100 # Return the global sys object, the only instance of the `Sys` class.
101 fun sys: Sys is intern
102
103
104 ###############################################################################
105 # Abstract Classes #
106 ###############################################################################
107
108 # The ancestor of class where objects are in a total order.
109 # In order to work, the method '<' has to be redefined.
110 interface Comparable
111 # What `self` can be compared to?
112 type OTHER: Comparable
113
114 # Is `self` lesser than `other`?
115 fun <(other: OTHER): Bool is abstract
116
117 # not `other` < `self`
118 # Note, the implementation must ensure that: `(x<=y) == (x<y or x==y)`
119 fun <=(other: OTHER): Bool do return not other < self
120
121 # not `self` < `other`
122 # Note, the implementation must ensure that: `(x>=y) == (x>y or x==y)`
123 fun >=(other: OTHER): Bool do return not self < other
124
125 # `other` < `self`
126 fun >(other: OTHER): Bool do return other < self
127
128 # -1 if <, +1 if > and 0 otherwise
129 # Note, the implementation must ensure that: (x<=>y == 0) == (x==y)
130 fun <=>(other: OTHER): Int
131 do
132 if self < other then
133 return -1
134 else if other < self then
135 return 1
136 else
137 return 0
138 end
139 end
140
141 # c <= self <= d
142 fun is_between(c: OTHER, d: OTHER): Bool
143 do
144 return c <= self and self <= d
145 end
146
147 # The maximum between `self` and `other` (prefers `self` if equals).
148 fun max(other: OTHER): OTHER
149 do
150 if self < other then
151 return other
152 else
153 return self
154 end
155 end
156
157 # The minimum between `self` and `c` (prefer `self` if equals)
158 fun min(c: OTHER): OTHER
159 do
160 if c < self then
161 return c
162 else
163 return self
164 end
165 end
166 end
167
168 # Discrete total orders.
169 interface Discrete
170 super Comparable
171
172 redef type OTHER: Discrete
173
174 # The next element.
175 fun successor(i: Int): OTHER is abstract
176
177 # The previous element.
178 fun predecessor(i: Int): OTHER is abstract
179
180 # The distance between self and d.
181 #
182 # assert 10.distance(15) == 5
183 # assert 'Z'.distance('A') == 25
184 fun distance(d: OTHER): Int
185 do
186 var cursor: OTHER
187 var stop: OTHER
188 if self < d then
189 cursor = self
190 stop = d
191 else if self > d then
192 cursor = d
193 stop = self
194 else
195 return 0
196 end
197
198 var nb = 0
199 while cursor < stop do
200 cursor = cursor.successor(1)
201 nb += 1
202 end
203 return nb
204 end
205 end
206
207 # A numeric value supporting mathematical operations
208 interface Numeric
209 super Comparable
210
211 redef type OTHER: Numeric
212
213 # Addition of `self` with `i`
214 fun +(i: OTHER): OTHER is abstract
215
216 # Substraction of `i` from `self`
217 fun -(i: OTHER): OTHER is abstract
218
219 # Inverse of `self`
220 fun -: OTHER is abstract
221
222 # Multiplication of `self` with `i`
223 fun *(i: OTHER): OTHER is abstract
224
225 # Division of `self` with `i`
226 fun /(i: OTHER): OTHER is abstract
227
228 # The integer part of `self`.
229 #
230 # assert (0.0).to_i == 0
231 # assert (0.9).to_i == 0
232 # assert (-0.9).to_i == 0
233 # assert (9.9).to_i == 9
234 # assert (-9.9).to_i == -9
235 fun to_i: Int is abstract
236
237 # The float equivalent of `self`
238 #
239 # assert 5.to_f == 5.0
240 # assert 5.to_f != 5 # Float and Int are not equals
241 fun to_f: Float is abstract
242
243 # Is this the value of zero in its domain?
244 fun is_zero: Bool do return self == zero
245
246 # The value of zero in the domain of `self`
247 fun zero: OTHER is abstract
248
249 # The value of `val` in the domain of `self`
250 #
251 # assert 1.0.value_of(2) == 2.0
252 # assert 1.0.value_of(2.0) == 2.0
253 # assert 1.value_of(2) == 2
254 # assert 1.value_of(2.0) == 2
255 fun value_of(val: Numeric): OTHER is abstract
256 end
257
258 ###############################################################################
259 # Native classes #
260 ###############################################################################
261
262 # Native Booleans.
263 # `true` and `false` are the only instances.
264 # Boolean are manipulated trough three special operators:
265 # `and`, `or`, `not`.
266 # Booleans are mainly used by conditional statement and loops.
267 universal Bool
268 redef fun object_id is intern
269 redef fun ==(b) is intern
270 redef fun !=(b) is intern
271 redef fun output is intern
272 redef fun hash do return to_i
273
274 # 1 if true and 0 if false
275 fun to_i: Int
276 do
277 if self then
278 return 1
279 else
280 return 0
281 end
282 end
283 end
284
285 # Native floating point numbers.
286 # Corresponds to C float.
287 universal Float
288 super Numeric
289
290 redef type OTHER: Float
291
292 redef fun object_id is intern
293 redef fun ==(i) is intern
294 redef fun !=(i) is intern
295 redef fun output is intern
296
297 redef fun <=(i): Bool is intern
298 redef fun <(i): Bool is intern
299 redef fun >=(i): Bool is intern
300 redef fun >(i): Bool is intern
301
302 redef fun +(i) is intern
303 redef fun - is intern
304 redef fun -(i) is intern
305 redef fun *(i) is intern
306 redef fun /(i) is intern
307
308 redef fun to_i is intern
309 redef fun to_f do return self
310
311 redef fun zero do return 0.0
312 redef fun value_of(val) do return val.to_f
313
314 redef fun <=>(other)
315 do
316 if self < other then
317 return -1
318 else if other < self then
319 return 1
320 else
321 return 0
322 end
323 end
324
325 redef fun is_between(c, d)
326 do
327 if self < c or d < self then
328 return false
329 else
330 return true
331 end
332 end
333
334 redef fun max(other)
335 do
336 if self < other then
337 return other
338 else
339 return self
340 end
341 end
342
343 redef fun min(c)
344 do
345 if c < self then
346 return c
347 else
348 return self
349 end
350 end
351 end
352
353 # Native integer numbers.
354 # Correspond to C int.
355 universal Int
356 super Discrete
357 super Numeric
358
359 redef type OTHER: Int
360
361 redef fun successor(i) do return self + i
362 redef fun predecessor(i) do return self - i
363
364 redef fun object_id is intern
365 redef fun hash do return self
366 redef fun ==(i) is intern
367 redef fun !=(i) is intern
368 redef fun output is intern
369
370 redef fun <=(i) is intern
371 redef fun <(i) is intern
372 redef fun >=(i) is intern
373 redef fun >(i) is intern
374 redef fun +(i) is intern
375
376 redef fun - is intern
377 redef fun -(i) is intern
378 redef fun *(i) is intern
379 redef fun /(i) is intern
380 fun %(i: Int): Int is intern
381
382 redef fun zero do return 0
383 redef fun value_of(val) do return val.to_i
384
385 # `i` bits shift fo the left (aka <<)
386 #
387 # assert 5.lshift(1) == 10
388 fun lshift(i: Int): Int is intern
389
390 # `i` bits shift fo the right (aka >>)
391 #
392 # assert 5.rshift(1) == 2
393 fun rshift(i: Int): Int is intern
394
395 redef fun to_i do return self
396 redef fun to_f is intern
397
398 redef fun distance(i)
399 do
400 var d = self - i
401 if d >= 0 then
402 return d
403 else
404 return -d
405 end
406 end
407
408 redef fun <=>(other)
409 do
410 if self < other then
411 return -1
412 else if other < self then
413 return 1
414 else
415 return 0
416 end
417 end
418
419 redef fun is_between(c, d)
420 do
421 if self < c or d < self then
422 return false
423 else
424 return true
425 end
426 end
427
428 redef fun max(other)
429 do
430 if self < other then
431 return other
432 else
433 return self
434 end
435 end
436
437 redef fun min(c)
438 do
439 if c < self then
440 return c
441 else
442 return self
443 end
444 end
445
446 # The character whose ASCII value is `self`.
447 #
448 # assert 65.ascii == 'A'
449 # assert 10.ascii == '\n'
450 fun ascii: Char is intern
451
452 # Number of digits of an integer in base `b` (plus one if negative)
453 #
454 # assert 123.digit_count(10) == 3
455 # assert 123.digit_count(2) == 7 # 1111011 in binary
456 fun digit_count(b: Int): Int
457 do
458 if b == 10 then return digit_count_base_10
459 var d: Int # number of digits
460 var n: Int # current number
461 # Sign
462 if self < 0 then
463 d = 1
464 n = - self
465 else if self == 0 then
466 return 1
467 else
468 d = 0
469 n = self
470 end
471 # count digits
472 while n > 0 do
473 d += 1
474 n = n / b # euclidian division /
475 end
476 return d
477 end
478
479 # Optimized version for base 10
480 fun digit_count_base_10: Int
481 do
482 var val: Int
483 var result: Int
484 if self < 0 then
485 result = 2
486 val = -self
487 else
488 result = 1
489 val = self
490 end
491 loop
492 if val < 10 then return result
493 if val < 100 then return result+1
494 if val < 1000 then return result+2
495 if val < 10000 then return result+3
496 val = val / 10000
497 result += 4
498 end
499 end
500
501 # Return the corresponding digit character
502 # If 0 <= `self` <= 9, return the corresponding character.
503 # assert 5.to_c == '5'
504 # If 10 <= `self` <= 36, return the corresponding letter [a..z].
505 # assert 15.to_c == 'f'
506 fun to_c: Char
507 do
508 assert self >= 0 and self <= 36 # TODO plan for this
509 if self < 10 then
510 return (self + '0'.ascii).ascii
511 else
512 return (self + ('a'.ascii - 10)).ascii
513 end
514 end
515
516 # The absolute value of self
517 #
518 # assert (-10).abs == 10
519 # assert 10.abs == 10
520 # assert 0.abs == 0
521 fun abs: Int
522 do
523 if self >= 0
524 then
525 return self
526 else
527 return -1 * self
528 end
529 end
530 end
531
532 # Native characters.
533 # Characters are denoted with simple quote.
534 # eg. `'a'` or `'\n'`.
535 universal Char
536 super Discrete
537 redef type OTHER: Char
538
539 redef fun object_id is intern
540 redef fun hash do return ascii
541 redef fun ==(o) is intern
542 redef fun !=(o) is intern
543 redef fun output is intern
544
545 redef fun <=(i) is intern
546 redef fun <(i) is intern
547 redef fun >=(i) is intern
548 redef fun >(i) is intern
549
550 redef fun successor(i) is intern
551 redef fun predecessor(i) is intern
552
553 redef fun distance(c)
554 do
555 var d = self.ascii - c.ascii
556 if d >= 0 then
557 return d
558 else
559 return -d
560 end
561 end
562
563 # If `self` is a digit then return this digit else return -1.
564 #
565 # assert '5'.to_i == 5
566 fun to_i: Int
567 do
568
569 if self == '-' then
570 return -1
571 else if is_digit then
572 return self.ascii - '0'.ascii
573 else
574 return self.to_lower.ascii - 'a'.ascii + 10
575 end
576 end
577
578 # the ascii value of self
579 #
580 # assert 'a'.ascii == 97
581 # assert '\n'.ascii == 10
582 fun ascii: Int is intern
583
584 # Return the lower case version of self.
585 # If self is not a letter, then return self
586 #
587 # assert 'A'.to_lower == 'a'
588 # assert 'a'.to_lower == 'a'
589 # assert '$'.to_lower == '$'
590 fun to_lower: Char
591 do
592 if is_upper then
593 return (ascii + ('a'.distance('A'))).ascii
594 else
595 return self
596 end
597 end
598
599 # Return the upper case version of self.
600 # If self is not a letter, then return self
601 #
602 # assert 'a'.to_upper == 'A'
603 # assert 'A'.to_upper == 'A'
604 # assert '$'.to_upper == '$'
605 fun to_upper: Char
606 do
607 if is_lower then
608 return (ascii - ('a'.distance('A'))).ascii
609 else
610 return self
611 end
612 end
613
614 # Is self a digit? (from '0' to '9')
615 #
616 # assert '0'.is_digit == true
617 # assert '9'.is_digit == true
618 # assert 'a'.is_digit == false
619 fun is_digit : Bool
620 do
621 return self >= '0' and self <= '9'
622 end
623
624 # Is self a lower case letter? (from 'a' to 'z')
625 #
626 # assert 'a'.is_lower == true
627 # assert 'z'.is_lower == true
628 # assert 'A'.is_lower == false
629 # assert '$'.is_lower == false
630 fun is_lower : Bool
631 do
632 return self >= 'a' and self <= 'z'
633 end
634
635 # Is self a upper case letter? (from 'A' to 'Z')
636 #
637 # assert 'A'.is_upper == true
638 # assert 'A'.is_upper == true
639 # assert 'z'.is_upper == false
640 # assert '$'.is_upper == false
641 fun is_upper : Bool
642 do
643 return self >= 'A' and self <= 'Z'
644 end
645
646 # Is self a letter? (from 'A' to 'Z' and 'a' to 'z')
647 #
648 # assert 'A'.is_letter == true
649 # assert 'A'.is_letter == true
650 # assert 'z'.is_letter == true
651 # assert '$'.is_letter == false
652 fun is_letter : Bool
653 do
654 return is_lower or is_upper
655 end
656 end
657
658 # Pointer classes are used to manipulate extern C structures.
659 extern class Pointer
660 # Is the address behind this Object at NULL?
661 fun address_is_null: Bool is extern "address_is_null"
662
663 # Free the memory pointed by this pointer
664 fun free `{ free(recv); `}
665 end
Nit language project; an oo programing language and its tool suite.