ghc/compiler/basicTypes/OccName.lhs

   1
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4
   5 \section[OccName]{@OccName@}
   6
   7 \begin{code}
   8 module OccName (
   9         -- The NameSpace type; abstact
  10         NameSpace, tcName, clsName, tcClsName, dataName, varName, tvName,
  11         uvName, nameSpaceString,
  12
  13         -- The OccName type
  14         OccName,        -- Abstract, instance of Outputable
  15         pprOccName,
  16
  17         mkSrcOccFS, mkSysOcc, mkSysOccFS, mkSrcVarOcc, mkKindOccFS,
  18         mkSuperDictSelOcc, mkDFunOcc, mkForeignExportOcc,
  19         mkDictOcc, mkWorkerOcc, mkMethodOcc, mkDefaultMethodOcc,
  20         mkDerivedTyConOcc, mkClassTyConOcc, mkClassDataConOcc, mkSpecOcc,
  21
  22         isTvOcc, isUvOcc, isDataOcc, isDataSymOcc, isSymOcc,
  23
  24         occNameFS, occNameString, occNameUserString, occNameSpace, occNameFlavour,
  25         setOccNameSpace,
  26
  27         -- Tidying up
  28         TidyOccEnv, emptyTidyOccEnv, tidyOccName, initTidyOccEnv,
  29
  30         -- Encoding
  31         EncodedString, EncodedFS, UserString, UserFS, encode, encodeFS, decode, pprEncodedFS,
  32
  33         -- The basic form of names
  34         isLexCon, isLexVar, isLexId, isLexSym,
  35         isLexConId, isLexConSym, isLexVarId, isLexVarSym,
  36         isLowerISO, isUpperISO
  37
  38     ) where
  39
  40 #include "HsVersions.h"
  41
  42 import Char     ( isDigit, isAlpha, isUpper, isLower, ISALPHANUM, ord, chr, digitToInt, intToDigit )
  43 import Util     ( thenCmp )
  44 import FiniteMap ( FiniteMap, emptyFM, lookupFM, addToFM, elemFM )
  45 import Outputable
  46 import GlaExts
  47 \end{code}
  48
  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
  51 (prefix) identifier.
  52
  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.
  57
  58 These type synonyms help documentation.
  59
  60 \begin{code}
  61 type UserFS     = FAST_STRING   -- As the user typed it
  62 type EncodedFS = FAST_STRING    -- Encoded form
  63
  64 type UserString = String        -- As the user typed it
  65 type EncodedString = String     -- Encoded form
  66
  67
  68 pprEncodedFS :: EncodedFS -> SDoc
  69 pprEncodedFS fs
  70   = getPprStyle         $ \ sty ->
  71     if userStyle sty then
  72         text (decode (_UNPK_ fs))
  73     else
  74         ptext fs
  75 \end{code}
  76
  77 %************************************************************************
  78 %*                                                                      *
  79 \subsection{Name space}
  80 %*                                                                      *
  81 %************************************************************************
  82
  83 \begin{code}
  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.
  90                deriving( Eq, Ord )
  91
  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!
  97
  98 dataName = DataName
  99 tvName   = TvName
 100 uvName   = UvName
 101 varName  = VarName
 102
 103
 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"
 110 \end{code}
 111
 112
 113 %************************************************************************
 114 %*                                                                      *
 115 \subsection[Name-pieces-datatypes]{The @OccName@ datatypes}
 116 %*                                                                      *
 117 %************************************************************************
 118
 119 \begin{code}
 120 data OccName = OccName
 121                         NameSpace
 122                         EncodedFS
 123 \end{code}
 124
 125
 126 \begin{code}
 127 instance Eq OccName where
 128     (OccName sp1 s1) == (OccName sp2 s2) = s1 == s2 && sp1 == sp2
 129
 130 instance Ord OccName where
 131     compare (OccName sp1 s1) (OccName sp2 s2) = (s1  `compare` s2) `thenCmp`
 132                                                 (sp1 `compare` sp2)
 133 \end{code}
 134
 135
 136 %************************************************************************
 137 %*                                                                      *
 138 \subsection{Printing}
 139 %*                                                                      *
 140 %************************************************************************
 141
 142 \begin{code}
 143 instance Outputable OccName where
 144     ppr = pprOccName
 145
 146 pprOccName :: OccName -> SDoc
 147 pprOccName (OccName sp occ) = pprEncodedFS occ
 148 \end{code}
 149
 150
 151 %************************************************************************
 152 %*                                                                      *
 153 \subsection{Construction}
 154 %*                                                                      *
 155 %************************************************************************
 156
 157 *Sys* things do no encoding; the caller should ensure that the thing is
 158 already encoded
 159
 160 \begin{code}
 161 mkSysOcc :: NameSpace -> EncodedString -> OccName
 162 mkSysOcc occ_sp str = ASSERT( alreadyEncoded str )
 163                       OccName occ_sp (_PK_ str)
 164
 165 mkSysOccFS :: NameSpace -> EncodedFS -> OccName
 166 mkSysOccFS occ_sp fs = ASSERT2( alreadyEncodedFS fs, ppr fs )
 167                        OccName occ_sp fs
 168
 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
 175 \end{code}
 176
 177 *Source-code* things are encoded.
 178
 179 \begin{code}
 180 mkSrcOccFS :: NameSpace -> UserFS -> OccName
 181 mkSrcOccFS occ_sp fs = mkSysOccFS occ_sp (encodeFS fs)
 182
 183 mkSrcVarOcc :: UserFS -> OccName
 184 mkSrcVarOcc fs = mkSysOccFS varName (encodeFS fs)
 185 \end{code}
 186
 187
 188
 189 %************************************************************************
 190 %*                                                                      *
 191 \subsection{Predicates and taking them apart}
 192 %*                                                                      *
 193 %************************************************************************
 194
 195 \begin{code}
 196 occNameFS :: OccName -> EncodedFS
 197 occNameFS (OccName _ s) = s
 198
 199 occNameString :: OccName -> EncodedString
 200 occNameString (OccName _ s) = _UNPK_ s
 201
 202 occNameUserString :: OccName -> UserString
 203 occNameUserString occ = decode (occNameString occ)
 204
 205 occNameSpace :: OccName -> NameSpace
 206 occNameSpace (OccName sp _) = sp
 207
 208 setOccNameSpace :: OccName -> NameSpace -> OccName
 209 setOccNameSpace (OccName _ occ) sp = OccName sp occ
 210
 211 -- occNameFlavour is used only to generate good error messages
 212 occNameFlavour :: OccName -> String
 213 occNameFlavour (OccName sp _) = nameSpaceString sp
 214 \end{code}
 215
 216 \begin{code}
 217 isTvOcc, isDataSymOcc, isSymOcc, isUvOcc :: OccName -> Bool
 218
 219 isTvOcc (OccName TvName _) = True
 220 isTvOcc other              = False
 221
 222 isUvOcc (OccName UvName _) = True
 223 isUvOcc other              = False
 224
 225 -- Data constructor operator (starts with ':', or '[]')
 226 -- Pretty inefficient!
 227 isDataSymOcc (OccName DataName s) = isLexConSym (decodeFS s)
 228 isDataSymOcc other                = False
 229
 230 isDataOcc (OccName DataName _) = True
 231 isDataOcc oter                 = False
 232
 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)
 237 \end{code}
 238
 239
 240 %************************************************************************
 241 %*                                                                      *
 242 \subsection{Making system names}
 243 %*                                                                      *
 244 %************************************************************************
 245
 246 Here's our convention for splitting up the interface file name space:
 247
 248         d...            dictionary identifiers
 249                         (local variables, so no name-clash worries)
 250
 251         $f...           dict-fun identifiers (from inst decls)
 252         $dm...          default methods
 253         $p...           superclass selectors
 254         $w...           workers
 255         $T...           compiler-generated tycons for dictionaries
 256         $D...           ...ditto data cons
 257         $sf..           specialised version of f
 258
 259         in encoded form these appear as Zdfxxx etc
 260
 261         :...            keywords (export:, letrec: etc.)
 262
 263 This knowledge is encoded in the following functions.
 264
 265
 266 @mk_deriv@ generates an @OccName@ from the one-char prefix and a string.
 267 NB: The string must already be encoded!
 268
 269 \begin{code}
 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
 274          -> OccName
 275
 276 mk_deriv occ_sp sys_prefix str = mkSysOcc occ_sp (encode sys_prefix ++ str)
 277 \end{code}
 278
 279 \begin{code}
 280 mkDictOcc, mkWorkerOcc, mkDefaultMethodOcc,
 281            mkClassTyConOcc, mkClassDataConOcc, mkSpecOcc
 282    :: OccName -> OccName
 283
 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"
 293
 294 mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
 295 \end{code}
 296
 297 \begin{code}
 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)
 303 \end{code}
 304
 305
 306 \begin{code}
 307 mkDFunOcc :: OccName    -- class, eg "Ord"
 308           -> OccName    -- tycon (or something convenient from the instance type)
 309                         --      eg "Maybe"
 310           -> Int        -- Unique to distinguish dfuns which share the previous two
 311                         --      eg 3
 312           -> OccName    -- "dOrdMaybe3"
 313
 314 mkDFunOcc cls_occ tycon_occ index
 315   = mk_deriv VarName "$f" (show_index ++ cls_str ++ tycon_str)
 316   where
 317     cls_str   = occNameString cls_occ
 318     tycon_str = occNameString tycon_occ
 319     show_index | index == 0 = ""
 320                | otherwise  = show index
 321 \end{code}
 322
 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)
 328
 329 The way it is now, -ddump-xx output may look confusing, but
 330 you can always say -dppr-debug to get the uniques.
 331
 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
 335
 336 e.g. a call to constructor MkFoo where
 337         data (Ord a) => Foo a = MkFoo a
 338
 339 If this is necessary, we do it by prefixing '$m'.  These
 340 guys never show up in error messages.  What a hack.
 341
 342 \begin{code}
 343 mkMethodOcc :: OccName -> OccName
 344 mkMethodOcc occ@(OccName VarName fs) = occ
 345 mkMethodOcc occ                      = mk_simple_deriv varName "$m" occ
 346 \end{code}
 347
 348
 349 %************************************************************************
 350 %*                                                                      *
 351 \subsection{Tidying them up}
 352 %*                                                                      *
 353 %************************************************************************
 354
 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.
 361
 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.
 365
 366 \begin{code}
 367 type TidyOccEnv = FiniteMap FAST_STRING Int     -- The in-scope OccNames
 368 emptyTidyOccEnv = emptyFM
 369
 370 initTidyOccEnv :: [OccName] -> TidyOccEnv       -- Initialise with names to avoid!
 371 initTidyOccEnv = foldl (\env (OccName _ fs) -> addToFM env fs 1) emptyTidyOccEnv
 372
 373 tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
 374
 375 tidyOccName in_scope occ@(OccName occ_sp fs)
 376   | not (fs `elemFM` in_scope)
 377   = (addToFM in_scope fs 1, occ)        -- First occurrence
 378
 379   | otherwise                           -- Already occurs
 380   = go in_scope (_UNPK_ fs)
 381   where
 382
 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
 387
 388                         Nothing -> (addToFM in_scope pk_str 1, mkSysOccFS occ_sp pk_str)
 389                                 -- str is now unique
 390                     where
 391                       pk_str = _PK_ str
 392 \end{code}
 393
 394
 395 %************************************************************************
 396 %*                                                                      *
 397 \subsection{The 'Z' encoding}
 398 %*                                                                      *
 399 %************************************************************************
 400
 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.
 404
 405 The basic encoding scheme is this.
 406
 407 * Tuples (,,,) are coded as Z3T
 408
 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
 414
 415 * Most other printable characters translate to 'Zx' for some
 416         alphabetic character x
 417
 418 * The others translate as 'Zxdd' where 'dd' is exactly two hexadecimal
 419         digits for the ord of the character
 420
 421         Before          After
 422         --------------------------
 423         Trak            Trak
 424         foo_wib         foo_wib
 425         >               Zg
 426         >1              Zg1
 427         foo#            fooZh
 428         foo##           fooZhZh
 429         foo##1          fooZhXh1
 430         fooZ            fooZZ
 431         :+              ZcZp
 432         ()              Z0T
 433         (,,,,)          Z4T
 434
 435
 436 \begin{code}
 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
 442                  where
 443                    ok '_' = True
 444                    ok ch  = ISALPHANUM ch
 445
 446 alreadyEncodedFS :: FAST_STRING -> Bool
 447 alreadyEncodedFS fs = alreadyEncoded (_UNPK_ fs)
 448
 449 encode :: UserString -> EncodedString
 450 encode cs = case maybe_tuple cs of
 451                 Just n  -> 'Z' : show n ++ "T"          -- Tuples go to Z2T etc
 452                 Nothing -> go cs
 453           where
 454                 go []     = []
 455                 go (c:cs) = encode_ch c ++ go cs
 456
 457 -- ToDo: Unboxed tuples too, perhaps?
 458 maybe_tuple ('(' : cs) = check_tuple (0::Int) cs
 459 maybe_tuple other      = Nothing
 460
 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
 465
 466 encodeFS :: UserFS -> EncodedFS
 467 encodeFS fast_str  | all unencodedChar str = fast_str
 468                    | otherwise             = _PK_ (encode str)
 469                    where
 470                      str = _UNPK_ fast_str
 471
 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
 477
 478 encode_ch :: Char -> EncodedString
 479 encode_ch c | unencodedChar c = [c]     -- Common case first
 480
 481 -- Constructors
 482 encode_ch '('  = "ZL"   -- Needed for things like (,), and (->)
 483 encode_ch ')'  = "ZR"   -- For symmetry with (
 484 encode_ch '['  = "ZM"
 485 encode_ch ']'  = "ZN"
 486 encode_ch ':'  = "ZC"
 487 encode_ch 'Z'  = "ZZ"
 488
 489 -- Variables
 490 encode_ch 'z'  = "zz"
 491 encode_ch '&'  = "za"
 492 encode_ch '|'  = "zb"
 493 encode_ch '$'  = "zd"
 494 encode_ch '='  = "ze"
 495 encode_ch '>'  = "zg"
 496 encode_ch '#'  = "zh"
 497 encode_ch '.'  = "zi"
 498 encode_ch '<'  = "zl"
 499 encode_ch '-'  = "zm"
 500 encode_ch '!'  = "zn"
 501 encode_ch '+'  = "zp"
 502 encode_ch '\'' = "zq"
 503 encode_ch '\\' = "zr"
 504 encode_ch '/'  = "zs"
 505 encode_ch '*'  = "zt"
 506 encode_ch '^'  = "zu"
 507 encode_ch '%'  = "zv"
 508 encode_ch c    = ['z', 'x', intToDigit hi, intToDigit lo]
 509                where
 510                  (hi,lo) = ord c `quotRem` 16
 511 \end{code}
 512
 513 Decode is used for user printing.
 514
 515 \begin{code}
 516 decodeFS :: FAST_STRING -> FAST_STRING
 517 decodeFS fs = _PK_ (decode (_UNPK_ fs))
 518
 519 decode :: EncodedString -> UserString
 520 decode [] = []
 521 decode ('Z' : rest) = decode_escape rest
 522 decode ('z' : rest) = decode_escape rest
 523 decode (c   : rest) = c : decode rest
 524
 525 decode_escape :: EncodedString -> UserString
 526
 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
 533
 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
 553
 554 -- Tuples are coded as Z23T
 555 decode_escape (c : rest)
 556   | isDigit c = go (digitToInt c) rest
 557   where
 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))
 561
 562 decode_escape (c : rest) = pprTrace "decode_escape" (char c) (decode rest)
 563 \end{code}
 564
 565
 566 %************************************************************************
 567 %*                                                                      *
 568 n\subsection{Lexical categories}
 569 %*                                                                      *
 570 %************************************************************************
 571
 572 These functions test strings to see if they fit the lexical categories
 573 defined in the Haskell report.
 574
 575 \begin{code}
 576 isLexCon,   isLexVar,    isLexId,    isLexSym    :: FAST_STRING -> Bool
 577 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FAST_STRING -> Bool
 578
 579 isLexCon cs = isLexConId  cs || isLexConSym cs
 580 isLexVar cs = isLexVarId  cs || isLexVarSym cs
 581
 582 isLexId  cs = isLexConId  cs || isLexVarId  cs
 583 isLexSym cs = isLexConSym cs || isLexVarSym cs
 584
 585 -------------
 586
 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
 592   where
 593     c = _HEAD_ cs
 594
 595 isLexVarId cs                           -- Ordinary prefix identifiers
 596   | _NULL_ cs    = False                --      e.g. "x", "_x"
 597   | otherwise    = isLower c || isLowerISO c || c == '_'
 598   where
 599     c = _HEAD_ cs
 600
 601 isLexConSym cs                          -- Infix type or data constructors
 602   | _NULL_ cs   = False                 --      e.g. ":-:", ":", "->"
 603   | otherwise   = c  == ':'
 604                || cs == SLIT("->")
 605   where
 606     c = _HEAD_ cs
 607
 608 isLexVarSym cs                          -- Infix identifiers
 609   | _NULL_ cs = False                   --      e.g. "+"
 610   | otherwise = isSymbolASCII c
 611              || isSymbolISO c
 612   where
 613     c = _HEAD_ cs
 614
 615 -------------
 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
 622 \end{code}