Name.lhs 19.9 KB
Newer Older
1
%
Simon Marlow's avatar
Simon Marlow committed
2
% (c) The University of Glasgow 2006
3
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 5 6 7
%
\section[Name]{@Name@: to transmit name info from renamer to typechecker}

\begin{code}
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
-- |
-- #name_types#
-- GHC uses several kinds of name internally:
--
-- * 'OccName.OccName': see "OccName#name_types"
--
-- * 'RdrName.RdrName': see "RdrName#name_types"
--
-- *  'Name.Name' is the type of names that have had their scoping and binding resolved. They
--   have an 'OccName.OccName' but also a 'Unique.Unique' that disambiguates Names that have
--   the same 'OccName.OccName' and indeed is used for all 'Name.Name' comparison. Names
--   also contain information about where they originated from, see "Name#name_sorts"
--
-- * 'Id.Id': see "Id#name_types"
--
-- * 'Var.Var': see "Var#name_types"
--
-- #name_sorts#
-- Names are one of:
--
--  * External, if they name things declared in other modules. Some external
--    Names are wired in, i.e. they name primitives defined in the compiler itself
--
--  * Internal, if they name things in the module being compiled. Some internal
--    Names are system names, if they are names manufactured by the compiler
33

34 35
module Name (
	-- * The main types
36
	Name,					-- Abstract
37 38 39
	BuiltInSyntax(..),

	-- ** Creating 'Name's
40
	mkInternalName, mkSystemName, mkDerivedInternalName, 
41
	mkSystemVarName, mkSysTvName, 
42
	mkFCallName, mkIPName,
43
        mkTickBoxOpName,
44
	mkExternalName, mkWiredInName,
45

46
	-- ** Manipulating and deconstructing 'Name's
47
	nameUnique, setNameUnique,
48
	nameOccName, nameModule, nameModule_maybe,
49
	tidyNameOcc, 
50
	hashName, localiseName,
51
  mkLocalisedOccName,
sof's avatar
sof committed
52

53
	nameSrcLoc, nameSrcSpan, pprNameLoc,
54

55
	-- ** Predicates on 'Name's
56
	isSystemName, isInternalName, isExternalName,
57 58 59
	isTyVarName, isTyConName, isDataConName, 
	isValName, isVarName,
	isWiredInName, isBuiltInSyntax,
60
	wiredInNameTyThing_maybe, 
61
	nameIsLocalOrFrom, stableNameCmp,
62 63

	-- * Class 'NamedThing' and overloaded friends
64
	NamedThing(..),
65
	getSrcLoc, getSrcSpan, getOccString,
66

67
 	pprInfixName, pprPrefixName, pprModulePrefix,
68 69 70

	-- Re-export the OccName stuff
	module OccName
71
    ) where
72

73 74
#include "Typeable.h"

