#lang planet chongkai/sml

signature WORD =
sig
type word = word8

val wordSize   : int

val orb        : word * word -> word
val andb       : word * word -> word
val xorb       : word * word -> word
val notb       : word -> word

val <<         : word * Word.word -> word
val >>         : word * Word.word -> word
val ~>>        : word * Word.word -> word

val +          : word * word -> word
val -          : word * word -> word
val *          : word * word -> word
val div        : word * word -> word
val mod        : word * word -> word

val >          : word * word -> bool
val <          : word * word -> bool
val >=         : word * word -> bool
val <=         : word * word -> bool
val compare    : word * word -> order

val min        : word * word -> word
val max        : word * word -> word

val toString   : word -> string
val fromString : string -> word option
val scan       : StringCvt.radix 
               -> (char, 'a) StringCvt.reader -> (word, 'a) StringCvt.reader
val fmt        : StringCvt.radix -> word -> string

val toInt      : word -> int
val toIntX     : word -> int            (* with sign extension *)
val fromInt    : int -> word

val toLargeInt    : word -> int
val toLargeIntX   : word -> int         (* with sign extension *)
val fromLargeInt  : int -> word

val toLargeWord   : word -> Word.word
val toLargeWordX  : word -> Word.word   (* with sign extension *)
val fromLargeWord : Word.word -> word
end

structure Word8 :> WORD =

struct
  
  local
      open StringCvt
      fun skipWSget getc source = getc (skipWS getc source)

      (* Below, 48 = ord #"0" and 55 = ord #"A" - 10. *)
      fun decval c = ord c - 48;
      fun hexval c =
      if #"0" <= c andalso c <= #"9" then
          ord c - 48
      else
          (ord c - 55) mod 32;

      fun prhex i =
      if i < 10 then chr(i + 48) else chr(i + 55);

      fun conv radix w =
      let fun h n res =
          if n = 0 then res
          else h (n div radix) (prhex (n mod radix) :: res)
          fun tostr n = h (n div radix) [prhex (n mod radix)]
      in String.implode (tostr (Word8help.toInt w)) end

    in
      fun scan radix getc source =
      let open StringCvt
          val source = skipWS getc source
          val (isDigit, factor) =
          case radix of
              BIN => (fn c => (#"0" <= c andalso c <= #"1"),  2)
            | OCT => (fn c => (#"0" <= c andalso c <= #"7"),  8)
            | DEC => (Char.isDigit,                          10)
            | HEX => (Char.isHexDigit,                       16)
          fun return res src =
          if res < 256 then SOME (Word8help.fromInt res, src)
          else raise Overflow
          fun dig1 NONE             = NONE
        | dig1 (SOME (c, rest)) =
          let
              fun digr res src =
                  case getc src of
                  NONE           => return res src
                | SOME (c, rest) =>
                  if isDigit c then
                      digr(factor*res+hexval c) rest
                  else
                      return res src
          in
              if isDigit c then digr (hexval c) rest else NONE
          end
          fun getdigs after0 src =
          case dig1 (getc src) of
              NONE => return 0 after0
            | res  => res
          fun hexprefix after0 src =
          if radix <> HEX then getdigs after0 src
          else
              case getc src of
              SOME(#"x", rest) => getdigs after0 rest
            | SOME(#"X", rest) => getdigs after0 rest
            | SOME _           => getdigs after0 src
            | NONE => return 0 after0
      in
          case getc source of
          SOME(#"0", after0) =>
              (case getc after0 of
               SOME(#"w", src2) => hexprefix after0 src2
             | SOME _           => hexprefix after0 after0
             | NONE             => return 0 after0)
        | SOME _ => dig1 (getc source)
        | NONE   => NONE
      end
      
      fun fromString s = scanString (scan HEX) s
    end
  
  open Word8help;

end