compiler/main/ParsePkgConf.y

   1 {
   2 {-# OPTIONS -fno-warn-unused-binds -fno-warn-unused-matches -fno-warn-missing-signatures -fno-warn-incomplete-patterns -Wwarn #-}
   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
  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                         _             -> 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                 _ -> p
 106         }
 107
 108         | VARID '=' pkgidlist
 109                 {% case unpackFS $1 of
 110                         "depends"     -> return (\p -> p{depends = $3})
 111                         _             -> happyError
 112                 }
 113
 114 pkgid   :: { PackageIdentifier }
 115         : CONID '{' VARID '=' CONID STRING ',' VARID '=' version '}'
 116             {% case unpackFS $5 of
 117                "PackageName" ->
 118                    return $ PackageIdentifier {
 119                                 pkgName = PackageName (unpackFS $6),
 120                                 pkgVersion = $10
 121                             }
 122                _ -> happyError
 123             }
 124
 125 version :: { Version }
 126         : CONID '{' VARID '=' intlist ',' VARID '=' strlist '}'
 127                         { Version{ versionBranch=$5,
 128                                    versionTags=map unpackFS $9 } }
 129
 130 pkgidlist :: { [PackageIdentifier] }
 131         : '[' pkgids ']'                { $2 }
 132         -- empty list case is covered by strlist, to avoid conflicts
 133
 134 pkgids  :: { [PackageIdentifier] }
 135         : pkgid                         { [ $1 ] }
 136         | pkgid ',' pkgids              { $1 : $3 }
 137
 138 intlist :: { [Int] }
 139         : '[' ']'                       { [] }
 140         | '[' ints ']'                  { $2 }
 141
 142 ints    :: { [Int] }
 143         : INT                           { [ fromIntegral $1 ] }
 144         | INT ',' ints                  { fromIntegral $1 : $3 }
 145
 146 strlist :: { [FastString] }
 147         : '[' ']'                       { [] }
 148         | '[' strs ']'                  { $2 }
 149
 150 strs    :: { [FastString] }
 151         : STRING                        { [ $1 ] }
 152         | STRING ',' strs               { $1 : $3 }
 153
 154 {
 155 happyError :: P a
 156 happyError = srcParseFail
 157
 158 loadPackageConfig :: DynFlags -> FilePath -> IO [PackageConfig]
 159 loadPackageConfig dflags conf_filename = do
 160    buf <- hGetStringBuffer conf_filename
 161    let loc  = mkSrcLoc (mkFastString conf_filename) 1 0
 162    case unP parse (mkPState buf loc dflags) of
 163         PFailed span err ->
 164            ghcError (InstallationError (showSDoc (mkLocMessage span err)))
 165
 166         POk _ pkg_details -> do
 167             return pkg_details
 168 }