75 76
import {-# SOURCE #-} TypeRep( TyThing )

Simon Marlow's avatar
Simon Marlow committed
77 78 79 80
import OccName
import Module
import SrcLoc
import Unique
81
import Util
Simon Marlow's avatar
Simon Marlow committed
82
import Maybes
83
import Binary
84
import StaticFlags
85
import FastTypes
Simon Marlow's avatar
Simon Marlow committed
86
import FastString
87
import Outputable
88

Simon Marlow's avatar
Simon Marlow committed
89
import Data.Array
90
import Data.Data
91
import Data.Word        ( Word32 )
92 93
\end{code}

94 95
%************************************************************************
%*									*
96
\subsection[Name-datatype]{The @Name@ datatype, and name construction}
97 98
%*									*
%************************************************************************
99
 
100
\begin{code}
101 102
-- | A unique, unambigious name for something, containing information about where
-- that thing originated.
103 104
data Name = Name {
		n_sort :: NameSort,	-- What sort of name it is
105
		n_occ  :: !OccName,	-- Its occurrence name
106 107
		n_uniq :: FastInt,      -- UNPACK doesn't work, recursive type
--(note later when changing Int# -> FastInt: is that still true about UNPACK?)
108
		n_loc  :: !SrcSpan	-- Definition site
109
	    }
Ian Lynagh's avatar
Ian Lynagh committed
110
    deriving Typeable
111

112 113 114 115
-- NOTE: we make the n_loc field strict to eliminate some potential
-- (and real!) space leaks, due to the fact that we don't look at
-- the SrcLoc in a Name all that often.

116
data NameSort
117
  = External Module
118
 
119
  | WiredIn Module TyThing BuiltInSyntax
120
	-- A variant of External, for wired-in things
121

122
  | Internal		-- A user-defined Id or TyVar
123 124 125 126
			-- defined in the module being compiled

  | System		-- A system-defined Id or TyVar.  Typically the
			-- OccName is very uninformative (like 's')
127

128 129
-- | BuiltInSyntax is for things like @(:)@, @[]@ and tuples, 
-- which have special syntactic forms.  They aren't in scope
130
-- as such.
131
data BuiltInSyntax = BuiltInSyntax | UserSyntax
132 133
\end{code}

134 135
Notes about the NameSorts:

136 137
1.  Initially, top-level Ids (including locally-defined ones) get External names, 
    and all other local Ids get Internal names
138

139
2.  Things with a External name are given C static labels, so they finally
140 141
    appear in the .o file's symbol table.  They appear in the symbol table
    in the form M.n.  If originally-local things have this property they
142
    must be made @External@ first.
143

144 145
3.  In the tidy-core phase, a External that is not visible to an importer
    is changed to Internal, and a Internal that is visible is changed to External
146 147

4.  A System Name differs in the following ways:
148 149 150 151 152 153 154 155 156
	a) has unique attached when printing dumps
	b) unifier eliminates sys tyvars in favour of user provs where possible

    Before anything gets printed in interface files or output code, it's
    fed through a 'tidy' processor, which zaps the OccNames to have
    unique names; and converts all sys-locals to user locals
    If any desugarer sys-locals have survived that far, they get changed to
    "ds1", "ds2", etc.

157 158 159 160 161 162 163 164
Built-in syntax => It's a syntactic form, not "in scope" (e.g. [])

Wired-in thing  => The thing (Id, TyCon) is fully known to the compiler, 
		   not read from an interface file. 
		   E.g. Bool, True, Int, Float, and many others

All built-in syntax is for wired-in things.

165 166 167 168 169
\begin{code}
nameUnique		:: Name -> Unique
nameOccName		:: Name -> OccName 
nameModule		:: Name -> Module
nameSrcLoc		:: Name -> SrcLoc
170
nameSrcSpan		:: Name -> SrcSpan
171

172
nameUnique  name = mkUniqueGrimily (iBox (n_uniq name))
173
nameOccName name = n_occ  name
174 175
nameSrcLoc  name = srcSpanStart (n_loc name)
nameSrcSpan name = n_loc  name
176 177
\end{code}

178 179 180 181 182 183
%************************************************************************
%*									*
\subsection{Predicates on names}
%*									*
%************************************************************************

184
\begin{code}
185 186 187 188
nameIsLocalOrFrom :: Module -> Name -> Bool
isInternalName	  :: Name -> Bool
isExternalName	  :: Name -> Bool
isSystemName	  :: Name -> Bool
189 190
isWiredInName	  :: Name -> Bool

191
isWiredInName (Name {n_sort = WiredIn _ _ _}) = True
twanvl's avatar
twanvl committed
192
isWiredInName _                               = False
193

194
wiredInNameTyThing_maybe :: Name -> Maybe TyThing
195
wiredInNameTyThing_maybe (Name {n_sort = WiredIn _ thing _}) = Just thing
twanvl's avatar
twanvl committed
196
wiredInNameTyThing_maybe _                                   = Nothing
197

twanvl's avatar
twanvl committed
198
isBuiltInSyntax :: Name -> Bool
199
isBuiltInSyntax (Name {n_sort = WiredIn _ _ BuiltInSyntax}) = True
twanvl's avatar
twanvl committed
200
isBuiltInSyntax _                                           = False
201

202 203
isExternalName (Name {n_sort = External _})    = True
isExternalName (Name {n_sort = WiredIn _ _ _}) = True
twanvl's avatar
twanvl committed
204
isExternalName _                               = False
205

