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 # This module is the root of the standard module hierarchy.
  15 package kernel
  16
  17 import end # Mark this module is a top level one. (must be only one)
  18
  19 ###############################################################################
  20 # System Classes                                                              #
  21 ###############################################################################
  22
  23 # The root of the class hierarchy.
  24 # Each class implicitely specialize Object.
  25 interface Object
  26         # The unique object identifier in the class
  27         meth object_id: Int is intern
  28
  29         # Return true is `self' and `other' have the same dynamic type
  30         meth is_same_type(other: Object): Bool is intern
  31
  32         # Have `self' and `other' the same value?
  33         ##
  34         # Implicitely, the default implementation, is ==
  35         meth ==(other: Object): Bool do return self is other
  36
  37         # Have `self' and `other' different values?
  38         ##
  39         # != is equivament with "not =".
  40         meth !=(other: Object): Bool do return not (self == other)
  41
  42         # Display self on stdout (debug only).
  43         meth output
  44         do
  45                 '<'.output
  46                 object_id.output
  47                 '>'.output
  48         end
  49
  50         protected meth exit(exit_value: Int) is intern # Quit the program.
  51         protected meth sys: Sys is intern # The global sys object
  52 end
  53
  54 # The main class of the program.
  55 class Sys
  56         # Instructions outside classes implicetely redefine this method.
  57         meth main do end
  58 end
  59
  60 ###############################################################################
  61 # Abstract Classes                                                            #
  62 ###############################################################################
  63
  64 # The ancestor of class where objects are in a total order.
  65 # In order to work, the method '<' has to be redefined.
  66 interface Comparable
  67         type OTHER: Comparable
  68
  69         # Is `self' lesser than `other'
  70         meth <(other: OTHER): Bool is abstract
  71
  72         # not `other' < `self'
  73         meth <=(other: OTHER): Bool do return not other < self
  74
  75         # not `self' < `other'
  76         meth >=(other: OTHER): Bool do return not self < other
  77
  78         # `other' < `self'
  79         meth >(other: OTHER): Bool do return other < self
  80
  81         # -1 if <, +1 if > and 0 otherwise
  82         meth <=>(other: OTHER): Int
  83         do
  84                 if self < other then
  85                         return -1
  86                 else if other < self then
  87                         return 1
  88                 else
  89                         return 0
  90                 end
  91         end
  92
  93         # c <= self <= d
  94         meth is_between(c: OTHER, d: OTHER): Bool
  95         do
  96                 return c <= self and self <= d
  97         end
  98
  99         # The maximum between `self' and `other' (prefers `self' if equals).
 100         meth max(other: OTHER): OTHER
 101         do
 102                 if self < other then
 103                         return other
 104                 else
 105                         return self
 106                 end
 107         end
 108
 109         # The minimum between `self' and `c' (prefer `self' if equals)
 110         meth min(c: OTHER): OTHER
 111         do
 112                 if c < self then
 113                         return c
 114                 else
 115                         return self
 116                 end
 117         end
 118 end
 119
 120 # Discrete total orders.
 121 interface Discrete
 122 special Comparable
 123
 124         redef type OTHER: Discrete
 125
 126         # The next element.
 127         meth succ: OTHER do return self + 1
 128
 129         # The previous element.
 130         meth prec: OTHER do return self - 1
 131
 132         # The `i' th successor element.
 133         meth +(i: Int): OTHER is abstract
 134
 135         # The `i' th previous element.
 136         meth -(i: Int): OTHER is abstract
 137
 138         # The distance between self and d.
 139         # 10.distance(15)       # --> 5
 140         # 'Z'.distance('A')     # --> 25
 141         meth distance(d: OTHER): Int
 142         do
 143                 var cursor: OTHER
 144                 var stop: OTHER
 145                 if self < d then
 146                         cursor = self
 147                         stop = d
 148                 else if self > d then
 149                         cursor = d
 150                         stop = self
 151                 else
 152                         return 0
 153                 end
 154
 155                 var nb = 0
 156                 while cursor < stop do
 157                         cursor = cursor.succ
 158                         nb += 1
 159                 end
 160                 return nb
 161         end
 162 end
 163
 164 ###############################################################################
 165 # Native classes                                                              #
 166 ###############################################################################
 167
 168 # Native booleans.
 169 # `true' and `false' are the only instances.
 170 # Boolean are manipulated trought three special operators:
 171 #        `and', `or', `not'.
 172 # Booleans are mainly used by conditional statement and loops.
 173 universal Bool
 174         redef meth object_id is intern
 175         redef meth ==(b) is intern
 176         redef meth !=(b) is intern
 177         redef meth output is intern
 178 end
 179
 180 # Native floating point numbers.
 181 # Corresponds to C float.
 182 universal Float
 183         redef meth object_id is intern
 184         redef meth output is intern
 185
 186         meth <=(i: Float): Bool is intern
 187         meth <(i: Float): Bool is intern
 188         meth >=(i: Float): Bool is intern
 189         meth >(i: Float): Bool is intern
 190         meth +(i: Float): Float is intern
 191         meth -: Float is intern
 192         meth -(i: Float): Float is intern
 193         meth *(i: Float): Float is intern
 194         meth /(i: Float): Float is intern
 195
 196         # The integer part of `self'.
 197         meth to_i: Int is intern
 198 end
 199
 200 # Native integer numbers.
 201 # Correspond to C int.
 202 universal Int
 203 special Discrete
 204         redef type OTHER: Int
 205
 206         redef meth object_id is intern
 207         redef meth ==(i) is intern
 208         redef meth !=(i) is intern
 209         redef meth output is intern
 210
 211         redef meth <=(i) is intern
 212         redef meth <(i) is intern
 213         redef meth >=(i) is intern
 214         redef meth >(i) is intern
 215         redef meth +(i) is intern
 216         meth -: Int is intern
 217         redef meth -(i) is intern
 218         meth *(i: Int): Int is intern
 219         meth /(i: Int): Int is intern
 220         meth %(i: Int): Int is intern
 221         meth lshift(i: Int): Int is intern
 222         meth rshift(i: Int): Int is intern
 223
 224         # The float equivalent of `self'
 225         meth to_f: Float is intern
 226
 227         redef meth succ is intern
 228         redef meth prec is intern
 229         redef meth distance(i)
 230         do
 231                 var d = self - i
 232                 if d >= 0 then
 233                         return d
 234                 else
 235                         return -d
 236                 end
 237         end
 238
 239         redef meth <=>(other)
 240         do
 241                 if self < other then
 242                         return -1
 243                 else if other < self then
 244                         return 1
 245                 else
 246                         return 0
 247                 end
 248         end
 249
 250         redef meth is_between(c, d)
 251         do
 252                 if self < c or d < self then
 253                         return false
 254                 else
 255                         return true
 256                 end
 257         end
 258
 259         redef meth max(other)
 260         do
 261                 if self < other then
 262                         return other
 263                 else
 264                         return self
 265                 end
 266         end
 267
 268         redef meth min(c)
 269         do
 270                 if c < self then
 271                         return c
 272                 else
 273                         return self
 274                 end
 275         end
 276
 277         # The character whose ASCII value is `self'.
 278         meth ascii: Char is intern
 279
 280         # Number of digits of an integer in base `b' plus one if negative)
 281         meth digit_count(b: Int): Int
 282         do
 283                 var d: Int # number of digits
 284                 var n: Int # current number
 285                 # Sign
 286                 if self < 0 then
 287                         d = 1
 288                         n = - self
 289                 else if self == 0 then
 290                         return 1
 291                 else
 292                         d = 0
 293                         n = self
 294                 end
 295                 # count digits
 296                 while n > 0 do
 297                         d += 1
 298                         n = n / b       # euclidian division /
 299                 end
 300                 return d
 301         end
 302
 303         # Return the corresponding digit character
 304         # If 0 <= `self' <= 9, return the corresponding character.
 305         # If 10 <= `self' <= 36, return the corresponding letter [a..z].
 306         meth to_c: Char
 307         do
 308                 assert self >= 0 and self <= 36 # TODO plan for this
 309                 if self < 10 then
 310                         return (self + '0'.ascii).ascii
 311                 else
 312                         return (self + ('a'.ascii - 10)).ascii
 313                 end
 314         end
 315 end
 316
 317 # Native characters.
 318 # Characters are denoted with simple quote.
 319 # eg. 'a' or '\n'.
 320 universal Char
 321 special Discrete
 322         redef type OTHER: Char
 323
 324         redef meth object_id is intern
 325         redef meth ==(o) is intern
 326         redef meth !=(o) is intern
 327         redef meth output is intern
 328
 329         redef meth <=(i) is intern
 330         redef meth <(i) is intern
 331         redef meth >=(i) is intern
 332         redef meth >(i) is intern
 333
 334         redef meth succ is intern
 335         redef meth prec is intern
 336
 337         redef meth distance(c)
 338         do
 339                 var d = self.ascii - c.ascii
 340                 if d >= 0 then
 341                         return d
 342                 else
 343                         return -d
 344                 end
 345         end
 346
 347         # If `self' is a digit then return this digit.
 348         meth to_i: Int
 349         do
 350
 351                 if self == '-' then
 352                         return -1
 353                 else if self >= '0' and self <= '9' then
 354                         return self.ascii - '0'.ascii
 355                 else
 356                         return self.to_lower.ascii - ('a'.ascii + 10)
 357                 end
 358         end
 359
 360         # the ascii value of self
 361         meth ascii: Int is intern
 362
 363         redef meth +(i) is intern
 364         redef meth -(i) is intern
 365
 366         # Char to lower case
 367         meth to_lower : Char
 368         do
 369                 if self >= 'A' and self <= 'Z' then
 370                         return (ascii + ('a'.distance('A'))).ascii
 371                 else
 372                         return self
 373                 end
 374         end
 375
 376         # Char to upper case
 377         meth to_upper : Char
 378         do
 379                 if self >= 'a' and self <= 'z' then
 380                         return (ascii - ('a'.distance('A'))).ascii
 381                 else
 382                         return self
 383                 end
 384         end
 385 end
 386
 387 # Pointer classes are used to manipulate extern C structures.
 388 universal Pointer
 389 end