X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=include%2FCTypes.h;h=f82faa8f0068bded177843c58cc19addf344fc0f;hb=2436086e76439e5e71bd2960b53cd9099d69cd0c;hp=cc0ea74307a69a87ee53bd57d05b409455bf6e7e;hpb=fd28932ae986f2a486b4b3463d7145d7f688048c;p=ghc-base.git

diff --git a/include/CTypes.h b/include/CTypes.h
index cc0ea74..f82faa8 100644
--- a/include/CTypes.h
+++ b/include/CTypes.h
@@ -1,12 +1,13 @@
 /* -----------------------------------------------------------------------------
- * $Id: CTypes.h,v 1.3 2002/08/03 19:32:17 reid Exp $
- *
  * Dirty CPP hackery for CTypes/CTypesISO
  *
  * (c) The FFI task force, 2000
  * -------------------------------------------------------------------------- */
 
-#include "MachDeps.h"
+#ifndef CTYPES__H
+#define CTYPES__H
+
+#include "Typeable.h"
 
 /* As long as there is no automatic derivation of classes for newtypes we resort
    to extremely dirty cpp-hackery.   :-P   Some care has to be taken when the
@@ -15,24 +16,24 @@
 /* A hacked version for GHC follows the Haskell 98 version... */
 #ifndef __GLASGOW_HASKELL__
 
-#define NUMERIC_TYPE(T,C,S,B) \
+#define ARITHMETIC_TYPE(T,C,S,B) \
 newtype T = T B deriving (Eq, Ord) ; \
 INSTANCE_NUM(T) ; \
-INSTANCE_READ(T) ; \
-INSTANCE_SHOW(T) ; \
+INSTANCE_REAL(T) ; \
+INSTANCE_READ(T,B) ; \
+INSTANCE_SHOW(T,B) ; \
 INSTANCE_ENUM(T) ; \
+INSTANCE_STORABLE(T) ; \
 INSTANCE_TYPEABLE0(T,C,S) ;
 
 #define INTEGRAL_TYPE(T,C,S,B) \
-NUMERIC_TYPE(T,C,S,B) ; \
+ARITHMETIC_TYPE(T,C,S,B) ; \
 INSTANCE_BOUNDED(T) ; \
-INSTANCE_REAL(T) ; \
 INSTANCE_INTEGRAL(T) ; \
 INSTANCE_BITS(T)
 
 #define FLOATING_TYPE(T,C,S,B) \
-NUMERIC_TYPE(T,C,S,B) ; \
-INSTANCE_REAL(T) ; \
+ARITHMETIC_TYPE(T,C,S,B) ; \
 INSTANCE_FRACTIONAL(T) ; \
 INSTANCE_FLOATING(T) ; \
 INSTANCE_REALFRAC(T) ; \
@@ -42,11 +43,11 @@ INSTANCE_REALFLOAT(T)
 #define fakeMap map
 #endif
 
-#define INSTANCE_READ(T) \
+#define INSTANCE_READ(T,B) \
 instance Read T where { \
    readsPrec p s = fakeMap (\(x, t) -> (T x, t)) (readsPrec p s) }
 
-#define INSTANCE_SHOW(T) \
+#define INSTANCE_SHOW(T,B) \
 instance Show T where { \
    showsPrec p (T x) = showsPrec p x }
 
@@ -158,30 +159,40 @@ instance RealFloat T where { \
    isIEEE         (T x) = isIEEE x ; \
    (T x) `atan2`  (T y) = T (x `atan2` y) }
 
+#define INSTANCE_STORABLE(T) \
+instance Storable T where { \
+   sizeOf    (T x)       = sizeOf x ; \
+   alignment (T x)       = alignment x ; \
+   peekElemOff a i       = liftM T (peekElemOff (castPtr a) i) ; \
+   pokeElemOff a i (T x) = pokeElemOff (castPtr a) i x }
+
 #else /* __GLASGOW_HASKELL__ */
 
 /* GHC can derive any class for a newtype, so we make use of that
  * here...
  */
 
-#define NUMERIC_CLASSES  Eq,Ord,Num,Enum
-#define INTEGRAL_CLASSES Bounded,Real,Integral,Bits
-#define FLOATING_CLASSES Real,Fractional,Floating,RealFrac,RealFloat
+#define ARITHMETIC_CLASSES  Eq,Ord,Num,Enum,Storable,Real
+#define INTEGRAL_CLASSES Bounded,Integral,Bits
+#define FLOATING_CLASSES Fractional,Floating,RealFrac,RealFloat
 
-#define NUMERIC_TYPE(T,C,S,B) \
-newtype T = T B deriving (NUMERIC_CLASSES); \
+#define ARITHMETIC_TYPE(T,C,S,B) \
+newtype T = T B deriving (ARITHMETIC_CLASSES); \
 INSTANCE_READ(T,B); \
-INSTANCE_SHOW(T,B)
+INSTANCE_SHOW(T,B); \
+INSTANCE_TYPEABLE0(T,C,S) ;
 
 #define INTEGRAL_TYPE(T,C,S,B) \
-newtype T = T B deriving (NUMERIC_CLASSES, INTEGRAL_CLASSES); \
+newtype T = T B deriving (ARITHMETIC_CLASSES, INTEGRAL_CLASSES); \
 INSTANCE_READ(T,B); \
-INSTANCE_SHOW(T,B)
+INSTANCE_SHOW(T,B); \
+INSTANCE_TYPEABLE0(T,C,S) ;
 
 #define FLOATING_TYPE(T,C,S,B) \
-newtype T = T B deriving (NUMERIC_CLASSES, FLOATING_CLASSES); \
+newtype T = T B deriving (ARITHMETIC_CLASSES, FLOATING_CLASSES); \
 INSTANCE_READ(T,B); \
-INSTANCE_SHOW(T,B)
+INSTANCE_SHOW(T,B); \
+INSTANCE_TYPEABLE0(T,C,S) ;
 
 #define INSTANCE_READ(T,B) \
 instance Read T where { \
@@ -195,3 +206,5 @@ instance Show T where { \
    showList		= unsafeCoerce# (showList :: [B] -> ShowS); }
 
 #endif /* __GLASGOW_HASKELL__ */
+
+#endif