206
isInternalName name = not (isExternalName name)
207

208
nameModule name = nameModule_maybe name `orElse` pprPanic "nameModule" (ppr name)
twanvl's avatar
twanvl committed
209
nameModule_maybe :: Name -> Maybe Module
210 211
nameModule_maybe (Name { n_sort = External mod})    = Just mod
nameModule_maybe (Name { n_sort = WiredIn mod _ _}) = Just mod
twanvl's avatar
twanvl committed
212
nameModule_maybe _                                  = Nothing
213

214 215 216 217
nameIsLocalOrFrom from name
  | isExternalName name = from == nameModule name
  | otherwise		= True

218 219
isTyVarName :: Name -> Bool
isTyVarName name = isTvOcc (nameOccName name)
220

221 222 223
isTyConName :: Name -> Bool
isTyConName name = isTcOcc (nameOccName name)

224 225 226 227 228 229 230 231 232
isDataConName :: Name -> Bool
isDataConName name = isDataOcc (nameOccName name)

isValName :: Name -> Bool
isValName name = isValOcc (nameOccName name)

isVarName :: Name -> Bool
isVarName = isVarOcc . nameOccName

233
isSystemName (Name {n_sort = System}) = True
twanvl's avatar
twanvl committed
234
isSystemName _                        = False
235 236 237 238 239 240 241 242
\end{code}


%************************************************************************
%*									*
\subsection{Making names}
%*									*
%************************************************************************
243

244
\begin{code}
245 246
-- | Create a name which is (for now at least) local to the current module and hence
-- does not need a 'Module' to disambiguate it from other 'Name's
247
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
Simon Peyton Jones's avatar
Simon Peyton Jones committed
248 249 250 251
mkInternalName uniq occ loc = Name { n_uniq = getKeyFastInt uniq
                                   , n_sort = Internal
                                   , n_occ = occ
                                   , n_loc = loc }
252 253 254 255 256 257 258 259
	-- NB: You might worry that after lots of huffing and
	-- puffing we might end up with two local names with distinct
	-- uniques, but the same OccName.  Indeed we can, but that's ok
	--	* the insides of the compiler don't care: they use the Unique
	--	* when printing for -ddump-xxx you can switch on -dppr-debug to get the
	--	  uniques if you get confused
	--	* for interface files we tidyCore first, which puts the uniques
	--	  into the print name (see setNameVisibility below)
260

261 262 263 264 265
mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
mkDerivedInternalName derive_occ uniq (Name { n_occ = occ, n_loc = loc })
  = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal
         , n_occ = derive_occ occ, n_loc = loc }

266
-- | Create a name which definitely originates in the given module
267
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
268
mkExternalName uniq mod occ loc 
269
  = Name { n_uniq = getKeyFastInt uniq, n_sort = External mod,
270
           n_occ = occ, n_loc = loc }
271

272 273
-- | Create a name which is actually defined by the compiler itself
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
274
mkWiredInName mod occ uniq thing built_in
275
  = Name { n_uniq = getKeyFastInt uniq,
276
	   n_sort = WiredIn mod thing built_in,
277
	   n_occ = occ, n_loc = wiredInSrcSpan }
278

279
-- | Create a name brought into being by the compiler
280
mkSystemName :: Unique -> OccName -> Name
281
mkSystemName uniq occ = Name { n_uniq = getKeyFastInt uniq, n_sort = System, 
282
			       n_occ = occ, n_loc = noSrcSpan }
283

284 285
mkSystemVarName :: Unique -> FastString -> Name
mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs)
286

287
mkSysTvName :: Unique -> FastString -> Name
288
mkSysTvName uniq fs = mkSystemName uniq (mkOccNameFS tvName fs)
289

290
-- | Make a name for a foreign call
291
mkFCallName :: Unique -> String -> Name
292
	-- The encoded string completely describes the ccall
293
mkFCallName uniq str =  Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, 
294
			       n_occ = mkVarOcc str, n_loc = noSrcSpan }
295

296

