-----------------------------------------------------------------------------
-- |
-- Module      :  Data.SBV.BitVectors.PrettyNum
-- Copyright   :  (c) Levent Erkok
-- License     :  BSD3
-- Maintainer  :  erkokl@gmail.com
-- Stability   :  experimental
-- Portability :  portable
--
-- Number representations in hex/bin
-----------------------------------------------------------------------------

{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE PatternGuards #-}

module Data.SBV.BitVectors.PrettyNum (PrettyNum(..), readBin) where

import Data.Char  (ord)
import Data.Int   (Int8, Int16, Int32, Int64)
import Data.List  (isPrefixOf)
import Data.Maybe (fromJust)
import Data.Word  (Word8, Word16, Word32, Word64)
import Numeric    (showIntAtBase, showHex, readInt)

import Data.SBV.BitVectors.Data
import Data.SBV.BitVectors.Model () -- instances only

-- | PrettyNum class captures printing of numbers in hex and binary formats; also supporting negative numbers.
--
-- Minimal complete definition: 'hexS' and 'binS'
class PrettyNum a where
  -- | Show a number in hexadecimal (starting with @0x@)
  hexS :: a -> String
  -- | Show a number in binary (starting with @0b@)
  binS :: a -> String
  -- | IO version of 'hexS'
  hex :: a -> IO ()
  hex = putStrLn . hexS
  -- | IO version of 'binS'
  bin   :: a -> IO ()
  bin = putStrLn . binS

-- Why not default methods? Because defaults need "Integral a" but Bool is not..
instance PrettyNum Bool   where {hexS = show; binS = show}
instance PrettyNum Word8  where {hexS = shex (False,8) ; binS = sbin (False,8) }
instance PrettyNum Int8   where {hexS = shex (True,8)  ; binS = sbin (True,8)  }
instance PrettyNum Word16 where {hexS = shex (False,16); binS = sbin (False,16)}
instance PrettyNum Int16  where {hexS = shex (True,16);  binS = sbin (True,16) }
instance PrettyNum Word32 where {hexS = shex (False,32); binS = sbin (False,32)}
instance PrettyNum Int32  where {hexS = shex (True,32);  binS = sbin (True,32) }
instance PrettyNum Word64 where {hexS = shex (False,64); binS = sbin (False,64)}
instance PrettyNum Int64  where {hexS = shex (True,64);  binS = sbin (True,64) }

instance PrettyNum CW where
  hexS cw | cwIsBit cw  = hexS (cwToBool cw)
  hexS cw               = shex (hasSign cw, sizeOf cw) (cwVal cw)

  binS cw | cwIsBit cw  = binS (cwToBool cw)
  binS cw               = sbin (hasSign cw, sizeOf cw) (cwVal cw)

instance (SymWord a, PrettyNum a) => PrettyNum (SBV a) where
  hexS s = maybe (show s) (hexS :: a -> String) $ unliteral s
  binS s = maybe (show s) (binS :: a -> String) $ unliteral s

shex :: (Integral a) => (Bool,Size) -> a -> String
shex (signed,size) a
 | a < 0
 = "-0x" ++ pad l (s16 (abs ((fromIntegral a) :: Integer)))  ++ t
 | True
 =  "0x" ++ pad l (s16 a) ++ t
 where t = " :: " ++ (if signed then "Int" else "Word") ++ show size
       l = (size + 3) `div` 4

sbin :: (Integral a) => (Bool,Size) -> a -> String
sbin (signed,size) a
 | a < 0
 = "-0b" ++ pad size (s2 (abs ((fromIntegral a) :: Integer)))  ++ t
 | True
 =  "0b" ++ pad size (s2 a) ++ t
 where t = " :: " ++ (if signed then "Int" else "Word") ++ show size

pad :: Int -> String -> String
pad l s = replicate (l - length s) '0' ++ s

s2, s16 :: Integral a => a -> String
s2  v = showIntAtBase 2 dig v "" where dig = fromJust . flip lookup [(0, '0'), (1, '1')]
s16 v = showHex v ""

-- | A more convenient interface for reading binary numbers, also supports negative numbers
readBin :: Num a => String -> a
readBin ('-':s) = -(readBin s)
readBin s = case readInt 2 isDigit cvt s' of
              [(a, "")] -> a
              _         -> error $ "SBV.readBin: Cannot read a binary number from: " ++ show s
  where cvt c = ord c - ord '0'
        isDigit = (`elem` "01")
        s' | "0b" `isPrefixOf` s = drop 2 s
           | True                = s