Merge ../HEAD
[ghc.git] / compiler / hsSyn / HsLit.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5 \section[HsLit]{Abstract syntax: source-language literals}
6
7 \begin{code}
8 {-# OPTIONS -fno-warn-tabs #-}
9 -- The above warning supression flag is a temporary kludge.
10 -- While working on this module you are encouraged to remove it and
11 -- detab the module (please do the detabbing in a separate patch). See
12 --     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
13 -- for details
14
15 {-# LANGUAGE DeriveDataTypeable #-}
16
17 module HsLit where
18
19 #include "HsVersions.h"
20
21 import {-# SOURCE #-} HsExpr( SyntaxExpr, pprExpr )
22 import BasicTypes ( FractionalLit(..) )
23 import Type     ( Type, Kind )
24 import Outputable
25 import FastString
26
27 import Data.Data
28 \end{code}
29
30
31 %************************************************************************
32 %*                                                                      *
33 \subsection{Annotating the syntax}
34 %*                                                                      *
35 %************************************************************************
36
37 \begin{code}
38 type PostTcKind = Kind
39 type PostTcType = Type          -- Used for slots in the abstract syntax
40                                 -- where we want to keep slot for a type
41                                 -- to be added by the type checker...but
42                                 -- before typechecking it's just bogus
43
44 placeHolderType :: PostTcType   -- Used before typechecking
45 placeHolderType  = panic "Evaluated the place holder for a PostTcType"
46
47 placeHolderKind :: PostTcKind   -- Used before typechecking
48 placeHolderKind  = panic "Evaluated the place holder for a PostTcKind"
49 \end{code}
50
51 %************************************************************************
52 %*                                                                      *
53 \subsection[HsLit]{Literals}
54 %*                                                                      *
55 %************************************************************************
56
57
58 \begin{code}
59 data HsLit
60   = HsChar          Char                -- Character
61   | HsCharPrim      Char                -- Unboxed character
62   | HsString        FastString          -- String
63   | HsStringPrim    FastBytes           -- Packed bytes
64   | HsInt           Integer             -- Genuinely an Int; arises from TcGenDeriv, 
65                                         --      and from TRANSLATION
66   | HsIntPrim       Integer             -- literal Int#
67   | HsWordPrim      Integer             -- literal Word#
68   | HsInt64Prim     Integer             -- literal Int64#
69   | HsWord64Prim    Integer             -- literal Word64#
70   | HsInteger       Integer  Type       -- Genuinely an integer; arises only from TRANSLATION
71                                         --      (overloaded literals are done with HsOverLit)
72   | HsRat           FractionalLit Type  -- Genuinely a rational; arises only from TRANSLATION
73                                         --      (overloaded literals are done with HsOverLit)
74   | HsFloatPrim     FractionalLit       -- Unboxed Float
75   | HsDoublePrim    FractionalLit       -- Unboxed Double
76   deriving (Data, Typeable)
77
78 instance Eq HsLit where
79   (HsChar x1)       == (HsChar x2)       = x1==x2
80   (HsCharPrim x1)   == (HsCharPrim x2)   = x1==x2
81   (HsString x1)     == (HsString x2)     = x1==x2
82   (HsStringPrim x1) == (HsStringPrim x2) = x1==x2
83   (HsInt x1)        == (HsInt x2)        = x1==x2
84   (HsIntPrim x1)    == (HsIntPrim x2)    = x1==x2
85   (HsWordPrim x1)   == (HsWordPrim x2)   = x1==x2
86   (HsInt64Prim x1)  == (HsInt64Prim x2)  = x1==x2
87   (HsWord64Prim x1) == (HsWord64Prim x2) = x1==x2
88   (HsInteger x1 _)  == (HsInteger x2 _)  = x1==x2
89   (HsRat x1 _)      == (HsRat x2 _)      = x1==x2
90   (HsFloatPrim x1)  == (HsFloatPrim x2)  = x1==x2
91   (HsDoublePrim x1) == (HsDoublePrim x2) = x1==x2
92   _                 == _                 = False
93
94 data HsOverLit id       -- An overloaded literal
95   = OverLit {
96         ol_val :: OverLitVal, 
97         ol_rebindable :: Bool,          -- Note [ol_rebindable]
98         ol_witness :: SyntaxExpr id,    -- Note [Overloaded literal witnesses]
99         ol_type :: PostTcType }
100   deriving (Data, Typeable)
101
102 data OverLitVal
103   = HsIntegral   !Integer       -- Integer-looking literals;
104   | HsFractional !FractionalLit -- Frac-looking literals
105   | HsIsString   !FastString    -- String-looking literals
106   deriving (Data, Typeable)
107
108 overLitType :: HsOverLit a -> Type
109 overLitType = ol_type
110 \end{code}
111
112 Note [ol_rebindable]
113 ~~~~~~~~~~~~~~~~~~~~
114 The ol_rebindable field is True if this literal is actually 
115 using rebindable syntax.  Specifically:
116
117   False iff ol_witness is the standard one
118   True  iff ol_witness is non-standard
119
120 Equivalently it's True if
121   a) RebindableSyntax is on
122   b) the witness for fromInteger/fromRational/fromString
123      that happens to be in scope isn't the standard one
124
125 Note [Overloaded literal witnesses]
126 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
127 *Before* type checking, the SyntaxExpr in an HsOverLit is the
128 name of the coercion function, 'fromInteger' or 'fromRational'.
129 *After* type checking, it is a witness for the literal, such as
130         (fromInteger 3) or lit_78
131 This witness should replace the literal.
132
133 This dual role is unusual, because we're replacing 'fromInteger' with 
134 a call to fromInteger.  Reason: it allows commoning up of the fromInteger
135 calls, which wouldn't be possible if the desguarar made the application.
136
137 The PostTcType in each branch records the type the overload literal is
138 found to have.
139
140 \begin{code}
141 -- Comparison operations are needed when grouping literals
142 -- for compiling pattern-matching (module MatchLit)
143 instance Eq (HsOverLit id) where
144   (OverLit {ol_val = val1}) == (OverLit {ol_val=val2}) = val1 == val2
145
146 instance Eq OverLitVal where
147   (HsIntegral i1)   == (HsIntegral i2)   = i1 == i2
148   (HsFractional f1) == (HsFractional f2) = f1 == f2
149   (HsIsString s1)   == (HsIsString s2)   = s1 == s2
150   _                 == _                 = False
151
152 instance Ord (HsOverLit id) where
153   compare (OverLit {ol_val=val1}) (OverLit {ol_val=val2}) = val1 `compare` val2
154
155 instance Ord OverLitVal where
156   compare (HsIntegral i1)   (HsIntegral i2)   = i1 `compare` i2
157   compare (HsIntegral _)    (HsFractional _)  = LT
158   compare (HsIntegral _)    (HsIsString _)    = LT
159   compare (HsFractional f1) (HsFractional f2) = f1 `compare` f2
160   compare (HsFractional _)  (HsIntegral _)    = GT
161   compare (HsFractional _)  (HsIsString _)    = LT
162   compare (HsIsString s1)   (HsIsString s2)   = s1 `compare` s2
163   compare (HsIsString _)    (HsIntegral _)    = GT
164   compare (HsIsString _)    (HsFractional _)  = GT
165 \end{code}
166
167 \begin{code}
168 instance Outputable HsLit where
169         -- Use "show" because it puts in appropriate escapes
170     ppr (HsChar c)       = pprHsChar c
171     ppr (HsCharPrim c)   = pprHsChar c <> char '#'
172     ppr (HsString s)     = pprHsString s
173     ppr (HsStringPrim s) = pprHsBytes s <> char '#'
174     ppr (HsInt i)        = integer i
175     ppr (HsInteger i _)  = integer i
176     ppr (HsRat f _)      = ppr f
177     ppr (HsFloatPrim f)  = ppr f <> char '#'
178     ppr (HsDoublePrim d) = ppr d <> text "##"
179     ppr (HsIntPrim i)    = integer i  <> char '#'
180     ppr (HsWordPrim w)   = integer w  <> text "##"
181     ppr (HsInt64Prim i)  = integer i  <> text "L#"
182     ppr (HsWord64Prim w) = integer w  <> text "L##"
183
184 -- in debug mode, print the expression that it's resolved to, too
185 instance OutputableBndr id => Outputable (HsOverLit id) where
186   ppr (OverLit {ol_val=val, ol_witness=witness}) 
187         = ppr val <+> (ifPprDebug (parens (pprExpr witness)))
188
189 instance Outputable OverLitVal where
190   ppr (HsIntegral i)   = integer i 
191   ppr (HsFractional f) = ppr f
192   ppr (HsIsString s)   = pprHsString s
193 \end{code}