297 298
mkTickBoxOpName :: Unique -> String -> Name
mkTickBoxOpName uniq str 
299
   = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, 
300
	    n_occ = mkVarOcc str, n_loc = noSrcSpan }
301

302
-- | Make the name of an implicit parameter
303 304
mkIPName :: Unique -> OccName -> Name
mkIPName uniq occ
305
  = Name { n_uniq = getKeyFastInt uniq,
306
	   n_sort = Internal,
307
	   n_occ  = occ,
308
	   n_loc = noSrcSpan }
309 310 311
\end{code}

\begin{code}
312 313 314
-- When we renumber/rename things, we need to be
-- able to change a Name's Unique to match the cached
-- one in the thing it's the name of.  If you know what I mean.
315
setNameUnique :: Name -> Unique -> Name
316
setNameUnique name uniq = name {n_uniq = getKeyFastInt uniq}
317

318 319 320 321 322 323
tidyNameOcc :: Name -> OccName -> Name
-- We set the OccName of a Name when tidying
-- In doing so, we change System --> Internal, so that when we print
-- it we don't get the unique by default.  It's tidy now!
tidyNameOcc name@(Name { n_sort = System }) occ = name { n_occ = occ, n_sort = Internal}
tidyNameOcc name 			    occ = name { n_occ = occ }
324

325
-- | Make the 'Name' into an internal name, regardless of what it was to begin with
326
localiseName :: Name -> Name
327
localiseName n = n { n_sort = Internal }
sof's avatar
sof committed
328 329
\end{code}

330 331 332 333 334
\begin{code}
-- |Create a localised variant of a name.  
--
-- If the name is external, encode the original's module name to disambiguate.
--
335 336
mkLocalisedOccName :: Module -> (Maybe String -> OccName -> OccName) -> Name -> OccName
mkLocalisedOccName this_mod mk_occ name = mk_occ origin (nameOccName name)
337
  where
338 339 340
    origin 
      | nameIsLocalOrFrom this_mod name = Nothing
      | otherwise                       = Just (moduleNameColons . moduleName . nameModule $ name)
341 342
\end{code}

343 344
%************************************************************************
%*									*
345
\subsection{Hashing and comparison}
346 347 348 349
%*									*
%************************************************************************

\begin{code}
350 351 352 353 354
hashName :: Name -> Int		-- ToDo: should really be Word
hashName name = getKey (nameUnique name) + 1
	-- The +1 avoids keys with lots of zeros in the ls bits, which 
	-- interacts badly with the cheap and cheerful multiplication in
	-- hashExpr
355

356 357
cmpName :: Name -> Name -> Ordering
cmpName n1 n2 = iBox (n_uniq n1) `compare` iBox (n_uniq n2)
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377

stableNameCmp :: Name -> Name -> Ordering
-- Compare lexicographically
stableNameCmp (Name { n_sort = s1, n_occ = occ1 })
	      (Name { n_sort = s2, n_occ = occ2 })
  = (s1 `sort_cmp` s2) `thenCmp` (occ1 `compare` occ2)
    -- The ordinary compare on OccNames is lexicogrpahic
  where
    -- Later constructors are bigger
    sort_cmp (External m1) (External m2)       = m1 `stableModuleCmp` m2
    sort_cmp (External {}) _                   = LT
    sort_cmp (WiredIn {}) (External {})        = GT
    sort_cmp (WiredIn m1 _ _) (WiredIn m2 _ _) = m1 `stableModuleCmp` m2
    sort_cmp (WiredIn {})     _                = LT
    sort_cmp Internal         (External {})    = GT
    sort_cmp Internal         (WiredIn {})     = GT
    sort_cmp Internal         Internal         = EQ
    sort_cmp Internal         System           = LT
    sort_cmp System           System           = EQ
    sort_cmp System           _                = GT
378
\end{code}
379

380 381 382 383 384 385 386 387
%************************************************************************
%*									*
\subsection[Name-instances]{Instance declarations}
%*									*
%************************************************************************

\begin{code}
instance Eq Name where
388 389
    a == b = case (a `compare` b) of { EQ -> True;  _ -> False }
    a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
