1 # This file is part of NIT ( http://www.nitlanguage.org ).
3 # This file is free software, which comes along with NIT. This software is
4 # distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
5 # without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
6 # PARTICULAR PURPOSE. You can modify it is you want, provided this header
7 # is kept unaltered, and a notification of the changes is added.
8 # You are allowed to redistribute it and sell it, alone or is a part of
11 # Basic integers of fixed-precision
13 # All classes defined here have C-equivalents and the semantics of their
14 # operations are the same as C's
18 # * UInt16 => uint16_t
20 # * UInt32 => uint32_t
22 # NOTE: No UInt8 is provided as Byte is the same
26 # All classes can be instanciated via a literal rule.
27 # Namely, a suffix to append after the literal integer.
45 # The Int8 equivalent of `self`
47 # assert (-1).to_i8 == 0xFFFFi8
48 # assert (1.9).to_i8 == 1i8
49 fun to_i8
: Int8 do return self.to_i
.to_i8
51 # The Int16 equivalent of `self`
53 # assert (-1).to_i16 == 0xFFFFi16
54 # assert (1.9).to_i16 == 1i16
55 fun to_i16
: Int16 do return self.to_i
.to_i16
57 # The UInt16 equivalent of `self`
59 # assert (-1).to_u16 == 0xFFFFu16
60 # assert (1.9).to_u16 == 1u16
61 fun to_u16
: UInt16 do return self.to_i
.to_u16
63 # The Int32 equivalent of `self`
65 # assert (-1).to_i32 == 0xFFFFFFFFi32
66 # assert (1.9).to_i32 == 1i32
67 fun to_i32
: Int32 do return self.to_i
.to_i32
69 # The UInt32 equivalent of `self`
71 # assert (-1).to_u32 == 0xFFFFFFFFu32
72 # assert (1.9).to_u32 == 1u32
73 fun to_u32
: UInt32 do return self.to_i
.to_u32
78 redef fun to_i8
is intern
79 redef fun to_i16
is intern
80 redef fun to_u16
is intern
81 redef fun to_i32
is intern
82 redef fun to_u32
is intern
86 redef fun to_i8
is intern
87 redef fun to_i16
is intern
88 redef fun to_u16
is intern
89 redef fun to_i32
is intern
90 redef fun to_u32
is intern
94 redef fun to_i8
is intern
95 redef fun to_i16
is intern
96 redef fun to_u16
is intern
97 redef fun to_i32
is intern
98 redef fun to_u32
is intern
101 # Native 8-bit signed integer.
102 # Same as a C `int8_t`
107 redef type OTHER: Int8
109 redef fun successor
(i
) do return self + i
.to_i8
110 redef fun predecessor
(i
) do return self - i
.to_i8
112 redef fun object_id
is intern
113 redef fun hash
do return self.to_i
114 redef fun ==(i
) is intern
115 redef fun !=(i
) is intern
116 redef fun output
is intern
118 redef fun <=(i
) is intern
119 redef fun <(i
) is intern
120 redef fun >=(i
) is intern
121 redef fun >(i
) is intern
122 redef fun +(i
) is intern
124 # assert -1i8 == 0xFFi8
125 # assert -0i8 == 0x00i8
126 redef fun - is intern
127 redef fun -(i
) is intern
128 redef fun *(i
) is intern
129 redef fun /(i
) is intern
131 # Modulo of `self` with `i`.
133 # Returns the remainder of division of `self` by `i`.
135 # assert 5i8 % 2i8 == 1i8
136 # assert 10i8 % 2i8 == 0i8
137 fun %(i
: Int8): Int8 is intern
139 redef fun zero
do return 0.to_i8
140 redef fun value_of
(val
) do return val
.to_i8
142 # `i` bits shift to the left
144 # assert 5i8 << 1 == 10i8
145 fun <<(i
: Int): Int8 is intern
147 # `i` bits shift to the right
149 # assert 5i8 >> 1 == 2i8
150 fun >>(i
: Int): Int8 is intern
152 redef fun to_i
is intern
153 redef fun to_f
is intern
154 redef fun to_b
is intern
155 redef fun to_i8
do return self
156 redef fun to_i16
is intern
157 redef fun to_u16
is intern
158 redef fun to_i32
is intern
159 redef fun to_u32
is intern
161 # Returns `self` as a Char according to its ASCII value.
162 fun ascii
: Char `{ return (uint32_t)self; `}
164 redef fun distance(i) do return (self - i).to_i
170 else if other < self then
177 redef fun is_between(c, d)
179 if self < c or d < self then
204 # Returns the result of a binary AND operation on `self` and `i
`
206 # assert 0x10i8 & 0x01i8 == 0i8
207 fun &(i: Int8): Int8 is intern
209 # Returns the result of a binary OR operation on `self` and `i
`
211 # assert 0x10i8 | 0x01i8 == 0x11i8
212 fun |(i: Int8): Int8 is intern
214 # Returns the result of a binary XOR operation on `self` and `i
`
216 # assert 0x101i8 ^ 0x110i8 == 0x11i8
217 fun ^(i: Int8): Int8 is intern
219 # Returns the 1's complement of `self`
221 # assert ~0x2Fi8 == 0xD0i8
222 fun ~: Int8 is intern
225 # Native 16-bit signed integer.
226 # Same as a C `int16_t
`
231 redef type OTHER: Int16
233 redef fun successor(i) do return self + i.to_i16
234 redef fun predecessor(i) do return self - i.to_i16
236 redef fun object_id is intern
237 redef fun hash do return self.to_i
238 redef fun ==(i) is intern
239 redef fun !=(i) is intern
240 redef fun output is intern
242 redef fun <=(i) is intern
243 redef fun <(i) is intern
244 redef fun >=(i) is intern
245 redef fun >(i) is intern
246 redef fun +(i) is intern
248 # assert -1i16 == 0xFFFFi16
249 # assert -0i16 == 0i16
250 redef fun - is intern
251 redef fun -(i) is intern
252 redef fun *(i) is intern
253 redef fun /(i) is intern
255 # Returns `self` as a Char according to its ASCII value.
256 fun ascii: Char `{ return (uint32_t)self; `}
258 # Modulo of `self` with `i`.
260 # Returns the remainder of division of `self` by `i`.
262 # assert 5i16 % 2i16 == 1i16
263 # assert 10i16 % 2i16 == 0i16
264 fun %(i
: Int16): Int16 is intern
266 redef fun zero
do return 0.to_i16
267 redef fun value_of
(val
) do return val
.to_i16
269 # `i` bits shift to the left
271 # assert 5i16 << 1 == 10i16
272 fun <<(i
: Int): Int16 is intern
274 # `i` bits shift to the right
276 # assert 5i16 >> 1 == 2i16
277 fun >>(i
: Int): Int16 is intern
279 redef fun to_i
is intern
280 redef fun to_f
is intern
281 redef fun to_b
is intern
282 redef fun to_i8
is intern
283 redef fun to_i16
do return self
284 redef fun to_u16
is intern
285 redef fun to_i32
is intern
286 redef fun to_u32
is intern
288 redef fun distance
(i
) do return (self - i
).to_i
294 else if other
< self then
301 redef fun is_between
(c
, d
)
303 if self < c
or d
< self then
328 # Returns the result of a binary AND operation on `self` and `i`
330 # assert 0x10i16 & 0x01i16 == 0i16
331 fun &(i
: Int16): Int16 is intern
333 # Returns the result of a binary OR operation on `self` and `i`
335 # assert 0x10i16 | 0x01i16 == 0x11i16
336 fun |(i
: Int16): Int16 is intern
338 # Returns the result of a binary XOR operation on `self` and `i`
340 # assert 0x101i16 ^ 0x110i16 == 0x11i16
341 fun ^
(i
: Int16): Int16 is intern
343 # Returns the 1's complement of `self`
345 # assert ~0x2Fi16 == 0xFFD0i16
346 fun ~
: Int16 is intern
349 # Native 16-bit unsigned integer.
350 # Same as a C `uint16_t`
355 redef type OTHER: UInt16
357 redef fun successor
(i
) do return self + i
.to_u16
358 redef fun predecessor
(i
) do return self - i
.to_u16
360 redef fun object_id
is intern
361 redef fun hash
do return self.to_i
362 redef fun ==(i
) is intern
363 redef fun !=(i
) is intern
364 redef fun output
is intern
366 redef fun <=(i
) is intern
367 redef fun <(i
) is intern
368 redef fun >=(i
) is intern
369 redef fun >(i
) is intern
370 redef fun +(i
) is intern
372 # assert -1u16 == 0xFFFFu16
373 # assert -0u16 == 0u16
374 redef fun - is intern
375 redef fun -(i
) is intern
376 redef fun *(i
) is intern
377 redef fun /(i
) is intern
379 # Modulo of `self` with `i`.
381 # Returns the remainder of division of `self` by `i`.
383 # assert 5u16 % 2u16 == 1u16
384 # assert 10u16 % 2u16 == 0u16
385 fun %(i
: UInt16): UInt16 is intern
387 redef fun zero
do return 0.to_u16
388 redef fun value_of
(val
) do return val
.to_u16
390 # Returns `self` as a Char according to its ASCII value.
391 fun ascii
: Char `{ return (uint32_t)self; `}
393 # `i
` bits shift to the left
395 # assert 5u16 << 1 == 10u16
396 fun <<(i: Int): UInt16 is intern
398 # `i
` bits shift to the right
400 # assert 5u16 >> 1 == 2u16
401 fun >>(i: Int): UInt16 is intern
403 redef fun to_i is intern
404 redef fun to_f is intern
405 redef fun to_b is intern
406 redef fun to_i8 is intern
407 redef fun to_i16 is intern
408 redef fun to_u16 do return self
409 redef fun to_i32 is intern
410 redef fun to_u32 is intern
412 redef fun distance(i) do return (self - i).to_i
418 else if other < self then
425 redef fun is_between(c, d)
427 if self < c or d < self then
452 # Returns the result of a binary AND operation on `self` and `i
`
454 # assert 0x10u16 & 0x01u16 == 0u16
455 fun &(i: UInt16): UInt16 is intern
457 # Returns the result of a binary OR operation on `self` and `i
`
459 # assert 0x10u16 | 0x01u16 == 0x11u16
460 fun |(i: UInt16): UInt16 is intern
462 # Returns the result of a binary XOR operation on `self` and `i
`
464 # assert 0x101u16 ^ 0x110u16 == 0x11u16
465 fun ^(i: UInt16): UInt16 is intern
467 # Returns the 1's complement of `self`
469 # assert ~0x2Fu16 == 0xFFD0u16
470 fun ~: UInt16 is intern
473 # Native 32-bit signed integer.
474 # Same as a C `int32_t
`
479 redef type OTHER: Int32
481 redef fun successor(i) do return self + i.to_i32
482 redef fun predecessor(i) do return self - i.to_i32
484 redef fun object_id is intern
485 redef fun hash do return self.to_i
486 redef fun ==(i) is intern
487 redef fun !=(i) is intern
488 redef fun output is intern
490 redef fun <=(i) is intern
491 redef fun <(i) is intern
492 redef fun >=(i) is intern
493 redef fun >(i) is intern
494 redef fun +(i) is intern
496 # assert -1i32 == 0xFFFFFFFFi32
497 # assert -0i32 == 0x00i32
498 redef fun - is intern
499 redef fun -(i) is intern
500 redef fun *(i) is intern
501 redef fun /(i) is intern
503 # Returns `self` as a Char according to its ASCII value.
504 fun ascii: Char `{ return (uint32_t)self; `}
506 # Modulo of `self` with `i`.
508 # Returns the remainder of division of `self` by `i`.
510 # assert 5i32 % 2i32 == 1i32
511 # assert 10i32 % 2i32 == 0i32
512 fun %(i
: Int32): Int32 is intern
514 redef fun zero
do return 0.to_i32
515 redef fun value_of
(val
) do return val
.to_i32
517 # `i` bits shift to the left
519 # assert 5i32 << 1 == 10i32
520 fun <<(i
: Int): Int32 is intern
522 # `i` bits shift to the right
524 # assert 5i32 >> 1 == 2i32
525 fun >>(i
: Int): Int32 is intern
527 redef fun to_i
is intern
528 redef fun to_f
is intern
529 redef fun to_b
is intern
530 redef fun to_i8
is intern
531 redef fun to_i16
is intern
532 redef fun to_u16
is intern
533 redef fun to_i32
do return self
534 redef fun to_u32
is intern
536 redef fun distance
(i
) do return (self - i
).to_i
542 else if other
< self then
549 redef fun is_between
(c
, d
)
551 if self < c
or d
< self then
576 # Returns the result of a binary AND operation on `self` and `i`
578 # assert 0x10i32 & 0x01i32 == 0i32
579 fun &(i
: Int32): Int32 is intern
581 # Returns the result of a binary OR operation on `self` and `i`
583 # assert 0x10i32 | 0x01i32 == 0x11i32
584 fun |(i
: Int32): Int32 is intern
586 # Returns the result of a binary XOR operation on `self` and `i`
588 # assert 0x101i32 ^ 0x110i32 == 0x11i32
589 fun ^
(i
: Int32): Int32 is intern
591 # Returns the 1's complement of `self`
593 # assert ~0x2Fi32 == 0xFFFFFFD0i32
594 fun ~
: Int32 is intern
597 # Native 32-bit unsigned integer.
598 # Same as a C `uint32_t`
603 redef type OTHER: UInt32
605 redef fun successor
(i
) do return self + i
.to_u32
606 redef fun predecessor
(i
) do return self - i
.to_u32
608 redef fun object_id
is intern
609 redef fun hash
do return self.to_i
610 redef fun ==(i
) is intern
611 redef fun !=(i
) is intern
612 redef fun output
is intern
614 redef fun <=(i
) is intern
615 redef fun <(i
) is intern
616 redef fun >=(i
) is intern
617 redef fun >(i
) is intern
618 redef fun +(i
) is intern
620 # assert -1u32 == 0xFFFFFFFFu32
621 # assert -0u32 == 0x00u32
622 redef fun - is intern
623 redef fun -(i
) is intern
624 redef fun *(i
) is intern
625 redef fun /(i
) is intern
627 # Returns `self` as a Char according to its ASCII value.
628 fun ascii
: Char `{ return (uint32_t)self; `}
630 # Modulo of `self` with `i
`.
632 # Returns the remainder of division of `self` by `i
`.
634 # assert 5u32 % 2u32 == 1u32
635 # assert 10u32 % 2u32 == 0u32
636 fun %(i: UInt32): UInt32 is intern
638 redef fun zero do return 0.to_u32
639 redef fun value_of(val) do return val.to_u32
641 # `i
` bits shift to the left
643 # assert 5u32 << 1 == 10u32
644 fun <<(i: Int): UInt32 is intern
646 # `i
` bits shift to the right
648 # assert 5u32 >> 1 == 2u32
649 fun >>(i: Int): UInt32 is intern
651 redef fun to_i is intern
652 redef fun to_f is intern
653 redef fun to_b is intern
654 redef fun to_i8 is intern
655 redef fun to_i16 is intern
656 redef fun to_u16 is intern
657 redef fun to_i32 is intern
658 redef fun to_u32 do return self
660 redef fun distance(i) do return (self - i).to_i
666 else if other < self then
673 redef fun is_between(c, d)
675 if self < c or d < self then
700 # Returns the result of a binary AND operation on `self` and `i
`
702 # assert 0x10u32 & 0x01u32 == 0u32
703 fun &(i: UInt32): UInt32 is intern
705 # Returns the result of a binary OR operation on `self` and `i
`
707 # assert 0x10u32 | 0x01u32 == 0x11u32
708 fun |(i: UInt32): UInt32 is intern
710 # Returns the result of a binary XOR operation on `self` and `i
`
712 # assert 0x101u32 ^ 0x110u32 == 0x11u32
713 fun ^(i: UInt32): UInt32 is intern
715 # Returns the 1's complement of `self`
717 # assert ~0x2Fu32 == 0xFFFFFFD0u32
718 fun ~: UInt32 is intern