[project @ 1997-11-05 16:11:17 by simonm]
[ghc-hetmet.git] / ghc / compiler / prelude / PrimOp.lhs
index 7af6822..f9818b0 100644 (file)
@@ -38,15 +38,15 @@ import TysWiredIn
 import CStrings                ( identToC )
 import Constants       ( mIN_MP_INT_SIZE, mP_STRUCT_SIZE )
 import HeapOffs                ( addOff, intOff, totHdrSize, HeapOffset )
-import PprStyle                ( codeStyle, ifaceStyle )
+import Outputable      ( PprStyle, Outputable(..), codeStyle, ifaceStyle )
 import PprType         ( pprParendGenType, GenTyVar{-instance Outputable-} )
 import Pretty
 import SMRep           ( SMRep(..), SMSpecRepKind(..), SMUpdateKind(..) )
 import TyCon           ( TyCon{-instances-} )
-import Type            ( getAppDataTyConExpandingDicts, maybeAppDataTyConExpandingDicts,
-                         mkForAllTys, mkFunTy, mkFunTys, applyTyCon, typePrimRep
+import Type            ( mkForAllTys, mkFunTy, mkFunTys, applyTyCon, typePrimRep,
+                         getAppDataTyConExpandingDicts, SYN_IE(Type)
                        )
-import TyVar           ( alphaTyVar, betaTyVar, gammaTyVar, GenTyVar{-instance Eq-} )
+import TyVar           --( alphaTyVar, betaTyVar, gammaTyVar, GenTyVar{-instance Eq-} )
 import Unique          ( Unique{-instance Eq-} )
 import Util            ( panic#, assoc, panic{-ToDo:rm-} )
 \end{code}
@@ -81,7 +81,7 @@ data PrimOp
     | IntRemOp | IntNegOp | IntAbsOp
 
     -- Word#-related ops:
-    | AndOp  | OrOp   | NotOp
+    | AndOp  | OrOp   | NotOp | XorOp
     | SllOp  | SraOp  | SrlOp  -- shift {left,right} {arithmetic,logical}
     | ISllOp | ISraOp | ISrlOp -- equivs on Int#s
     | Int2WordOp | Word2IntOp -- casts
@@ -147,6 +147,7 @@ data PrimOp
        -- This is just a cheesy encoding of a bunch of ops.
        -- Note that ForeignObjRep is not included -- the only way of
        -- creating a ForeignObj is with a ccall or casm.
+    | IndexOffForeignObjOp PrimRep
 
     | UnsafeFreezeArrayOp | UnsafeFreezeByteArrayOp
 
@@ -154,7 +155,8 @@ data PrimOp
     | TakeMVarOp | PutMVarOp
     | ReadIVarOp | WriteIVarOp
 
-    | MakeForeignObjOp -- foreign objects (malloc pointers or any old URL)
+    | MakeForeignObjOp  -- foreign objects (malloc pointers or any old URL)
+    | WriteForeignObjOp -- modifying foreign objects [obscuro factor: 200]
     | MakeStablePtrOp | DeRefStablePtrOp
 \end{code}
 
@@ -259,180 +261,187 @@ about using it this way?? ADR)
 Deriving Ix is what we really want! ToDo
 (Chk around before deleting...)
 \begin{code}
-tagOf_PrimOp CharGtOp                  = (ILIT(1) :: FAST_INT)
-tagOf_PrimOp CharGeOp                  = ILIT(  2)
-tagOf_PrimOp CharEqOp                  = ILIT(  3)
-tagOf_PrimOp CharNeOp                  = ILIT(  4)
-tagOf_PrimOp CharLtOp                  = ILIT(  5)
-tagOf_PrimOp CharLeOp                  = ILIT(  6)
-tagOf_PrimOp IntGtOp                   = ILIT(  7)
-tagOf_PrimOp IntGeOp                   = ILIT(  8)
-tagOf_PrimOp IntEqOp                   = ILIT(  9)
-tagOf_PrimOp IntNeOp                   = ILIT( 10)
-tagOf_PrimOp IntLtOp                   = ILIT( 11)
-tagOf_PrimOp IntLeOp                   = ILIT( 12)
-tagOf_PrimOp WordGtOp                  = ILIT( 13)
-tagOf_PrimOp WordGeOp                  = ILIT( 14)
-tagOf_PrimOp WordEqOp                  = ILIT( 15)
-tagOf_PrimOp WordNeOp                  = ILIT( 16)
-tagOf_PrimOp WordLtOp                  = ILIT( 17)
-tagOf_PrimOp WordLeOp                  = ILIT( 18)
-tagOf_PrimOp AddrGtOp                  = ILIT( 19)
-tagOf_PrimOp AddrGeOp                  = ILIT( 20)
-tagOf_PrimOp AddrEqOp                  = ILIT( 21)
-tagOf_PrimOp AddrNeOp                  = ILIT( 22)
-tagOf_PrimOp AddrLtOp                  = ILIT( 23)
-tagOf_PrimOp AddrLeOp                  = ILIT( 24)
-tagOf_PrimOp FloatGtOp                 = ILIT( 25)
-tagOf_PrimOp FloatGeOp                 = ILIT( 26)
-tagOf_PrimOp FloatEqOp                 = ILIT( 27)
-tagOf_PrimOp FloatNeOp                 = ILIT( 28)
-tagOf_PrimOp FloatLtOp                 = ILIT( 29)
-tagOf_PrimOp FloatLeOp                 = ILIT( 30)
-tagOf_PrimOp DoubleGtOp                        = ILIT( 31)
-tagOf_PrimOp DoubleGeOp                        = ILIT( 32)
-tagOf_PrimOp DoubleEqOp                        = ILIT( 33)
-tagOf_PrimOp DoubleNeOp                        = ILIT( 34)
-tagOf_PrimOp DoubleLtOp                        = ILIT( 35)
-tagOf_PrimOp DoubleLeOp                        = ILIT( 36)
-tagOf_PrimOp OrdOp                     = ILIT( 37)
-tagOf_PrimOp ChrOp                     = ILIT( 38)
-tagOf_PrimOp IntAddOp                  = ILIT( 39)
-tagOf_PrimOp IntSubOp                  = ILIT( 40)
-tagOf_PrimOp IntMulOp                  = ILIT( 41)
-tagOf_PrimOp IntQuotOp                 = ILIT( 42)
-tagOf_PrimOp IntRemOp                  = ILIT( 44)
-tagOf_PrimOp IntNegOp                  = ILIT( 45)
-tagOf_PrimOp IntAbsOp                  = ILIT( 46)
-tagOf_PrimOp AndOp                     = ILIT( 47)
-tagOf_PrimOp OrOp                      = ILIT( 48)
-tagOf_PrimOp NotOp                     = ILIT( 49)
-tagOf_PrimOp SllOp                     = ILIT( 50)
-tagOf_PrimOp SraOp                     = ILIT( 51)
-tagOf_PrimOp SrlOp                     = ILIT( 52)
-tagOf_PrimOp ISllOp                    = ILIT( 53)
-tagOf_PrimOp ISraOp                    = ILIT( 54)
-tagOf_PrimOp ISrlOp                    = ILIT( 55)
-tagOf_PrimOp Int2WordOp                        = ILIT( 56)
-tagOf_PrimOp Word2IntOp                        = ILIT( 57)
-tagOf_PrimOp Int2AddrOp                        = ILIT( 58)
-tagOf_PrimOp Addr2IntOp                        = ILIT( 59)
-tagOf_PrimOp FloatAddOp                        = ILIT( 60)
-tagOf_PrimOp FloatSubOp                        = ILIT( 61)
-tagOf_PrimOp FloatMulOp                        = ILIT( 62)
-tagOf_PrimOp FloatDivOp                        = ILIT( 63)
-tagOf_PrimOp FloatNegOp                        = ILIT( 64)
-tagOf_PrimOp Float2IntOp               = ILIT( 65)
-tagOf_PrimOp Int2FloatOp               = ILIT( 66)
-tagOf_PrimOp FloatExpOp                        = ILIT( 67)
-tagOf_PrimOp FloatLogOp                        = ILIT( 68)
-tagOf_PrimOp FloatSqrtOp               = ILIT( 69)
-tagOf_PrimOp FloatSinOp                        = ILIT( 70)
-tagOf_PrimOp FloatCosOp                        = ILIT( 71)
-tagOf_PrimOp FloatTanOp                        = ILIT( 72)
-tagOf_PrimOp FloatAsinOp               = ILIT( 73)
-tagOf_PrimOp FloatAcosOp               = ILIT( 74)
-tagOf_PrimOp FloatAtanOp               = ILIT( 75)
-tagOf_PrimOp FloatSinhOp               = ILIT( 76)
-tagOf_PrimOp FloatCoshOp               = ILIT( 77)
-tagOf_PrimOp FloatTanhOp               = ILIT( 78)
-tagOf_PrimOp FloatPowerOp              = ILIT( 79)
-tagOf_PrimOp DoubleAddOp               = ILIT( 80)
-tagOf_PrimOp DoubleSubOp               = ILIT( 81)
-tagOf_PrimOp DoubleMulOp               = ILIT( 82)
-tagOf_PrimOp DoubleDivOp               = ILIT( 83)
-tagOf_PrimOp DoubleNegOp               = ILIT( 84)
-tagOf_PrimOp Double2IntOp              = ILIT( 85)
-tagOf_PrimOp Int2DoubleOp              = ILIT( 86)
-tagOf_PrimOp Double2FloatOp            = ILIT( 87)
-tagOf_PrimOp Float2DoubleOp            = ILIT( 88)
-tagOf_PrimOp DoubleExpOp               = ILIT( 89)
-tagOf_PrimOp DoubleLogOp               = ILIT( 90)
-tagOf_PrimOp DoubleSqrtOp              = ILIT( 91)
-tagOf_PrimOp DoubleSinOp               = ILIT( 92)
-tagOf_PrimOp DoubleCosOp               = ILIT( 93)
-tagOf_PrimOp DoubleTanOp               = ILIT( 94)
-tagOf_PrimOp DoubleAsinOp              = ILIT( 95)
-tagOf_PrimOp DoubleAcosOp              = ILIT( 96)
-tagOf_PrimOp DoubleAtanOp              = ILIT( 97)
-tagOf_PrimOp DoubleSinhOp              = ILIT( 98)
-tagOf_PrimOp DoubleCoshOp              = ILIT( 99)
-tagOf_PrimOp DoubleTanhOp              = ILIT(100)
-tagOf_PrimOp DoublePowerOp             = ILIT(101)
-tagOf_PrimOp IntegerAddOp              = ILIT(102)
-tagOf_PrimOp IntegerSubOp              = ILIT(103)
-tagOf_PrimOp IntegerMulOp              = ILIT(104)
-tagOf_PrimOp IntegerQuotRemOp          = ILIT(105)
-tagOf_PrimOp IntegerDivModOp           = ILIT(106)
-tagOf_PrimOp IntegerNegOp              = ILIT(107)
-tagOf_PrimOp IntegerCmpOp              = ILIT(108)
-tagOf_PrimOp Integer2IntOp             = ILIT(109)
-tagOf_PrimOp Int2IntegerOp             = ILIT(110)
-tagOf_PrimOp Word2IntegerOp            = ILIT(111)
-tagOf_PrimOp Addr2IntegerOp            = ILIT(112)
-tagOf_PrimOp FloatEncodeOp             = ILIT(113)
-tagOf_PrimOp FloatDecodeOp             = ILIT(114)
-tagOf_PrimOp DoubleEncodeOp            = ILIT(115)
-tagOf_PrimOp DoubleDecodeOp            = ILIT(116)
-tagOf_PrimOp NewArrayOp                        = ILIT(117)
-tagOf_PrimOp (NewByteArrayOp CharRep)  = ILIT(118)
-tagOf_PrimOp (NewByteArrayOp IntRep)   = ILIT(119)
-tagOf_PrimOp (NewByteArrayOp AddrRep)  = ILIT(120)
-tagOf_PrimOp (NewByteArrayOp FloatRep) = ILIT(121)
-tagOf_PrimOp (NewByteArrayOp DoubleRep)= ILIT(122)
-tagOf_PrimOp SameMutableArrayOp                = ILIT(123)
-tagOf_PrimOp SameMutableByteArrayOp    = ILIT(124)
-tagOf_PrimOp ReadArrayOp               = ILIT(125)
-tagOf_PrimOp WriteArrayOp              = ILIT(126)
-tagOf_PrimOp IndexArrayOp              = ILIT(127)
-tagOf_PrimOp (ReadByteArrayOp CharRep)     = ILIT(128)
-tagOf_PrimOp (ReadByteArrayOp IntRep)      = ILIT(129)
-tagOf_PrimOp (ReadByteArrayOp AddrRep)     = ILIT(130)
-tagOf_PrimOp (ReadByteArrayOp FloatRep)    = ILIT(131)
-tagOf_PrimOp (ReadByteArrayOp DoubleRep)   = ILIT(132)
-tagOf_PrimOp (WriteByteArrayOp CharRep)    = ILIT(133)
-tagOf_PrimOp (WriteByteArrayOp IntRep)     = ILIT(134)
-tagOf_PrimOp (WriteByteArrayOp AddrRep)    = ILIT(135)
-tagOf_PrimOp (WriteByteArrayOp FloatRep)   = ILIT(136)
-tagOf_PrimOp (WriteByteArrayOp DoubleRep)  = ILIT(137)
-tagOf_PrimOp (IndexByteArrayOp CharRep)    = ILIT(138)
-tagOf_PrimOp (IndexByteArrayOp IntRep)     = ILIT(139)
-tagOf_PrimOp (IndexByteArrayOp AddrRep)    = ILIT(140)
-tagOf_PrimOp (IndexByteArrayOp FloatRep)   = ILIT(141)
-tagOf_PrimOp (IndexByteArrayOp DoubleRep)  = ILIT(142)
-tagOf_PrimOp (IndexOffAddrOp CharRep)      = ILIT(143)
-tagOf_PrimOp (IndexOffAddrOp IntRep)       = ILIT(144)
-tagOf_PrimOp (IndexOffAddrOp AddrRep)      = ILIT(145)
-tagOf_PrimOp (IndexOffAddrOp FloatRep)     = ILIT(146)
-tagOf_PrimOp (IndexOffAddrOp DoubleRep)    = ILIT(147)
-tagOf_PrimOp UnsafeFreezeArrayOp           = ILIT(148)
-tagOf_PrimOp UnsafeFreezeByteArrayOp       = ILIT(149)
-tagOf_PrimOp NewSynchVarOp                 = ILIT(150)
-tagOf_PrimOp TakeMVarOp                            = ILIT(151)
-tagOf_PrimOp PutMVarOp                     = ILIT(152)
-tagOf_PrimOp ReadIVarOp                            = ILIT(153)
-tagOf_PrimOp WriteIVarOp                   = ILIT(154)
-tagOf_PrimOp MakeForeignObjOp              = ILIT(155)
-tagOf_PrimOp MakeStablePtrOp               = ILIT(156)
-tagOf_PrimOp DeRefStablePtrOp              = ILIT(157)
-tagOf_PrimOp (CCallOp _ _ _ _ _)           = ILIT(158)
-tagOf_PrimOp ErrorIOPrimOp                 = ILIT(159)
-tagOf_PrimOp ReallyUnsafePtrEqualityOp     = ILIT(160)
-tagOf_PrimOp SeqOp                         = ILIT(161)
-tagOf_PrimOp ParOp                         = ILIT(162)
-tagOf_PrimOp ForkOp                        = ILIT(163)
-tagOf_PrimOp DelayOp                       = ILIT(164)
-tagOf_PrimOp WaitReadOp                            = ILIT(165)
-tagOf_PrimOp WaitWriteOp                   = ILIT(166)
-
-tagOf_PrimOp ParGlobalOp                   = ILIT(167)
-tagOf_PrimOp ParLocalOp                            = ILIT(168)
-tagOf_PrimOp ParAtOp                       = ILIT(169)
-tagOf_PrimOp ParAtAbsOp                            = ILIT(170)
-tagOf_PrimOp ParAtRelOp                            = ILIT(171)
-tagOf_PrimOp ParAtForNowOp                 = ILIT(172)
-tagOf_PrimOp CopyableOp                            = ILIT(173)
-tagOf_PrimOp NoFollowOp                            = ILIT(174)
+tagOf_PrimOp CharGtOp                        = (ILIT(1) :: FAST_INT)
+tagOf_PrimOp CharGeOp                        = ILIT(  2)
+tagOf_PrimOp CharEqOp                        = ILIT(  3)
+tagOf_PrimOp CharNeOp                        = ILIT(  4)
+tagOf_PrimOp CharLtOp                        = ILIT(  5)
+tagOf_PrimOp CharLeOp                        = ILIT(  6)
+tagOf_PrimOp IntGtOp                         = ILIT(  7)
+tagOf_PrimOp IntGeOp                         = ILIT(  8)
+tagOf_PrimOp IntEqOp                         = ILIT(  9)
+tagOf_PrimOp IntNeOp                         = ILIT( 10)
+tagOf_PrimOp IntLtOp                         = ILIT( 11)
+tagOf_PrimOp IntLeOp                         = ILIT( 12)
+tagOf_PrimOp WordGtOp                        = ILIT( 13)
+tagOf_PrimOp WordGeOp                        = ILIT( 14)
+tagOf_PrimOp WordEqOp                        = ILIT( 15)
+tagOf_PrimOp WordNeOp                        = ILIT( 16)
+tagOf_PrimOp WordLtOp                        = ILIT( 17)
+tagOf_PrimOp WordLeOp                        = ILIT( 18)
+tagOf_PrimOp AddrGtOp                        = ILIT( 19)
+tagOf_PrimOp AddrGeOp                        = ILIT( 20)
+tagOf_PrimOp AddrEqOp                        = ILIT( 21)
+tagOf_PrimOp AddrNeOp                        = ILIT( 22)
+tagOf_PrimOp AddrLtOp                        = ILIT( 23)
+tagOf_PrimOp AddrLeOp                        = ILIT( 24)
+tagOf_PrimOp FloatGtOp                       = ILIT( 25)
+tagOf_PrimOp FloatGeOp                       = ILIT( 26)
+tagOf_PrimOp FloatEqOp                       = ILIT( 27)
+tagOf_PrimOp FloatNeOp                       = ILIT( 28)
+tagOf_PrimOp FloatLtOp                       = ILIT( 29)
+tagOf_PrimOp FloatLeOp                       = ILIT( 30)
+tagOf_PrimOp DoubleGtOp                              = ILIT( 31)
+tagOf_PrimOp DoubleGeOp                              = ILIT( 32)
+tagOf_PrimOp DoubleEqOp                              = ILIT( 33)
+tagOf_PrimOp DoubleNeOp                              = ILIT( 34)
+tagOf_PrimOp DoubleLtOp                              = ILIT( 35)
+tagOf_PrimOp DoubleLeOp                              = ILIT( 36)
+tagOf_PrimOp OrdOp                           = ILIT( 37)
+tagOf_PrimOp ChrOp                           = ILIT( 38)
+tagOf_PrimOp IntAddOp                        = ILIT( 39)
+tagOf_PrimOp IntSubOp                        = ILIT( 40)
+tagOf_PrimOp IntMulOp                        = ILIT( 41)
+tagOf_PrimOp IntQuotOp                       = ILIT( 42)
+tagOf_PrimOp IntRemOp                        = ILIT( 44)
+tagOf_PrimOp IntNegOp                        = ILIT( 45)
+tagOf_PrimOp IntAbsOp                        = ILIT( 46)
+tagOf_PrimOp AndOp                           = ILIT( 47)
+tagOf_PrimOp OrOp                            = ILIT( 48)
+tagOf_PrimOp NotOp                           = ILIT( 49)
+tagOf_PrimOp XorOp                           = ILIT( 50)
+tagOf_PrimOp SllOp                           = ILIT( 51)
+tagOf_PrimOp SraOp                           = ILIT( 52)
+tagOf_PrimOp SrlOp                           = ILIT( 53)
+tagOf_PrimOp ISllOp                          = ILIT( 54)
+tagOf_PrimOp ISraOp                          = ILIT( 55)
+tagOf_PrimOp ISrlOp                          = ILIT( 56)
+tagOf_PrimOp Int2WordOp                              = ILIT( 57)
+tagOf_PrimOp Word2IntOp                              = ILIT( 58)
+tagOf_PrimOp Int2AddrOp                              = ILIT( 59)
+tagOf_PrimOp Addr2IntOp                              = ILIT( 60)
+tagOf_PrimOp FloatAddOp                              = ILIT( 61)
+tagOf_PrimOp FloatSubOp                              = ILIT( 62)
+tagOf_PrimOp FloatMulOp                              = ILIT( 63)
+tagOf_PrimOp FloatDivOp                              = ILIT( 64)
+tagOf_PrimOp FloatNegOp                              = ILIT( 65)
+tagOf_PrimOp Float2IntOp                     = ILIT( 66)
+tagOf_PrimOp Int2FloatOp                     = ILIT( 67)
+tagOf_PrimOp FloatExpOp                              = ILIT( 68)
+tagOf_PrimOp FloatLogOp                              = ILIT( 69)
+tagOf_PrimOp FloatSqrtOp                     = ILIT( 70)
+tagOf_PrimOp FloatSinOp                              = ILIT( 71)
+tagOf_PrimOp FloatCosOp                              = ILIT( 72)
+tagOf_PrimOp FloatTanOp                              = ILIT( 73)
+tagOf_PrimOp FloatAsinOp                     = ILIT( 74)
+tagOf_PrimOp FloatAcosOp                     = ILIT( 75)
+tagOf_PrimOp FloatAtanOp                     = ILIT( 76)
+tagOf_PrimOp FloatSinhOp                     = ILIT( 77)
+tagOf_PrimOp FloatCoshOp                     = ILIT( 78)
+tagOf_PrimOp FloatTanhOp                     = ILIT( 79)
+tagOf_PrimOp FloatPowerOp                    = ILIT( 80)
+tagOf_PrimOp DoubleAddOp                     = ILIT( 81)
+tagOf_PrimOp DoubleSubOp                     = ILIT( 82)
+tagOf_PrimOp DoubleMulOp                     = ILIT( 83)
+tagOf_PrimOp DoubleDivOp                     = ILIT( 84)
+tagOf_PrimOp DoubleNegOp                     = ILIT( 85)
+tagOf_PrimOp Double2IntOp                    = ILIT( 86)
+tagOf_PrimOp Int2DoubleOp                    = ILIT( 87)
+tagOf_PrimOp Double2FloatOp                  = ILIT( 88)
+tagOf_PrimOp Float2DoubleOp                  = ILIT( 89)
+tagOf_PrimOp DoubleExpOp                     = ILIT( 90)
+tagOf_PrimOp DoubleLogOp                     = ILIT( 91)
+tagOf_PrimOp DoubleSqrtOp                    = ILIT( 92)
+tagOf_PrimOp DoubleSinOp                     = ILIT( 93)
+tagOf_PrimOp DoubleCosOp                     = ILIT( 94)
+tagOf_PrimOp DoubleTanOp                     = ILIT( 95)
+tagOf_PrimOp DoubleAsinOp                    = ILIT( 96)
+tagOf_PrimOp DoubleAcosOp                    = ILIT( 97)
+tagOf_PrimOp DoubleAtanOp                    = ILIT( 98)
+tagOf_PrimOp DoubleSinhOp                    = ILIT( 99)
+tagOf_PrimOp DoubleCoshOp                    = ILIT(100)
+tagOf_PrimOp DoubleTanhOp                    = ILIT(101)
+tagOf_PrimOp DoublePowerOp                   = ILIT(102)
+tagOf_PrimOp IntegerAddOp                    = ILIT(103)
+tagOf_PrimOp IntegerSubOp                    = ILIT(104)
+tagOf_PrimOp IntegerMulOp                    = ILIT(105)
+tagOf_PrimOp IntegerQuotRemOp                = ILIT(106)
+tagOf_PrimOp IntegerDivModOp                 = ILIT(107)
+tagOf_PrimOp IntegerNegOp                    = ILIT(108)
+tagOf_PrimOp IntegerCmpOp                    = ILIT(109)
+tagOf_PrimOp Integer2IntOp                   = ILIT(110)
+tagOf_PrimOp Int2IntegerOp                   = ILIT(111)
+tagOf_PrimOp Word2IntegerOp                  = ILIT(112)
+tagOf_PrimOp Addr2IntegerOp                  = ILIT(113)
+tagOf_PrimOp FloatEncodeOp                   = ILIT(114)
+tagOf_PrimOp FloatDecodeOp                   = ILIT(115)
+tagOf_PrimOp DoubleEncodeOp                  = ILIT(116)
+tagOf_PrimOp DoubleDecodeOp                  = ILIT(117)
+tagOf_PrimOp NewArrayOp                              = ILIT(118)
+tagOf_PrimOp (NewByteArrayOp CharRep)        = ILIT(119)
+tagOf_PrimOp (NewByteArrayOp IntRep)         = ILIT(120)
+tagOf_PrimOp (NewByteArrayOp AddrRep)        = ILIT(121)
+tagOf_PrimOp (NewByteArrayOp FloatRep)       = ILIT(122)
+tagOf_PrimOp (NewByteArrayOp DoubleRep)       = ILIT(123)
+tagOf_PrimOp SameMutableArrayOp                      = ILIT(124)
+tagOf_PrimOp SameMutableByteArrayOp          = ILIT(125)
+tagOf_PrimOp ReadArrayOp                     = ILIT(126)
+tagOf_PrimOp WriteArrayOp                    = ILIT(127)
+tagOf_PrimOp IndexArrayOp                    = ILIT(128)
+tagOf_PrimOp (ReadByteArrayOp CharRep)       = ILIT(129)
+tagOf_PrimOp (ReadByteArrayOp IntRep)        = ILIT(130)
+tagOf_PrimOp (ReadByteArrayOp AddrRep)       = ILIT(131)
+tagOf_PrimOp (ReadByteArrayOp FloatRep)       = ILIT(132)
+tagOf_PrimOp (ReadByteArrayOp DoubleRep)      = ILIT(133)
+tagOf_PrimOp (WriteByteArrayOp CharRep)       = ILIT(134)
+tagOf_PrimOp (WriteByteArrayOp IntRep)       = ILIT(135)
+tagOf_PrimOp (WriteByteArrayOp AddrRep)       = ILIT(136)
+tagOf_PrimOp (WriteByteArrayOp FloatRep)      = ILIT(137)
+tagOf_PrimOp (WriteByteArrayOp DoubleRep)     = ILIT(138)
+tagOf_PrimOp (IndexByteArrayOp CharRep)       = ILIT(139)
+tagOf_PrimOp (IndexByteArrayOp IntRep)       = ILIT(140)
+tagOf_PrimOp (IndexByteArrayOp AddrRep)       = ILIT(141)
+tagOf_PrimOp (IndexByteArrayOp FloatRep)      = ILIT(142)
+tagOf_PrimOp (IndexByteArrayOp DoubleRep)     = ILIT(143)
+tagOf_PrimOp (IndexOffAddrOp CharRep)        = ILIT(144)
+tagOf_PrimOp (IndexOffAddrOp IntRep)         = ILIT(145)
+tagOf_PrimOp (IndexOffAddrOp AddrRep)        = ILIT(146)
+tagOf_PrimOp (IndexOffAddrOp FloatRep)       = ILIT(147)
+tagOf_PrimOp (IndexOffAddrOp DoubleRep)       = ILIT(148)
+tagOf_PrimOp (IndexOffForeignObjOp CharRep)   = ILIT(149)
+tagOf_PrimOp (IndexOffForeignObjOp IntRep)    = ILIT(150)
+tagOf_PrimOp (IndexOffForeignObjOp AddrRep)   = ILIT(151)
+tagOf_PrimOp (IndexOffForeignObjOp FloatRep)  = ILIT(152)
+tagOf_PrimOp (IndexOffForeignObjOp DoubleRep) = ILIT(153)
+tagOf_PrimOp UnsafeFreezeArrayOp             = ILIT(154)
+tagOf_PrimOp UnsafeFreezeByteArrayOp         = ILIT(155)
+tagOf_PrimOp NewSynchVarOp                   = ILIT(156)
+tagOf_PrimOp TakeMVarOp                              = ILIT(157)
+tagOf_PrimOp PutMVarOp                       = ILIT(158)
+tagOf_PrimOp ReadIVarOp                              = ILIT(159)
+tagOf_PrimOp WriteIVarOp                     = ILIT(160)
+tagOf_PrimOp MakeForeignObjOp                = ILIT(161)
+tagOf_PrimOp WriteForeignObjOp               = ILIT(162)
+tagOf_PrimOp MakeStablePtrOp                 = ILIT(163)
+tagOf_PrimOp DeRefStablePtrOp                = ILIT(164)
+tagOf_PrimOp (CCallOp _ _ _ _ _)             = ILIT(165)
+tagOf_PrimOp ErrorIOPrimOp                   = ILIT(166)
+tagOf_PrimOp ReallyUnsafePtrEqualityOp       = ILIT(167)
+tagOf_PrimOp SeqOp                           = ILIT(168)
+tagOf_PrimOp ParOp                           = ILIT(169)
+tagOf_PrimOp ForkOp                          = ILIT(170)
+tagOf_PrimOp DelayOp                         = ILIT(171)
+tagOf_PrimOp WaitReadOp                              = ILIT(172)
+tagOf_PrimOp WaitWriteOp                     = ILIT(173)
+
+tagOf_PrimOp ParGlobalOp                     = ILIT(174)
+tagOf_PrimOp ParLocalOp                              = ILIT(175)
+tagOf_PrimOp ParAtOp                         = ILIT(176)
+tagOf_PrimOp ParAtAbsOp                              = ILIT(177)
+tagOf_PrimOp ParAtRelOp                              = ILIT(178)
+tagOf_PrimOp ParAtForNowOp                   = ILIT(179)
+tagOf_PrimOp CopyableOp                              = ILIT(180)
+tagOf_PrimOp NoFollowOp                              = ILIT(181)
 
 tagOf_PrimOp _ = panic# "tagOf_PrimOp: pattern-match"
 
@@ -490,6 +499,7 @@ allThePrimOps
        AndOp,
        OrOp,
        NotOp,
+       XorOp,
        SllOp,
        SraOp,
        SrlOp,
@@ -588,6 +598,11 @@ allThePrimOps
        IndexOffAddrOp AddrRep,
        IndexOffAddrOp FloatRep,
        IndexOffAddrOp DoubleRep,
+       IndexOffForeignObjOp CharRep,
+       IndexOffForeignObjOp IntRep,
+       IndexOffForeignObjOp AddrRep,
+       IndexOffForeignObjOp FloatRep,
+       IndexOffForeignObjOp DoubleRep,
        UnsafeFreezeArrayOp,
        UnsafeFreezeByteArrayOp,
        NewSynchVarOp,
@@ -597,6 +612,7 @@ allThePrimOps
        ReadIVarOp,
        WriteIVarOp,
        MakeForeignObjOp,
+       WriteForeignObjOp,
        MakeStablePtrOp,
        DeRefStablePtrOp,
        ReallyUnsafePtrEqualityOp,
@@ -763,6 +779,7 @@ primOpInfo IntQuotOp = Dyadic SLIT("quotInt#")       intPrimTy
 primOpInfo IntRemOp  = Dyadic SLIT("remInt#")   intPrimTy
 
 primOpInfo IntNegOp  = Monadic SLIT("negateInt#") intPrimTy
+primOpInfo IntAbsOp  = Monadic SLIT("absInt#") intPrimTy
 \end{code}
 
 %************************************************************************
@@ -777,6 +794,7 @@ A @Word#@ is an unsigned @Int#@.
 primOpInfo AndOp    = Dyadic  SLIT("and#")     wordPrimTy
 primOpInfo OrOp            = Dyadic  SLIT("or#")       wordPrimTy
 primOpInfo NotOp    = Monadic SLIT("not#")     wordPrimTy
+primOpInfo XorOp    = Monadic SLIT("xor#")     wordPrimTy
 
 primOpInfo SllOp
   = PrimResult SLIT("shiftL#")  [] [wordPrimTy, intPrimTy] wordPrimTyCon WordRep []
@@ -1048,6 +1066,13 @@ primOpInfo (IndexOffAddrOp kind)
     in
     PrimResult op_str [] [addrPrimTy, intPrimTy] prim_tycon kind []
 
+primOpInfo (IndexOffForeignObjOp kind)
+  = let
+       (str, _, prim_tycon) = getPrimRepInfo kind
+       op_str = _PK_ ("index" ++ str ++ "OffForeignObj#")
+    in
+    PrimResult op_str [] [foreignObjPrimTy, intPrimTy] prim_tycon kind []
+
 ---------------------------------------------------------------------------
 primOpInfo UnsafeFreezeArrayOp
   = let {
@@ -1147,7 +1172,7 @@ primOpInfo WaitWriteOp
 
 %************************************************************************
 %*                                                                     *
-\subsubsection[PrimOps-makeForeignObj]{PrimOpInfo for Foreign Objects}
+\subsubsection[PrimOps-ForeignObj]{PrimOpInfo for Foreign Objects}
 %*                                                                     *
 %************************************************************************
 
@@ -1164,7 +1189,7 @@ When a @ForeignObj@ becomes garbage, a user-defined finalisation routine
 associated with the object is invoked (currently, each ForeignObj has a
 direct reference to its finaliser).  -- SOF
 
-The only function defined over @ForeignObj@s is:
+A @ForeignObj@ is created by the @makeForeignObj#@ primitive:
 
 \begin{pseudocode}
 makeForeignObj# :: Addr#  -- foreign object
@@ -1172,6 +1197,7 @@ makeForeignObj# :: Addr#  -- foreign object
                -> StateAndForeignObj# _RealWorld# ForeignObj#
 \end{pseudocode}
 
+
 \begin{code}
 primOpInfo MakeForeignObjOp
   = AlgResult SLIT("makeForeignObj#") [] 
@@ -1179,6 +1205,34 @@ primOpInfo MakeForeignObjOp
        stateAndForeignObjPrimTyCon [realWorldTy]
 \end{code}
 
+[Experimental--SOF]
+In addition, another @ForeignObj@ primitive is provided for destructively modifying
+the external object wrapped up inside a @ForeignObj@. This primitive is used
+when a mixed programming interface of implicit and explicit de-allocation is used,
+e.g., if @ForeignObj@s are used to implement @Handle@s, then @Handle@s can be
+released either explicitly (through @hClose@) or implicitly (via a finaliser).
+When releasing/closing the @Handle@ explicitly, care must be taken to avoid having 
+the finaliser for the embedded @ForeignObj@ attempt the same thing later.
+We deal with this situation, by allowing the programmer to destructively modify
+the data field of the @ForeignObj@ to hold a special value the finaliser recognises,
+and does not attempt to free (e.g., filling the data slot with \tr{NULL}).
+
+\begin{pseudocode}
+writeForeignObj# :: ForeignObj#  -- foreign object
+                -> Addr#        -- new data value
+               -> StateAndForeignObj# _RealWorld# ForeignObj#
+\end{pseudocode}
+
+\begin{code}
+primOpInfo WriteForeignObjOp
+ = let {
+       s = alphaTy; s_tv = alphaTyVar
+    } in
+   PrimResult SLIT("writeForeignObj#") [s_tv]
+       [foreignObjPrimTy, addrPrimTy, mkStatePrimTy s]
+       statePrimTyCon VoidRep [s]
+\end{code}
+
 %************************************************************************
 %*                                                                     *
 \subsubsection[PrimOp-stable-pointers]{PrimOpInfo for ``stable pointers''}
@@ -1332,7 +1386,7 @@ primOpInfo ErrorIOPrimOp -- errorIO# :: PrimIO () -> State# RealWorld#
        statePrimTyCon VoidRep [realWorldTy]
   where
     primio_ish_ty result
-      = mkFunTy (mkStateTy realWorldTy) (mkTupleTy 2 [result, mkStateTy realWorldTy])
+      = mkFunTy (mkStatePrimTy realWorldTy) (mkSTretTy realWorldTy result)
 \end{code}
 
 %************************************************************************
@@ -1345,8 +1399,7 @@ primOpInfo ErrorIOPrimOp -- errorIO# :: PrimIO () -> State# RealWorld#
 primOpInfo (CCallOp _ _ _ arg_tys result_ty)
   = AlgResult SLIT("ccall#") [] arg_tys result_tycon tys_applied
   where
-    (result_tycon, tys_applied, _) = --trace "PrimOp.getAppDataTyConExpandingDicts" $
-                                    getAppDataTyConExpandingDicts result_ty
+    (result_tycon, tys_applied, _) = getAppDataTyConExpandingDicts result_ty
 
 #ifdef DEBUG
 primOpInfo op = panic ("primOpInfo:"++ show (I# (tagOf_PrimOp op)))
@@ -1400,13 +1453,18 @@ primOpHeapReq DoubleDecodeOp    = FixedHeapRequired
                                  (addOff (totHdrSize (DataRep mIN_MP_INT_SIZE))
                                          (intOff mIN_MP_INT_SIZE)))
 
--- ccall may allocate heap if it is explicitly allowed to (_ccall_gc_)
--- or if it returns a ForeignObj.
+{-
+  ccall may allocate heap if it is explicitly allowed to (_ccall_gc_)
+  or if it returns a ForeignObj.
 
+  Hmm..the allocation for makeForeignObj# is known (and fixed), so
+  why dod we need to be so indeterminate about it? --SOF
+-}
 primOpHeapReq (CCallOp _ _ mayGC@True  _ _) = VariableHeapRequired
 primOpHeapReq (CCallOp _ _ mayGC@False _ _) = NoHeapRequired
 
 primOpHeapReq MakeForeignObjOp = VariableHeapRequired
+primOpHeapReq WriteForeignObjOp        = NoHeapRequired
 
 -- this occasionally has to expand the Stable Pointer table
 primOpHeapReq MakeStablePtrOp  = VariableHeapRequired
@@ -1553,7 +1611,8 @@ fragilePrimOp :: PrimOp -> Bool
 fragilePrimOp ParOp = True
 fragilePrimOp ForkOp = True
 fragilePrimOp SeqOp = True
-fragilePrimOp MakeForeignObjOp = True  -- SOF
+fragilePrimOp MakeForeignObjOp  = True  -- SOF
+fragilePrimOp WriteForeignObjOp = True  -- SOF
 fragilePrimOp MakeStablePtrOp  = True
 fragilePrimOp DeRefStablePtrOp = True  -- ??? JSM & ADR
 
@@ -1625,6 +1684,7 @@ primOpNeedsWrapper DoubleEncodeOp         = True
 primOpNeedsWrapper DoubleDecodeOp      = True
 
 primOpNeedsWrapper MakeForeignObjOp    = True
+primOpNeedsWrapper WriteForeignObjOp   = True
 primOpNeedsWrapper MakeStablePtrOp     = True
 primOpNeedsWrapper DeRefStablePtrOp    = True
 
@@ -1708,6 +1768,7 @@ commutableOp IntAddOp       = True
 commutableOp IntMulOp    = True
 commutableOp AndOp       = True
 commutableOp OrOp        = True
+commutableOp XorOp       = True
 commutableOp IntEqOp     = True
 commutableOp IntNeOp     = True
 commutableOp IntegerAddOp = True
@@ -1732,11 +1793,10 @@ compare_fun_ty ty = mkFunTys [ty, ty] boolTy
 
 Output stuff:
 \begin{code}
-pprPrimOp  :: PprStyle -> PrimOp -> Pretty
+pprPrimOp  :: PprStyle -> PrimOp -> Doc
 showPrimOp :: PprStyle -> PrimOp -> String
 
-showPrimOp sty op
-  = ppShow 1000{-random-} (pprPrimOp sty op)
+showPrimOp sty op = render (pprPrimOp sty op)
 
 pprPrimOp sty (CCallOp fun is_casm may_gc arg_tys res_ty)
   = let
@@ -1747,22 +1807,22 @@ pprPrimOp sty (CCallOp fun is_casm may_gc arg_tys res_ty)
               if may_gc then "_ccall_GC_ " else "_ccall_ "
 
        after
-         = if is_casm then ppStr "''" else ppNil
+         = if is_casm then text "''" else empty
 
        pp_tys
-         = ppCat (map (pprParendGenType sty) (res_ty:arg_tys))
+         = hsep (map (pprParendGenType sty) (res_ty:arg_tys))
     in
-    ppBesides [ppStr before, ppPStr fun, after, ppSP, ppLbrack, pp_tys, ppRbrack]
+    hcat [text before, ptext fun, after, space, brackets pp_tys]
 
 pprPrimOp sty other_op
   | codeStyle sty      -- For C just print the primop itself
   = identToC str
 
   | ifaceStyle sty     -- For interfaces Print it qualified with GHC.
-  = ppPStr SLIT("GHC.") `ppBeside` ppPStr str
+  = ptext SLIT("GHC.") <> ptext str
 
   | otherwise          -- Unqualified is good enough
-  = ppPStr str
+  = ptext str
   where
     str = primOp_str other_op