basis-library/primitive/prim-word.sml

   1 (* Copyright (C) 1999-2007 Henry Cejtin, Matthew Fluet, Suresh
   2  *    Jagannathan, and Stephen Weeks.
   3  * Copyright (C) 1997-2000 NEC Research Institute.
   4  *
   5  * MLton is released under a BSD-style license.
   6  * See the file MLton-LICENSE for details.
   7  *)
   8
   9 (* Primitive names are special -- see atoms/prim.fun. *)
  10
  11 signature PRIM_WORD =
  12    sig
  13       eqtype word
  14       type t = word
  15
  16       val sizeInBits: Primitive.Int32.int
  17       val sizeInBitsWord: Primitive.Word32.word
  18
  19       val + : word * word -> word
  20       val andb : word * word -> word
  21       val <<? : word * Primitive.Word32.word -> word
  22       val * : word * word -> word
  23       val ~ : word -> word
  24       val notb : word -> word
  25       val orb : word * word -> word
  26       val quotUnsafe : word * word -> word
  27       val remUnsafe: word * word -> word
  28       val rolUnsafe: word * Primitive.Word32.word -> word
  29       val rorUnsafe: word * Primitive.Word32.word -> word
  30       val ~>>? : word * Primitive.Word32.word -> word
  31       val >>? : word * Primitive.Word32.word -> word
  32       val - : word * word -> word
  33       val xorb: word * word -> word
  34
  35       val < : word * word -> bool
  36       val <= : word * word -> bool
  37       val > : word * word -> bool
  38       val >= : word * word -> bool
  39       val compare: word * word -> Primitive.Order.order
  40       val min: word * word -> word
  41       val max: word * word -> word
  42    end
  43
  44 structure Primitive = struct
  45
  46 open Primitive
  47
  48 structure Word1 =
  49    struct
  50       open Word1
  51       type big = Word8.word
  52       val fromBigUnsafe = _prim "WordU8_extdToWord1": big -> word;
  53       val toBig = _prim "WordU1_extdToWord8": word -> big;
  54       val sizeInBits: Int32.int = 1
  55    end
  56 structure Word2 =
  57    struct
  58       open Word2
  59       type big = Word8.word
  60       val fromBigUnsafe = _prim "WordU8_extdToWord2": big -> word;
  61       val toBig = _prim "WordU2_extdToWord8": word -> big;
  62       val sizeInBits: Int32.int = 2
  63    end
  64 structure Word3 =
  65    struct
  66       open Word3
  67       type big = Word8.word
  68       val fromBigUnsafe = _prim "WordU8_extdToWord3": big -> word;
  69       val toBig = _prim "WordU3_extdToWord8": word -> big;
  70       val sizeInBits: Int32.int = 3
  71    end
  72 structure Word4 =
  73    struct
  74       open Word4
  75       type big = Word8.word
  76       val fromBigUnsafe = _prim "WordU8_extdToWord4": big -> word;
  77       val toBig = _prim "WordU4_extdToWord8": word -> big;
  78       val sizeInBits: Int32.int = 4
  79    end
  80 structure Word5 =
  81    struct
  82       open Word5
  83       type big = Word8.word
  84       val fromBigUnsafe = _prim "WordU8_extdToWord5": big -> word;
  85       val toBig = _prim "WordU5_extdToWord8": word -> big;
  86       val sizeInBits: Int32.int = 5
  87    end
  88 structure Word6 =
  89    struct
  90       open Word6
  91       type big = Word8.word
  92       val fromBigUnsafe = _prim "WordU8_extdToWord6": big -> word;
  93       val toBig = _prim "WordU6_extdToWord8": word -> big;
  94       val sizeInBits: Int32.int = 6
  95    end
  96 structure Word7 =
  97    struct
  98       open Word7
  99       type big = Word8.word
 100       val fromBigUnsafe = _prim "WordU8_extdToWord7": big -> word;
 101       val toBig = _prim "WordU7_extdToWord8": word -> big;
 102       val sizeInBits: Int32.int = 7
 103    end
 104 structure Word8 =
 105    struct
 106       open Word8
 107
 108       val sizeInBits: Int32.int = 8
 109       val sizeInBitsWord: Word32.word =
 110          IntWordConv.zextdFromInt32ToWord32 sizeInBits
 111
 112       val + = _prim "Word8_add": word * word -> word;
 113       val andb = _prim "Word8_andb": word * word -> word;
 114       val <<? = _prim "Word8_lshift": word * Word32.word -> word;
 115       val * = _prim "WordU8_mul": word * word -> word;
 116       val ~ = _prim "Word8_neg": word -> word;
 117       val notb = _prim "Word8_notb": word -> word;
 118       val orb = _prim "Word8_orb": word * word -> word;
 119       val quotUnsafe = _prim "WordU8_quot": word * word -> word;
 120       val remUnsafe = _prim "WordU8_rem": word * word -> word;
 121       val rolUnsafe = _prim "Word8_rol": word * Word32.word -> word;
 122       val rorUnsafe = _prim "Word8_ror": word * Word32.word -> word;
 123       val ~>>? = _prim "WordS8_rshift": word * Word32.word -> word;
 124       val >>? = _prim "WordU8_rshift": word * Word32.word -> word;
 125       val - = _prim "Word8_sub": word * word -> word;
 126       val xorb = _prim "Word8_xorb": word * word -> word;
 127
 128       val < = _prim "WordU8_lt": word * word -> bool;
 129    end
 130 structure Word8 : PRIM_WORD =
 131    struct
 132       open Word8
 133       local
 134          structure S = IntegralComparisons(Word8)
 135       in
 136          open S
 137       end
 138    end
 139 structure Word9 =
 140    struct
 141       open Word9
 142       type big = Word16.word
 143       val fromBigUnsafe = _prim "WordU16_extdToWord9": big -> word;
 144       val toBig = _prim "WordU9_extdToWord16": word -> big;
 145       val sizeInBits: Int32.int = 9
 146    end
 147 structure Word10 =
 148    struct
 149       open Word10
 150       type big = Word16.word
 151       val fromBigUnsafe = _prim "WordU16_extdToWord10": big -> word;
 152       val toBig = _prim "WordU10_extdToWord16": word -> big;
 153       val sizeInBits: Int32.int = 10
 154    end
 155 structure Word11 =
 156    struct
 157       open Word11
 158       type big = Word16.word
 159       val fromBigUnsafe = _prim "WordU16_extdToWord11": big -> word;
 160       val toBig = _prim "WordU11_extdToWord16": word -> big;
 161       val sizeInBits: Int32.int = 11
 162    end
 163 structure Word12 =
 164    struct
 165       open Word12
 166       type big = Word16.word
 167       val fromBigUnsafe = _prim "WordU16_extdToWord12": big -> word;
 168       val toBig = _prim "WordU12_extdToWord16": word -> big;
 169       val sizeInBits: Int32.int = 12
 170    end
 171 structure Word13 =
 172    struct
 173       open Word13
 174       type big = Word16.word
 175       val fromBigUnsafe = _prim "WordU16_extdToWord13": big -> word;
 176       val toBig = _prim "WordU13_extdToWord16": word -> big;
 177       val sizeInBits: Int32.int = 13
 178    end
 179 structure Word14 =
 180    struct
 181       open Word14
 182       type big = Word16.word
 183       val fromBigUnsafe = _prim "WordU16_extdToWord14": big -> word;
 184       val toBig = _prim "WordU14_extdToWord16": word -> big;
 185       val sizeInBits: Int32.int = 14
 186    end
 187 structure Word15 =
 188    struct
 189       open Word15
 190       type big = Word16.word
 191       val fromBigUnsafe = _prim "WordU16_extdToWord15": big -> word;
 192       val toBig = _prim "WordU15_extdToWord16": word -> big;
 193       val sizeInBits: Int32.int = 15
 194    end
 195 structure Word16 =
 196    struct
 197       open Word16
 198
 199       val sizeInBits: Int32.int = 16
 200       val sizeInBitsWord: Word32.word =
 201          IntWordConv.zextdFromInt32ToWord32 sizeInBits
 202
 203       val + = _prim "Word16_add": word * word -> word;
 204       val andb = _prim "Word16_andb": word * word -> word;
 205       val <<? = _prim "Word16_lshift": word * Word32.word -> word;
 206       val * = _prim "WordU16_mul": word * word -> word;
 207       val ~ = _prim "Word16_neg": word -> word;
 208       val notb = _prim "Word16_notb": word -> word;
 209       val orb = _prim "Word16_orb": word * word -> word;
 210       val quotUnsafe = _prim "WordU16_quot": word * word -> word;
 211       val remUnsafe = _prim "WordU16_rem": word * word -> word;
 212       val rolUnsafe = _prim "Word16_rol": word * Word32.word -> word;
 213       val rorUnsafe = _prim "Word16_ror": word * Word32.word -> word;
 214       val ~>>? = _prim "WordS16_rshift": word * Word32.word -> word;
 215       val >>? = _prim "WordU16_rshift": word * Word32.word -> word;
 216       val - = _prim "Word16_sub": word * word -> word;
 217       val xorb = _prim "Word16_xorb": word * word -> word;
 218
 219       val < = _prim "WordU16_lt": word * word -> bool;
 220    end
 221 structure Word16 : PRIM_WORD =
 222    struct
 223       open Word16
 224       local
 225          structure S = IntegralComparisons(Word16)
 226       in
 227          open S
 228       end
 229    end
 230 structure Word17 =
 231    struct
 232       open Word17
 233       type big = Word32.word
 234       val fromBigUnsafe = _prim "WordU32_extdToWord17": big -> word;
 235       val toBig = _prim "WordU17_extdToWord32": word -> big;
 236       val sizeInBits: Int32.int = 17
 237    end
 238 structure Word18 =
 239    struct
 240       open Word18
 241       type big = Word32.word
 242       val fromBigUnsafe = _prim "WordU32_extdToWord18": big -> word;
 243       val toBig = _prim "WordU18_extdToWord32": word -> big;
 244       val sizeInBits: Int32.int = 18
 245    end
 246 structure Word19 =
 247    struct
 248       open Word19
 249       type big = Word32.word
 250       val fromBigUnsafe = _prim "WordU32_extdToWord19": big -> word;
 251       val toBig = _prim "WordU19_extdToWord32": word -> big;
 252       val sizeInBits: Int32.int = 19
 253    end
 254 structure Word20 =
 255    struct
 256       open Word20
 257       type big = Word32.word
 258       val fromBigUnsafe = _prim "WordU32_extdToWord20": big -> word;
 259       val toBig = _prim "WordU20_extdToWord32": word -> big;
 260       val sizeInBits: Int32.int = 20
 261    end
 262 structure Word21 =
 263    struct
 264       open Word21
 265       type big = Word32.word
 266       val fromBigUnsafe = _prim "WordU32_extdToWord21": big -> word;
 267       val toBig = _prim "WordU21_extdToWord32": word -> big;
 268       val sizeInBits: Int32.int = 21
 269    end
 270 structure Word22 =
 271    struct
 272       open Word22
 273       type big = Word32.word
 274       val fromBigUnsafe = _prim "WordU32_extdToWord22": big -> word;
 275       val toBig = _prim "WordU22_extdToWord32": word -> big;
 276       val sizeInBits: Int32.int = 22
 277    end
 278 structure Word23 =
 279    struct
 280       open Word23
 281       type big = Word32.word
 282       val fromBigUnsafe = _prim "WordU32_extdToWord23": big -> word;
 283       val toBig = _prim "WordU23_extdToWord32": word -> big;
 284       val sizeInBits: Int32.int = 23
 285    end
 286 structure Word24 =
 287    struct
 288       open Word24
 289       type big = Word32.word
 290       val fromBigUnsafe = _prim "WordU32_extdToWord24": big -> word;
 291       val toBig = _prim "WordU24_extdToWord32": word -> big;
 292       val sizeInBits: Int32.int = 24
 293    end
 294 structure Word25 =
 295    struct
 296       open Word25
 297       type big = Word32.word
 298       val fromBigUnsafe = _prim "WordU32_extdToWord25": big -> word;
 299       val toBig = _prim "WordU25_extdToWord32": word -> big;
 300       val sizeInBits: Int32.int = 25
 301    end
 302 structure Word26 =
 303    struct
 304       open Word26
 305       type big = Word32.word
 306       val fromBigUnsafe = _prim "WordU32_extdToWord26": big -> word;
 307       val toBig = _prim "WordU26_extdToWord32": word -> big;
 308       val sizeInBits: Int32.int = 26
 309    end
 310 structure Word27 =
 311    struct
 312       open Word27
 313       type big = Word32.word
 314       val fromBigUnsafe = _prim "WordU32_extdToWord27": big -> word;
 315       val toBig = _prim "WordU27_extdToWord32": word -> big;
 316       val sizeInBits: Int32.int = 27
 317    end
 318 structure Word28 =
 319    struct
 320       open Word28
 321       type big = Word32.word
 322       val fromBigUnsafe = _prim "WordU32_extdToWord28": big -> word;
 323       val toBig = _prim "WordU28_extdToWord32": word -> big;
 324       val sizeInBits: Int32.int = 28
 325    end
 326 structure Word29 =
 327    struct
 328       open Word29
 329       type big = Word32.word
 330       val fromBigUnsafe = _prim "WordU32_extdToWord29": big -> word;
 331       val toBig = _prim "WordU29_extdToWord32": word -> big;
 332       val sizeInBits: Int32.int = 29
 333    end
 334 structure Word30 =
 335    struct
 336       open Word30
 337       type big = Word32.word
 338       val fromBigUnsafe = _prim "WordU32_extdToWord30": big -> word;
 339       val toBig = _prim "WordU30_extdToWord32": word -> big;
 340       val sizeInBits: Int32.int = 30
 341    end
 342 structure Word31 =
 343    struct
 344       open Word31
 345       type big = Word32.word
 346       val fromBigUnsafe = _prim "WordU32_extdToWord31": big -> word;
 347       val toBig = _prim "WordU31_extdToWord32": word -> big;
 348       val sizeInBits: Int32.int = 31
 349    end
 350 structure Word32 =
 351    struct
 352       open Word32
 353
 354       val sizeInBits: Int32.int = 32
 355       val sizeInBitsWord: Word32.word =
 356          IntWordConv.zextdFromInt32ToWord32 sizeInBits
 357
 358       val + = _prim "Word32_add": word * word -> word;
 359       val andb = _prim "Word32_andb": word * word -> word;
 360       val <<? = _prim "Word32_lshift": word * Word32.word -> word;
 361       val * = _prim "WordU32_mul": word * word -> word;
 362       val ~ = _prim "Word32_neg": word -> word;
 363       val notb = _prim "Word32_notb": word -> word;
 364       val orb = _prim "Word32_orb": word * word -> word;
 365       val quotUnsafe = _prim "WordU32_quot": word * word -> word;
 366       val remUnsafe = _prim "WordU32_rem": word * word -> word;
 367       val rolUnsafe = _prim "Word32_rol": word * Word32.word -> word;
 368       val rorUnsafe = _prim "Word32_ror": word * Word32.word -> word;
 369       val ~>>? = _prim "WordS32_rshift": word * Word32.word -> word;
 370       val >>? = _prim "WordU32_rshift": word * Word32.word -> word;
 371       val - = _prim "Word32_sub": word * word -> word;
 372       val xorb = _prim "Word32_xorb": word * word -> word;
 373
 374       val < = _prim "WordU32_lt": word * word -> bool;
 375    end
 376 structure Word32 : PRIM_WORD =
 377    struct
 378       open Word32
 379       local
 380          structure S = IntegralComparisons(Word32)
 381       in
 382          open S
 383       end
 384    end
 385 structure Word64 =
 386    struct
 387       open Word64
 388
 389       val sizeInBits: Int32.int = 64
 390       val sizeInBitsWord: Word32.word =
 391          IntWordConv.zextdFromInt32ToWord32 sizeInBits
 392
 393       val + = _prim "Word64_add": word * word -> word;
 394       val andb = _prim "Word64_andb": word * word -> word;
 395       val <<? = _prim "Word64_lshift": word * Word32.word -> word;
 396       val * = _prim "WordU64_mul": word * word -> word;
 397       val ~ = _prim "Word64_neg": word -> word;
 398       val notb = _prim "Word64_notb": word -> word;
 399       val orb = _prim "Word64_orb": word * word -> word;
 400       val quotUnsafe = _prim "WordU64_quot": word * word -> word;
 401       val remUnsafe = _prim "WordU64_rem": word * word -> word;
 402       val rolUnsafe = _prim "Word64_rol": word * Word32.word -> word;
 403       val rorUnsafe = _prim "Word64_ror": word * Word32.word -> word;
 404       val ~>>? = _prim "WordS64_rshift": word * Word32.word -> word;
 405       val >>? = _prim "WordU64_rshift": word * Word32.word -> word;
 406       val - = _prim "Word64_sub": word * word -> word;
 407       val xorb = _prim "Word64_xorb": word * word -> word;
 408
 409       val < = _prim "WordU64_lt": word * word -> bool;
 410    end
 411 structure Word64 : PRIM_WORD =
 412    struct
 413       open Word64
 414       local
 415          structure S = IntegralComparisons(Word64)
 416       in
 417          open S
 418       end
 419    end
 420
 421 end