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