From: Ian Lynagh <igloo@earth.li>
Date: Tue, 25 Mar 2008 23:30:34 +0000 (+0000)
Subject: Fix warnings in main/Constants
X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=commitdiff_plain;h=ed9b6b23e6f647871acb47916f8c247a2f192a1c

Fix warnings in main/Constants
---

diff --git a/compiler/main/Constants.lhs b/compiler/main/Constants.lhs
index 5db909d..d26db11 100644
--- a/compiler/main/Constants.lhs
+++ b/compiler/main/Constants.lhs
@@ -4,13 +4,6 @@
 \section[Constants]{Info about this compilation}
 
 \begin{code}
-{-# OPTIONS -w #-}
--- The above warning supression flag is a temporary kludge.
--- While working on this module you are encouraged to remove it and fix
--- any warnings in the module. See
---     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
--- for details
-
 module Constants (module Constants) where
 
 import Data.Bits (shiftL)
@@ -20,6 +13,8 @@ import Data.Bits (shiftL)
 -- we want; if we just hope a -I... will get the right one, we could
 -- be in trouble.
 
+-- XXX This define is a bit of a hack, and should be done more nicely
+#define FAST_STRING_NOT_NEEDED 1
 #include "HsVersions.h"
 #include "../includes/MachRegs.h"
 #include "../includes/Constants.h"
@@ -32,24 +27,36 @@ import Data.Bits (shiftL)
 All pretty arbitrary:
 
 \begin{code}
-mAX_TUPLE_SIZE = (62 :: Int)    -- Should really match the number
-                                -- of decls in Data.Tuple
-mAX_CONTEXT_REDUCTION_DEPTH = (20 :: Int)
+mAX_TUPLE_SIZE :: Int
+mAX_TUPLE_SIZE = 62 -- Should really match the number
+                    -- of decls in Data.Tuple
+
+mAX_CONTEXT_REDUCTION_DEPTH :: Int
+mAX_CONTEXT_REDUCTION_DEPTH = 20
 \end{code}
 
 
 \begin{code}
 -- specialised fun/thunk/constr closure types
-mAX_SPEC_THUNK_SIZE   = (MAX_SPEC_THUNK_SIZE :: Int)
-mAX_SPEC_FUN_SIZE     = (MAX_SPEC_FUN_SIZE :: Int)
-mAX_SPEC_CONSTR_SIZE  = (MAX_SPEC_CONSTR_SIZE :: Int)
+mAX_SPEC_THUNK_SIZE :: Int
+mAX_SPEC_THUNK_SIZE = MAX_SPEC_THUNK_SIZE
+
+mAX_SPEC_FUN_SIZE :: Int
+mAX_SPEC_FUN_SIZE = MAX_SPEC_FUN_SIZE
+
+mAX_SPEC_CONSTR_SIZE :: Int
+mAX_SPEC_CONSTR_SIZE = MAX_SPEC_CONSTR_SIZE
 
 -- pre-compiled thunk types
-mAX_SPEC_SELECTEE_SIZE	= (MAX_SPEC_SELECTEE_SIZE :: Int)
-mAX_SPEC_AP_SIZE        = (MAX_SPEC_AP_SIZE :: Int)
+mAX_SPEC_SELECTEE_SIZE :: Int
+mAX_SPEC_SELECTEE_SIZE = MAX_SPEC_SELECTEE_SIZE
+
+mAX_SPEC_AP_SIZE :: Int
+mAX_SPEC_AP_SIZE = MAX_SPEC_AP_SIZE
 
 -- closure sizes: these do NOT include the header (see below for header sizes)
-mIN_PAYLOAD_SIZE	= (MIN_PAYLOAD_SIZE::Int)
+mIN_PAYLOAD_SIZE ::Int
+mIN_PAYLOAD_SIZE = MIN_PAYLOAD_SIZE
 \end{code}
 
 \begin{code}
@@ -65,90 +72,129 @@ mAX_CHARLIKE = MAX_CHARLIKE
 A section of code-generator-related MAGIC CONSTANTS.
 
 \begin{code}
-mAX_Vanilla_REG	= (MAX_VANILLA_REG :: Int)
-mAX_Float_REG	= (MAX_FLOAT_REG :: Int)
-mAX_Double_REG	= (MAX_DOUBLE_REG :: Int)
-mAX_Long_REG    = (MAX_LONG_REG  :: Int)
+mAX_Vanilla_REG :: Int
+mAX_Vanilla_REG	= MAX_VANILLA_REG
+
+mAX_Float_REG :: Int
+mAX_Float_REG = MAX_FLOAT_REG
+
+mAX_Double_REG :: Int
+mAX_Double_REG = MAX_DOUBLE_REG
+
+mAX_Long_REG :: Int
+mAX_Long_REG = MAX_LONG_REG
+
+mAX_Real_Vanilla_REG :: Int
+mAX_Real_Vanilla_REG = MAX_REAL_VANILLA_REG
 
-mAX_Real_Vanilla_REG	= (MAX_REAL_VANILLA_REG :: Int)
-mAX_Real_Float_REG	= (MAX_REAL_FLOAT_REG :: Int)
-mAX_Real_Double_REG	= (MAX_REAL_DOUBLE_REG :: Int)
+mAX_Real_Float_REG :: Int
+mAX_Real_Float_REG = MAX_REAL_FLOAT_REG
+
+mAX_Real_Double_REG :: Int
+mAX_Real_Double_REG	= MAX_REAL_DOUBLE_REG
+
+mAX_Real_Long_REG :: Int
 #ifdef MAX_REAL_LONG_REG
-mAX_Real_Long_REG	= (MAX_REAL_LONG_REG :: Int)
+mAX_Real_Long_REG = MAX_REAL_LONG_REG
 #else
-mAX_Real_Long_REG       = (0::Int)
+mAX_Real_Long_REG = 0
 #endif
 \end{code}
 
 Closure header sizes.
 
 \begin{code}
-sTD_HDR_SIZE       = (STD_HDR_SIZE       :: Int)
-pROF_HDR_SIZE      = (PROF_HDR_SIZE      :: Int)
-gRAN_HDR_SIZE      = (GRAN_HDR_SIZE      :: Int)
+sTD_HDR_SIZE :: Int
+sTD_HDR_SIZE = STD_HDR_SIZE
+
+pROF_HDR_SIZE :: Int
+pROF_HDR_SIZE = PROF_HDR_SIZE
+
+gRAN_HDR_SIZE :: Int
+gRAN_HDR_SIZE = GRAN_HDR_SIZE
 \end{code}
 
 Size of a double in StgWords.
 
 \begin{code}
-dOUBLE_SIZE     = SIZEOF_DOUBLE :: Int
-wORD64_SIZE     = 8 :: Int
-iNT64_SIZE      = wORD64_SIZE
+dOUBLE_SIZE :: Int
+dOUBLE_SIZE = SIZEOF_DOUBLE
+
+wORD64_SIZE :: Int
+wORD64_SIZE = 8
+
+iNT64_SIZE :: Int
+iNT64_SIZE = wORD64_SIZE
 \end{code}
 
 This tells the native code generator the size of the spill
 area is has available.
 
 \begin{code}
-rESERVED_C_STACK_BYTES = (RESERVED_C_STACK_BYTES :: Int)
+rESERVED_C_STACK_BYTES :: Int
+rESERVED_C_STACK_BYTES = RESERVED_C_STACK_BYTES
 \end{code}
 
 The amount of (Haskell) stack to leave free for saving registers when
 returning to the scheduler.
 
 \begin{code}
-rESERVED_STACK_WORDS = (RESERVED_STACK_WORDS :: Int)
+rESERVED_STACK_WORDS :: Int
+rESERVED_STACK_WORDS = RESERVED_STACK_WORDS
 \end{code}
 
 Continuations that need more than this amount of stack should do their
 own stack check (see bug #1466).
 
 \begin{code}
-aP_STACK_SPLIM = (AP_STACK_SPLIM :: Int)
+aP_STACK_SPLIM :: Int
+aP_STACK_SPLIM = AP_STACK_SPLIM
 \end{code}
 
 Size of a word, in bytes
 
 \begin{code}
-wORD_SIZE = (SIZEOF_HSWORD :: Int)
-wORD_SIZE_IN_BITS = wORD_SIZE * 8 :: Int
+wORD_SIZE :: Int
+wORD_SIZE = SIZEOF_HSWORD
+
+wORD_SIZE_IN_BITS :: Int
+wORD_SIZE_IN_BITS = wORD_SIZE * 8
 \end{code}
 
 Amount of pointer bits used for semi-tagging constructor closures
 
 \begin{code}
-tAG_BITS    = (TAG_BITS :: Int)
-tAG_MASK    = ((1 `shiftL` tAG_BITS) - 1) :: Int
-mAX_PTR_TAG = tAG_MASK :: Int
+tAG_BITS :: Int
+tAG_BITS = TAG_BITS
+
+tAG_MASK :: Int
+tAG_MASK = (1 `shiftL` tAG_BITS) - 1
+
+mAX_PTR_TAG :: Int
+mAX_PTR_TAG = tAG_MASK
 \end{code}
 
 Size of a C int, in bytes. May be smaller than wORD_SIZE.
 
 \begin{code}
-cINT_SIZE = (SIZEOF_INT :: Int)
+cINT_SIZE :: Int
+cINT_SIZE = SIZEOF_INT
 \end{code}
 
 Size of a storage manager block (in bytes).
 
 \begin{code}
-bLOCK_SIZE = (BLOCK_SIZE :: Int)
-bLOCK_SIZE_W = (bLOCK_SIZE `quot` wORD_SIZE :: Int)
+bLOCK_SIZE :: Int
+bLOCK_SIZE = BLOCK_SIZE
+bLOCK_SIZE_W :: Int
+bLOCK_SIZE_W = bLOCK_SIZE `quot` wORD_SIZE
 \end{code}
 
 Number of bits to shift a bitfield left by in an info table.
 
 \begin{code}
-bITMAP_BITS_SHIFT = (BITMAP_BITS_SHIFT :: Int)
+bITMAP_BITS_SHIFT :: Int
+bITMAP_BITS_SHIFT = BITMAP_BITS_SHIFT
 \end{code}
 
 Constants derived from headers in ghc/includes, generated by the program
diff --git a/includes/mkDerivedConstants.c b/includes/mkDerivedConstants.c
index 2fe99b6..56296ec 100644
--- a/includes/mkDerivedConstants.c
+++ b/includes/mkDerivedConstants.c
@@ -40,8 +40,9 @@
 #endif
 
 #if defined(GEN_HASKELL)
-#define def_offset(str, offset) \
-    printf("oFFSET_" str " = %" SIZET_FMT "::Int\n", offset);
+#define def_offset(str, offset)                          \
+    printf("oFFSET_" str " :: Int\n");                   \
+    printf("oFFSET_" str " = %" SIZET_FMT "\n", offset);
 #else
 #define def_offset(str, offset) \
     printf("#define OFFSET_" str " %" SIZET_FMT "\n", offset);
@@ -87,8 +88,9 @@
     struct_field_macro(str)
 
 #if defined(GEN_HASKELL)
-#define def_size(str, size) \
-    printf("sIZEOF_" str " = %d::Int\n", size);
+#define def_size(str, size)                \
+    printf("sIZEOF_" str " :: Int\n");     \
+    printf("sIZEOF_" str " = %d\n", size);
 #else
 #define def_size(str, size) \
     printf("#define SIZEOF_" str " %d\n", size);