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,
11 tvName, nameSpaceString,
14 OccName, -- Abstract, instance of Outputable
17 mkOccFS, mkSysOcc, mkSysOccFS, mkFCallOcc, mkVarOcc, mkKindOccFS,
18 mkSuperDictSelOcc, mkDFunOcc, mkForeignExportOcc,
19 mkDictOcc, mkIPOcc, mkWorkerOcc, mkMethodOcc, mkDefaultMethodOcc,
20 mkDerivedTyConOcc, mkClassTyConOcc, mkClassDataConOcc, mkSpecOcc,
21 mkGenOcc1, mkGenOcc2, mkLocalOcc,
23 isTvOcc, isTcOcc, isDataOcc, isDataSymOcc, isSymOcc, isValOcc,
25 occNameFS, occNameString, occNameUserString, occNameSpace, occNameFlavour,
29 TidyOccEnv, emptyTidyOccEnv, tidyOccName, initTidyOccEnv,
32 EncodedString, EncodedFS, UserString, UserFS, encode, encodeFS, decode, pprEncodedFS,
34 -- The basic form of names
35 isLexCon, isLexVar, isLexId, isLexSym,
36 isLexConId, isLexConSym, isLexVarId, isLexVarSym,
37 isLowerISO, isUpperISO
41 #include "HsVersions.h"
43 import Char ( isDigit, isUpper, isLower, ISALPHANUM, ord, chr, digitToInt )
44 import Util ( thenCmp )
45 import Unique ( Unique )
46 import FiniteMap ( FiniteMap, emptyFM, lookupFM, addToFM, elemFM )
51 We hold both module names and identifier names in a 'Z-encoded' form
52 that makes them acceptable both as a C identifier and as a Haskell
55 They can always be decoded again when printing error messages
56 or anything else for the user, but it does make sense for it
57 to be represented here in encoded form, so that when generating
58 code the encoding operation is not performed on each occurrence.
60 These type synonyms help documentation.
63 type UserFS = FAST_STRING -- As the user typed it
64 type EncodedFS = FAST_STRING -- Encoded form
66 type UserString = String -- As the user typed it
67 type EncodedString = String -- Encoded form
70 pprEncodedFS :: EncodedFS -> SDoc
72 = getPprStyle $ \ sty ->
74 -- ptext (decodeFS fs) would needlessly pack the string again
75 then text (decode (_UNPK_ fs))
79 %************************************************************************
81 \subsection{Name space}
83 %************************************************************************
86 data NameSpace = VarName -- Variables
87 | DataName -- Data constructors
88 | TvName -- Type variables
89 | TcClsName -- Type constructors and classes; Haskell has them
90 -- in the same name space for now.
93 -- Though type constructors and classes are in the same name space now,
94 -- the NameSpace type is abstract, so we can easily separate them later
95 tcName = TcClsName -- Type constructors
96 clsName = TcClsName -- Classes
97 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 TcClsName = "Type constructor or class"
112 %************************************************************************
114 \subsection[Name-pieces-datatypes]{The @OccName@ datatypes}
116 %************************************************************************
119 data OccName = OccName
126 instance Eq OccName where
127 (OccName sp1 s1) == (OccName sp2 s2) = s1 == s2 && sp1 == sp2
129 instance Ord OccName where
130 compare (OccName sp1 s1) (OccName sp2 s2) = (s1 `compare` s2) `thenCmp`
135 %************************************************************************
137 \subsection{Printing}
139 %************************************************************************
142 instance Outputable OccName where
145 pprOccName :: OccName -> SDoc
146 pprOccName (OccName sp occ) = pprEncodedFS occ
150 %************************************************************************
152 \subsection{Construction}
154 %************************************************************************
156 *Sys* things do no encoding; the caller should ensure that the thing is
160 mkSysOcc :: NameSpace -> EncodedString -> OccName
161 mkSysOcc occ_sp str = ASSERT2( alreadyEncoded str, text str )
162 OccName occ_sp (_PK_ str)
164 mkSysOccFS :: NameSpace -> EncodedFS -> OccName
165 mkSysOccFS occ_sp fs = ASSERT2( alreadyEncodedFS fs, ppr fs )
168 mkFCallOcc :: EncodedString -> OccName
169 -- This version of mkSysOcc doesn't check that the string is already encoded,
170 -- because it will be something like "{__ccall f dyn Int# -> Int#}"
171 -- This encodes a lot into something that then parses like an Id.
172 -- But then alreadyEncoded complains about the braces!
173 mkFCallOcc str = OccName varName (_PK_ str)
175 -- Kind constructors get a special function. Uniquely, they are not encoded,
176 -- so that they have names like '*'. This means that *even in interface files*
177 -- we'll get kinds like (* -> (* -> *)). We can't use mkSysOcc because it
178 -- has an ASSERT that doesn't hold.
179 mkKindOccFS :: NameSpace -> EncodedFS -> OccName
180 mkKindOccFS occ_sp fs = OccName occ_sp fs
183 *Source-code* things are encoded.
186 mkOccFS :: NameSpace -> UserFS -> OccName
187 mkOccFS occ_sp fs = mkSysOccFS occ_sp (encodeFS fs)
189 mkVarOcc :: UserFS -> OccName
190 mkVarOcc fs = mkSysOccFS varName (encodeFS fs)
195 %************************************************************************
197 \subsection{Predicates and taking them apart}
199 %************************************************************************
202 occNameFS :: OccName -> EncodedFS
203 occNameFS (OccName _ s) = s
205 occNameString :: OccName -> EncodedString
206 occNameString (OccName _ s) = _UNPK_ s
208 occNameUserString :: OccName -> UserString
209 occNameUserString occ = decode (occNameString occ)
211 occNameSpace :: OccName -> NameSpace
212 occNameSpace (OccName sp _) = sp
214 setOccNameSpace :: OccName -> NameSpace -> OccName
215 setOccNameSpace (OccName _ occ) sp = OccName sp occ
217 -- occNameFlavour is used only to generate good error messages
218 occNameFlavour :: OccName -> String
219 occNameFlavour (OccName sp _) = nameSpaceString sp
223 isTvOcc, isDataSymOcc, isSymOcc, isTcOcc :: OccName -> Bool
225 isTvOcc (OccName TvName _) = True
226 isTvOcc other = False
228 isTcOcc (OccName TcClsName _) = True
229 isTcOcc other = False
231 isValOcc (OccName VarName _) = True
232 isValOcc (OccName DataName _) = True
233 isValOcc other = False
235 -- Data constructor operator (starts with ':', or '[]')
236 -- Pretty inefficient!
237 isDataSymOcc (OccName DataName s) = isLexConSym (decodeFS s)
238 isDataSymOcc other = False
240 isDataOcc (OccName DataName _) = True
241 isDataOcc other = False
243 -- Any operator (data constructor or variable)
244 -- Pretty inefficient!
245 isSymOcc (OccName DataName s) = isLexConSym (decodeFS s)
246 isSymOcc (OccName VarName s) = isLexSym (decodeFS s)
250 %************************************************************************
252 \subsection{Making system names}
254 %************************************************************************
256 Here's our convention for splitting up the interface file name space:
258 d... dictionary identifiers
259 (local variables, so no name-clash worries)
261 $f... dict-fun identifiers (from inst decls)
262 $dm... default methods
263 $p... superclass selectors
265 :T... compiler-generated tycons for dictionaries
266 :D... ...ditto data cons
267 $sf.. specialised version of f
269 in encoded form these appear as Zdfxxx etc
271 :... keywords (export:, letrec: etc.)
272 --- I THINK THIS IS WRONG!
274 This knowledge is encoded in the following functions.
277 @mk_deriv@ generates an @OccName@ from the prefix and a string.
278 NB: The string must already be encoded!
281 mk_deriv :: NameSpace
282 -> String -- Distinguishes one sort of derived name from another
283 -> EncodedString -- Must be already encoded!! We don't want to encode it a
284 -- second time because encoding isn't idempotent
287 mk_deriv occ_sp sys_prefix str = mkSysOcc occ_sp (encode sys_prefix ++ str)
291 mkDictOcc, mkIPOcc, mkWorkerOcc, mkDefaultMethodOcc,
292 mkClassTyConOcc, mkClassDataConOcc, mkSpecOcc
293 :: OccName -> OccName
295 -- These derived variables have a prefix that no Haskell value could have
296 mkWorkerOcc = mk_simple_deriv varName "$w"
297 mkDefaultMethodOcc = mk_simple_deriv varName "$dm"
298 mkDerivedTyConOcc = mk_simple_deriv tcName ":" -- The : prefix makes sure it classifies
299 mkClassTyConOcc = mk_simple_deriv tcName ":T" -- as a tycon/datacon
300 mkClassDataConOcc = mk_simple_deriv dataName ":D" --
301 mkDictOcc = mk_simple_deriv varName "$d"
302 mkIPOcc = mk_simple_deriv varName "$i"
303 mkSpecOcc = mk_simple_deriv varName "$s"
304 mkForeignExportOcc = mk_simple_deriv varName "$f"
305 mkGenOcc1 = mk_simple_deriv varName "$gfrom" -- Generics
306 mkGenOcc2 = mk_simple_deriv varName "$gto" -- Generics
307 mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
311 mkSuperDictSelOcc :: Int -- Index of superclass, eg 3
312 -> OccName -- Class, eg "Ord"
313 -> OccName -- eg "$p3Ord"
314 mkSuperDictSelOcc index cls_occ
315 = mk_deriv varName "$p" (show index ++ occNameString cls_occ)
317 mkLocalOcc :: Unique -- Unique
318 -> OccName -- Local name (e.g. "sat")
319 -> OccName -- Nice unique version ("$L23sat")
321 = mk_deriv varName "$L" (show uniq ++ occNameString occ)
326 mkDFunOcc :: EncodedString -- Typically the class and type glommed together e.g. "OrdMaybe"
327 -> OccName -- "$fOrdMaybe"
329 mkDFunOcc string = mk_deriv VarName "$f" string
332 We used to add a '$m' to indicate a method, but that gives rise to bad
333 error messages from the type checker when we print the function name or pattern
334 of an instance-decl binding. Why? Because the binding is zapped
335 to use the method name in place of the selector name.
336 (See TcClassDcl.tcMethodBind)
338 The way it is now, -ddump-xx output may look confusing, but
339 you can always say -dppr-debug to get the uniques.
341 However, we *do* have to zap the first character to be lower case,
342 because overloaded constructors (blarg) generate methods too.
343 And convert to VarName space
345 e.g. a call to constructor MkFoo where
346 data (Ord a) => Foo a = MkFoo a
348 If this is necessary, we do it by prefixing '$m'. These
349 guys never show up in error messages. What a hack.
352 mkMethodOcc :: OccName -> OccName
353 mkMethodOcc occ@(OccName VarName fs) = occ
354 mkMethodOcc occ = mk_simple_deriv varName "$m" occ
358 %************************************************************************
360 \subsection{Tidying them up}
362 %************************************************************************
364 Before we print chunks of code we like to rename it so that
365 we don't have to print lots of silly uniques in it. But we mustn't
366 accidentally introduce name clashes! So the idea is that we leave the
367 OccName alone unless it accidentally clashes with one that is already
368 in scope; if so, we tack on '1' at the end and try again, then '2', and
369 so on till we find a unique one.
371 There's a wrinkle for operators. Consider '>>='. We can't use '>>=1'
372 because that isn't a single lexeme. So we encode it to 'lle' and *then*
373 tack on the '1', if necessary.
376 type TidyOccEnv = FiniteMap FAST_STRING Int -- The in-scope OccNames
377 emptyTidyOccEnv = emptyFM
379 initTidyOccEnv :: [OccName] -> TidyOccEnv -- Initialise with names to avoid!
380 initTidyOccEnv = foldl (\env (OccName _ fs) -> addToFM env fs 1) emptyTidyOccEnv
382 tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
384 tidyOccName in_scope occ@(OccName occ_sp fs)
385 | not (fs `elemFM` in_scope)
386 = (addToFM in_scope fs 1, occ) -- First occurrence
388 | otherwise -- Already occurs
389 = go in_scope (_UNPK_ fs)
392 go in_scope str = case lookupFM in_scope pk_str of
393 Just n -> go (addToFM in_scope pk_str (n+1)) (str ++ show n)
394 -- Need to go round again, just in case "t3" (say)
395 -- clashes with a "t3" that's already in scope
397 Nothing -> (addToFM in_scope pk_str 1, mkSysOccFS occ_sp pk_str)
404 %************************************************************************
406 \subsection{The 'Z' encoding}
408 %************************************************************************
410 This is the main name-encoding and decoding function. It encodes any
411 string into a string that is acceptable as a C name. This is the name
412 by which things are known right through the compiler.
414 The basic encoding scheme is this.
416 * Tuples (,,,) are coded as Z3T
418 * Alphabetic characters (upper and lower) and digits
419 all translate to themselves;
420 except 'Z', which translates to 'ZZ'
421 and 'z', which translates to 'zz'
422 We need both so that we can preserve the variable/tycon distinction
424 * Most other printable characters translate to 'zx' or 'Zx' for some
425 alphabetic character x
427 * The others translate as 'znnnU' where 'nnn' is the decimal number
431 --------------------------
443 (# #) Z1H unboxed 1-tuple (note the space)
444 (#,,,,#) Z5H unboxed 5-tuple
445 (NB: There is no Z1T nor Z0H.)
448 -- alreadyEncoded is used in ASSERTs to check for encoded
449 -- strings. It isn't fail-safe, of course, because, say 'zh' might
450 -- be encoded or not.
451 alreadyEncoded :: String -> Bool
452 alreadyEncoded s = all ok s
455 -- This is a bit of a lie; if we really wanted spaces
456 -- in names we'd have to encode them. But we do put
457 -- spaces in ccall "occurrences", and we don't want to
459 ok ch = ISALPHANUM ch
461 alreadyEncodedFS :: FAST_STRING -> Bool
462 alreadyEncodedFS fs = alreadyEncoded (_UNPK_ fs)
464 encode :: UserString -> EncodedString
465 encode cs = case maybe_tuple cs of
466 Just n -> n -- Tuples go to Z2T etc
470 go (c:cs) = encode_ch c ++ go cs
472 maybe_tuple "(# #)" = Just("Z1H")
473 maybe_tuple ('(' : '#' : cs) = case count_commas (0::Int) cs of
474 (n, '#' : ')' : cs) -> Just ('Z' : shows (n+1) "H")
476 maybe_tuple "()" = Just("Z0T")
477 maybe_tuple ('(' : cs) = case count_commas (0::Int) cs of
478 (n, ')' : cs) -> Just ('Z' : shows (n+1) "T")
480 maybe_tuple other = Nothing
482 count_commas :: Int -> String -> (Int, String)
483 count_commas n (',' : cs) = count_commas (n+1) cs
484 count_commas n cs = (n,cs)
486 encodeFS :: UserFS -> EncodedFS
487 encodeFS fast_str | all unencodedChar str = fast_str
488 | otherwise = _PK_ (encode str)
490 str = _UNPK_ fast_str
492 unencodedChar :: Char -> Bool -- True for chars that don't need encoding
493 unencodedChar 'Z' = False
494 unencodedChar 'z' = False
495 unencodedChar c = c >= 'a' && c <= 'z'
496 || c >= 'A' && c <= 'Z'
497 || c >= '0' && c <= '9'
499 encode_ch :: Char -> EncodedString
500 encode_ch c | unencodedChar c = [c] -- Common case first
503 encode_ch '(' = "ZL" -- Needed for things like (,), and (->)
504 encode_ch ')' = "ZR" -- For symmetry with (
524 encode_ch '\'' = "zq"
525 encode_ch '\\' = "zr"
530 encode_ch c = 'z' : shows (ord c) "U"
533 Decode is used for user printing.
536 decodeFS :: FAST_STRING -> FAST_STRING
537 decodeFS fs = _PK_ (decode (_UNPK_ fs))
539 decode :: EncodedString -> UserString
541 decode ('Z' : rest) = decode_escape rest
542 decode ('z' : rest) = decode_escape rest
543 decode (c : rest) = c : decode rest
545 decode_escape :: EncodedString -> UserString
547 decode_escape ('L' : rest) = '(' : decode rest
548 decode_escape ('R' : rest) = ')' : decode rest
549 decode_escape ('M' : rest) = '[' : decode rest
550 decode_escape ('N' : rest) = ']' : decode rest
551 decode_escape ('C' : rest) = ':' : decode rest
552 decode_escape ('Z' : rest) = 'Z' : decode rest
554 decode_escape ('z' : rest) = 'z' : decode rest
555 decode_escape ('a' : rest) = '&' : decode rest
556 decode_escape ('b' : rest) = '|' : decode rest
557 decode_escape ('c' : rest) = '^' : decode rest
558 decode_escape ('d' : rest) = '$' : decode rest
559 decode_escape ('e' : rest) = '=' : decode rest
560 decode_escape ('g' : rest) = '>' : decode rest
561 decode_escape ('h' : rest) = '#' : decode rest
562 decode_escape ('i' : rest) = '.' : decode rest
563 decode_escape ('l' : rest) = '<' : decode rest
564 decode_escape ('m' : rest) = '-' : decode rest
565 decode_escape ('n' : rest) = '!' : decode rest
566 decode_escape ('p' : rest) = '+' : decode rest
567 decode_escape ('q' : rest) = '\'' : decode rest
568 decode_escape ('r' : rest) = '\\' : decode rest
569 decode_escape ('s' : rest) = '/' : decode rest
570 decode_escape ('t' : rest) = '*' : decode rest
571 decode_escape ('u' : rest) = '_' : decode rest
572 decode_escape ('v' : rest) = '%' : decode rest
574 -- Tuples are coded as Z23T
575 -- Characters not having a specific code are coded as z224U
576 decode_escape (c : rest)
577 | isDigit c = go (digitToInt c) rest
579 go n (c : rest) | isDigit c = go (10*n + digitToInt c) rest
580 go 0 ('T' : rest) = "()" ++ (decode rest)
581 go n ('T' : rest) = '(' : replicate (n-1) ',' ++ ')' : decode rest
582 go 1 ('H' : rest) = "(# #)" ++ (decode rest)
583 go n ('H' : rest) = '(' : '#' : replicate (n-1) ',' ++ '#' : ')' : decode rest
584 go n ('U' : rest) = chr n : decode rest
585 go n other = pprPanic "decode_escape" (ppr n <+> text (c:rest))
587 decode_escape (c : rest) = pprTrace "decode_escape" (char c) (decode rest)
591 %************************************************************************
593 \subsection{Lexical categories}
595 %************************************************************************
597 These functions test strings to see if they fit the lexical categories
598 defined in the Haskell report.
601 isLexCon, isLexVar, isLexId, isLexSym :: FAST_STRING -> Bool
602 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FAST_STRING -> Bool
604 isLexCon cs = isLexConId cs || isLexConSym cs
605 isLexVar cs = isLexVarId cs || isLexVarSym cs
607 isLexId cs = isLexConId cs || isLexVarId cs
608 isLexSym cs = isLexConSym cs || isLexVarSym cs
612 isLexConId cs -- Prefix type or data constructors
613 | _NULL_ cs = False -- e.g. "Foo", "[]", "(,)"
614 | cs == SLIT("[]") = True
615 | otherwise = startsConId (_HEAD_ cs)
617 isLexVarId cs -- Ordinary prefix identifiers
618 | _NULL_ cs = False -- e.g. "x", "_x"
619 | otherwise = startsVarId (_HEAD_ cs)
621 isLexConSym cs -- Infix type or data constructors
622 | _NULL_ cs = False -- e.g. ":-:", ":", "->"
623 | cs == SLIT("->") = True
624 | otherwise = startsConSym (_HEAD_ cs)
626 isLexVarSym cs -- Infix identifiers
627 | _NULL_ cs = False -- e.g. "+"
628 | otherwise = startsVarSym (_HEAD_ cs)
631 startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
632 startsVarSym c = isSymbolASCII c || isSymbolISO c -- Infix Ids
633 startsConSym c = c == ':' -- Infix data constructors
634 startsVarId c = isLower c || isLowerISO c || c == '_' -- Ordinary Ids
635 startsConId c = isUpper c || isUpperISO c || c == '(' -- Ordinary type constructors and data constructors
638 isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
639 isSymbolISO c = ord c `elem` (0xd7 : 0xf7 : [0xa1 .. 0xbf])
640 isUpperISO (C# c#) = c# `geChar#` '\xc0'# && c# `leChar#` '\xde'# && c# `neChar#` '\xd7'#
641 --0xc0 <= oc && oc <= 0xde && oc /= 0xd7 where oc = ord c
642 isLowerISO (C# c#) = c# `geChar#` '\xdf'# && c# `leChar#` '\xff'# && c# `neChar#` '\xf7'#
643 --0xdf <= oc && oc <= 0xff && oc /= 0xf7 where oc = ord c