390 391

instance Ord Name where
392 393
    a <= b = case (a `compare` b) of { LT -> True;  EQ -> True;  GT -> False }
    a <	 b = case (a `compare` b) of { LT -> True;  EQ -> False; GT -> False }
394 395 396
    a >= b = case (a `compare` b) of { LT -> False; EQ -> True;  GT -> True  }
    a >	 b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True  }
    compare a b = cmpName a b
397

398
instance Uniquable Name where
399
    getUnique = nameUnique
400

401
instance NamedThing Name where
402
    getName n = n
403 404 405 406 407 408

instance Data Name where
  -- don't traverse?
  toConstr _   = abstractConstr "Name"
  gunfold _ _  = error "gunfold"
  dataTypeOf _ = mkNoRepType "Name"
409 410
\end{code}

411 412 413 414 415 416 417 418
%************************************************************************
%*									*
\subsection{Binary}
%*									*
%************************************************************************

\begin{code}
instance Binary Name where
419 420 421
   put_ bh name =
      case getUserData bh of 
        UserData{ ud_put_name = put_name } -> put_name bh name
422 423 424

   get bh = do
        i <- get bh
425
        return $! (ud_symtab (getUserData bh) ! fromIntegral (i::Word32))
426
\end{code}
427

428 429 430 431 432
%************************************************************************
%*									*
\subsection{Pretty printing}
%*									*
%************************************************************************
433 434 435

\begin{code}
instance Outputable Name where
436 437
    ppr name = pprName name

438 439 440
instance OutputableBndr Name where
    pprBndr _ name = pprName name

twanvl's avatar
twanvl committed
441 442
pprName :: Name -> SDoc
pprName (Name {n_sort = sort, n_uniq = u, n_occ = occ})
443
  = getPprStyle $ \ sty ->
444
    case sort of
445 446
      WiredIn mod _ builtin   -> pprExternal sty uniq mod occ True  builtin
      External mod  	      -> pprExternal sty uniq mod occ False UserSyntax
447 448
      System   		      -> pprSystem sty uniq occ
      Internal    	      -> pprInternal sty uniq occ
449
  where uniq = mkUniqueGrimily (iBox u)
450

twanvl's avatar
twanvl committed
451
pprExternal :: PprStyle -> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc
452
pprExternal sty uniq mod occ is_wired is_builtin
453
  | codeStyle sty = ppr mod <> char '_' <> ppr_z_occ_name occ
454 455 456
	-- In code style, always qualify
	-- ToDo: maybe we could print all wired-in things unqualified
	-- 	 in code style, to reduce symbol table bloat?
457
  | debugStyle sty = pp_mod <> ppr_occ_name occ
458 459 460 461 462
		     <> braces (hsep [if is_wired then ptext (sLit "(w)") else empty,
				      pprNameSpaceBrief (occNameSpace occ), 
		 		      pprUnique uniq])
  | BuiltInSyntax <- is_builtin = ppr_occ_name occ  -- Never qualify builtin syntax
  | otherwise		        = pprModulePrefix sty mod occ <> ppr_occ_name occ
463 464 465
  where
    pp_mod | opt_SuppressModulePrefixes = empty
           | otherwise                  = ppr mod <> dot 
466

twanvl's avatar
twanvl committed
467
pprInternal :: PprStyle -> Unique -> OccName -> SDoc
468
pprInternal sty uniq occ
469
  | codeStyle sty  = pprUnique uniq
470
  | debugStyle sty = ppr_occ_name occ <> braces (hsep [pprNameSpaceBrief (occNameSpace occ), 
471
				 		       pprUnique uniq])
472
  | dumpStyle sty  = ppr_occ_name occ <> ppr_underscore_unique uniq
473 474
			-- For debug dumps, we're not necessarily dumping
			-- tidied code, so we need to print the uniques.
475
  | otherwise      = ppr_occ_name occ	-- User style
476

477
-- Like Internal, except that we only omit the unique in Iface style
twanvl's avatar
twanvl committed
478
pprSystem :: PprStyle -> Unique -> OccName -> SDoc
479
pprSystem sty uniq occ
480
  | codeStyle sty  = pprUnique uniq
