From 6e94381eefe415d0b44035cac92416d4ec0c4c98 Mon Sep 17 00:00:00 2001 From: ii8 Date: Sat, 5 Jul 2025 13:16:53 +0100 Subject: [PATCH] debug-me: update to 1.20221231. --- srcpkgs/debug-me/files/stack.yaml | 6 - srcpkgs/debug-me/patches/basement.patch | 242 ++++++++++++++++++++++++ srcpkgs/debug-me/patches/cborg.patch | 212 +++++++++++++++++++++ srcpkgs/debug-me/patches/deps.patch | 20 ++ srcpkgs/debug-me/patches/memory.patch | 36 ++++ srcpkgs/debug-me/template | 34 +++- 6 files changed, 539 insertions(+), 11 deletions(-) delete mode 100644 srcpkgs/debug-me/files/stack.yaml create mode 100644 srcpkgs/debug-me/patches/basement.patch create mode 100644 srcpkgs/debug-me/patches/cborg.patch create mode 100644 srcpkgs/debug-me/patches/deps.patch create mode 100644 srcpkgs/debug-me/patches/memory.patch diff --git a/srcpkgs/debug-me/files/stack.yaml b/srcpkgs/debug-me/files/stack.yaml deleted file mode 100644 index f2b1a79d70c..00000000000 --- a/srcpkgs/debug-me/files/stack.yaml +++ /dev/null @@ -1,6 +0,0 @@ -packages: -- '.' -resolver: lts-19.0 -extra-deps: - - posix-pty-0.2.1.1 - - sandi-0.5@sha256:b278d072ca717706ea38f9bd646e023f7f2576a778fb43565b434f93638849aa,3010 diff --git a/srcpkgs/debug-me/patches/basement.patch b/srcpkgs/debug-me/patches/basement.patch new file mode 100644 index 00000000000..e934f8e67b2 --- /dev/null +++ b/srcpkgs/debug-me/patches/basement.patch @@ -0,0 +1,242 @@ +From 38be2c93acb6f459d24ed6c626981c35ccf44095 Mon Sep 17 00:00:00 2001 +From: Sylvain Henry +Date: Thu, 16 Feb 2023 15:40:45 +0100 +Subject: [PATCH] Fix build on 32-bit architectures + +--- + basement/Basement/Bits.hs | 4 ++++ + basement/Basement/From.hs | 24 ----------------------- + basement/Basement/Numerical/Additive.hs | 4 ++++ + basement/Basement/Numerical/Conversion.hs | 20 +++++++++++++++++++ + basement/Basement/PrimType.hs | 6 +++++- + basement/Basement/Types/OffsetSize.hs | 22 +++++++++++++++++++-- + 6 files changed, 53 insertions(+), 27 deletions(-) + +diff --git a/basement/Basement/Bits.hs b/basement/Basement/Bits.hs +index 7eeea0f5..24520ed7 100644 +--- a/basement/Basement/Bits.hs ++++ b/basement/Basement/Bits.hs +@@ -54,8 +54,12 @@ import GHC.Int + import Basement.Compat.Primitive + + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 904 ++import GHC.Exts ++#else + import GHC.IntWord64 + #endif ++#endif + + -- | operation over finite bits + class FiniteBitsOps bits where +diff --git a/basement/Basement/From.hs b/basement/Basement/From.hs +index 7bbe141c..80014b3e 100644 +--- a/basement/Basement/From.hs ++++ b/basement/Basement/From.hs +@@ -272,23 +272,11 @@ instance (NatWithinBound (CountOf ty) n, KnownNat n, PrimType ty) + tryFrom = BlockN.toBlockN . UArray.toBlock . BoxArray.mapToUnboxed id + + instance (KnownNat n, NatWithinBound Word8 n) => From (Zn64 n) Word8 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . unZn64 where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . unZn64 where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# w)) +-#endif + instance (KnownNat n, NatWithinBound Word16 n) => From (Zn64 n) Word16 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . unZn64 where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . unZn64 where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# w)) +-#endif + instance (KnownNat n, NatWithinBound Word32 n) => From (Zn64 n) Word32 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . unZn64 where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . unZn64 where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# w)) +-#endif + instance From (Zn64 n) Word64 where + from = unZn64 + instance From (Zn64 n) Word128 where +@@ -297,23 +285,11 @@ instance From (Zn64 n) Word256 where + from = from . unZn64 + + instance (KnownNat n, NatWithinBound Word8 n) => From (Zn n) Word8 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# w)) +-#endif + instance (KnownNat n, NatWithinBound Word16 n) => From (Zn n) Word16 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# w)) +-#endif + instance (KnownNat n, NatWithinBound Word32 n) => From (Zn n) Word32 where +-#if __GLASGOW_HASKELL__ >= 904 +- from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# (GHC.Prim.word64ToWord# w))) +-#else + from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# w)) +-#endif + instance (KnownNat n, NatWithinBound Word64 n) => From (Zn n) Word64 where + from = naturalToWord64 . unZn + instance (KnownNat n, NatWithinBound Word128 n) => From (Zn n) Word128 where +diff --git a/basement/Basement/Numerical/Additive.hs b/basement/Basement/Numerical/Additive.hs +index d0dfb973..8ab65aa0 100644 +--- a/basement/Basement/Numerical/Additive.hs ++++ b/basement/Basement/Numerical/Additive.hs +@@ -30,8 +30,12 @@ import qualified Basement.Types.Word128 as Word128 + import qualified Basement.Types.Word256 as Word256 + + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 904 ++import GHC.Exts ++#else + import GHC.IntWord64 + #endif ++#endif + + -- | Represent class of things that can be added together, + -- contains a neutral element and is commutative. +diff --git a/basement/Basement/Numerical/Conversion.hs b/basement/Basement/Numerical/Conversion.hs +index db502c07..fddc8232 100644 +--- a/basement/Basement/Numerical/Conversion.hs ++++ b/basement/Basement/Numerical/Conversion.hs +@@ -26,8 +26,12 @@ import GHC.Word + import Basement.Compat.Primitive + + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 904 ++import GHC.Exts ++#else + import GHC.IntWord64 + #endif ++#endif + + intToInt64 :: Int -> Int64 + #if WORD_SIZE_IN_BITS == 64 +@@ -96,11 +100,22 @@ int64ToWord64 (I64# i) = W64# (int64ToWord64# i) + #endif + + #if WORD_SIZE_IN_BITS == 64 ++#if __GLASGOW_HASKELL__ >= 904 ++word64ToWord# :: Word64# -> Word# ++word64ToWord# i = word64ToWord# i ++#else + word64ToWord# :: Word# -> Word# + word64ToWord# i = i ++#endif + {-# INLINE word64ToWord# #-} + #endif + ++#if WORD_SIZE_IN_BITS < 64 ++word64ToWord32# :: Word64# -> Word32# ++word64ToWord32# i = wordToWord32# (word64ToWord# i) ++{-# INLINE word64ToWord32# #-} ++#endif ++ + -- | 2 Word32s + data Word32x2 = Word32x2 {-# UNPACK #-} !Word32 + {-# UNPACK #-} !Word32 +@@ -113,9 +128,14 @@ word64ToWord32s (W64# w64) = Word32x2 (W32# (wordToWord32# (uncheckedShiftRL# (G + word64ToWord32s (W64# w64) = Word32x2 (W32# (wordToWord32# (uncheckedShiftRL# w64 32#))) (W32# (wordToWord32# w64)) + #endif + #else ++#if __GLASGOW_HASKELL__ >= 904 ++word64ToWord32s :: Word64 -> Word32x2 ++word64ToWord32s (W64# w64) = Word32x2 (W32# (word64ToWord32# (uncheckedShiftRL64# w64 32#))) (W32# (word64ToWord32# w64)) ++#else + word64ToWord32s :: Word64 -> Word32x2 + word64ToWord32s (W64# w64) = Word32x2 (W32# (word64ToWord# (uncheckedShiftRL64# w64 32#))) (W32# (word64ToWord# w64)) + #endif ++#endif + + wordToChar :: Word -> Char + wordToChar (W# word) = C# (chr# (word2Int# word)) +diff --git a/basement/Basement/PrimType.hs b/basement/Basement/PrimType.hs +index f8ca2926..a888ec91 100644 +--- a/basement/Basement/PrimType.hs ++++ b/basement/Basement/PrimType.hs +@@ -54,7 +54,11 @@ import Basement.Nat + import qualified Prelude (quot) + + #if WORD_SIZE_IN_BITS < 64 +-import GHC.IntWord64 ++#if __GLASGOW_HASKELL__ >= 904 ++import GHC.Exts ++#else ++import GHC.IntWord64 ++#endif + #endif + + #ifdef FOUNDATION_BOUNDS_CHECK +diff --git a/basement/Basement/Types/OffsetSize.hs b/basement/Basement/Types/OffsetSize.hs +index cd944927..1ea80dad 100644 +--- a/basement/Basement/Types/OffsetSize.hs ++++ b/basement/Basement/Types/OffsetSize.hs +@@ -70,8 +70,12 @@ import Data.List (foldl') + import qualified Prelude + + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 904 ++import GHC.Exts ++#else + import GHC.IntWord64 + #endif ++#endif + + -- | File size in bytes + newtype FileSize = FileSize Word64 +@@ -225,20 +229,26 @@ countOfRoundUp alignment (CountOf n) = CountOf ((n + (alignment-1)) .&. compleme + + csizeOfSize :: CountOf Word8 -> CSize + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 904 ++csizeOfSize (CountOf (I# sz)) = CSize (W32# (wordToWord32# (int2Word# sz))) ++#else + csizeOfSize (CountOf (I# sz)) = CSize (W32# (int2Word# sz)) ++#endif + #else + #if __GLASGOW_HASKELL__ >= 904 + csizeOfSize (CountOf (I# sz)) = CSize (W64# (wordToWord64# (int2Word# sz))) +- + #else + csizeOfSize (CountOf (I# sz)) = CSize (W64# (int2Word# sz)) +- + #endif + #endif + + csizeOfOffset :: Offset8 -> CSize + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 904 ++csizeOfOffset (Offset (I# sz)) = CSize (W32# (wordToWord32# (int2Word# sz))) ++#else + csizeOfOffset (Offset (I# sz)) = CSize (W32# (int2Word# sz)) ++#endif + #else + #if __GLASGOW_HASKELL__ >= 904 + csizeOfOffset (Offset (I# sz)) = CSize (W64# (wordToWord64# (int2Word# sz))) +@@ -250,7 +260,11 @@ csizeOfOffset (Offset (I# sz)) = CSize (W64# (int2Word# sz)) + sizeOfCSSize :: CSsize -> CountOf Word8 + sizeOfCSSize (CSsize (-1)) = error "invalid size: CSSize is -1" + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 904 ++sizeOfCSSize (CSsize (I32# sz)) = CountOf (I# (int32ToInt# sz)) ++#else + sizeOfCSSize (CSsize (I32# sz)) = CountOf (I# sz) ++#endif + #else + #if __GLASGOW_HASKELL__ >= 904 + sizeOfCSSize (CSsize (I64# sz)) = CountOf (I# (int64ToInt# sz)) +@@ -261,7 +275,11 @@ sizeOfCSSize (CSsize (I64# sz)) = CountOf (I# sz) + + sizeOfCSize :: CSize -> CountOf Word8 + #if WORD_SIZE_IN_BITS < 64 ++#if __GLASGOW_HASKELL__ >= 904 ++sizeOfCSize (CSize (W32# sz)) = CountOf (I# (word2Int# (word32ToWord# sz))) ++#else + sizeOfCSize (CSize (W32# sz)) = CountOf (I# (word2Int# sz)) ++#endif + #else + #if __GLASGOW_HASKELL__ >= 904 + sizeOfCSize (CSize (W64# sz)) = CountOf (I# (word2Int# (word64ToWord# sz))) diff --git a/srcpkgs/debug-me/patches/cborg.patch b/srcpkgs/debug-me/patches/cborg.patch new file mode 100644 index 00000000000..b44ba514458 --- /dev/null +++ b/srcpkgs/debug-me/patches/cborg.patch @@ -0,0 +1,212 @@ +commit 9d1418bb8b38cb9a438d7f18835b1ef7ef12b234 +Author: amesgen +Date: Sun Sep 10 20:03:40 2023 +0200 + + Fix compilation and support GHC >=9.2 on 32bit + +diff --git a/cborg/src/Codec/CBOR/Decoding.hs b/cborg/src/Codec/CBOR/Decoding.hs +index a7d774c..bf68e68 100644 +--- a/cborg/src/Codec/CBOR/Decoding.hs ++++ b/cborg/src/Codec/CBOR/Decoding.hs +@@ -315,11 +315,16 @@ getDecodeAction (Decoder k) = k (\x -> return (Done x)) + toInt8 :: Int# -> Int8 + toInt16 :: Int# -> Int16 + toInt32 :: Int# -> Int32 +-toInt64 :: Int# -> Int64 + toWord8 :: Word# -> Word8 + toWord16 :: Word# -> Word16 + toWord32 :: Word# -> Word32 ++#if defined(ARCH_64bit) ++toInt64 :: Int# -> Int64 + toWord64 :: Word# -> Word64 ++#else ++toInt64 :: Int64# -> Int64 ++toWord64 :: Word64# -> Word64 ++#endif + #if MIN_VERSION_ghc_prim(0,8,0) + toInt8 n = I8# (intToInt8# n) + toInt16 n = I16# (intToInt16# n) +@@ -327,8 +332,7 @@ toInt32 n = I32# (intToInt32# n) + toWord8 n = W8# (wordToWord8# n) + toWord16 n = W16# (wordToWord16# n) + toWord32 n = W32# (wordToWord32# n) +-#if WORD_SIZE_IN_BITS == 64 +-#if MIN_VERSION_base(4,17,0) ++#if MIN_VERSION_base(4,17,0) && defined(ARCH_64bit) + toInt64 n = I64# (intToInt64# n) + toWord64 n = W64# (wordToWord64# n) + #else +@@ -336,10 +340,6 @@ toInt64 n = I64# n + toWord64 n = W64# n + #endif + #else +-toInt64 n = I64# (intToInt64# n) +-toWord64 n = W64# (wordToWord64# n) +-#endif +-#else + toInt8 n = I8# n + toInt16 n = I16# n + toInt32 n = I32# n +@@ -986,7 +986,7 @@ type ByteOffset = Int64 + -- @since 0.2.2.0 + peekByteOffset :: Decoder s ByteOffset + peekByteOffset = Decoder (\k -> return (PeekByteOffset (\off# -> k (I64# +-#if MIN_VERSION_base(4,17,0) ++#if MIN_VERSION_base(4,17,0) && !defined(ARCH_32bit) + (intToInt64# off#) + #else + off# +diff --git a/cborg/src/Codec/CBOR/Magic.hs b/cborg/src/Codec/CBOR/Magic.hs +index cdeb455..bfae638 100644 +--- a/cborg/src/Codec/CBOR/Magic.hs ++++ b/cborg/src/Codec/CBOR/Magic.hs +@@ -120,7 +120,7 @@ import qualified Numeric.Half as Half + import Data.Bits ((.|.), unsafeShiftL) + #endif + +-#if defined(ARCH_32bit) ++#if defined(ARCH_32bit) && !MIN_VERSION_ghc_prim(0,8,0) + import GHC.IntWord64 (wordToWord64#, word64ToWord#, + intToInt64#, int64ToInt#, + leWord64#, ltWord64#, word64ToInt64#) +@@ -173,7 +173,7 @@ grabWord64 (Ptr ip#) = W64# (wordToWord64# (byteSwap# (word64ToWord# (indexWord6 + grabWord64 (Ptr ip#) = W64# (byteSwap# (indexWord64OffAddr# ip# 0#)) + #endif + #else +-grabWord64 (Ptr ip#) = W64# (byteSwap64# (word64ToWord# (indexWord64OffAddr# ip# 0#))) ++grabWord64 (Ptr ip#) = W64# (byteSwap64# (indexWord64OffAddr# ip# 0#)) + #endif + + #elif defined(MEM_UNALIGNED_OPS) && \ +@@ -484,7 +484,7 @@ word16ToInt (W16# w#) = I# (word2Int# (word16ToWord# w#)) + word32ToInt (W32# w#) = I# (word2Int# (word32ToWord# w#)) + #else + word32ToInt (W32# w#) = +- case isTrue# (w# `ltWord#` 0x80000000##) of ++ case isTrue# (word32ToWord# w# `ltWord#` 0x80000000##) of + True -> Just (I# (word2Int# (word32ToWord# w#))) + False -> Nothing + #endif +@@ -530,6 +530,19 @@ word64ToInt (W64# w#) = + {-# INLINE word64ToInt #-} + + #if defined(ARCH_32bit) ++#if MIN_VERSION_ghc_prim(0,8,0) ++word8ToInt64 (W8# w#) = I64# (intToInt64# (word2Int# (word8ToWord# w#))) ++word16ToInt64 (W16# w#) = I64# (intToInt64# (word2Int# (word16ToWord# w#))) ++word32ToInt64 (W32# w#) = I64# (word64ToInt64# (wordToWord64# (word32ToWord# w#))) ++word64ToInt64 (W64# w#) = ++ case isTrue# (w# `ltWord64#` uncheckedShiftL64# (wordToWord64# 1##) 63#) of ++ True -> Just (I64# (word64ToInt64# w#)) ++ False -> Nothing ++ ++word8ToWord64 (W8# w#) = W64# (wordToWord64# (word8ToWord# w#)) ++word16ToWord64 (W16# w#) = W64# (wordToWord64# (word16ToWord# w#)) ++word32ToWord64 (W32# w#) = W64# (wordToWord64# (word32ToWord# w#)) ++#else + word8ToInt64 (W8# w#) = I64# (intToInt64# (word2Int# w#)) + word16ToInt64 (W16# w#) = I64# (intToInt64# (word2Int# w#)) + word32ToInt64 (W32# w#) = I64# (word64ToInt64# (wordToWord64# w#)) +@@ -541,6 +554,7 @@ word64ToInt64 (W64# w#) = + word8ToWord64 (W8# w#) = W64# (wordToWord64# w#) + word16ToWord64 (W16# w#) = W64# (wordToWord64# w#) + word32ToWord64 (W32# w#) = W64# (wordToWord64# w#) ++#endif + + {-# INLINE word8ToInt64 #-} + {-# INLINE word16ToInt64 #-} +diff --git a/cborg/src/Codec/CBOR/Read.hs b/cborg/src/Codec/CBOR/Read.hs +index 6546575..c4dc761 100644 +--- a/cborg/src/Codec/CBOR/Read.hs ++++ b/cborg/src/Codec/CBOR/Read.hs +@@ -63,7 +63,7 @@ import qualified Data.Text as T + import qualified Data.Text.Encoding as T + import Data.Word + import GHC.Word +-#if defined(ARCH_32bit) ++#if defined(ARCH_32bit) && !MIN_VERSION_ghc_prim(0,8,0) + import GHC.IntWord64 + #endif + import GHC.Exts +@@ -510,8 +510,8 @@ go_fast !bs da@(ConsumeNegWord64Canonical k) = + go_fast !bs da@(ConsumeInt64Canonical k) = + case tryConsumeInt64 (BS.unsafeHead bs) bs of + DecodeFailure -> go_fast_end bs da +- DecodedToken sz i@(I64# i#) +- | isInt64Canonical sz i -> k i# >>= go_fast (BS.unsafeDrop sz bs) ++ DecodedToken sz (I64# i#) ++ | isInt64Canonical sz i# -> k i# >>= go_fast (BS.unsafeDrop sz bs) + | otherwise -> go_fast_end bs da + + go_fast !bs da@(ConsumeListLen64Canonical k) = +@@ -994,8 +994,8 @@ go_fast_end !bs (ConsumeNegWord64Canonical k) = + go_fast_end !bs (ConsumeInt64Canonical k) = + case tryConsumeInt64 (BS.unsafeHead bs) bs of + DecodeFailure -> return $! SlowFail bs "expected int64" +- DecodedToken sz i@(I64# i#) +- | isInt64Canonical sz i -> k i# >>= go_fast_end (BS.unsafeDrop sz bs) ++ DecodedToken sz (I64# i#) ++ | isInt64Canonical sz i# -> k i# >>= go_fast_end (BS.unsafeDrop sz bs) + | otherwise -> return $! SlowFail bs "non-canonical int64" + + go_fast_end !bs (ConsumeListLen64Canonical k) = +@@ -1271,7 +1271,7 @@ go_slow da bs !offset = do + + SlowPeekByteOffset bs' k -> + lift +-#if MIN_VERSION_base(4,17,0) ++#if MIN_VERSION_base(4,17,0) && !defined(ARCH_32bit) + (k (int64ToInt# off#)) + #else + (k off#) +@@ -1381,7 +1381,7 @@ go_slow_overlapped da sz bs_cur bs_next !offset = + SlowPeekByteOffset bs_empty k -> + assert (BS.null bs_empty) $ do + lift +-#if MIN_VERSION_base(4,17,0) ++#if MIN_VERSION_base(4,17,0) && !defined(ARCH_32bit) + (k (int64ToInt# off#)) + #else + (k off#) +@@ -1565,17 +1565,17 @@ isIntCanonical sz i + {-# INLINE isWord64Canonical #-} + isWord64Canonical :: Int -> Word64 -> Bool + isWord64Canonical sz w +- | sz == 2 = w > 0x17) +- | sz == 3 = w > 0xff) +- | sz == 5 = w > 0xffff) +- | sz == 9 = w > 0xffffffff) ++ | sz == 2 = w > 0x17 ++ | sz == 3 = w > 0xff ++ | sz == 5 = w > 0xffff ++ | sz == 9 = w > 0xffffffff + | otherwise = True + + {-# INLINE isInt64Canonical #-} + isInt64Canonical :: Int -> Int64# -> Bool + isInt64Canonical sz i# +- | isTrue# (i# `ltInt64#` intToInt64# 0#) = isWord64Canonical sz (not64# w#) +- | otherwise = isWord64Canonical sz w# ++ | isTrue# (i# `ltInt64#` intToInt64# 0#) = isWord64Canonical sz (W64# (not64# w#)) ++ | otherwise = isWord64Canonical sz (W64# w#) + where + w# = int64ToWord64# i# + #endif +@@ -1796,7 +1796,7 @@ tryConsumeInteger hdr !bs = case word8ToWord hdr of + 0x1b -> let !w = eatTailWord64 bs + sz = 9 + #if defined(ARCH_32bit) +- in DecodedToken sz (BigIntToken (isWord64Canonical sz (word64ToWord w)) $! toInteger w) ++ in DecodedToken sz (BigIntToken (isWord64Canonical sz w) $! toInteger w) + #else + in DecodedToken sz (BigIntToken (isWordCanonical sz (word64ToWord w)) $! toInteger w) + #endif +@@ -1838,7 +1838,7 @@ tryConsumeInteger hdr !bs = case word8ToWord hdr of + 0x3b -> let !w = eatTailWord64 bs + sz = 9 + #if defined(ARCH_32bit) +- in DecodedToken sz (BigIntToken (isWord64Canonical sz (word64ToWord w)) $! (-1 - toInteger w)) ++ in DecodedToken sz (BigIntToken (isWord64Canonical sz w) $! (-1 - toInteger w)) + #else + in DecodedToken sz (BigIntToken (isWordCanonical sz (word64ToWord w)) $! (-1 - toInteger w)) + #endif diff --git a/srcpkgs/debug-me/patches/deps.patch b/srcpkgs/debug-me/patches/deps.patch new file mode 100644 index 00000000000..121f8e70d26 --- /dev/null +++ b/srcpkgs/debug-me/patches/deps.patch @@ -0,0 +1,20 @@ +--- a/debug-me.cabal 2025-07-05 13:11:54.095974453 +0100 ++++ b/debug-me.cabal 2025-07-05 13:11:59.253974699 +0100 +@@ -55,7 +55,7 @@ + Build-Depends: + base (>= 4.9 && < 5.0) + , network (>= 2.6) +- , bytestring < 0.12 ++ , bytestring < 0.13 + , cryptonite (>= 0.20) + , unix (>= 2.7) + , process (>= 1.4) +@@ -64,7 +64,7 @@ + , stm-chans (>= 3.0) + , posix-pty (>= 0.2.1) + , terminal-size (>= 0.3) +- , aeson (>= 0.11 && < 2.1) ++ , aeson (>= 0.11 && < 2.3) + , sandi (>= 0.4) + , text (>= 1.2.2) + , optparse-applicative (>= 0.12) diff --git a/srcpkgs/debug-me/patches/memory.patch b/srcpkgs/debug-me/patches/memory.patch new file mode 100644 index 00000000000..2a6d85b720d --- /dev/null +++ b/srcpkgs/debug-me/patches/memory.patch @@ -0,0 +1,36 @@ +From 2738929ce15b4c8704bbbac24a08539b5d4bf30e Mon Sep 17 00:00:00 2001 +From: sternenseemann +Date: Mon, 14 Aug 2023 10:51:30 +0200 +Subject: [PATCH] Data.Memory.Internal.CompatPrim64: fix 32 bit with GHC >= 9.4 + +Since 9.4, GHC.Prim exports Word64# operations like timesWord64# even on +i686 whereas GHC.IntWord64 no longer exists. Therefore, we can just use +the ready made solution. + +Closes #98, as it should be the better solution. +--- + Data/Memory/Internal/CompatPrim64.hs | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/Data/Memory/Internal/CompatPrim64.hs b/Data/Memory/Internal/CompatPrim64.hs +index b9eef8a..a134c88 100644 +--- a/memory/Data/Memory/Internal/CompatPrim64.hs ++++ b/memory/Data/Memory/Internal/CompatPrim64.hs +@@ -150,6 +150,7 @@ w64# :: Word# -> Word# -> Word# -> Word64# + w64# w _ _ = w + + #elif WORD_SIZE_IN_BITS == 32 ++#if __GLASGOW_HASKELL__ < 904 + import GHC.IntWord64 + import GHC.Prim (Word#) + +@@ -158,6 +159,9 @@ timesWord64# a b = + let !ai = word64ToInt64# a + !bi = word64ToInt64# b + in int64ToWord64# (timesInt64# ai bi) ++#else ++import GHC.Prim ++#endif + + w64# :: Word# -> Word# -> Word# -> Word64# + w64# _ hw lw = diff --git a/srcpkgs/debug-me/template b/srcpkgs/debug-me/template index c886d07b175..a7a5ad71e00 100644 --- a/srcpkgs/debug-me/template +++ b/srcpkgs/debug-me/template @@ -1,19 +1,43 @@ # Template file for 'debug-me' pkgname=debug-me -version=1.20220324 +version=1.20221231 revision=1 -build_style=haskell-stack -stackage="lts-19.0" +build_style=cabal +cabal_index_state=2025-07-05T11:40:57Z makedepends="zlib-devel" short_desc="Secure remote debugging" maintainer="Orphaned " license="AGPL-3.0-or-later" homepage="https://debug-me.branchable.com/" -distfiles="https://git.joeyh.name/index.cgi/${pkgname}.git/snapshot/${pkgname}-${version}.tar.gz" -checksum=9fd6256aa34408106ff095e0560850aca3558a774be4ce19de6ab6e81fbfdb9f +distfiles="https://git.joeyh.name/index.cgi/${pkgname}.git/snapshot/${pkgname}-${version}.tar.gz + https://hackage.haskell.org/package/basement-0.0.16/basement-0.0.16.tar.gz + https://hackage.haskell.org/package/memory-0.18.0/memory-0.18.0.tar.gz + https://hackage.haskell.org/package/cborg-0.2.10.0/cborg-0.2.10.0.tar.gz" +checksum="c16b63a99d9cb177f28318e4598debaf974eda791da37fc66e13780959356373 + 7fb77e249aef76ba5aed3059d556800ce02b614597c488ba01f0a16449146300 + fd4eb6f638e24b81b4e6cdd68772a531726f2f67686c8969d3407d82f7862e3e + 17fe070c38fc498cab49bcb9d6215b7747d53bedf96502e9bcce9cad73b9c797" nocross=yes # Can't yet cross compile Haskell nopie_files="/usr/bin/debug-me" +skip_extraction="basement-0.0.16.tar.gz memory-0.18.0.tar.gz cborg-0.2.10.0.tar.gz" + +post_extract() { + vsrcextract -C basement basement-0.0.16.tar.gz + vsrcextract -C memory memory-0.18.0.tar.gz + vsrcextract -C cborg cborg-0.2.10.0.tar.gz +} + +post_configure() { + # Fix build on i686 by using patched basement, memory and cborg packages + echo 'packages: ./basement ./memory ./cborg' >> cabal.project.local + + # Fix build on musl by pretending to be glibc, + # otherwise it thinks we're freebsd + echo 'package posix-pty' >> cabal.project.local + echo ' ghc-options: -optc=-D__GLIBC__' >> cabal.project.local +} post_install() { + vman debug-me.1 vlicense AGPL }