ghc/compiler/main/ParsePkgConf.y

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