481
  | debugStyle sty = ppr_occ_name occ <> ppr_underscore_unique uniq
482
		     <> braces (pprNameSpaceBrief (occNameSpace occ))
483
  | otherwise	   = ppr_occ_name occ <> ppr_underscore_unique uniq
484 485 486
				-- If the tidy phase hasn't run, the OccName
				-- is unlikely to be informative (like 's'),
				-- so print the unique
487

488 489 490 491 492

pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc
-- Print the "M." part of a name, based on whether it's in scope or not
-- See Note [Printing original names] in HscTypes
pprModulePrefix sty mod occ
493 494 495
  | opt_SuppressModulePrefixes = empty
  
  | otherwise
496 497 498 499 500 501 502
  = case qualName sty mod occ of	           -- See Outputable.QualifyName:
      NameQual modname -> ppr modname <> dot       -- Name is in scope       
      NameNotInScope1  -> ppr mod <> dot           -- Not in scope
      NameNotInScope2  -> ppr (modulePackageId mod) <> colon     -- Module not in
                          <> ppr (moduleName mod) <> dot         -- scope eithber
      _otherwise       -> empty

503 504 505 506 507 508 509
ppr_underscore_unique :: Unique -> SDoc
-- Print an underscore separating the name from its unique
-- But suppress it if we aren't printing the uniques anyway
ppr_underscore_unique uniq
  | opt_SuppressUniques = empty
  | otherwise		= char '_' <> pprUnique uniq

twanvl's avatar
twanvl committed
510
ppr_occ_name :: OccName -> SDoc
511
ppr_occ_name occ = ftext (occNameFS occ)
512 513
	-- Don't use pprOccName; instead, just print the string of the OccName; 
	-- we print the namespace in the debug stuff above
514 515 516

-- In code style, we Z-encode the strings.  The results of Z-encoding each FastString are
-- cached behind the scenes in the FastString implementation.
twanvl's avatar
twanvl committed
517
ppr_z_occ_name :: OccName -> SDoc
518
ppr_z_occ_name occ = ftext (zEncodeFS (occNameFS occ))
519

520 521
-- Prints (if mod information is available) "Defined at <loc>" or 
--  "Defined in <mod>" information for a Name.
522
pprNameLoc :: Name -> SDoc
Ian Lynagh's avatar
Ian Lynagh committed
523 524 525 526 527 528 529 530
pprNameLoc name = case nameSrcSpan name of
                  RealSrcSpan s ->
                      pprDefnLoc s
                  UnhelpfulSpan _
                   | isInternalName name || isSystemName name ->
                      ptext (sLit "<no location info>")
                   | otherwise ->
                      ptext (sLit "Defined in ") <> ppr (nameModule name)
531
\end{code}
532

533 534 535 536 537 538 539
%************************************************************************
%*									*
\subsection{Overloaded functions related to Names}
%*									*
%************************************************************************

\begin{code}
540
-- | A class allowing convenient access to the 'Name' of various datatypes
541
class NamedThing a where
542
    getOccName :: a -> OccName
543 544 545
    getName    :: a -> Name

    getOccName n = nameOccName (getName n)	-- Default method
546 547 548 549
\end{code}

\begin{code}
getSrcLoc	    :: NamedThing a => a -> SrcLoc
550
getSrcSpan	    :: NamedThing a => a -> SrcSpan
551
getOccString	    :: NamedThing a => a -> String
552

553
getSrcLoc	    = nameSrcLoc	   . getName
554
getSrcSpan	    = nameSrcSpan	   . getName
555
getOccString 	    = occNameString	   . getOccName
556 557 558 559 560 561

pprInfixName, pprPrefixName :: (Outputable a, NamedThing a) => a -> SDoc
-- See Outputable.pprPrefixVar, pprInfixVar; 
-- add parens or back-quotes as appropriate
pprInfixName  n = pprInfixVar  (isSymOcc (getOccName n)) (ppr n)
pprPrefixName n = pprPrefixVar (isSymOcc (getOccName n)) (ppr n)
562 563
\end{code}