[project @ 2000-05-22 14:16:09 by simonmar]

[ghc-hetmet.git] / ghc / compiler / basicTypes / OccName.lhs

diff --git a/ghc/compiler/basicTypes/OccName.lhs b/ghc/compiler/basicTypes/OccName.lhs
index 1720506..7a59270 100644 (file)
--- a/ghc/compiler/basicTypes/OccName.lhs
+++ b/ghc/compiler/basicTypes/OccName.lhs
@@ -7,19 +7,19 @@
 \begin{code}
 module OccName (
        -- The NameSpace type; abstact
-       NameSpace, tcName, clsName, tcClsName, dataName, varName, tvName,
-       uvName, nameSpaceString, 
+       NameSpace, tcName, clsName, tcClsName, dataName, varName, ipName,
+       tvName, uvName, nameSpaceString, 
 
        -- The OccName type
        OccName,        -- Abstract, instance of Outputable
        pprOccName, 
 
-       mkSrcOccFS, mkSysOcc, mkSysOccFS, mkSrcVarOcc, mkKindOccFS,
+       mkSrcOccFS, mkSysOcc, mkSysOccFS, mkCCallOcc, mkSrcVarOcc, mkKindOccFS,
        mkSuperDictSelOcc, mkDFunOcc, mkForeignExportOcc,
-       mkDictOcc, mkWorkerOcc, mkMethodOcc, mkDefaultMethodOcc,
+       mkDictOcc, mkIPOcc, mkWorkerOcc, mkMethodOcc, mkDefaultMethodOcc,
        mkDerivedTyConOcc, mkClassTyConOcc, mkClassDataConOcc, mkSpecOcc,
        
-       isTvOcc, isUvOcc, isDataOcc, isDataSymOcc, isSymOcc,
+       isTvOcc, isUvOcc, isDataOcc, isDataSymOcc, isSymOcc, isIPOcc, isValOcc,
 
        occNameFS, occNameString, occNameUserString, occNameSpace, occNameFlavour, 
        setOccNameSpace,
@@ -82,11 +82,12 @@ pprEncodedFS fs
 
 \begin{code}
 data NameSpace = VarName       -- Variables
+              | IPName         -- Implicit Parameters
               | DataName       -- Data constructors
               | TvName         -- Type variables
               | UvName         -- Usage variables
               | TcClsName      -- Type constructors and classes; Haskell has them
-                               -- in the same name space for now.  
+                               -- in the same name space for now.
               deriving( Eq, Ord )
 
 -- Though type constructors and classes are in the same name space now,
@@ -99,11 +100,13 @@ dataName = DataName
 tvName   = TvName
 uvName   = UvName
 varName  = VarName
+ipName   = IPName
 
 
 nameSpaceString :: NameSpace -> String
 nameSpaceString DataName  = "Data constructor"
 nameSpaceString VarName   = "Variable"
+nameSpaceString IPName    = "Implicit Param"
 nameSpaceString TvName    = "Type variable"
 nameSpaceString UvName    = "Usage variable"
 nameSpaceString TcClsName = "Type constructor or class"
@@ -159,13 +162,20 @@ already encoded
 
 \begin{code}
 mkSysOcc :: NameSpace -> EncodedString -> OccName
-mkSysOcc occ_sp str = ASSERT( alreadyEncoded str )
+mkSysOcc occ_sp str = ASSERT2( alreadyEncoded str, text str )
                      OccName occ_sp (_PK_ str)
 
 mkSysOccFS :: NameSpace -> EncodedFS -> OccName
 mkSysOccFS occ_sp fs = ASSERT2( alreadyEncodedFS fs, ppr fs )
                       OccName occ_sp fs
 
+mkCCallOcc :: EncodedString -> OccName
+-- This version of mkSysOcc doesn't check that the string is already encoded,
+-- because it will be something like "{__ccall f dyn Int# -> Int#}" 
+-- This encodes a lot into something that then parses like an Id.
+-- But then alreadyEncoded complains about the braces!
+mkCCallOcc str = OccName varName (_PK_ str)
+
 -- Kind constructors get a speical function.  Uniquely, they are not encoded,
 -- so that they have names like '*'.  This means that *even in interface files*
 -- we'll get kinds like (* -> (* -> *)).  We can't use mkSysOcc because it
@@ -222,18 +232,25 @@ isTvOcc other              = False
 isUvOcc (OccName UvName _) = True
 isUvOcc other              = False
 
+isValOcc (OccName VarName  _) = True
+isValOcc (OccName DataName _) = True
+isValOcc other               = False
+
 -- Data constructor operator (starts with ':', or '[]')
 -- Pretty inefficient!
 isDataSymOcc (OccName DataName s) = isLexConSym (decodeFS s)
 isDataSymOcc other               = False
 
 isDataOcc (OccName DataName _) = True
-isDataOcc oter                = False
+isDataOcc other                       = False
 
 -- Any operator (data constructor or variable)
 -- Pretty inefficient!
 isSymOcc (OccName DataName s) = isLexConSym (decodeFS s)
 isSymOcc (OccName VarName s)  = isLexSym (decodeFS s)
+
+isIPOcc (OccName IPName _) = True
+isIPOcc _                 = False
 \end{code}
 
 
@@ -277,7 +294,7 @@ mk_deriv occ_sp sys_prefix str = mkSysOcc occ_sp (encode sys_prefix ++ str)
 \end{code}
 
 \begin{code}
-mkDictOcc, mkWorkerOcc, mkDefaultMethodOcc,
+mkDictOcc, mkIPOcc, mkWorkerOcc, mkDefaultMethodOcc,
           mkClassTyConOcc, mkClassDataConOcc, mkSpecOcc
    :: OccName -> OccName
 
@@ -288,6 +305,7 @@ mkDerivedTyConOcc  = mk_simple_deriv tcName   ":"   -- The : prefix makes sure it
 mkClassTyConOcc    = mk_simple_deriv tcName   ":T"     -- as a tycon/datacon
 mkClassDataConOcc  = mk_simple_deriv dataName ":D"     --
 mkDictOcc         = mk_simple_deriv varName  "$d"
+mkIPOcc                   = mk_simple_deriv varName  "$i"
 mkSpecOcc         = mk_simple_deriv varName  "$s"
 mkForeignExportOcc = mk_simple_deriv varName  "$f"
 
@@ -404,7 +422,7 @@ The basic encoding scheme is this.
 
 * Tuples (,,,) are coded as Z3T
 
-* Alphabetic characters (upper and lower), digits, and '_'
+* Alphabetic characters (upper and lower) and digits
        all translate to themselves; 
        except 'Z', which translates to 'ZZ'
        and    'z', which translates to 'zz'
@@ -438,7 +456,10 @@ The basic encoding scheme is this.
 alreadyEncoded :: String -> Bool
 alreadyEncoded s = all ok s
                 where
-                  ok '_' = True
+                  ok ' ' = True                -- This is a bit of a lie; if we really wanted spaces
+                                               -- in names we'd have to encode them.  But we do put
+                                               -- spaces in ccall "occurrences", and we don't want to
+                                               -- reject them here
                   ok ch  = ISALPHANUM ch
 
 alreadyEncodedFS :: FAST_STRING -> Bool
@@ -468,7 +489,6 @@ encodeFS fast_str  | all unencodedChar str = fast_str
                     str = _UNPK_ fast_str
 
 unencodedChar :: Char -> Bool  -- True for chars that don't need encoding
-unencodedChar '_' = True
 unencodedChar 'Z' = False
 unencodedChar 'z' = False
 unencodedChar c   = ISALPHANUM c
@@ -488,6 +508,7 @@ encode_ch 'Z'  = "ZZ"
 encode_ch 'z'  = "zz"
 encode_ch '&'  = "za"
 encode_ch '|'  = "zb"
+encode_ch '^'  = "zc"
 encode_ch '$'  = "zd"
 encode_ch '='  = "ze"
 encode_ch '>'  = "zg"
@@ -501,7 +522,7 @@ encode_ch '\'' = "zq"
 encode_ch '\\' = "zr"
 encode_ch '/'  = "zs"
 encode_ch '*'  = "zt"
-encode_ch '^'  = "zu"
+encode_ch '_'  = "zu"
 encode_ch '%'  = "zv"
 encode_ch c    = ['z', 'x', intToDigit hi, intToDigit lo]
               where