compiler/main/ParsePkgConf.y

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