Add utility functions for accessing PA info during vectorisation
[ghc-hetmet.git] / 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 Control.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                         "extraGHCiLibraries"-> p{extraGHCiLibraries= $3}
86                         "includeDirs"       -> p{includeDirs       = $3}
87                         "includes"          -> p{includes          = $3}
88                         "hugsOptions"       -> p{hugsOptions       = $3}
89                         "ccOptions"         -> p{ccOptions         = $3}
90                         "ldOptions"         -> p{ldOptions         = $3}
91                         "frameworkDirs"     -> p{frameworkDirs     = $3}
92                         "frameworks"        -> p{frameworks        = $3}
93                         "haddockInterfaces" -> p{haddockInterfaces = $3}
94                         "haddockHTMLs"      -> p{haddockHTMLs      = $3}
95                         "depends"           -> p{depends = []}
96                                 -- empty list only, non-empty handled below
97                         other -> p
98                 }
99
100         | VARID '=' pkgidlist
101                 {% case unpackFS $1 of
102                         "depends"     -> return (\p -> p{depends = $3})
103                         _other        -> happyError
104                 }
105
106 pkgid   :: { PackageIdentifier }
107         : CONID '{' VARID '=' STRING ',' VARID '=' version '}'
108                         { PackageIdentifier{ pkgName = unpackFS $5, 
109                                              pkgVersion = $9 } }
110
111 version :: { Version }
112         : CONID '{' VARID '=' intlist ',' VARID '=' strlist '}'
113                         { Version{ versionBranch=$5, versionTags=$9 } }
114
115 pkgidlist :: { [PackageIdentifier] }
116         : '[' pkgids ']'                { $2 }
117         -- empty list case is covered by strlist, to avoid conflicts
118
119 pkgids  :: { [PackageIdentifier] }
120         : pkgid                         { [ $1 ] }
121         | pkgid ',' pkgids              { $1 : $3 }
122
123 intlist :: { [Int] }
124         : '[' ']'                       { [] }
125         | '[' ints ']'                  { $2 }
126
127 ints    :: { [Int] }
128         : INT                           { [ fromIntegral $1 ] }
129         | INT ',' ints                  { fromIntegral $1 : $3 }
130
131 strlist :: { [String] }
132         : '[' ']'                       { [] }
133         | '[' strs ']'                  { $2 }
134
135 strs    :: { [String] }
136         : STRING                        { [ unpackFS $1 ] }
137         | STRING ',' strs               { unpackFS $1 : $3 }
138
139 {
140 happyError :: P a
141 happyError = srcParseFail
142
143 loadPackageConfig :: FilePath -> IO [PackageConfig]
144 loadPackageConfig conf_filename = do
145    buf <- hGetStringBuffer conf_filename
146    let loc  = mkSrcLoc (mkFastString conf_filename) 1 0
147    case unP parse (mkPState buf loc defaultDynFlags) of
148         PFailed span err -> 
149            throwDyn (InstallationError (showSDoc (mkLocMessage span err)))
150
151         POk _ pkg_details -> do
152             return pkg_details
153 }