2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
5 \section[OccName]{@OccName@}
9 -- The NameSpace type; abstact
10 NameSpace, tcName, clsName, tcClsName, dataName, varName, tvName,
11 uvName, nameSpaceString,
14 OccName, -- Abstract, instance of Outputable
17 mkSrcOccFS, mkSysOcc, mkSysOccFS, mkSrcVarOcc, mkKindOccFS,
18 mkSuperDictSelOcc, mkDFunOcc, mkForeignExportOcc,
19 mkDictOcc, mkWorkerOcc, mkMethodOcc, mkDefaultMethodOcc,
20 mkDerivedTyConOcc, mkClassTyConOcc, mkClassDataConOcc, mkSpecOcc,
22 isTvOcc, isUvOcc, isDataOcc, isDataSymOcc, isSymOcc,
24 occNameFS, occNameString, occNameUserString, occNameSpace, occNameFlavour,
28 TidyOccEnv, emptyTidyOccEnv, tidyOccName, initTidyOccEnv,
31 EncodedString, EncodedFS, UserString, UserFS, encode, encodeFS, decode, pprEncodedFS,
33 -- The basic form of names
34 isLexCon, isLexVar, isLexId, isLexSym,
35 isLexConId, isLexConSym, isLexVarId, isLexVarSym,
36 isLowerISO, isUpperISO
40 #include "HsVersions.h"
42 import Char ( isDigit, isAlpha, isUpper, isLower, ISALPHANUM, ord, chr, digitToInt, intToDigit )
43 import Util ( thenCmp )
44 import FiniteMap ( FiniteMap, emptyFM, lookupFM, addToFM, elemFM )
49 We hold both module names and identifier names in a 'Z-encoded' form
50 that makes them acceptable both as a C identifier and as a Haskell
53 They can always be decoded again when printing error messages
54 or anything else for the user, but it does make sense for it
55 to be represented here in encoded form, so that when generating
56 code the encoding operation is not performed on each occurrence.
58 These type synonyms help documentation.
61 type UserFS = FAST_STRING -- As the user typed it
62 type EncodedFS = FAST_STRING -- Encoded form
64 type UserString = String -- As the user typed it
65 type EncodedString = String -- Encoded form
68 pprEncodedFS :: EncodedFS -> SDoc
70 = getPprStyle $ \ sty ->
72 text (decode (_UNPK_ fs))
77 %************************************************************************
79 \subsection{Name space}
81 %************************************************************************
84 data NameSpace = VarName -- Variables
85 | DataName -- Data constructors
86 | TvName -- Type variables
87 | UvName -- Usage variables
88 | TcClsName -- Type constructors and classes; Haskell has them
89 -- in the same name space for now.
92 -- Though type constructors and classes are in the same name space now,
93 -- the NameSpace type is abstract, so we can easily separate them later
94 tcName = TcClsName -- Type constructors
95 clsName = TcClsName -- Classes
96 tcClsName = TcClsName -- Not sure which!
104 nameSpaceString :: NameSpace -> String
105 nameSpaceString DataName = "Data constructor"
106 nameSpaceString VarName = "Variable"
107 nameSpaceString TvName = "Type variable"
108 nameSpaceString UvName = "Usage variable"
109 nameSpaceString TcClsName = "Type constructor or class"
113 %************************************************************************
115 \subsection[Name-pieces-datatypes]{The @OccName@ datatypes}
117 %************************************************************************
120 data OccName = OccName
127 instance Eq OccName where
128 (OccName sp1 s1) == (OccName sp2 s2) = s1 == s2 && sp1 == sp2
130 instance Ord OccName where
131 compare (OccName sp1 s1) (OccName sp2 s2) = (s1 `compare` s2) `thenCmp`
136 %************************************************************************
138 \subsection{Printing}
140 %************************************************************************
143 instance Outputable OccName where
146 pprOccName :: OccName -> SDoc
147 pprOccName (OccName sp occ) = pprEncodedFS occ
151 %************************************************************************
153 \subsection{Construction}
155 %************************************************************************
157 *Sys* things do no encoding; the caller should ensure that the thing is
161 mkSysOcc :: NameSpace -> EncodedString -> OccName
162 mkSysOcc occ_sp str = ASSERT( alreadyEncoded str )
163 OccName occ_sp (_PK_ str)
165 mkSysOccFS :: NameSpace -> EncodedFS -> OccName
166 mkSysOccFS occ_sp fs = ASSERT2( alreadyEncodedFS fs, ppr fs )
169 -- Kind constructors get a speical function. Uniquely, they are not encoded,
170 -- so that they have names like '*'. This means that *even in interface files*
171 -- we'll get kinds like (* -> (* -> *)). We can't use mkSysOcc because it
172 -- has an ASSERT that doesn't hold.
173 mkKindOccFS :: NameSpace -> EncodedFS -> OccName
174 mkKindOccFS occ_sp fs = OccName occ_sp fs
177 *Source-code* things are encoded.
180 mkSrcOccFS :: NameSpace -> UserFS -> OccName
181 mkSrcOccFS occ_sp fs = mkSysOccFS occ_sp (encodeFS fs)
183 mkSrcVarOcc :: UserFS -> OccName
184 mkSrcVarOcc fs = mkSysOccFS varName (encodeFS fs)
189 %************************************************************************
191 \subsection{Predicates and taking them apart}
193 %************************************************************************
196 occNameFS :: OccName -> EncodedFS
197 occNameFS (OccName _ s) = s
199 occNameString :: OccName -> EncodedString
200 occNameString (OccName _ s) = _UNPK_ s
202 occNameUserString :: OccName -> UserString
203 occNameUserString occ = decode (occNameString occ)
205 occNameSpace :: OccName -> NameSpace
206 occNameSpace (OccName sp _) = sp
208 setOccNameSpace :: OccName -> NameSpace -> OccName
209 setOccNameSpace (OccName _ occ) sp = OccName sp occ
211 -- occNameFlavour is used only to generate good error messages
212 occNameFlavour :: OccName -> String
213 occNameFlavour (OccName sp _) = nameSpaceString sp
217 isTvOcc, isDataSymOcc, isSymOcc, isUvOcc :: OccName -> Bool
219 isTvOcc (OccName TvName _) = True
220 isTvOcc other = False
222 isUvOcc (OccName UvName _) = True
223 isUvOcc other = False
225 -- Data constructor operator (starts with ':', or '[]')
226 -- Pretty inefficient!
227 isDataSymOcc (OccName DataName s) = isLexConSym (decodeFS s)
228 isDataSymOcc other = False
230 isDataOcc (OccName DataName _) = True
231 isDataOcc oter = False
233 -- Any operator (data constructor or variable)
234 -- Pretty inefficient!
235 isSymOcc (OccName DataName s) = isLexConSym (decodeFS s)
236 isSymOcc (OccName VarName s) = isLexSym (decodeFS s)
240 %************************************************************************
242 \subsection{Making system names}
244 %************************************************************************
246 Here's our convention for splitting up the interface file name space:
248 d... dictionary identifiers
249 (local variables, so no name-clash worries)
251 $f... dict-fun identifiers (from inst decls)
252 $dm... default methods
253 $p... superclass selectors
255 $T... compiler-generated tycons for dictionaries
256 $D... ...ditto data cons
257 $sf.. specialised version of f
259 in encoded form these appear as Zdfxxx etc
261 :... keywords (export:, letrec: etc.)
263 This knowledge is encoded in the following functions.
266 @mk_deriv@ generates an @OccName@ from the one-char prefix and a string.
267 NB: The string must already be encoded!
270 mk_deriv :: NameSpace
271 -> String -- Distinguishes one sort of derived name from another
272 -> EncodedString -- Must be already encoded!! We don't want to encode it a
273 -- second time because encoding isn't itempotent
276 mk_deriv occ_sp sys_prefix str = mkSysOcc occ_sp (encode sys_prefix ++ str)
280 mkDictOcc, mkWorkerOcc, mkDefaultMethodOcc,
281 mkClassTyConOcc, mkClassDataConOcc, mkSpecOcc
282 :: OccName -> OccName
284 -- These derived variables have a prefix that no Haskell value could have
285 mkWorkerOcc = mk_simple_deriv varName "$w"
286 mkDefaultMethodOcc = mk_simple_deriv varName "$dm"
287 mkDerivedTyConOcc = mk_simple_deriv tcName ":" -- The : prefix makes sure it classifies
288 mkClassTyConOcc = mk_simple_deriv tcName ":T" -- as a tycon/datacon
289 mkClassDataConOcc = mk_simple_deriv dataName ":D" --
290 mkDictOcc = mk_simple_deriv varName "$d"
291 mkSpecOcc = mk_simple_deriv varName "$s"
292 mkForeignExportOcc = mk_simple_deriv varName "$f"
294 mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
298 mkSuperDictSelOcc :: Int -- Index of superclass, eg 3
299 -> OccName -- Class, eg "Ord"
300 -> OccName -- eg "p3Ord"
301 mkSuperDictSelOcc index cls_occ
302 = mk_deriv varName "$p" (show index ++ occNameString cls_occ)
307 mkDFunOcc :: OccName -- class, eg "Ord"
308 -> OccName -- tycon (or something convenient from the instance type)
310 -> Int -- Unique to distinguish dfuns which share the previous two
312 -> OccName -- "dOrdMaybe3"
314 mkDFunOcc cls_occ tycon_occ index
315 = mk_deriv VarName "$f" (show_index ++ cls_str ++ tycon_str)
317 cls_str = occNameString cls_occ
318 tycon_str = occNameString tycon_occ
319 show_index | index == 0 = ""
320 | otherwise = show index
323 We used to add a '$m' to indicate a method, but that gives rise to bad
324 error messages from the type checker when we print the function name or pattern
325 of an instance-decl binding. Why? Because the binding is zapped
326 to use the method name in place of the selector name.
327 (See TcClassDcl.tcMethodBind)
329 The way it is now, -ddump-xx output may look confusing, but
330 you can always say -dppr-debug to get the uniques.
332 However, we *do* have to zap the first character to be lower case,
333 because overloaded constructors (blarg) generate methods too.
334 And convert to VarName space
336 e.g. a call to constructor MkFoo where
337 data (Ord a) => Foo a = MkFoo a
339 If this is necessary, we do it by prefixing '$m'. These
340 guys never show up in error messages. What a hack.
343 mkMethodOcc :: OccName -> OccName
344 mkMethodOcc occ@(OccName VarName fs) = occ
345 mkMethodOcc occ = mk_simple_deriv varName "$m" occ
349 %************************************************************************
351 \subsection{Tidying them up}
353 %************************************************************************
355 Before we print chunks of code we like to rename it so that
356 we don't have to print lots of silly uniques in it. But we mustn't
357 accidentally introduce name clashes! So the idea is that we leave the
358 OccName alone unless it accidentally clashes with one that is already
359 in scope; if so, we tack on '1' at the end and try again, then '2', and
360 so on till we find a unique one.
362 There's a wrinkle for operators. Consider '>>='. We can't use '>>=1'
363 because that isn't a single lexeme. So we encode it to 'lle' and *then*
364 tack on the '1', if necessary.
367 type TidyOccEnv = FiniteMap FAST_STRING Int -- The in-scope OccNames
368 emptyTidyOccEnv = emptyFM
370 initTidyOccEnv :: [OccName] -> TidyOccEnv -- Initialise with names to avoid!
371 initTidyOccEnv = foldl (\env (OccName _ fs) -> addToFM env fs 1) emptyTidyOccEnv
373 tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
375 tidyOccName in_scope occ@(OccName occ_sp fs)
376 | not (fs `elemFM` in_scope)
377 = (addToFM in_scope fs 1, occ) -- First occurrence
379 | otherwise -- Already occurs
380 = go in_scope (_UNPK_ fs)
383 go in_scope str = case lookupFM in_scope pk_str of
384 Just n -> go (addToFM in_scope pk_str (n+1)) (str ++ show n)
385 -- Need to go round again, just in case "t3" (say)
386 -- clashes with a "t3" that's already in scope
388 Nothing -> (addToFM in_scope pk_str 1, mkSysOccFS occ_sp pk_str)
395 %************************************************************************
397 \subsection{The 'Z' encoding}
399 %************************************************************************
401 This is the main name-encoding and decoding function. It encodes any
402 string into a string that is acceptable as a C name. This is the name
403 by which things are known right through the compiler.
405 The basic encoding scheme is this.
407 * Tuples (,,,) are coded as Z3T
409 * Alphabetic characters (upper and lower), digits, and '_'
410 all translate to themselves;
411 except 'Z', which translates to 'ZZ'
412 and 'z', which translates to 'zz'
413 We need both so that we can preserve the variable/tycon distinction
415 * Most other printable characters translate to 'Zx' for some
416 alphabetic character x
418 * The others translate as 'Zxdd' where 'dd' is exactly two hexadecimal
419 digits for the ord of the character
422 --------------------------
437 -- alreadyEncoded is used in ASSERTs to check for encoded
438 -- strings. It isn't fail-safe, of course, because, say 'zh' might
439 -- be encoded or not.
440 alreadyEncoded :: String -> Bool
441 alreadyEncoded s = all ok s
444 ok ch = ISALPHANUM ch
446 alreadyEncodedFS :: FAST_STRING -> Bool
447 alreadyEncodedFS fs = alreadyEncoded (_UNPK_ fs)
449 encode :: UserString -> EncodedString
450 encode cs = case maybe_tuple cs of
451 Just n -> 'Z' : show n ++ "T" -- Tuples go to Z2T etc
455 go (c:cs) = encode_ch c ++ go cs
457 -- ToDo: Unboxed tuples too, perhaps?
458 maybe_tuple ('(' : cs) = check_tuple (0::Int) cs
459 maybe_tuple other = Nothing
461 check_tuple :: Int -> String -> Maybe Int
462 check_tuple n (',' : cs) = check_tuple (n+1) cs
463 check_tuple n ")" = Just n
464 check_tuple n other = Nothing
466 encodeFS :: UserFS -> EncodedFS
467 encodeFS fast_str | all unencodedChar str = fast_str
468 | otherwise = _PK_ (encode str)
470 str = _UNPK_ fast_str
472 unencodedChar :: Char -> Bool -- True for chars that don't need encoding
473 unencodedChar '_' = True
474 unencodedChar 'Z' = False
475 unencodedChar 'z' = False
476 unencodedChar c = ISALPHANUM c
478 encode_ch :: Char -> EncodedString
479 encode_ch c | unencodedChar c = [c] -- Common case first
482 encode_ch '(' = "ZL" -- Needed for things like (,), and (->)
483 encode_ch ')' = "ZR" -- For symmetry with (
502 encode_ch '\'' = "zq"
503 encode_ch '\\' = "zr"
508 encode_ch c = ['z', 'x', intToDigit hi, intToDigit lo]
510 (hi,lo) = ord c `quotRem` 16
513 Decode is used for user printing.
516 decodeFS :: FAST_STRING -> FAST_STRING
517 decodeFS fs = _PK_ (decode (_UNPK_ fs))
519 decode :: EncodedString -> UserString
521 decode ('Z' : rest) = decode_escape rest
522 decode ('z' : rest) = decode_escape rest
523 decode (c : rest) = c : decode rest
525 decode_escape :: EncodedString -> UserString
527 decode_escape ('Z' : rest) = 'Z' : decode rest
528 decode_escape ('C' : rest) = ':' : decode rest
529 decode_escape ('L' : rest) = '(' : decode rest
530 decode_escape ('R' : rest) = ')' : decode rest
531 decode_escape ('M' : rest) = '[' : decode rest
532 decode_escape ('N' : rest) = ']' : decode rest
534 decode_escape ('z' : rest) = 'z' : decode rest
535 decode_escape ('a' : rest) = '&' : decode rest
536 decode_escape ('b' : rest) = '|' : decode rest
537 decode_escape ('d' : rest) = '$' : decode rest
538 decode_escape ('e' : rest) = '=' : decode rest
539 decode_escape ('g' : rest) = '>' : decode rest
540 decode_escape ('h' : rest) = '#' : decode rest
541 decode_escape ('i' : rest) = '.' : decode rest
542 decode_escape ('l' : rest) = '<' : decode rest
543 decode_escape ('m' : rest) = '-' : decode rest
544 decode_escape ('n' : rest) = '!' : decode rest
545 decode_escape ('p' : rest) = '+' : decode rest
546 decode_escape ('q' : rest) = '\'' : decode rest
547 decode_escape ('r' : rest) = '\\' : decode rest
548 decode_escape ('s' : rest) = '/' : decode rest
549 decode_escape ('t' : rest) = '*' : decode rest
550 decode_escape ('u' : rest) = '^' : decode rest
551 decode_escape ('v' : rest) = '%' : decode rest
552 decode_escape ('x' : d1 : d2 : rest) = chr (digitToInt d1 * 16 + digitToInt d2) : decode rest
554 -- Tuples are coded as Z23T
555 decode_escape (c : rest)
556 | isDigit c = go (digitToInt c) rest
558 go n (c : rest) | isDigit c = go (10*n + digitToInt c) rest
559 go n ('T' : rest) = '(' : replicate n ',' ++ ')' : decode rest
560 go n other = pprPanic "decode_escape" (ppr n <+> text (c:rest))
562 decode_escape (c : rest) = pprTrace "decode_escape" (char c) (decode rest)
566 %************************************************************************
568 n\subsection{Lexical categories}
570 %************************************************************************
572 These functions test strings to see if they fit the lexical categories
573 defined in the Haskell report.
576 isLexCon, isLexVar, isLexId, isLexSym :: FAST_STRING -> Bool
577 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FAST_STRING -> Bool
579 isLexCon cs = isLexConId cs || isLexConSym cs
580 isLexVar cs = isLexVarId cs || isLexVarSym cs
582 isLexId cs = isLexConId cs || isLexVarId cs
583 isLexSym cs = isLexConSym cs || isLexVarSym cs
587 isLexConId cs -- Prefix type or data constructors
588 | _NULL_ cs = False -- e.g. "Foo", "[]", "(,)"
589 | cs == SLIT("[]") = True
590 | c == '(' = True -- (), (,), (,,), ...
591 | otherwise = isUpper c || isUpperISO c
595 isLexVarId cs -- Ordinary prefix identifiers
596 | _NULL_ cs = False -- e.g. "x", "_x"
597 | otherwise = isLower c || isLowerISO c || c == '_'
601 isLexConSym cs -- Infix type or data constructors
602 | _NULL_ cs = False -- e.g. ":-:", ":", "->"
603 | otherwise = c == ':'
608 isLexVarSym cs -- Infix identifiers
609 | _NULL_ cs = False -- e.g. "+"
610 | otherwise = isSymbolASCII c
616 isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
617 isSymbolISO c = ord c `elem` (0xd7 : 0xf7 : [0xa1 .. 0xbf])
618 isUpperISO (C# c#) = c# `geChar#` '\xc0'# && c# `leChar#` '\xde'# && c# `neChar#` '\xd7'#
619 --0xc0 <= oc && oc <= 0xde && oc /= 0xd7 where oc = ord c
620 isLowerISO (C# c#) = c# `geChar#` '\xdf'# && c# `leChar#` '\xff'# && c# `neChar#` '\xf7'#
621 --0xdf <= oc && oc <= 0xff && oc /= 0xf7 where oc = ord c