wrap4.hs

-- GHC wrapper for "methodically" and friends.
-- $ cc -c stub.c
-- $ ghci wrap4.hs stub.o
{-# LANGUAGE BlockArguments, LambdaCase #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE ExtendedDefaultRules #-}
import Prelude (Bool(..), Char, Int, Word, String, IO)
import Data.Char (chr, ord)
import qualified Prelude
import qualified Data.Map as Map
import System.IO.Unsafe (unsafePerformIO)
import System.Exit (exitSuccess)
import Text.RawString.QQ

default (Int)
_to64 :: Word -> Word -> Word
_to64 a b = Prelude.fromIntegral a Prelude.+ Prelude.fromIntegral b Prelude.* (2 :: Word)  Prelude.^ 32
_lohi :: Word -> (Word, Word)
_lohi w = (Prelude.fromIntegral r, Prelude.fromIntegral q)
  where (q, r) = w `Prelude.divMod` (2 Prelude.^ 32)

intFromWord :: Word -> Int
intFromWord = Prelude.fromIntegral

word64Add a b c d = _lohi $ _to64 a b Prelude.+ _to64 c d
word64Sub a b c d = _lohi $ _to64 a b Prelude.- _to64 c d
word64Mul a b c d = _lohi $ _to64 a b Prelude.* _to64 c d
word64Div a b c d = _lohi $ _to64 a b `Prelude.div` _to64 c d
word64Mod a b c d = _lohi $ _to64 a b `Prelude.mod` _to64 c d

intAdd :: Int -> Int -> Int
intAdd = (Prelude.+)
intSub :: Int -> Int -> Int
intSub = (Prelude.-)
intMul :: Int -> Int -> Int
intMul = (Prelude.*)
intDiv :: Int -> Int -> Int
intDiv = Prelude.div
intMod :: Int -> Int -> Int
intMod = Prelude.mod
intQuot :: Int -> Int -> Int
intQuot = Prelude.quot
intRem :: Int -> Int -> Int
intRem = Prelude.rem
intEq :: Int -> Int -> Bool
intEq = (Prelude.==)
intLE :: Int -> Int -> Bool
intLE = (Prelude.<=)

wordAdd :: Word -> Word -> Word
wordAdd = (Prelude.+)
wordSub :: Word -> Word -> Word
wordSub = (Prelude.-)
wordMul :: Word -> Word -> Word
wordMul = (Prelude.*)
wordDiv :: Word -> Word -> Word
wordDiv = Prelude.div
wordMod :: Word -> Word -> Word
wordMod = Prelude.mod
wordQuot :: Word -> Word -> Word
wordQuot = Prelude.quot
wordRem :: Word -> Word -> Word
wordRem = Prelude.rem
wordEq :: Word -> Word -> Bool
wordEq = (Prelude.==)
wordLE :: Word -> Word -> Bool
wordLE = (Prelude.<=)
wordFromInt :: Int -> Word
wordFromInt = Prelude.fromIntegral

charEq :: Char -> Char -> Bool
charEq = (Prelude.==)
charLE :: Char -> Char -> Bool
charLE = (Prelude.<=)
ioPure = Prelude.pure :: a -> IO a
ioBind = (Prelude.>>=) :: IO a -> (a -> IO b) -> IO b
#define ffi foreign import ccall
#define export --
#include "methodically.hs"
instance Prelude.Functor Parser where fmap = fmap
instance Prelude.Applicative Parser where pure = pure ; (<*>) = (<*>)
instance Prelude.Monad Parser where return = return ; (>>=) = (>>=)
instance Prelude.Functor (Either a) where fmap = fmap
instance Prelude.Applicative (Either a) where pure = pure ; (<*>) = (<*>)
instance Prelude.Monad (Either a) where return = return ; (>>=) = (>>=)
instance Prelude.Functor Maybe where fmap = fmap
instance Prelude.Applicative Maybe where pure = pure ; (<*>) = (<*>)
instance Prelude.Monad Maybe where return = return ; (>>=) = (>>=)

-- instance Prelude.Show Pred where showsPrec _ = showPred
-- instance Prelude.Show Type where showsPrec _ = showType
-- instance Prelude.Show Ast where showsPrec _ = showAst False
-- instance Prelude.Show Qual where showsPrec _ = showQual