compiler/main/ParsePkgConf.y

   1 {
   2 {-# OPTIONS -w #-}
   3 -- The above warning supression flag is a temporary kludge.
   4 -- While working on this module you are encouraged to remove it and fix
   5 -- any warnings in the module. See
   6 --     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
   7 -- for details
   8
   9 module ParsePkgConf( loadPackageConfig ) where
  10
  11 #include "HsVersions.h"
  12
  13 import PackageConfig
  14 import Lexer
  15 import Module
  16 import DynFlags
  17 import FastString
  18 import StringBuffer
  19 import ErrUtils  ( mkLocMessage )
  20 import SrcLoc
  21 import Outputable
  22 import Panic     ( GhcException(..) )
  23 import Control.Exception ( throwDyn )
  24
  25 }
  26
  27 %token
  28  '{'            { L _ ITocurly }
  29  '}'            { L _ ITccurly }
  30  '['            { L _ ITobrack }
  31  ']'            { L _ ITcbrack }
  32  ','            { L _ ITcomma }
  33  '='            { L _ ITequal }
  34  VARID          { L _ (ITvarid    $$) }
  35  CONID          { L _ (ITconid    $$) }
  36  STRING         { L _ (ITstring   $$) }
  37  INT            { L _ (ITinteger  $$) }
  38
  39 %monad { P } { >>= } { return }
  40 %lexer { lexer } { L _ ITeof }
  41 %name parse
  42 %tokentype { Located Token }
  43 %%
  44
  45 pkgconf :: { [ PackageConfig ] }
  46         : '[' ']'                       { [] }
  47         | '[' pkgs ']'                  { reverse $2 }
  48
  49 pkgs    :: { [ PackageConfig ] }
  50         : pkg                           { [ $1 ] }
  51         | pkgs ',' pkg                  { $3 : $1 }
  52
  53 pkg     :: { PackageConfig }
  54         : CONID '{' fields '}'          { $3 defaultPackageConfig }
  55
  56 fields  :: { PackageConfig -> PackageConfig }
  57         : field                         { \p -> $1 p }
  58         | fields ',' field              { \p -> $1 ($3 p) }
  59
  60 field   :: { PackageConfig -> PackageConfig }
  61         : VARID '=' pkgid
  62                 {% case unpackFS $1 of
  63                         "package"     -> return (\p -> p{package = $3})
  64                         _other        -> happyError
  65                 }
  66
  67         | VARID '=' STRING              { id }
  68                 -- we aren't interested in the string fields, they're all
  69                 -- boring (copyright, maintainer etc.)
  70
  71         | VARID '=' CONID
  72                 {% case unpackFS $1 of {
  73                         "exposed" ->
  74                            case unpackFS $3 of {
  75                                 "True"  -> return (\p -> p{exposed=True});
  76                                 "False" -> return (\p -> p{exposed=False});
  77                                 _       -> happyError };
  78                         "license" -> return id; -- not interested
  79                         _         -> happyError }
  80                 }
  81
  82         | VARID '=' CONID STRING        { id }
  83                 -- another case of license
  84
  85         | VARID '=' strlist
  86         {\p -> case unpackFS $1 of
  87                 "exposedModules"    -> p{exposedModules    = map mkModuleNameFS $3}
  88                 "hiddenModules"     -> p{hiddenModules     = map mkModuleNameFS $3}
  89                 "importDirs"        -> p{importDirs        = map unpackFS $3}
  90                 "libraryDirs"       -> p{libraryDirs       = map unpackFS $3}
  91                 "hsLibraries"       -> p{hsLibraries       = map unpackFS $3}
  92                 "extraLibraries"    -> p{extraLibraries    = map unpackFS $3}
  93                 "extraGHCiLibraries"-> p{extraGHCiLibraries= map unpackFS $3}
  94                 "includeDirs"       -> p{includeDirs       = map unpackFS $3}
  95                 "includes"          -> p{includes          = map unpackFS $3}
  96                 "hugsOptions"       -> p{hugsOptions       = map unpackFS $3}
  97                 "ccOptions"         -> p{ccOptions         = map unpackFS $3}
  98                 "ldOptions"         -> p{ldOptions         = map unpackFS $3}
  99                 "frameworkDirs"     -> p{frameworkDirs     = map unpackFS $3}
 100                 "frameworks"        -> p{frameworks        = map unpackFS $3}
 101                 "haddockInterfaces" -> p{haddockInterfaces = map unpackFS $3}
 102                 "haddockHTMLs"      -> p{haddockHTMLs      = map unpackFS $3}
 103                 "depends"           -> p{depends = []}
 104                         -- empty list only, non-empty handled below
 105                 other -> p
 106         }
 107
 108         | VARID '=' pkgidlist
 109                 {% case unpackFS $1 of
 110                         "depends"     -> return (\p -> p{depends = $3})
 111                         _other        -> happyError
 112                 }
 113
 114 pkgid   :: { PackageIdentifier }
 115         : CONID '{' VARID '=' STRING ',' VARID '=' version '}'
 116                         { PackageIdentifier{ pkgName = unpackFS $5,
 117                                              pkgVersion = $9 } }
 118
 119 version :: { Version }
 120         : CONID '{' VARID '=' intlist ',' VARID '=' strlist '}'
 121                         { Version{ versionBranch=$5,
 122                                    versionTags=map unpackFS $9 } }
 123
 124 pkgidlist :: { [PackageIdentifier] }
 125         : '[' pkgids ']'                { $2 }
 126         -- empty list case is covered by strlist, to avoid conflicts
 127
 128 pkgids  :: { [PackageIdentifier] }
 129         : pkgid                         { [ $1 ] }
 130         | pkgid ',' pkgids              { $1 : $3 }
 131
 132 intlist :: { [Int] }
 133         : '[' ']'                       { [] }
 134         | '[' ints ']'                  { $2 }
 135
 136 ints    :: { [Int] }
 137         : INT                           { [ fromIntegral $1 ] }
 138         | INT ',' ints                  { fromIntegral $1 : $3 }
 139
 140 strlist :: { [FastString] }
 141         : '[' ']'                       { [] }
 142         | '[' strs ']'                  { $2 }
 143
 144 strs    :: { [FastString] }
 145         : STRING                        { [ $1 ] }
 146         | STRING ',' strs               { $1 : $3 }
 147
 148 {
 149 happyError :: P a
 150 happyError = srcParseFail
 151
 152 loadPackageConfig :: FilePath -> IO [PackageConfig]
 153 loadPackageConfig conf_filename = do
 154    buf <- hGetStringBuffer conf_filename
 155    let loc  = mkSrcLoc (mkFastString conf_filename) 1 0
 156    case unP parse (mkPState buf loc defaultDynFlags) of
 157         PFailed span err ->
 158            throwDyn (InstallationError (showSDoc (mkLocMessage span err)))
 159
 160         POk _ pkg_details -> do
 161             return pkg_details
 162 }