3       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !!"""#############################$$$$$$$$$$$$$$$$$$$$ $ $ $ $ %%%%%%%%%%%%%&&&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&A&B&C&D&E&F&G&H&I&J&K&L&M&N&O&P&Q&R&S&T&U&V&W&X&Y&Z&[&\&]&^&_&`&a&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z&{&|&}&~&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''((((((((((((((((((((((((((((((((((( ( ( ( ( ((((((((((((((((((( (!("(#($(%(&('((())*)+),)-).)/)0)1)2)3)4)5)6)7)8)9):);)<)=)>)?)@)A)B)C)D)E)F)G)H)I)J)K)L)M)N)O)P)Q)R)S)T)U)V)W)X)Y)Z)[)\)])^)_)`)a)b)c)d)e)f)g)h)i)j)k)l)m)n)o)p)q)r)s)t*u*v*w*x*y*z*{*|*}*~***++,,,,,,,,,,,,,,,,---------------------------....../////////00000011111122222222222233333344566666666666666666667789999999:::::::::::::: : : : : :;;;;;;;;;;;;;;;;;; ;!;";#;$;%;&;';(;);*;+;,;-;.;/;0;1;2;3;4;5;6;7;8;9;:;;;<;=<>=?=@=A=B=C=D=E=F=G>H>I>J>K>L>M?N?O?P?Q?R?S?T?U?V@W@X@Y@Z@[@\@]@^@_@`@a@b@c@d@e@f@g@h@i@j@k@lAmBnBoBpBqBrCsCtCuDvEwFxFyFzF{F|F}F~FNG Safe-Inferred  Thomas Tuegel 2010BSD3cabal-devel@haskell.orgportable Safe-InferredIf true, then children of this group may be run in parallel. Note that this setting is not inherited by children. In particular, consider a group F with "concurrently = False" that has some children, including a group T with "concurrently = True". The children of group T may be run concurrently with each other, as long as none are run at the same time as any of the direct children of group F.&IA human-readable description of the option to guide the user setting it.+Perform the test.,1A name for the test, unique within a test suite.-0Users can select groups of tests by their tags..5Descriptions of the options recognized by this test./Try to set the named option to the given value. Returns an error message if the option is not supported or the value could not be correctly parsed; otherwise, a )5 with the option set to the given value is returned.0PCreate a named group of tests, which are assumed to be safe to run in parallel.+  !"#$%&'()*+,-./0+  !"#$%&'()*+,-./0+)*+,-./#$%&'( !"  0     !"#$%&'()*+,-./0...cabal-devel@haskell.orgportable Safe-Inferred1No unliteration.22 takes a filename (for error reports), and transforms the given string, to eliminate the literate comments from the program text.121221 12H(c) Sven Panne 2002-2005/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportable Safe-Inferred sDescribes whether an option takes an argument or not, and if so how the argument is injected into a value of type a.optional argumentoption requires argumentno argument expectedEach  describes a single option.The arguments to  are:list of short option characters*list of long option strings (without "--")argument descriptorexplanation of option for user-What to do with options following non-optionswrap non-options into options*freely intersperse options and non-options+no option processing after first non-optionReturn a string describing the usage of a command, derived from the header (first argument) and the options described by the second argument.pProcess the command-line, and return the list of values that matched (and those that didn't). The arguments are:The order requirements (see )The option descriptions (see )9The actual command line arguments (presumably got from IJ).j returns a triple consisting of the option arguments, a list of non-options, and a list of error messages.This is almost the same as , but returns a quadruple consisting of the option arguments, a list of non-options, a list of unrecognized options, and a list of error messages. cabal-devel@haskell.orgportable Safe-Inferred343443342011, Dan Knappcabal-devel@haskell.orgportable Safe-Inferred5Represents a dialect of C. The Monoid instance expresses backward compatibility, in the sense that 'mappend a b' is the least inclusive dialect which both a and b! can be correctly interpreted as.:A list of all file extensions which are recognized as possibly containing some dialect of C code. Note that this list is only for source files, not for header files.;Takes a dialect of C and whether code is intended to be passed through the preprocessor, and returns a filename extension for containing that code.<Infers from a filename's extension the dialect of C which it contains, and whether it is intended to be passed through the preprocessor. 56789:;<56789:;<59876:;<59876:;<"(c) The University of Glasgow 2002/BSD-style (see the file libraries/base/LICENSE)libraries@haskell.orgportable Safe-Inferred >LConsumes and returns the next character. Fails if there is no input left.?PLook-ahead: returns the part of the input that is left, without consuming it.@ Always fails.ASymmetric choice.B}Local, exclusive, left-biased choice: If left parser locally produces any result at all, then right parser is not used.CzTransforms a parser into one that does the same, but in addition returns the exact characters read. IMPORTANT NOTE: C] gives a runtime error if its first argument is built using any occurrences of readS_to_P.DTConsumes and returns the next character, if it satisfies the specified predicate.E+Parses and returns the specified character.F(Parses and returns the specified string.GBParses the first zero or more characters satisfying the predicate.HAParses the first one or more characters satisfying the predicate.I+Combines all parsers in the specified list.JSkips all whitespace.K count n p  parses n occurrences of p/ in sequence. A list of results is returned.L between open close p  parses open, followed by p and finally close. Only the value of p is returned.M option x p will either parse p or return x without consuming any input.N optional p optionally parses p and always returns ().O4Parses zero or more occurrences of the given parser.P3Parses one or more occurrences of the given parser.QLike O, but discards the result.RLike P, but discards the result.S sepBy p sep$ parses zero or more occurrences of p, separated by sep*. Returns a list of values returned by p.T sepBy1 p sep# parses one or more occurrences of p, separated by sep*. Returns a list of values returned by p.U endBy p sep$ parses zero or more occurrences of p, separated and ended by sep.V endBy p sep# parses one or more occurrences of p, separated and ended by sep.W chainr p op x$ parses zero or more occurrences of p, separated by op#. Returns a value produced by a right9 associative application of all functions returned by op!. If there are no occurrences of p, x is returned.X chainl p op x$ parses zero or more occurrences of p, separated by op#. Returns a value produced by a left9 associative application of all functions returned by op!. If there are no occurrences of p, x is returned.YLike W(, but parses one or more occurrences of p.ZLike X(, but parses one or more occurrences of p.[manyTill p end$ parses zero or more occurrences of p, until end3 succeeds. Returns a list of values returned by p.\hConverts a parser into a Haskell ReadS-style function. This is the main way in which you can "run" a =" parser: the expanded type is 1 readP_to_S :: ReadP a -> String -> [(a,String)] ]Converts a Haskell ReadS-style function into a parser. Warning: This introduces local backtracking in the resulting parser, and therefore a possible inefficiency.3=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]"=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]"=>?ABC@DEFGHJIKLMNOPQRSTUVWXZY[\]-=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]ABDuncan Coutts 2007cabal-devel@haskell.orgportable Safe-Inferred^_`ab^_`ab^_`ab^_`abFIsaac Jones, Simon Marlow 2003-2004 Duncan Coutts 2008BSD3cabal-devel@haskell.orgportable Safe-Inferred*+l$A complementary representation of a mr. Instead of a boolean version predicate it uses an increasing sequence of non-overlapping, non-empty intervals.aThe key point is that this representation gives a canonical representation for the semantics of mxs. This makes it easier to check things like whether a version range is empty, covers all versions, or requires a certain minimum or maximum version. It also makes it easy to check equality or containment. It also makes it easier to identify 'simple' version predicates for translation into foreign packaging systems that do not support complex version range expressions.vThe version range -any4. That is, a version range containing all versions. withinRange v anyVersion = TruewHThe empty version range, that is a version range containing no versions.WThis can be constructed using any unsatisfiable version range expression, for example  > 1 && < 1. withinRange v noVersion = FalsexThe version range == v (withinRange v' (thisVersion v) = v' == vyThe version range  v|| v +withinRange v' (notThisVersion v) = v' /= vzThe version range > v (withinRange v' (laterVersion v) = v' > v{The version range >= v +withinRange v' (orLaterVersion v) = v' >= v|The version range < v *withinRange v' (earlierVersion v) = v' < v}The version range <= v -withinRange v' (orEarlierVersion v) = v' <= v~The version range  vr1 || vr2 X withinRange v' (unionVersionRanges vr1 vr2) = withinRange v' vr1 || withinRange v' vr2The version range  vr1 && vr2 \ withinRange v' (intersectVersionRanges vr1 vr2) = withinRange v' vr1 && withinRange v' vr2The version range == v.*.For example, for version 1.2, the version range == 1.2.* is the same as >= 1.2 && < 1.3 withinRange v' (laterVersion v) = v' >= v && v' < upper v where upper (Version lower t) = Version (init lower ++ [last lower + 1]) tThe version range >= v1 && <= v2.oIn practice this is not very useful because we normally use inclusive lower bounds and exclusive upper bounds. (withinRange v' (laterVersion v) = v' > v@Given a version range, remove the highest upper bound. Example: (>= 1 && < 3) || (>= 4 && < 5) is converted to  (>= 1 &&  3)|| (= 4).-Fold over the basic syntactic structure of a m.bThis provides a syntactic view of the expression defining the version range. The syntactic sugar ">= v", "<= v" and "== v.*"2 is presented in terms of the other basic syntax.For a semantic view use .An extended variant of < that also provides a view of in which the syntactic sugar ">= v", "<= v" and "== v.*"I is presented explicitly rather than in terms of the other basic syntax..Does this version fall within the given range?(This is the evaluation function for the m type.View a m as a union of intervals.5This provides a canonical view of the semantics of a m\ as opposed to the syntax of the expression used to define it. For the syntactic view use .Each interval is non-empty. The sequence is in increasing order and no intervals overlap or touch. Therefore only the first and last can be unbounded. The sequence can be empty if the range is empty (e.g. a range expression like  1&& 2).COther checks are trivial to implement using this view. For example: hisNoVersion vr | [] <- asVersionIntervals vr = True | otherwise = False isSpecificVersion vr | [(LowerBound v InclusiveBound ,UpperBound v' InclusiveBound)] <- asVersionIntervals vr , v == v' = Just v | otherwise = Nothing Does this m place any restriction on the ! or is it in fact equivalent to u.^Note this is a semantic check, not simply a syntactic check. So for example the following is True (for all v). EisAnyVersion (EarlierVersion v `UnionVersionRanges` orLaterVersion v)This is the converse of l. It check if the version range is empty, if there is no possible version that satisfies the version range.For example this is True (for all v): FisNoVersion (EarlierVersion v `IntersectVersionRanges` LaterVersion v)6Is this version range in fact just a specific version?For example the version range ">= 3 && <= 3" contains only the version 3. Simplify a m expression. For non-empty version ranges this produces a canonical form. Empty or inconsistent version ranges are left as-is because that provides more information."If you need a canonical form use )fromVersionIntervals . toVersionIntervals&It satisfies the following properties: 8withinRange v (simplifyVersionRange r) = withinRange v r  withinRange v r = withinRange v r' ==> simplifyVersionRange r = simplifyVersionRange r' || isNoVersion r || isNoVersion r'&Inspect the list of version intervals.Directly construct a l from a list of intervals.Each interval must be non-empty. The sequence must be in increasing order and no intervals may overlap or touch. If any of these conditions are not satisfied the function returns Nothing.6Check an upper bound does not intersect a lower bound:--| or ---) or ---] or ---) but not ---] |--- (--- (--- [--- [---5Test if a version falls within the version intervals.VIt exists mostly for completeness and testing. It satisfies the following properties: }withinIntervals v (toVersionIntervals vr) = withinRange v vr withinIntervals v ivs = withinRange v (fromVersionIntervals ivs) Convert a m$ to a sequence of version intervals. Convert a l value back into a m0 expression representing the version intervals.@cdefghijklmnopqrstuvwxyz{|}~"-any" version "== v" "> v" "< v""_ || _" union"_ && _" intersection "-any" version "== v" "> v" "< v" ">= v" "<= v""== v.*" wildcard. The function is passed the inclusive lower bound and the exclusive upper bounds of the range defined by the wildcard."_ || _" union"_ && _" intersection "(_)" parentheses3cdefghijklmnopqrstuvwxyz{|}~3mutsrqponvwxyz|{}~kijfhgcedl2cedfhgijklmutsrqponvwxyz{|}~ Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportable Safe-Inferred+Like * but compatible with the old ReadS parser.IIt is compatible in the sense that it accepts only the same strings, eg GHC4 but not "ghc". However other strings get mapped to  . The point of this is that we do not allow extra valid values that would upset older Cabal versions that had a stricter parser however we cope with new values more gracefully so that we'll be able to introduce new value in future without breaking things so much.vThe default compiler flavour to pick when compiling stuff. This defaults to the compiler used to build the Cabal lib.4However if it's not a recognised compiler then it's = and the user will have to specify which compiler they want.   The License data type.8Isaac Jones 2003-2005 Duncan Coutts 2008BSD3cabal-devel@haskell.orgportable Safe-Inferred+Indicates the license under which a package's source code is released. Versions of the licenses not listed here will be rejected by Hackage and cause  cabal check to issue a warning.$Indicates an erroneous license name.Any other software license.eNo license. The package may not be legally modified or redistributed by anyone but the rightsholder.ZThe author of a package disclaims any copyright to its source code and dedicates it to the public domain. This is not a software license. Please note that it is not possible to dedicate works to the public domain in every jurisdiction, nor is a work that is in the public domain in one jurisdiction necessarily in the public domain elsewhere. https://www.apache.org/licenses/Apache License, version 2.0. https://www.mozilla.org/MPL/#Mozilla Public License, version 2.0. &http://www.opensource.org/licenses/MIT MIT license. 1http://directory.fsf.org/wiki/License:BSD_4Clause4-clause BSD license. This license has not been approved by the OSI and is incompatible with the GNU GPL. It is provided for historical reasons and should be avoided. /http://www.opensource.org/licenses/bsd-3-clause3-clause BSD license. .http://www.opensource.org/licenses/bsd-license2-clause BSD license.$GNU Lesser General Public License,  7https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html version 2.1 or  &https://www.gnu.org/licenses/lgpl.html version 3. &https://www.gnu.org/licenses/agpl.html,GNU Affero General Public License, version 3.GNU General Public License,  6https://www.gnu.org/licenses/old-licenses/gpl-2.0.html version 2 or  %https://www.gnu.org/licenses/gpl.html version 3..The list of all currently recognised licenses.  Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportable Safe-Inferred+ ?Subclass of packages that have specific versioned dependencies.!So for example a not-yet-configured package has dependencies on version ranges, not specific versions. A configured or an already installed package depends on exact versions. Some operations or data structures (like dependency graphs) only make sense on this subclass of package types.Class of things that have a Types in this class are all notions of a package. This allows us to have different types for the different phases that packages go though, from simple name/id, package description, configured or installed packages.;Not all kinds of packages can be uniquely identified by a n. In particular, installed packages cannot, there may be many installed instances of the same source package.0Describes a dependency on a source package (API)An InstalledPackageId uniquely identifies an instance of an installed package. There can be at most one package with a given 1 in a package database, or overlay of databases."The name and version of a package.!The name of this package, eg. foo#the version of this package, eg 1.24Type alias so we can use the shorter name PackageId. Simplify the m expression in a . See . Duncan Coutts 2008BSD3cabal-devel@haskell.orgportable Safe-Inferred+A valid Haskell module name. Construct a  from a valid module name .This is just a convenience function intended for valid module strings. It is an error if it is used with a string that is not a valid module name. If you are parsing user input then use K instead.The module name Main.DThe individual components of a hierarchical module name. For example 1components (fromString "A.B.C") = ["A", "B", "C"]SConvert a module name to a file path, but without any file extension. For example: )toFilePath (fromString "A.B.C") = "A/B/C"   Duncan Coutts 2007-2008cabal-devel@haskell.orgportable Safe-Inferred+3How strict to be when classifying strings into the  and  enums.vThe reason we have multiple ways to do the classification is because there are two situations where we need to do it.For parsing OS and arch names in .cabal files we really want everyone to be referring to the same or or arch by the same name. Variety is not a virtue in this case. We don't mind about case though.For the System.Info.os/arch different Haskell implementations use different names for the same or/arch. Also they tend to distinguish versions of an OS/arch which we just don't care about.The  classification allows us to recognise aliases that are already in common use but it allows us to distinguish them from the canonical name which enables us to warn about such deprecated aliases.4The platform Cabal was compiled on. In most cases, LocalBuildInfo.hostPlatform8 should be used instead (the platform we're targeting).5&&Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportable Safe-Inferred #The name of the benchmark being run,The result of the test suite being run, eg pass, fail, or error.$The name of the test suite being run+The executable name; used in shell wrappersThe CPU architecture name, eg i386 or x86_64The operating system name, eg windows or linux"The compiler name and version, eg  ghc-6.6.1The $pkgid package Id path variable, eg foo-1.0The $version package version path variableThe $pkg package name path variableThe $htmldir path variableThe $docdir path variableThe  $datasubdir path variableThe $datadir path variableThe  $libsubdir path variableThe $libdir path variableThe $bindir path variableThe $prefix path variable_An abstract path, possibly containing variables that need to be substituted for to get a real .The location prefix for the copy command. )The installation directories in terms of s that contain variables.The defaults for most of the directories are relative to each other, in particular they are all relative to a single prefix. This makes it convenient for the user to override the default installation directory by only having to specify --prefix=... rather than overriding each individually. This is done by allowing $-style variables in the dirs. These are expanded by textual substitution (see $).A few of these installation directories are split into two components, the dir and subdir. The full installation path is formed by combining the two together with /Y. The reason for this is compatibility with other Unix build systems which also support --libdir and  --datadir/. We would like users to be able to configure --libdir=/usr/lib64 for example but because by default we want to support installing multiple versions of packages and building the same package for multiple compilers we append the libsubdir to get: /usr/lib64/$pkgid/$compiler.{An additional complication is the need to support relocatable packages on systems which support such things, like Windows. 9The directories where we will install files for packages.We have several different directories for different types of files since many systems have conventions whereby different types of files in a package are installed in different directories. This is particularly the case on Unix style systems.5Substitute the install dir templates into each other.To prevent cyclic substitutions, only some variables are allowed in particular dir templates. If out of scope vars are present, they are not substituted for. Checking for any remaining unsubstituted vars can be done as a subsequent operation.-The reason it is done this way is so that in ! we can replace  with the  and get resulting s that still have the U in them. Doing this makes it each to check which paths are relative to the $prefix. Convert from abstract install directories to actual absolute ones by substituting for all the variables in the abstract paths, to get real absolute path.!BCheck which of the paths are relative to the installation $prefix.If any of the paths are not relative, ie they are absolute paths, then it prevents us from making a relocatable package (also known as a "prefix independent" package)." Convert a  to a  including any template vars.#7Convert back to a path, any remaining vars are included%=The initial environment has all the static stuff but no pathsF       !"# $%&'()   7      !"#$%&'()7      !"#$%('&)       !"# $%&'()   Isaac Jones 2003-2004BSD3libraries@haskell.orgportable Safe-Inferred+o+UAllow the user to write ambiguous types, and the type inference engine to infer them. \http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#ambiguity,9Enable explicit namespaces in module import/export lists. ]http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#explicit-namespaces-8Enables support for type classes with no type parameter. ghttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#nullary-type-classes.?Allows the use of floating literal syntax for all instances of  , including  and . Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#num-decimals/6Allows the use of binary integer literal syntax (e.g.  0b11001001 to denote 201). Yhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#binary-literals0;Desugars negative literals directly (without using negate). [http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#negative-literals1#Triggers the generation of derived : instances for every datatype and type class declaration. Zhttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#auto-derive-typeable2pEnables case expressions that have no alternatives. Also applies to lambda-case expressions if they are enabled. Thttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#empty-case3WEnable overloading of list literals, arithmetic sequences and list patterns using the IsList type class. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#overloaded-lists4+Enable explicit role annotations, like in ( data T a@R). Bhttp://www.haskell.org/ghc/docs/latest/html/users_guide/roles.html5Enable parallel arrays syntax ([:, :]) for Data Parallel Haskell. <http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell6Enable datatype promotion. Fhttp://www.haskell.org/ghc/docs/latest/html/users_guide/promotion.html7Enable kind polymorphism. Nhttp://www.haskell.org/ghc/docs/latest/html/users_guide/kind-polymorphism.html8Allow type classimplicit parameterbequality constraints to be used as types with the special kind constraint. Also generalise the  (ctxt => ty)H syntax so that any type of kind constraint can occur before the arrow. Lhttp://www.haskell.org/ghc/docs/latest/html/users_guide/constraint-kind.html9zCompile a module in the Unsafe, Safe Haskell mode so that modules compiled using Safe, Safe Haskell mode can't import it. Thttp://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-trust:Compile a module in the Trustworthy, Safe Haskell mode -- no restrictions apply but the module is marked as trusted as long as the package the module resides in is trusted. Thttp://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-trust;tCompile a module in the Safe, Safe Haskell mode -- a restricted form of the Haskell language to ensure type safety. Thttp://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-trust<Allow imports to be qualified with a safe keyword that requires the imported module be trusted as according to the Safe Haskell definition of trust. import safe Network.Socket Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/safe-haskell.html#safe-imports=&Enable non-decreasing indentation for do blocks. fhttp://www.haskell.org/ghc/docs/latest/html/users_guide/bugs-and-infelicities.html#infelicities-syntax>Enable deriving for the LM class. Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeable?Enable deriving for the NO class. Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeable@Enable deriving for the PQ class. Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeableALocal (let and where) bindings are monomorphic. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#mono-local-bindsB0Allow contexts to be put on datatypes, e.g. the Eq a in /data Eq a => Set a = NilSet | ConsSet a (Set a). chttp://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#datatype-contextsCMake forallN a keyword in types, which can be used to give the generalisation explicitly. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#explicit-forallsDqMakes much of the Haskell sugar be desugared into calls to the function with a particular name that is in scope. [http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#rebindable-syntaxEEnable support lambda-case expressions. Uhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#lambda-caseFEnable support for multi-way if -expressions. Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#multi-way-ifGImprove the layout rule when if expressions are used in a do block.H!Support for patterns of the form n + k, where k is an integer literal. Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#n-k-patternsIHAllows GHC primops, written in C--, to be imported into a Haskell file.J(Enables the use of tuple sections, e.g. (, True) desugars into x -> (x, True). Xhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#tuple-sectionsKAllow regular pattern matching over lists, as discussed in the paper "Regular Expression Patterns" by Niklas Broberg, Andreas Farre and Josef Svenningsson, from ICFP '04.LxAllow concrete XML syntax to be used in expressions and patterns, as per the Haskell Server Pages extension language:  &http://www.haskell.org/haskellwiki/HSP. The ideas behind it are discussed in the paper "Haskell Server Pages through Dynamic Loading" by Niklas Broberg, from Haskell Workshop '05.M]Enable view patterns, which match a value by applying a function and matching on the result. Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#view-patternsNcEnable monad comprehensions, which generalise the list comprehension syntax to work for any monad. ^http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#monad-comprehensionsO\Enable generalized list comprehensions, supporting operations such as sorting and grouping. ihttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#generalised-list-comprehensionsPcEnable quasi-quotation, a mechanism for defining new concrete syntax for expressions and patterns. _http://www.haskell.org/ghc/docs/latest/html/users_guide/template-haskell.html#th-quasiquotationQURelax the interpretation of left operator sections to allow unary postfix operators. [http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#postfix-operatorsR (deprecated)1 Change the syntax for qualified infix operators. ahttp://www.haskell.org/ghc/docs/6.12.3/html/users_guide/syntax-extns.html#new-qualified-operatorsS (deprecated)A Allow a type variable to be instantiated at a polymorphic type. mhttp://www.haskell.org/ghc/docs/6.12.3/html/users_guide/other-type-extensions.html#impredicative-polymorphismTcAllow imports to be qualified by the package name the module is intended to be imported from, e.g. import "network" Network.Socket Yhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#package-importsUVAllow a class method's type to place additional constraints on a class type variable. ehttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#class-method-typesV?Allow type signatures to be specified in instance declarations. `http://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-sigsW&Enable support for default signatures. khttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#class-default-signaturesXEnable deriving for RS and RT. Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeableYEnable deriving for classes  and UV. Whttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#deriving-typeableZEnable unboxed tuples. Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/primitives.html#unboxed-tuples[EAllow default instantiation of polymorphic types in more situations. jhttp://www.haskell.org/ghc/docs/latest/html/users_guide/interactive-evaluation.html#extended-default-rules\DRelax the requirements on mutually-recursive polymorphic functions. _http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#typing-binds]"Make pattern bindings monomorphic. Rhttp://www.haskell.org/ghc/docs/latest/html/users_guide/monomorphism.html#id630981^>Enable GADT syntax for declaring ordinary algebraic datatypes. \http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#gadt-style_{Enable generalized algebraic data types, in which type variables may be instantiated on a per-constructor basis. Implies ^. Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#gadt`VEnable overloading of string literals using a type class, much like integer literals. ehttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#overloaded-stringsa=Enable traditional record syntax (as supported by Haskell 98) chttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#traditional-record-syntaxbQAllow a record field name to be disambiguated by the type of the record it's in. ]http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#disambiguate-fieldscDeprecated, use s instead.dEnable syntax for implicitly binding local names corresponding to the field names of a record. A wildcard binds all unmentioned names, unlike s. Zhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#record-wildcardse\Allow the name of a type constructor, type class, or type variable to be an infix operator.f|Defer validity checking of types until after expanding type synonyms, relaxing the constraints on how synonyms may be used. _http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#type-synonymsg*Allow use of CAPI FFI calling convention (foreign import capi). Ihttp://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.html#ffi-capihEnable interruptible FFI. Rhttp://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.html#ffi-interruptiblei:Allow the use of unboxed types as foreign types, e.g. in foreign import and foreign export. Ihttp://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.html#id681687jpAllow certain Unicode characters to stand for certain ASCII character sequences, e.g. keywords and punctuation. Xhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#unicode-syntaxk=Allow a standalone declaration which invokes the type class deriving mechanism. Zhttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#stand-alone-derivinglcAllow data types and type synonyms which are indexed by types, i.e. ad-hoc polymorphism for types. Jhttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-families.htmlmAllow the character #W as a postfix modifier on identifiers. Also enables literal syntax for unboxed values. Thttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#magic-hashnHEnable an alternate syntax for string literals, with string templating. Ahttp://cvs.haskell.org/Hugs/pages/users_guide/here-documents.htmloEnable type synonyms which are transparent in some definitions and opaque elsewhere, as a way of implementing abstract datatypes. Fhttp://cvs.haskell.org/Hugs/pages/users_guide/restricted-synonyms.htmlp,Enable the "Trex" extensible records system. Ahttp://cvs.haskell.org/Hugs/pages/users_guide/hugs-only.html#TREXqAllow a type declared with newtype to use deriving9 for any class with an instance for the underlying type. Vhttp://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html#newtype-derivingrDEnable a form of guard which matches a pattern and binds variables. Xhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#pattern-guardssEnable syntax for implicitly binding local names corresponding to the field names of a record. Puns bind specific names, unlike d. Uhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#record-punst,Enable the implicit importing of the module Prelude. When disabled, when desugaring certain built-in syntax into ordinary identifiers, use whatever is in scope rather than the Prelude -- version. [http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#rebindable-syntaxu (deprecated)l Enable generic type classes, with default instances defined in terms of the algebraic structure of a type. Lhttp://www.haskell.org/ghc/docs/latest/html/users_guide/generic-classes.htmlvEnable arrow notation. Khttp://www.haskell.org/ghc/docs/latest/html/users_guide/arrow-notation.htmlwEnable the Foreign Function Interface. In GHC, implements the standard Haskell 98 Foreign Function Interface Addendum, plus some GHC-specific extensions. @http://www.haskell.org/ghc/docs/latest/html/users_guide/ffi.htmlxDEnable Template Haskell, a system for compile-time metaprogramming. Mhttp://www.haskell.org/ghc/docs/latest/html/users_guide/template-haskell.htmly&Allow type synonyms in instance heads. ihttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#flexible-instance-headzbEnable a form of pattern which forces evaluation before an attempted match, and a form of strict let/where binding. Jhttp://www.haskell.org/ghc/docs/latest/html/users_guide/bang-patterns.html{]Allow an explicit kind signature giving the kind of types over which a type variable ranges. Zhttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#kinding|.Run the C preprocessor on Haskell source code. [http://www.haskell.org/ghc/docs/latest/html/users_guide/options-phases.html#c-pre-processor}2Allow data type declarations with no constructors. _http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#nullary-types~ORelax some restrictions on the form of the context of an instance declaration. ahttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-rulesHRelax some restrictions on the form of the context of a type signature. dhttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#flexible-contexts7Enable implicit function parameters with dynamic scope. fhttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#implicit-parametersDeprecated, use  instead.=Cause a type variable in a signature, which has an explicit forallQ quantifier, to scope over the definition of the accompanying value declaration. hhttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#scoped-type-variables1Allow existentially-quantified data constructors. lhttp://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#existential-quantification@Allow data constructors to have polymorphic arguments. Unlike -, does not allow this for ordinary functions. khttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#universal-quantificationNAllow a universally-quantified type to occur on the left of a function arrow. khttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#universal-quantificationLike Y but does not allow a higher-rank type to itself appear on the left of a function arrow. khttp://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#universal-quantification$Allow a specification attached to a multi-parameter type class which indicates that some parameters are entirely determined by others. The implementation will check that this property holds for the declared instances, and will use this property to reduce ambiguity in instance resolution. jhttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#functional-dependencies,Enable the dreaded monomorphism restriction. Ihttp://www.haskell.org/ghc/docs/latest/html/users_guide/monomorphism.html*Allow multiple parameters in a type class. khttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#multi-param-type-classesdProvide syntax for writing list comprehensions which iterate over several lists together, like the  family of functions. fhttp://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#parallel-list-comprehensions Allows recursive bindings using mdo, a variant of do. DoRec( provides a different, preferred syntax. _http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#recursive-do-notation (deprecated) Allows recursive bindings in do blocks, using the rec keyword. See also .Implies . Allow the implementation to choose an instance even when it is possible that further instantiation of types will lead to a more specific instance being applicable. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-overlapIgnore structural rules guaranteeing the termination of class instance resolution. Termination is guaranteed by a fixed-depth recursion stack, and compilation may fail if this depth is exceeded. hhttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#undecidable-instancescAllow overlapping class instances, provided there is a unique most specific instance for each use. chttp://www.haskell.org/ghc/docs/latest/html/users_guide/type-class-extensions.html#instance-overlap2This represents language extensions beyond a base  definition (such as L) that are supported by some implementations, usually in some special mode.VWhere applicable, references are given to an implementation's official documentation.4An unknown extension, identified by the name of its LANGUAGE pragma.Disable a known extensionEnable a known extension+This represents a Haskell language dialect. Language ;s are interpreted relative to one of these base languages.,An unknown language, identified by its name.BThe Haskell 2010 language as defined by the Haskell 2010 report. /http://www.haskell.org/onlinereport/haskell2010>The Haskell 98 language as defined by the Haskell 98 report. http://haskell.org/onlinereport/_Extensions that have been deprecated, possibly paired with another extension that replaces it. for *s is really really slow so for the Text instance what we do is make a simple table indexed off the first letter in the extension name. The extension names actually cover the range 'A'-'Z'q pretty densely and the biggest bucket is 7 so it's not too bad. We just do a linear search within each bucket.This gives an order of magnitude improvement in parsing speed, and it'll also allow us to do case insensitive matches in future if we prefer.x*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ q*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~q*~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+ *e~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+ Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportable Safe-Inferred+W?A boolean expression parameterized over the variable type used.A ConfVar# represents the variable type used.A " is a total or partial mapping of s to !j flag values. It represents the flags chosen by the user or discovered during configuration. For example --flags=foo --flags=-bar becomes [("foo", True), ("bar", False)]A 1 is the name of a user-defined configuration flagA flag can represent a feature to be included, or a way of linking a target against its dependencies, or in fact whatever you can think of.IAn enumeration of common source control systems. The fields used in the n depend on the type of repo. The tools and methods used to obtain and track the repo depend on the repo type./What this repo info is for, what it represents.The repository containing the sources for this exact package version or release. For this kind of repo a tag should be given to give enough information to re-create the exact sources.The repository for the "head" or development version of the project. This repo is where we should track the latest development activity or the usual repo people should get to contribute patches.CInformation about the source revision control system for a package.When specifying a repo it is useful to know the meaning or intention of the information as doing so enables automation. There are two obvious common purposes: one is to find the repo for the latest development version, the other is to find the repo for this specific release. The ReopKind6 specifies which one we mean (or another custom one).A package can specify one or the other kind or both. Most will specify just a head repo but some may want to specify a repo to reconstruct the sources for this package release. The required information is the  which tells us if it's using ,  for example. The ? and other details are interpreted according to the repo type.)The kind of repo. This field is required.;The type of the source repository system for this repo, eg  or . This field is required.)The location of the repository. For most )s this is a URL. This field is required. can put multiple "modules" on one server and requires a module name in addition to the location to identify a particular repo. Logically this is part of the location but unfortunately has to be specified separately. This field is required for the  $ and should not be given otherwise.The name or identifier of the branch, if any. Many source control systems have the notion of multiple branches in a repo that exist in the same location. For example  and  use this while systems like  use different locations for different branches. This field is optional but should be used if necessary to identify the sources, especially for the  repo kind.UThe tag identify a particular state of the repository. This should be given for the  repo kind and not for  kind.Some repositories contain multiple projects in different subdirectories This field specifies the subdirectory where this packages sources can be found, eg the subdirectory containing the .cabal file. It is interpreted relative to the root of the repository. This field is optional. If not given the default is "." ie no subdirectory.component is buildable heretools needed to build this bit'options for pre-processing Haskell codeoptions for C compileroptions for linker!pkg-config packages that are usedsupport frameworks for Mac OS X.where to look for the Haskell module hierarchynon-exposed or non-main modules+language used when not explicitly specified'other languages used within the package'language extensions used by all modules1other language extensions used within the package*the old extensions field, treated same as Kwhat libraries to link with when compiling a program that uses your packagedirectories to find .h files'The .h files to be found in includeDirs$.h files to install with the package@Custom fields starting with x-, stored in a simple assoc-list.7Dependencies specific to a library or executable target3The "benchmark-type" field in the benchmark stanza.,Some unknown benchmark type e.g. "type: foo""type: exitcode-stdio-x.y"nThe benchmark interfaces that are currently defined. Each benchmark must specify which interface it supports.ZMore interfaces may be defined in future, either new revisions or totally new interfaces.uA benchmark that does not conform to one of the above interfaces for the given reason (e.g. unknown benchmark type).Benchmark interface "exitcode-stdio-1.0". The benchmark takes the form of an executable. It returns a zero exit code for success, non-zero for failure. The stdout and stderr channels may be logged. It takes no command line parameters and nothing on stdin.%A "benchmark" stanza in a cabal file./The "test-type" field in the test suite stanza.'Some unknown test type e.g. "type: foo""type: detailed-x.y""type: exitcode-stdio-x.y"pThe test suite interfaces that are currently defined. Each test suite must specify which interface it supports.ZMore interfaces may be defined in future, either new revisions or totally new interfaces.qA test suite that does not conform to one of the above interfaces for the given reason (e.g. unknown test type).Test interface "detailed-0.9". The test-suite takes the form of a library containing a designated module that exports "tests :: [Test]".Test interface "exitcode-stdio-1.0". The test-suite takes the form of an executable. It returns a zero exit code for success, non-zero for failure. The stdout and stderr channels may be logged. It takes no command line parameters and nothing on stdin.&A "test-suite" stanza in a cabal file.$Is the lib to be exposed by default?.The type of build system used by this package.a package that uses an unknown build type cannot actually be built. Doing it this way rather than just giving a parse error means we get better error messages and allows you to inspect the rest of the package description.uses user-supplied Setup.hs or  Setup.lhs (default)calls Distribution.Make.defaultMaincalls 9Distribution.Simple.defaultMainWithHooks defaultUserHooks, which invokes  configure@ to generate additional build information used by later phases.calls Distribution.Simple.defaultMain:This data type is the internal representation of the file  pkg.cabal. It contains two kinds of information about the package: information which is needed for all packages, such as the package name and version, and information which is needed for the simple build system only, such as the compiler options and library name.'"A one-line summary of this package(*A more verbose description of this package*@Custom fields starting with x-, stored in a simple assoc-list.,The version of the Cabal spec that this package description uses. For historical reasons this is specified with a version range but only ranges of the form >= vf make sense. We are in the process of transitioning to specifying just a single version, not a range.7OThe version of the Cabal spec that this package should be interpreted against.Historically we used a version range but we are switching to using a single version. Currently we accept either. This function converts into a single version by ignoring upper bounds in the version range.8UThe range of versions of the Cabal tools that this package is intended to work with.This function is deprecated and should not be used for new purposes, only to support old packages that rely on the old interpretation.<%does this package have any libraries?"# version of <=tIf the package description has a library section, call the given function with the library build info as argument.>HGet all the module names from the library (exposed and internal modules)@'does this package have any executables?A%Perform the action on each buildable   in the package description.B$Get all the module names from an exeD'Does this package have any test suites?E/Get all the enabled test suites from a package.F$Perform an action on each buildable  in a package.G+Get all the module names from a test suite.K&Does this package have any benchmarks?L.Get all the enabled benchmarks from a package.M$Perform an action on each buildable  in a package.N*Get all the module names from a benchmark.RThe  for the library (if there is one and it's buildable), and all buildable executables, test suites and benchmarks. Useful for gathering dependencies.SThe s used by this componentTThe +s that are used somewhere by this componentUThe  Extensions/ that are used by all modules in this componentW1Select options for a particular Haskell compiler.      !"#$%&'()*+,-./0123456789:;<"=>?@ABCDEFGH$IJKLMNOPQRSTUVWX%&'(Y)*+,-./0123456      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY !"#$%&'()*+,-./0123456978:;=<>     ?A@BIHCDFGEPOJKMNLQRSTUWVYXM       !"#$%&'()*+,-./0123456789:;<"=>?@ABCDEFGH$IJKLMNOPQRSTUVWX%&'(Y)*+,-./0123456Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportable Safe-Inferred [Some compilers support optimising. Some have different levels. For compliers that do not the level is just capped to the level they do support._We typically get packages from several databases, and stack them together. This type lets us be explicit about that stacking. For example typical stacks include: n[GlobalPackageDB] [GlobalPackageDB, UserPackageDB] [GlobalPackageDB, SpecificPackageDB "package.conf.inplace"]Note that the ck is invariably at the bottom since it contains the rts, base and other special compiler-specific packages.We are not restricted to using just the above combinations. In particular we can use several custom package dbs and the user package db together.>When it comes to writing, the top most (last) package is used.`rSome compilers have a notion of a database of available packages. For some there is just one global db of packages, other compilers support a per-user or an arbitrary db specified at some location in the file system. This can be used to build isloated environments of packages, for example to build a collection of related packages without installing them globally.fCompiler flavour and version.gSupported language standards.hSupported extensions.i?A key-value map for properties not covered by the above fields.maReturn the package that we should register into. This is the package db at the top of the stack.nMake package paths absolutesBFor the given compiler, return the extensions it does not support.tFFor the given compiler, return the flags for the supported extensions.u0Does this compiler support parallel --make mode?Z[\]^_`abcdefghijklmnopqr7st8u.Z[\]^_`abcdefghijklmnopqrstudefghijkl`cba_mno[^]\pZrqtsuZ[^]\_`cbadefghijklmnopqr7st8uJose Iborra 2008BSD3cabal-devel@haskell.orgportable Safe-Inferredv"Parser with simple error reporting 9vwxyz{|}:vwxyz{|}vwxyz{|}9vwxyz{|}:Ian Lynagh 2007BSD3cabal-devel@haskell.orgportable Safe-Inferred~;<=> ~ ~ ~>=<; Safe-InferredW Safe-Inferred?@ABCDEFG?D?@ABCDEXNoneH:Copies a file to a new destination. Often you should use I instead.ILike H, but does not touch the target if source and destination are already byte-identical. This is recommended as it is useful for time-stamp based recompilation avoidance.J[Checks if two files are byte-identical. Returns False if either of the files do not exist. KLMNHIJKLNHIJ KLMNHIJ#Isaac Jones, Simon Marlow 2003-2004=BSD3 portions Copyright (c) 2007, Galois Inc.cabal-devel@haskell.orgportableNone 9Advanced options for  and .Keep temporary files?dir prefix and extension, like "foo/bar/*.baz" corresponds to FileGlob "foo/bar" ".baz"%No glob at all, just an ordinary fileCNon fatal conditions that may be indicative of an error or problem.We display these at the  verbosity level.Useful status messages.We display these at the  verbosity level.This is for the ordinary helpful status messages that users see. Just enough information to know that things are working but not floods of detail.,More detail on the operation of some action.6We display these messages when the verbosity level is 'Detailed internal debugging information6We display these messages when the verbosity level is  A variant of Y that doesn't perform the automatic line wrapping. Produces better output in some cases.XPerform an IO action, catching any IO exceptions and printing an error if one occurs.FWraps text to the default line width. Existing newlines are preserved.HWraps a list of words to a list of lines of words of a particular width.$Run a command and return its output.8The output is assumed to be text in the locale encoding.Run a command and return its output, errors and exit status. Optionally also supply some input. Also provides control over whether the binary/text mode of the input and output.Look for a program on the path.Look for a program and try to find it's version number. It can accept either an absolute path or the name of a program binary, in which case we will look for the program on the path.Like the Unix xargs program. Useful for when we've got very long command lines that might overflow an OS limit on command line length and so you need to invoke a command multiple times to get all the args in.@Use it with either of the rawSystem variants above. For example: @xargs (32*1024) (rawSystemExit verbosity) prog fixedArgs bigArgsJFind a file by looking in a search path. The file path must match exactly.Find a file by looking in a search path with one of a list of possible file extensions. The file base name should be given and it will be tried with each of the extensions in each element of the search path.Like x but returns which element of the search path the file was found in, and the file path relative to that base directory.@Finds the files corresponding to a list of Haskell module names.As  but for a list of module names.5Find the file corresponding to a Haskell module name.This is similar to j but specialised to a module name. The function fails if the file corresponding to the module is missing.9List all the files in a directory and all subdirectories.The order places files in sub-directories after all the files in their parent directories. The list is generated lazily so is not well defined if the source directory structure changes before the list is used.,Is this directory in the system search path?(Compare the modification times of two files to see if the first is newer than the second. The first file must exist but the second need not. The expected use case is when the second file is generated using the first. In this use case, if the result is True then the second file is out of date.Like -, but also checks that the first file exists.Same as createDirectoryIfMissing% but logs at higher verbosity levels.Copies a file without copying file permissions. The target file is created with default permissions. Any existing target file is replaced.3At higher verbosity levels it logs an info message.Install an ordinary file. This is like a file copy but the permissions are set appropriately for an installed file. On Unix it is "-rw-r--r--" while on Windows it uses the default permissions for the target directory.Install an executable file. This is like a file copy but the permissions are set appropriately for an installed file. On Unix it is "-rwxr-xr-x" while on Windows it uses the default permissions for the target directory.EInstall a file that may or not be executable, preserving permissions.Given a relative path to a file, copy it to the given directory, preserving the relative path and creating the parent directories if needed.OCommon implementation of , ,  and .Copies a bunch of files to a target directory, preserving the directory structure in the target location. The target directories are created if they do not exist.The files are identified by a pair of base directory and a path relative to that base. It is only the relative part that is preserved in the destination. For example: RcopyFiles normal "dist/src" [("", "src/Foo.hs"), ("dist/build/", "src/Bar.hs")]qThis would copy "src/Foo.hs" to "dist/src/src/Foo.hs" and copy "dist/build/src/Bar.hs" to "dist/src/src/Bar.hs".This operation is not atomic. Any IO failure during the copy (including any missing source files) leaves the target in an unknown state so it is best to use it with a freshly created directory so that it can be simply deleted if anything goes wrong. This is like  but uses . This is like  but uses . This is like  but uses .This installs all the files in a directory to a target location, preserving the directory layout. All the files are assumed to be ordinary rather than executable files.Like P., but also checks that the file is executable.4Use a temporary filename that doesn't already exist. A version of  that additionally takes a  argument.%Create and use a temporary directory.Creates a new temporary directory inside the given directory, making use of the template. The temp directory is deleted after use. For example: >withTempDirectory verbosity "src" "sdist." $ \tmpDir -> do ...The tmpDir: will be a new subdirectory of the given directory, e.g.  src/sdist.342. A version of  that additionally takes a  argument.?Gets the contents of a file, but guarantee that it gets closed.The file is read lazily but if it is not fully consumed by the action then the remaining input is truncated and the file is closed.Writes a file atomically.mThe file is either written sucessfully or an IO exception is raised and the original file is left unchanged.On windows it is not possible to delete a file that is open by a process. This case will give an IO exception but the atomic property is not affected.Write a file but only if it would have new content. If we would be writing the same as the existing content then leave the file as is so that we do not update the file's modification time.,NB: the file is assumed to be ASCII-encoded.DThe path name that represents the current directory. In Unix, it's "."D, but this is system-specific. (E.g. AmigaOS uses the empty string "" for the current directory.)Package description file (pkgname.cabal)DFind a package description file in the given directory. Looks for .cabal files.Like  , but calls  in case of error.-Optional auxiliary package information file (pkgname .buildinfo)FFind auxiliary package information in the given directory. Looks for  .buildinfo files.QDIgnore a Unicode byte order mark (BOM) at the beginning of the input2Reads a UTF8 encoded text file as a Unicode StringReads lazily using ordinary R.2Reads a UTF8 encoded text file as a Unicode StringSame behaviour as .4Writes a Unicode String as a UTF8 encoded text file.Uses ", so provides the same guarantees.3Fix different systems silly line ending conventionsX.a description of the action we were attemptingthe action itselfSTUNew working dir or inheritNew environment or inheritstdinstdoutstderrProgram location ArgumentsNew working dir or inheritNew environment or inheritinput text and binary modeoutput in binary modeoutput, errors, exit version args8function to select version number from program outputlocationsearch locations File Name"build prefix (location of objects)search suffixesmodules"build prefix (location of objects)search suffixesmoduleCreate its parents too?VOTemp dir to create the file inFile name template. See G.Temp dir to create the file inFile name template. See G. Where to look pkgname.cabalDirectory to searchdir/pkgname .buildinfo , if presentWQTTTSTUVOWQY"(c) The University of Glasgow 2004BSD3cabal-devel@haskell.orgportableNoneXWe parse generically based on indent level and braces '{' '}'. To do that we split into lines and then '{' '}' tokens and other spans within a line.Y"span in a line, following bracketsZThe Z token is for bits that start a line, eg: "\n blah blah { blah" tokenises to: 8[Line n 2 False "blah blah", OpenBracket, Span n "blah"]cso lines are the only ones that can have nested layout, since they have a known indentation level.eg: we can't have this: if ... { } else otherubecause other cannot nest under else, since else doesn't start a line so cannot have nested layout. It'd have to be: if ... { } else other]but that's not so common, people would normally use layout or brackets not both in a single if else construct. "if ... { foo : bar } else other this is OK[1A conditional block with an optional else branch:  if  condition {  field* } else {  field* } \KA section with a name and possible parameter. The syntactic structure is:   sectionname  arg {  field* } ] A regular  property: value field^4The type of a function which, given a name-value pair of an unrecognized field, and the current structure being built, decides whether to incorporate the unrecognized field (by returning Just x, where x is a possibly modified version of the structure being built), or not (by returning Nothing).!Field descriptor. The parameter a< parameterizes over where the field's value is stored in.fieldSet n str x5 Parses the field value from the given input string str and stores the result in xK if the parse was successful. Otherwise, reports an error on line number n._A default unrecognized field parser which simply returns Nothing, i.e. ignores all unrecognized fields, so warnings will be generated.`A default unrecognized field parser which silently (i.e. no warnings will be generated) ignores unrecognized fields, by returning the structure being built unmodified.aTokenise a single line, splitting on '{' '}' and the spans in between. Also trims leading & trailing space on those spans within the line.bHParse the stream of tokens into a tree of them, based on indent / layoutcParse the stream of tokens into a tree of them, based on indent This parse state expect to be in a layout context, though possibly nested within a braces context so we may still encounter closing braces.d}Parse the stream of tokens into a tree of them, based on explicit braces This parse state expects to find a closing bracket.e\Convert the parse tree into the Field AST Also check for dodgy uses of tabs in indentation.f Convert ifthenelse \s to [sgparse a module namehPretty-print free-format text, ensuring that it is vertically aligned, and with blank lines replaced by dots for correct re-parsing.iir breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines.j(the indentation used for pretty printinglklmXnoYZp[\]^qrstuvwxyz{|}~_`abc(indent level of the parent/previous line'accumulating param, trees in this levelremaining tokens1collected trees on this level and trailing tokensd(line of the '{', used for error messages'accumulating param, trees in this levelremaining tokens1collected trees on this level and trailing tokensefg'The parser for the stuff between commas'The parser for the stuff between commas'The parser for the stuff between commas'The parser for the stuff between commashijMp[\]^qrtuvwxz{}~_`ghjYklmXZYonp]\[^rqstuvwxyz{|}~_`abcdefghij"(c) The University of Glasgow 2004libraries@haskell.orgportableNone,     1     1            Z"(c) The University of Glasgow 2004BSD3cabal-devel@haskell.orgportableNoneBThis is the InstalledPackageInfo type used by ghc-6.4.2 and later.It's here purely for the  instance so that we can read the package database used by those ghc versions. It is a little hacky to read the package db directly, but we do need the info and until ghc-6.9 there was no better method.@In ghc-6.4.1 and before the format was slightly different. See Distribution.Simple.GHC.IPI642/["(c) The University of Glasgow 2004BSD3cabal-devel@haskell.orgportableNone@This is the InstalledPackageInfo type used by ghc-6.4 and 6.4.1.It's here purely for the  instance so that we can read the package database used by those ghc versions. It is a little hacky to read the package db directly, but we do need the info and until ghc-6.9 there was no better method.+In ghc-6.4.2 the format changed a bit. See Distribution.Simple.GHC.IPI642Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone(Common flags that apply to every command Long command line option strings !Short command line option strings!aAn OptionField takes one or more OptDescrs, describing the command line interface for the field.&LWe usually have a data type for storing configuration values, where every field stores a configuration option, and the user sets the value either via command line flags or a configuration file. An individual OptionField models such a field, and we usually build a list of options associated to a configuration data type.1QThe name of the command as it would be entered on the command line. For example "build".2BA short, one line description of the command to use in help texts.3IA function that maps a program name to a usage summary for this command.4;Additional explanation of the command to use in help texts.5Initial / empty flags6&All the Option fields for this command7zCreate an option taking a single OptDescr. No explicit Name is given for the Option, the name is the first LFlag given.8Create an option taking several OptDescrs. You will have to give the flags and description individually to the OptDescr constructor.9.Create a string-valued command line interface.:CCreate a string-valued command line interface with a default value.;!(String -> a) variant of "reqArg"<!(String -> a) variant of "optArg"@create a Choice optionAcreate a Choice option out of an enumeration type. As long flags, the Show output is used. As short flags, the first character which does not conflict with a previous one is used.Buto view as a FieldDescr, we sort the list of interfaces (Req > Bool > Choice > Opt) and consider only the first one.D:Show flags in the standard long option command line format DThe help text for this command with descriptions of all the options.EMake a Command from standard GetOpt options.F'Parse a bunch of command line argumentsGjMark command as hidden. Hidden commands don't show up in the 'progname help' or 'progname --help' output.JUtility function, many commands do not accept additional flags. This action fails with a helpful error message if the user supplies any extra.G     !"#$%&'()*+,-./012345678DMkOptDescr constructors partially applied to flags and description.9:;<=>?@ABCD Enameshort descriptionlong descriptioninitial/empty flagsoptionsF&Is the command a global or subcommand?GHIJ5 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJ5/0123456DF,.-EGHJI&'()+78CB!%$#"* 9;:<=>?@A.     !%$#"&'()*+,.-/0123456789:;<=>?@ABCD EFGHIJThomas Schilling, 2007BSD3cabal-devel@haskell.orgportableNone 0A set of targets with their package dependenciestA map of dependencies. Newtyped since the default monoid instance is not appropriate. The monoid instance uses .)Result of dependency test. Isomorphic to Maybe d but renamed for clarity.5Simplify the condition and return its free variables.Simplify a configuration condition using the OS and arch names. Returns the names of all the flags occurring in the condition.K.Parse a configuration condition from a string.JTry to find a flag assignment that satisfies the constraints of all trees.Returns either the missing dependencies, or a tuple containing the resulting data, the associated dependencies, and the chosen flag assignments.In case of failure, the _smallest_ number of of missing dependencies is returned. [TODO: Could also be specified with a function argument.]LTODO: The current algorithm is rather naive. A better approach would be to:IRule out possible paths, by taking a look at the associated dependencies.Infer the required values for the conditions of these paths, and calculate the required domains for the variables used in these conditions. Then picking a flag assignment would be linear (I guess).iThis would require some sort of SAT solving, though, thus it's not implemented unless we really need it. Flatten a CondTree. This will resolve the CondTree by taking all possible paths into account. Note that since branches represent exclusive choices this may not result in a "sane" result.!mCombine the target-specific dependencies in a TargetSet to give the dependencies for the package as a whole."\Collect up the targets in a TargetSet of tagged targets, storing the dependencies as we go.Q>Create a package description with all configurations resolved.This function takes a ; and several environment parameters and tries to generate G by finding a flag assignment that result in satisfiable dependencies.&It takes as inputs a not necessarily complete specifications of flags assignments, an optional package index as well as platform parameters. If some flags are not assigned explicitly, this function will try to pick an assignment that causes this function to succeed. The package index is optional since on some platforms we cannot determine which packages have been installed before. When no package index is supplied, every dependency is assumed to be satisfiable, therefore all not explicitly assigned flags will get their default values.This function will fail if it cannot find a flag assignment that leads to satisfiable dependencies. (It will not try alternative assignments for explicitly specified flags.) In case of failure it will return a minimum number of dependencies that could not be satisfied. On success, it will return the package description and the full flag assignment chosen.RhFlatten a generic package description by ignoring all conditions and just join the field descriptors into on package description. Note, however, that this may lead to inconsistent field values, since all values are joined into one field, which may not be possible in the original package description, due to the use of exclusive choices (if ... else ...).TODO: One particularly tricky case is defaulting. In the original package description, e.g., the source directory might either be the default or a certain, explicitly set path. Since defaults are filled in only after the package has been resolved and when no explicit value has been set, the default path will be missing from the package description returned by this function.+#$%&'()*+,-./0(partial) variable assignmentKLMNO3Domain for each flag name, will be tested in order.-OS as returned by Distribution.System.buildOS1Arch as returned by Distribution.System.buildArchCompiler flavour + versionAdditional constraintsDependency test function.}Either the missing dependencies (error case), or a pair of (set of build targets with dependencies, chosen flag assignments)123 P!4 Input mapExtra constraints"Q%Explicitly specified flag assignmentsjIs a given dependency satisfiable from the set of available packages? If this is unknown then use True.The  and Compiler + VersionAdditional constraintshEither missing dependencies or the resolved package description along with the flag assignments chosen.R56789:;<KLMNOPQRQRKPLONM#('&%$)*+,.-0/KLMNO123 P!4"QR56789:;<Lennart Kolmodin 2008BSD3cabal-devel@haskell.orgportableNoneSJA record of operations needed to check the contents of packages. Used by `.W-Results of some kind of failed package check.There are a range of severities, from merely dubious to totally insane. All of them come with a human readable explanation. In future we may augment them with more machine readable explanations, for example to help an IDE suggest automatic corrections.XAn issue that is OK in the author's environment but is almost certain to be a portability problem for other environments. We can quite legitimately refuse to publicly distribute packages with these problems.Y$An issue that might not be a problem for the package author but might be annoying or detrimental when the package is distributed to users. We should encourage distributed packages to be free from these issues, but occasionally there are justifiable reasons so we cannot ban them entirely.ZA problem that is likely to affect building the package, or an issue that we'd like every package author to be aware of, even if the package is never distributed.[This package description is no good. There's no way it's going to build sensibly. This should give an error at configure time.]?Check for common mistakes and problems in package descriptions.This is the standard collection of checks covering all aspects except for checks that require looking at files within the package. For those see _.It requires the I and optionally a particular configuration of that package. If you pass @ then we just check a version of the generic description using R.=,Check that this package description is sane.>3Check that the package declares the version in the "cabal-version" field correctly.?A variation on the normal Text instance, shows any ()'s in the original textual syntax. We need to show these otherwise it's confusing to users when we complain of their presence but do not pretty print them!@ACheck the build-depends fields for any weirdness or bad practise._Sanity check things that requires IO. It looks at the files in the package and expects to find the package unpacked in at the given file path.`eSanity check things that requires looking at files in the package. This is a generalised version of _7 that can work in any monad for which you can provide S operations.zThe point of this extra generality is to allow doing checks in some virtual file system, for example a tarball in memory.aCheck the names of all files in a package for portability problems. This should be done for example when creating or validating a package tarball.A=Check a file name is valid for the portable POSIX tar format.vThe POSIX tar format has a restriction on the length of file names. It is unfortunately not a simple restriction like a maximum length. The exact restriction is that either the whole path be 100 characters or less, or it be possible to split the path on a directory separator such that the first part is 155 characters or less and the second part 100 characters or less.0STUVWXYZ[\BC]^=DEFGHIJKLMNO>?P@Q_`RSTUVWaXAYZ[\]STUVWXYZ[\]^_`aW[ZYX\\\\]^_`STUVa(STUVW[ZYX\\\\BC]^=DEFGHIJKLMNO>?P@Q_`RSTUVWaXAYZ[\]Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone^sAn intermediate type just used for parsing the benchmark stanza. After validation it is converted into the proper  type._tAn intermediate type just used for parsing the test-suite stanza. After validation it is converted into the proper  type.`Store any fields beginning with "x-" in the customFields field of a PackageDescription. All other fields will generate a warning.a`Given a parser and a filename, return the parse of the file, after checking if the file exists.jParse the given package file.kParses the given file into a .In Cabal 1.2 the syntax for package descriptions was changed to a format with sections and possibly indented property descriptions.bParse a list of fields, given a list of field descriptions, a structure to accumulate the parsed fields, and a function that can decide what to do with fields which don't match any of the field descriptions.Dcdef^ghijk_lmnopb`cqdrsetuvwxyfzghaij{|}~kb.descriptions of fields we know how to parse1possibly do something with unrecognized fields accumulatorfields to be parsedlist of parseable fields1possibly do something with unrecognized fieldsaccumulated result and warningsthe field to be parsedlmnopbcdefghijklmnopjmknilopbcdfheg8cdef^ghijk_lmnopb`cqdrsetuvwxyfzghaij{|}~kblmnopNone+Recompile with false for regression testingq7Writes a .cabal file from a generic package descriptionr0Writes a generic package description to a stringqrqrqrqrp(c) David Himmelstrup 2005, Bjorn Bringert 2007, Duncan Coutts 2008-2009cabal-devel@haskell.orgportableNonew>The collection of information about packages from one or more  PackageDBs.-Packages are uniquely identified in by their Q, they can also be efficiently looked up by package name or by name and version.x*Build an index out of a bunch of packages.If there are duplicates by $ then later ones mask earlier ones.yMerge two indexes.SPackages from the second mask packages from the first if they have the exact same ."For packages with the same source , packages from the second are "preferred" over those from the first. Being preferred means they are top result when we do a lookup by source M. This is the mechanism we use to prefer user packages over global packages.z(Inserts a single package into the index.8This is equivalent to (but slightly quicker than) using  or y with a singleton index.{2Removes a single installed package from the index.|&Removes all packages with this source  from the index.}DRemoves all packages with this (case-sensitive) name from the index.~$Get all the packages from the index.$Get all the packages from the index.4They are grouped by package name (case-sensitively).$Get all the packages from the index.AThey are grouped by source package id (package name and version).4Does a lookup by source package id (name & version)..Since multiple package DBs mask each other by (, then we get back at most one package.4Does a lookup by source package id (name & version).>There can be multiple installed packages with the same source  but different K. They are returned in order of preference, with the most preferred first.%Does a lookup by source package name.=Does a lookup by source package name and a range of versions.oWe get back any number of versions of the specified package name, all satisfying the version range constraint./Does a case-insensitive search by package name.If there is only one package that compares case-insensitively to this name then the search is unambiguous and we get back all versions of that package. If several match case-insensitively but one matches exactly then it is also unambiguous. If however several match case-insensitively and none match exactly then we have an ambiguous result, and we get back all the versions of all the packages. The list of ambiguous results is split by exact package name. So it is a non-empty list of non-empty lists.9Does a case-insensitive substring search by package name.BThat is, all packages that contain the given string in their name.\Find if there are any cycles in the dependency graph. If there are no cycles the result is [].This actually computes the strongly connected components. So it gives us a list of groups of packages where within each group they all depend on each other, directly or indirectly.HAll packages that have immediate dependencies that are not in the index.GReturns such packages along with the dependencies that they're missing.ATries to take the transitive closure of the package dependencies.If the transitive closure is complete then it returns that subset of the index. Otherwise it returns the broken packages as in .Note that if the result is Right []3 it is because at least one of the original given s do not occur in the index.BTakes the transitive closure of the packages reverse dependencies. The given s must be in the index.+Builds a graph of the package dependencies.Dependencies on other packages that are not in the index are discarded. You can check if there are any such dependencies with .LGiven a package index where we assume we want to use all the packages (use  if you need to get such a index subset) find out if the dependencies within it use consistent versions of each package. Return all cases where multiple packages depend on different versions of some other package.Each element in the result is a package name along with the packages that depend on it and the versions they require. These are guaranteed to be distinct.!stuvwxyz{|}~stuvwxyz{|}~wxyz{|}svut~svutwxyz{|}~\ Safe-InferredDuncan Coutts 2013cabal-devel@haskell.orgportableNoneThe system defaultA specific dirOA search path to use when locating executables. This is analogous to the unix $PATH or win32 %PATH%Q but with the ability to use the system default method for finding executables () which on unix is simply looking on the $PATH* but on win32 is a bit more complicated).The default to use is [ProgSearchPathDefault] but you can add extra dirs either before, after or instead of the default, e.g. here we add an extra dir to search after the usual ones. 8['ProgramSearchPathDefault', 'ProgramSearchPathDir' dir] Interpret a  to construct a new $PATHx env var. Note that this is close but not perfect because on Windows the search algorithm looks at more than just the %PATH%.)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNoneWhere a program was found. Also tells us whether it's specified by user or not. This includes not just the path, but the program as well.$The program was found automatically.HThe user gave the path to this program, eg. --ghc-path=/usr/bin/ghc-6.6KRepresents a program which has been configured and is thus ready to be run.(These are usually made by configuring a =, but if you have to construct one directly then start with  and override any extra fields.Just the name again,The version of this program, if it is known.Default command-line args for this program. These flags will appear first on the command line, so they can be overridden by subsequent flags.Override command-line args for this program. These flags will appear last on the command line, so they override all earlier flags.Override environment variables for this program. These env vars will extend/override the prevailing environment of the current to form the environment for the new process.Location of the program. eg. /usr/bin/ghc-6.4-Represents a program which can be configured.9Note: rather than constructing this directly, start with  and override any extra fields.'The simple name of the program, eg. ghczA function to search for the program if its location was not specified by the user. Usually this will just be a call to .It is supplied with the prevailing search path which will typically just be used as-is, but can be extended or ignored as needed.Try to find the version of the program. For many programs this is not possible or is not necessary so it's OK to return Nothing.A function to do any additional configuration after we have located the program (and perhaps identified its version). For example it could add args, or environment vars.&The full path of a configured program./Suppress any extra arguments added by the user.Make a simple named program.By default we'll just search for it in the path and not try to find the version name. You can override these behaviours if necessary, eg: JsimpleProgram "foo" { programFindLocation = ... , programFindVersion ... }Make a simple . 2simpleConfiguredProgram "foo" (FoundOnSystem path)Duncan Coutts 2009cabal-devel@haskell.orgportableNone7Represents a specific invocation of a specific program.This is used as an intermediate type between deciding how to call a program and actually doing it. This provides the opportunity to the caller to adjust how the program will be called. These invocations can either be run directly or turned into shell or batch scripts.AReturn the current environment extended with the given overrides.Like the unix xargs program. Useful for when we've got very long command lines that might overflow an OS limit on command line length and so you need to invoke a command multiple times to get all the args in.It takes four template invocations corresponding to the simple, initial, middle and last invocations. If the number of args given is small enough that we can get away with just a single invocation then the simple one is used:  $ simple argsIf the number of args given means that we need to use multiple invocations then the templates for the initial, middle and last invocations are used: I$ initial args_0 $ middle args_1 $ middle args_2 ... $ final args_n Duncan Coutts 2009, 2013cabal-devel@haskell.orgportableNone Call hc-pkg9 to initialise a package database at the location {path}. hc-pkg init {path}Run hc-pkg` using a given package DB stack, directly forwarding the provided command-line arguments to it.Call hc-pkg to register a package. Ahc-pkg register {filename | -} [--user | --global | --package-db]Call hc-pkg to re-register a package. Ahc-pkg register {filename | -} [--user | --global | --package-db]Call hc-pkg to unregister a package <hc-pkg unregister [pkgid] [--user | --global | --package-db]Call hc-pkg to expose a package. 8hc-pkg expose [pkgid] [--user | --global | --package-db]Call hc-pkg to expose a package. 8hc-pkg expose [pkgid] [--user | --global | --package-db]Call hc-pkgK to get all the details of all the packages in the given package database.Call hc-pkgQ to get the source package Id of all the packages in the given package database.(This is much less information than with L, but also rather quicker. Note in particular that it does not include the , just the source 3 which is not necessarily unique in any package db. Duncan Coutts 2009cabal-devel@haskell.orgportableNoneCall ld -r* to link a bunch of object files together.!Thomas Tuegel 2011cabal-devel@haskell.orgportableNone%Invoke hpc with the given parameters.TPrior to HPC version 0.7 (packaged with GHC 7.8), hpc did not handle multiple .mix paths correctly, so we print a warning, and only pass it the first path in the list. This means that e.g. test suites that import their library as a dependency can still work, but those that include the library modules directly (in other-modules) don't.Path to .tix filePaths to .mix file directories(Path where html output should be located&List of modules to exclude from reportPath to .tix filePaths to .mix file directories)Path where html output should be located'List of modules to exclude from reportPaths to .tix filesPath to resultant .tix file%List of modules to exclude from unionPaths to .tix filesPath to resultant .tix file%List of modules to exclude from union"Duncan Coutts 2009cabal-devel@haskell.orgportableNoneoGenerate a system script, either POSIX shell script or Windows batch file as appropriate for the given system.5Generate a POSIX shell script that invokes a program.5Generate a Windows batch file that invokes a program.#)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNoneUThe default list of programs. These programs are typically used internally to Cabal.$)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNoneThe configuration is a collection of information about programs. It contains information both about configured programs and also about programs that we are yet to configure.The idea is that we start from a collection of unconfigured programs and one by one we try to configure them at which point we move them into the configured collection. For unconfigured programs we record not just the C but also any user-provided arguments and location for the program.>The Read/Show instance does not preserve all the unconfigured Programs because X is not in Read/Show because it contains functions. So to fully restore a deserialised . use this function to add back all the known s.IIt does not add the default programs, but you probably want them, use ) in addition to any extra you might need./Add a known program that we may configure laterGet the current  used by the . This is the default list of locations where programs are looked for when configuring them. This can be overridden for specific programs (with f), and specific known programs can modify or ignore this search path in their own configuration code.Change the current  used by the }. This will affect programs that are configured from here on, so you should usually set it before configuring any programs.User-specify this path. Basically override any path information for this program in the configuration. If it's not a known program ignore it.User-specify the arguments for this program. Basically override any args information for this program in the configuration. If it's not a known program, ignore it..Like ) but for a list of progs and their paths.Like ( but for a list of progs and their args.FGet the path that has been previously specified for a program, if any.EGet any extra args that have been previously specified for a program. Try to find a configured program,Update a configured program in the database.List all configured programs.Try to configure a specific program. If the program is already included in the collection of unconfigured programs then we use any user-supplied location and arguments. If the program gets configured successfully it gets added to the configured collection.Note that it is not a failure if the program cannot be configured. It's only a failure if the user supplied a location and the program could not be found at that location.The reason for it not being a failure at this stage is that we don't know up front all the programs we will need, so we try to configure them all. To verify that a program was actually sucessfully configured use  .$Configure a bunch of programs using  . Just a . JTry to configure all the known programs that have not yet been configured. \reconfigure a bunch of programs given new user-specified args. It takes the same inputs as  and - and for all progs with a new path it calls . ;Check that a program is configured and available to be run.lIt raises an exception if the program could not be configured, otherwise it returns the configured program. ;Check that a program is configured and available to be run.tAdditionally check that the version of the program number is suitable and return it. For example you could require  AnyVersion or orLaterVersion ( [1,0] [])It raises an exception if the program could not be configured or the version is unsuitable, otherwise it returns the configured program and its version number.% Program name"user-specified path to the program Program nameuser-specified args            !    %)Isaac Jones 2006, Duncan Coutts 2007-2009cabal-devel@haskell.orgportableNone"Runs the given configured program.6Runs the given configured program and gets the output.?Looks up the given program in the program database and runs it.?Looks up the given program in the program database and runs it.   VerbosityThe program to runAny extra arguments to add VerbosityThe program to runAny extra arguments to add verbosityThe program to runlook up the program hereAny extra arguments to add verbosityThe program to runlook up the program hereAny extra arguments to adde     f       &8Isaac Jones 2003-2004 Duncan Coutts 2007BSD3cabal-devel@haskell.orgportableNone.\ Flags to register and  unregister2: (user package, gen-script, in-place, verbosity)d Flags to sdist: (snapshot, verbosity)k Flags to install: (package db, verbosity)r Flags to copy6: (destdir, copy-prefix (backwards compat), verbosity)w Flags to  configure commandy All programs that cabal may runzuser specified programs paths{user specified programs args|Extend the $PATH}4The "flavor" of the compiler, such as GHC or Hugs.~given compiler locationgiven hc-pkg locationEnable vanilla libraryEnable profiling in the libraryBuild shared library+Enable dynamic linking of the executables.%Enable profiling in the executables.Extra arguments to  configureEnable optimization.Installed executable prefix.Installed executable suffix.Installation paths"path to search for extra librariespath to search for header files "dist" prefixverbosity levelThe --user/--global flagWhich package DBs to use!Enable compiling library for GHCiEnable -split-objs with GHCEnable executable strippingEnable library stripping)Additional constraints for dependencies.The packages depended on.Enable test suite compilationEnable benchmark compilation#Enable test suite program coverage.}All direct dependencies and flags are provided on the command line by the user via the '--dependency' and '--flags' options.:Flags that apply at the top level, not to any sub-command.1All flags are monoids, they come in two flavours:  list flags eg !--ghc-option=foo --ghc-option=bar&gives us all the values ["foo", "bar"] singular value flags, eg: --enable-foo --disable-foogives us Just False So this Flag type is for the latter singular kind of flag. Its monoid instance gives us the behaviour where it starts out as ' and later flags override earlier ones.For each known program PROG in progConf , produce a  with-PROG &.Like *, but allows to customise the option name.For each known program PROG in progConf , produce a  PROG-option &.For each known program PROG in progConf , produce a  PROG-options &.Arguments to pass to a  configure script, e.g. generated by autoconf.pHelper function to split a string into a list of arguments. It's supposed to handle quoted things sensibly, eg: \splitArgs "--foo=\"C:\Program Files\Bar\" --baz" = ["--foo=C:\Program Files\Bar", "--baz"] !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~wxyz{|}~rstuvklmnopqBCDEFGHIJKLMNOPQRSTUVWXYZ[56789:;<./01234=>?@A\]^_`abcdefghij !"#$%&'()-,+*  l  !"#$%&'()-,+*./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw$xyz{|}~'Martin Sj&#xF6;gren 2004BSD3cabal-devel@haskell.orgportableNone ) (None2 -static -dynamic-too -dynamic -statice.g. -Odph -O2 -O -O0ghc --abi-hash( | GhcModeDepAnalysis -- ^ ghc -M( | GhcModeEvaluate -- ^ ghc -eghci / ghc --interactive  ghc --make ghc ghc -c%A structured set of GHC options/flags&The major mode for the ghc invocation._Any extra options to pass directly to ghc. These go at the end and hence override other stuff.pExtra default flags to pass directly to ghc. These go at the beginning and so can be overridden by other stuff.CThe main input files; could be .hs, .hi, .c, .o, depending on mode./The names of input Haskell modules, mainly for --make mode.Location for output file; the ghc -o flag.$Location for dynamic output file in  mode; the  ghc -dyno flag.?Start with an empty search path for Haskell source files; the ghc -i flag (-i$ on it's own with no path argument).*Search path for Haskell source files; the ghc -i flag.1The package name the modules will belong to; the ghc -package-name flag"GHC package databases to use, the ghc -package-conf flagThe GHC packages to use. For compatability with old and new ghc, this requires both the short and long form of the package id; the  ghc -package or ghc -package-id flags.$Start with a clean package set; the ghc -hide-all-packages flag/Don't automatically link in Haskell98 etc; the ghc -no-auto-link-packages flag.#Names of libraries to link in; the ghc -l flag.*Search path for libraries to link in; the ghc -L flag.+Options to pass through to the linker; the  ghc -optl flag.%OSX only: frameworks to link in; the ghc -framework flag. 1Don't do the link step, useful in make mode; the  ghc -no-link flag. Don't link in the normal RTS main entry point; the ghc -no-hs-main flag. /Options to pass through to the C compiler; the  ghc -optc flag. $Options to pass through to CPP; the  ghc -optP flag. 4Search path for CPP includes like header files; the ghc -I flag.0Extra header files to include at CPP stage; the ghc -optP-include flag.5Extra header files to include for old-style FFI; the  ghc -#include flag.The base language; the ghc -XHaskell98 or  -XHaskell2010 flag.The language extensions; the ghc -X flag.hA GHC version-dependent mapping of extensions to flags. This must be set to be able to make use of the .$What optimisation level to use; the ghc -O flag.Compile in profiling mode; the  ghc -prof flag.*Use the "split object files" feature; the ghc -split-objs flag.(Run N jobs simultaneously (if possible). Extra GHCi startup scripts; the  -ghci-script flagonly in  modeonly in  mode$9Get GHC to be quiet or verbose with what it's doing; the ghc -v flag.%ZLet GHC know that it is Cabal that's calling it. Modifies some of the GHC error messages.F      !"#$%&'(C      !"#$%&'(C      !"#$%'(& 0      !"#$%&'()Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNone$4MResolved internal and external package dependencies for this component. The  specifies a set of build dependencies that must be satisfied in terms of version ranges. This field fixes those dependencies to the specific versions available on this machine for this compiler.@1Data cached after configuration step. See also w.BdOptions passed to the configuration step. Needed to re-run configuration when .cabal is out of dateCuExtra args on the command line for the configuration step. Needed to re-run configuration when .cabal is out of dateDxThe installation directories for the various different kinds of files TODO: inplaceDirTemplates :: InstallDirs FilePathE The compiler we're building withFThe platform we're building forGKWhere to build the package. TODO: eliminate hugs's scratchDir, use builddirH*Where to put the result of the Hugs build.I}All the components to build, ordered by topological sort, and with their dependencies over the intrapackage dependency graphJhAll the info about the installed packages that the current package depends on (directly or indirectly).K5the filename containing the .cabal file, if availableLJThe resolved package description, that does not contain any conditionals.M"Location and args for all programsN)What package database to use, global/userOWhether to build normal libs.P,Whether to build profiling versions of libs.Q)Whether to build shared versions of libs.R'Whether to link executables dynamicallyS+Whether to build executables for profiling.T2Whether to build with optimization (if available).U1Whether to build libs suitable for use with GHCi.V&Use -split-objs with GHC, if availableW+Whether to strip executables during installX)Whether to strip libraries during installY/Prefix to be prepended to installed executablesZ.Suffix to be appended to installed executables[_External package dependencies for the package as a whole. This is the union of the individual 4, less any internal deps.\The installed package Id we use for local packages registered in the local package db. This is what is used for intra-package deps between components.a?All the components in the package (libs, exes, or test suites).bAll the components in the package that are buildable and enabled. Thus this excludes non-buildable components and test suites or benchmarks that have been disabled.hIf the package description has a library section, call the given function with the library build info as argument. Extended version of =* that also gives corresponding build info.i%Perform the action on each buildable  3 in the package description. Extended version of A+ that also gives corresponding build info.l%Perform the action on each buildable  or  V (Component) in the PackageDescription, subject to the build order specified by the compBuildOrder field of the given @qSee  rSee !K)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs     "#%&'())*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsN@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\;?>=<6:987]/321045444-.^`_cd),+*abefgnoplmkhijqrs),+*-./ 3210454446:987;?>=<@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs*9Isaac Jones 2003-2004, Duncan Coutts 2008BSD3cabal-devel@haskell.orgportableNonew4The directory in which we put auto-generated modulesy?The name of the auto-generated module associated with a package~+Extension for executable files (typically "" on Unix and "exe" on Windows or OS/2)=Extension for object files. For GHC and NHC the extension is "o". Hugs uses either "o" or "obj"" depending on the used C compiler.CExtension for dynamically linked (or shared) libraries (typically "so" on Unix and "dll" on Windows) tuvwxyz{|}~tuvwxyz{|}~tuvwyxz{|}~ tuvwxyz{|}~+bIsaac Jones 2003-2005, Ross Paterson 2006, Duncan Coutts 2007-2008cabal-devel@haskell.orgportableNone[Generates the name of the environment variable controlling the path component of interest.Tpath component; one of "bindir", "libdir", "datadir", "libexecdir", or "sysconfdir"environment variable name,(c) Duncan Coutts 2012BSD-likeduncan@community.haskell.orgNoneA matcher embodies a way to match some input as being some recognised value. In particular it deals with multiple and ambigious matches.&There are various matcher primitives ( matchExactly, ), ways to combine matchers ( ambigiousWith, shadows;) and finally we can run a matcher against an input using . (no such thing, actually got) expected thing(actually got)A fully resolved build target.,A specific file within a specific component..A specific module within a specific component.A specific component4Various ways that a user may specify a build target.A target specified by a qualifier and name. This could be a component name qualified by the component namespace kind, or a module or file qualified by the component name. Pcabal build lib:foo exe:foo cabal build foo:Data.Foo cabal build foo:Data/Foo.hsOA target specified by a single name. This could be a component module or file. Jcabal build foo cabal build Data.Foo cabal build Data/Foo.hs Data/Foo.hscRGiven a bunch of user-specified targets, try to resolve what it is they refer to.Combine two matchers. Exact matches are used over inexact matches but if we have multiple exact, or inexact then the we collect all the ambigious matches.)Combine two matchers. This is similar to  ambigiousWith with the difference that an exact match from the left matcher shadows any exact match on the right. Inexact matches are still collected however.)Lift a list of matches to an exact match.)Lift a list of matches to an exact match.fGiven a matcher and a key to look up, use the matcher to find all the possible matches. There may be  , a single  match or you may have an " match with several possibilities.6A primitive matcher that looks up a value in a finite Map. It checks for an exact or inexact match. We get an inexact match if the match is not exact, but the canonical forms match. It takes a canonicalisation function for this purpose.So for example if we used string case fold as the canonicalisation function, then we would get case insensitive matching (but it will still report an exact match when the case matches too).r                             ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T UR                             ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U-None /Logs test suite results, itemized by test case.\Logs all test results for a package, broken down first by test suite and then by test case.A 1 with package and platform information specified.<Count the number of pass, fail, and error test results in a  tree.From a %, determine if the test suite passed.From a %, determine if the test suite failed.From a 1, determine if the test suite encountered errors.Print a summary to the console after all test suites have been run indicating the number of successful test suites and cases. Returns  V if all test suites passed and  W otherwise.~Print a summary of a single test case's result to the console, supressing output for certain verbosity or test filter levels.|Print a summary of the test suite's results on the console, suppressing output for certain verbosity or test filter levels.)Passes, fails, and errors, respectively. Xtest suite nametest suite results X.Isaac Jones 2003-2006BSD3cabal-devel@haskell.orgportableNone Y&The flags for the supported extensionsHBuilding a package for JHC. Currently C source files are not supported.LBuilding an executable for JHC. Currently C source files are not supported.  Z Y [ \  Z Y [ \/Isaac Jones 2003-2007BSD3cabal-devel@haskell.orgportableNone ]/Adjust the way we find and configure gcc and ld ^:Get the packages from specific PackageDBs, not cumulative.Build a library with LHC.Build an executable with LHC. _YFilter the "-threaded" flag when profiling as it does not work with ghc-6.8 and older.Install executables for GHC.6Install for ghc, .hi, .a and, if --with-ghci given, .o ] ` a b ^ c _ d e f g h i jWhere to copy the files toBuild locationExecutable (prefix,suffix) kinstall location&install location for dynamic librariesBuild location   ] ` a b ^ c _ d e f g h i j k08Isaac Jones 2003-2006 Duncan Coutts 2009BSD3cabal-devel@haskell.orgportableNone l&The flags for the supported extensions mCThis is a backup option for existing versions of nhc98 which do not supply proper installed package info files for the bundled libs. Instead we look for the .cabal file and extract the package version from that. We don't know any other details for such packages, in particular we pretend that they have no dependencies.RFIX: For now, the target must contain a main module. Not used ATM. Re-add later.Building an executable for NHC.Install executables for NHC.#Install for nhc98: .hi and .a files n l o p q r m s t u verbosityinstall locationBuild locationExecutable (prefix,suffix) verbosityinstall locationBuild location n l o p q r m s t u1Andres Loeh 2009BSD3cabal-devel@haskell.orgportableNone v'The flags for the supported extensions. wlHack to add version numbers to UHC-built-in packages. This should sooner or later be fixed on the UHC side. x*Name of the installed package config file. yCheck if a certain dir contains a valid package. Currently, we are looking only for the presence of an installed package configuration. TODO: Actually make use of the information provided in the file. z4Create a trivial package info from a directory name. { v | } w x y ~ z    { v | } w x y ~ z   2None install location&install location for dynamic librariesBuild location   3Thomas Tuegel 2011BSD3cabal-devel@haskell.orgportableNonekConditionally enable Haskell Program Coverage by adding the necessary GHC options to a PackageDescription.TODO: do this differently in the build stage by constructing local build info, not by modifying the original PackageDescription.?Path to the .tix file containing a test suite's sum statistics.*Generate the HTML markup for a test suite.<Generate the HTML markup for all of a package's test suites.Enable coverage?"dist/" prefix "dist/" prefix/Directory containing component's HPC .mix files "dist/" prefixComponent name,Directory containing test suite's .mix files"dist/" prefixComponent name,Directory containing test suite's .tix files"dist/" prefixComponent namePath to test suite's .tix file"dist/" prefixComponent name*Path to test suite's HTML markup directory"dist/" prefix Library name"dist/" prefix Library name 4cabal-devel@haskell.orgportableNone  5Duncan Coutts 2009cabal-devel@haskell.orgportableNoneCall ar: to create a library archive from a bunch of object files. ar by default includes various metadata for each object file in their respective headers, so the output can differ for the same inputs, making it difficult to avoid re-linking. GNU ar(1) has a deterministic mode (-Dr) flag that always writes zero for the mtime, UID and GID, and 0644 for the file mode. However detecting whether -DJ is supported seems rather harder than just re-implementing this feature.  6Isaac Jones 2003-2007BSD3cabal-devel@haskell.orgportableNone Given something like usrlocalbinghc-6.6.1(.exe) we try and find the corresponding tool; e.g. if the tool is ghc-pkg, we try looking for a versioned or unversioned ghc-pkg in the same dir, that is: f/usr/local/bin/ghc-pkg-ghc-6.6.1(.exe) /usr/local/bin/ghc-pkg-6.6.1(.exe) /usr/local/bin/ghc-pkg(.exe) Given something like usrlocalbinghc-6.6.1(.exe) we try and find a corresponding ghc-pkg, we try looking for both a versioned and unversioned ghc-pkg in the same dir, that is: f/usr/local/bin/ghc-pkg-ghc-6.6.1(.exe) /usr/local/bin/ghc-pkg-6.6.1(.exe) /usr/local/bin/ghc-pkg(.exe) Given something like usrlocalbinghc-6.6.1(.exe) we try and find a corresponding hsc2hs, we try looking for both a versioned and unversioned hsc2hs in the same dir, that is: c/usr/local/bin/hsc2hs-ghc-6.6.1(.exe) /usr/local/bin/hsc2hs-6.6.1(.exe) /usr/local/bin/hsc2hs(.exe) /Adjust the way we find and configure gcc and ld IFor GHC 6.6.x and earlier, the mapping from supported extensions to flags9Given a single package DB, return all installed packages.8Given a package DB stack, return all installed packages. Given a list of !(PackageDB, InstalledPackageInfo) pairs, produce a  PackageIndex. Helper function used by  and . Return the $ to the global GHC package database. :Get the packages from specific PackageDBs, not cumulative.Build a library with GHC.Build a library with GHC..Start a REPL without loading any source files.Build an executable with GHC.Build an executable with GHC. YFilter the "-threaded" flag when profiling as it does not work with ghc-6.8 and older. .Strip out flags that are not supported in ghciyExtracts a String representing a hash of the ABI of a built library. It can fail if the library has not yet been built.Install executables for GHC.6Install for ghc, .hi, .a and, if --with-ghci given, .o5Create an empty package DB at the specified location.mRun 'ghc-pkg' using a given package DB stack, directly forwarding the provided command-line arguments to it.+        Where to copy the files toBuild locationExecutable (prefix,suffix)install location&install location for dynamic librariesBuild location  +          7Simon Marlow 2008cabal-devel@haskell.orgportableNoneThe contents of the cabal_macros.h" for the given configured package.(Helper function that generates just the  VERSION_pkg and MIN_VERSION_pkgb macros for a list of package ids (usually used with the specific deps of a configured package). (Helper function that generates just the TOOL_VERSION_pkg and MIN_TOOL_VERSION_pkg* macros for a list of configured programs. Common implementation of  and  .  8 Safe-Inferred 9None:The name of the stub executable associated with a library  TestSuite.SThe filename of the source file for the stub executable associated with a library  TestSuite.$Write the source file for a library  TestSuite stub executable.2Source code for library test suite stub executableMain function for test stubs. Once, it was written directly into the stub, but minimizing the amount of code actually in the stub maximizes the number of detectable errors when Cabal is compiled.  The test runner used in library  TestSuite$ stub executables. Runs a list of gs. An executable calling this function is meant to be invoked as the child of a Cabal process during  ./setup test. A  , provided by Cabal, is read from the standard input; it supplies the name of the test suite and the location of the machine-readable test suite log file. Human-readable log information is written to the standard output for capture by the calling Cabal process.From a test stub, write the : to temporary file for the calling Cabal process to read.  library  TestSuite# for which a stub is being created6path to directory where stub source should be located    :+(c) 2003-2005, Isaac Jones, Malcolm WallaceBSD3cabal-devel@haskell.orgportableNonegA preprocessor for turning non-Haskell files with the given extension into plain Haskell source files.The interface to a preprocessor, which may be implemented using an external program, but need not be. The arguments are the name of the input file, the name of the output file and a verbosity level. Here is a simple example that merely prepends a comment to the given source file: tppTestHandler :: PreProcessor ppTestHandler = PreProcessor { platformIndependent = True, runPreProcessor = mkSimplePreProcessor $ \inFile outFile verbosity -> do info verbosity (inFile++" has been preprocessed to "++outFile) stuff <- readFile inFile writeFile outFile ("-- preprocessed as a test\n\n" ++ stuff) return ExitSuccess We split the input and output file names into a base directory and the rest of the file name. The input base dir is the path in the list of search dirs that this file was found in. The output base dir is the build dir where all the generated source files are put.*The reason for splitting it up this way is that some pre-processors don't simply generate one output .hs file from one input file but have dependencies on other genereated files (notably c2hs, where building one .hs file may require reading other .chi files, and then compiling the .hs file may require reading a generated .h file). In these cases the generated files need to embed relative path names to each other (eg the generated .hs file mentions the .h file in the FFI imports). This path must be relative to the base directory where the genereated files are located, it cannot be relative to the top level of the build tree because the compilers do not look for .h files relative to there, ie we do not use "-I .", instead we use "-I dist/build" (or whatever dist dir has been set by the user)Most pre-processors do not care of course, so mkSimplePreProcessor and runSimplePreProcessor functions handle the simple case.(Apply preprocessors to the sources from 2 for a given component (lib, exe, or test suite). QFind the first extension of the file that exists, and preprocess it if required. >Convenience function; get the suffixes of these preprocessors. GStandard preprocessors: GreenCard, c2hs, hsc2hs, happy, alex and cpphs. source directoriesbuild directorypreprocess for sdistmodule file name verbositybuiltin suffixespossible preprocessors                         ;Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone-Hooks allow authors to add specific functionality before and after a command is run, and also to specify additional preprocessors.WARNING: The hooks interface is under rather constant flux as we try to understand users needs. Setup files that depend on this interface may break in future releases. Used for  ./setup testRead the description file3Custom preprocessors in addition to and overriding knownSuffixHandlers.gThese programs are detected at configure time. Arguments for them are added to the configure command.$Hook to run before configure command?Over-ride this hook to get different behavior during configure.#Hook to run after configure commandHHook to run before build command. Second arg indicates verbosity level.;Over-ride this hook to get different behavior during build.GHook to run after build command. Second arg indicates verbosity level.GHook to run before repl command. Second arg indicates verbosity level.DOver-ride this hook to get different behavior during interpretation.FHook to run after repl command. Second arg indicates verbosity level.HHook to run before clean command. Second arg indicates verbosity level.;Over-ride this hook to get different behavior during clean.GHook to run after clean command. Second arg indicates verbosity level. Hook to run before copy command!:Over-ride this hook to get different behavior during copy."Hook to run after copy command#"Hook to run before install command$=Over-ride this hook to get different behavior during install.%dHook to run after install command. postInst should be run on the target, not on the build machine.&HHook to run before sdist command. Second arg indicates verbosity level.';Over-ride this hook to get different behavior during sdist.(GHook to run after sdist command. Second arg indicates verbosity level.)#Hook to run before register command*BOver-ride this hook to get different behavior during registration.+"Hook to run after register command,%Hook to run before unregister command-DOver-ride this hook to get different behavior during unregistration..$Hook to run after unregister command/KHook to run before hscolour command. Second arg indicates verbosity level.0>Over-ride this hook to get different behavior during hscolour.1JHook to run after hscolour command. Second arg indicates verbosity level.2JHook to run before haddock command. Second arg indicates verbosity level.3=Over-ride this hook to get different behavior during haddock.4IHook to run after haddock command. Second arg indicates verbosity level.5 Hook to run before test command.6:Over-ride this hook to get different behavior during test.7Hook to run after test command.8!Hook to run before bench command.9;Over-ride this hook to get different behavior during bench.: Hook to run after bench command.<Empty  which do nothing./ !"#$%&'()*+,-./0123456789:;</ !"#$%&'()*+,-./0123456789:;Create a source distribution.?List all source files of a package. Returns a tuple of lists: first component is a list of ordinary files, second one is a list of those files that may be executable. KList those source files that may be executable (e.g. the configure script). HList those source files that should be copied with ordinary permissions.@)Prepare a directory tree of source files. )Find the setup script file, if it exists. KCreate a default setup script in the target directory, if it doesn't exist. Find the main executable file. CGiven a list of include paths, try to find the include file named f]. Return the name of the file and the full path, or exit with error if there's no such file. YRemove the auto-generated module ('Paths_*') from 'exposed-modules' and 'other-modules'.APrepare a directory tree of source files for a snapshot version. It is expected that the appropriate snapshot version has already been set in the package description, eg using B or C.B Modifies a A by appending a snapshot number corresponding to the given date.C Modifies a A by appending a snapshot number corresponding to the given date.DWGiven a date produce a corresponding integer representation. For example given a date 18032008 produce the number 20080318.EECreate an archive from a tree of source files, and clean up the tree. 8Given a buildinfo, return the names of all source files. )The name of the tarball without extension  verbosityinfo from cabal fileinfo from configuresource tree to archivename of archive to create>information from the tarballInformation from configureverbosity & snapshotbuild prefix (temp dir)'extra preprocessors (includes suffixes)? verbosityinfo from the cabal file'extra preprocessors (include suffixes) @ verbosityinfo from the cabal filesource tree to populate'extra preprocessors (includes suffixes) A verbosityinfo from the cabal filesource tree to populate(extra preprocessors (includes suffixes)  verbosityinfo from the cabal file source treeBCDE Extra preprocessorsExposed modulesF >?@ABCDEF >F@EABCD? >? @ A BCDE F >8Isaac Jones 2003-2006 Duncan Coutts 2009BSD3cabal-devel@haskell.orgportableNone &The flags for the supported extensions LThis is a backup option for existing versions of Hugs which do not supply proper installed package info files for the bundled libs. Instead we look for the Paths_pkgname.hs file and extract the package version from that. We don't know any other details for such packages, in particular we pretend that they have no dependencies.IBuilding a package for Hugs.J Building an executable for Hugs. Read the initial part of a source file, before any Haskell code, and return the contents of any LANGUAGE, OPTIONS and INCLUDE pragmas. #Strip comments from Haskell source.KInstall for Hugs. For install, copy-prefix = prefix, but for copy they're different. The library goes in <copy-prefix>/lib/hugs/packages/<pkgname> (i.e. <prefix>/lib/hugs/packages/<pkgname> on the target system). Each executable goes in <copy-prefix>/lib/hugs/programs/<exename> (i.e. <prefix>/lib/hugs/programs/<exename> on the target system) with a script <copy-prefix>/bin/<exename> pointing at <prefix>/lib/hugs/programs/<exename>. Filename used by Hugs for the main module of an executable. This is a simple filename, so that Hugs will look for any auxiliary modules it uses relative to the directory it's in.G H IJ output directory%library source dirs, if building exesModules preserve pragmas?input source textK verbosityLibrary install locationProgram install locationExecutable install location!Program location on target systemBuild locationExecutable (prefix,suffix) LGHIJKLGHIJKLG H IJ K L?Isaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNoneO5Create an empty package DB at the specified location.PRun hc-pkg` using a given package DB stack, directly forwarding the provided command-line arguments to it.R Construct F for a library in a package, given a set of installation directories.S Construct 3 for a library that is in place in the build tree.:This function knows about the layout of in place packages.T Construct 6 for the final install location of a library package.;This function knows about the layout of installed packages. M(Install in the user's database?; verboseNOPQ R8Translate relative include dir paths to absolute paths.Stop of the build treelocation of the dist treeTU MNOPQRSTU MUOPQNSTR MNOPQ RSTU @Isaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone \Try to read the a.] Read the a. Error if it doesn't exist. Also fail if the file containing LocalBuildInfo is older than the .cabal file, indicating that a re-configure is required.^Try to read the a._$After running configure, output the @ to the a.`MCheck that localBuildInfoFile is up-to-date with respect to the .cabal file.a dist/setup-configb Perform the "./setup configure" action. Returns the  .setup-config file. GTest for a package dependency and record the version we have installed.dLike c, but for a single package DB.eKThe user interface specifies the package dbs to use with a combination of --global, --user and $--package-db=global|user|clear|$filer. This function combines the global/user flag and interprets the package-db flag into a single package db stack.fMakes a " from C compiler and linker flags.This can be used with the output from configuration programs like pkg-config and similar package-specific programs like mysql-config, freealut-config etc. For example: ccflags <- rawSystemProgramStdoutConf verbosity prog conf ["--cflags"] ldflags <- rawSystemProgramStdoutConf verbosity prog conf ["--libs"] return (ccldOptionsBuildInfo (words ccflags) (words ldflags)) =Output package check warnings and errors. Exit if any errors./ VWXYZ[\]^_ `ab Internally defined packagesInstalled packages:Packages for which we have been given specific deps to use cde fghij k  VWXYZ[\]^_`abcdefghijkb_]`\^acdijhgfkeWZYXV[ (   VWZYX[\]^_ `ab cde fghij k AIsaac Jones 2003-2004BSD3cabal-devel@haskell.orgportableNonel Perform the "./setup install" and " ./setup copyb" actions. Move files into place based on the prefix argument. FIX: nhc isn't implemented yet. &Install the files listed in data-files ,Install the files listed in install-includesl information from the .cabal file#information from the configure stepflags sent to copy or install lll BhIsaac Jones 2003-2005, Ross Paterson 2006, Duncan Coutts 2007-2008, 2012BSD3cabal-devel@haskell.orgportableNonem4Build the libraries and executables in this package.o7Start an interpreter without loading any package files. Translate a exe-style # component into an exe for building Translate a lib-style ( component into a lib + exe for building Translate a exe-style # component into an exe for building RInitialize a new package db file for libraries defined internally to the package.q!Generate and write out the Paths_ pkg.hs and cabal_macros.h files DCheck that the given build targets are valid in the current context.)Also swizzle into a more convenient form.m'Mostly information from the .cabal fileConfiguration information#Flags that the user passed to build%preprocessors to run before compilingn'Mostly information from the .cabal fileConfiguration information#Flags that the user passed to build%preprocessors to run before compilingo p "dist" prefix'mostly information from the .cabal fileConfiguration informationThe verbosity to useq mnopqmnopqmno pq CIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNone 2the FilePath of a directory, it's a monoid under ( /) Qrecord that represents the arguments to the haddock executable, a product monoid. ?path of the interface file, relative to argOutputDir, required. ?package name, required. !(hide modules ?, modules to hide) ignore export lists in modules? @(template for modules, template for symbols, template for lines) optional custom CSS file. optional URL to contents page GHTML or Hoogle doc or both? required.  0(interface file, URL to the HTML docs for links) $where to generate the documentation. ?page's title, required. ?prologue text, required. additional flags to pass to ghc ?to find the correct ghc, required. modules to process. *Call haddock with the specified arguments.sGiven a list of ps, return a list of interfaces and HTML paths, and an optional warning for packages with missing documentation. :The directory where we put build results for an executable2                r   template for HTML location template for HTML location  template for HTML location    s !t " # $ % & ' (rstrts                   r          s !t " # $ % & ' (DNoneu )uuu )EThomas Tuegel 2010BSD3cabal-devel@haskell.orgportableNonev Perform the " ./setup test " action.v information from the .cabal file#information from the configure stepflags sent to test *vvv *FIsaac Jones 2003-2005BSD3cabal-devel@haskell.orgportableNonewA simple implementation of main for a Cabal setup script. It reads the package description file using IO, and performs the action specified on the command line.x A version of w[ that is passed the command line arguments, rather than getting them from the environment.yA customizable version of w.zA customizable version of w- that also takes the command line arguments.{Like wP, but accepts the package description as input rather than using IO to read it. +VCombine the preprocessors in the given hooks with the preprocessors built into cabal.|LHooks that correspond to a plain instantiation of the "simple" build system}Basic autoconf : runs  ./configure , if present.the pre-hooks , ,  , #, ) and ,+ read additional build information from package .buildinfo , if present.Thus  configure/ can use local system information to generate package .buildinfo and possibly other files.$wxyz{ , + - . / 0 1 2 3 4 5 6 7 8 9 : ; < = >|}~ ? @ A B C D E F,cdefghijklmnopqrstuvwxyz{|}~*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~[\]^_`abcdefghijklmnopqrstu !"#$%&'()*+,-./0123456789:;<wxyz{|}~8w{x !"#$%&'()*+,-./0123456789:;yz|~}<$wxyz{ , + - . / 0 1 2 3 4 5 6 7 8 9 : ; < = >|}~ ? @ A B C D E F G]^_]^`]^a]^a]bc]defghijjklmnopqrmstuvwxyz{|}~K                                                        ! ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D EFGHIJKLMNOPQRSTUVWXYZ[\]^__`abcdefghijklmnopqrstuvwxyz{|}~"3       !"#$%&'()*+,-./0123456789:;<=>??@ABCDEFGHIJKLLMNOPQQRSTUUVWXYZ[\]^__`abcdefghijklmnopqrstuvwxyz{|}~XX     YYY Y!Y"Y#Y$Y%Y&Y'Y(Y)Y*Y+Y,-.-/0acdefhilmn1V234567823 9$%:';<=>?@ABCDEFGHIJKLMNOPQRSSTUVWXYZZ[\]^_`abcdefghijklmnopqrstuvwxyz{||}~ !!"""############# # # # # ############$$$$$$$ $!$"$#$$$%$&$'$($)$*$+$,$-$.$/$0$1%2%3%4%5%6%7%8%9%:%;%<%=%>&?&?&@&A&B&C&C&D&E&F&G&H&I&J&K&L&M&N&O&P&Q&Q&R&S&T&U&V&W&W&X&Y&Z&[&\&]&^&^&_&`&a&b&b&c&d&e&f&g&h&i&j&k&l&m&n&o&p&q&r&s&s&t&u&v&w&x&y&z&z&{&|&}&~&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&g&h&&&&&&&'''(((((((((((((((( ( ( ( ( ( ((((((((((((((((((( (!("(#($(%(&('((()(*(+(,(-(.(/(0(1(2(3(4(5(6(7(8(9(:(;)<)=)>)?)@)@)A)B)C)D)E)F)G)H)I)J)K)L)M)N)O)P)Q)R)R)S)T)U)V)W)X)Y)Z)[)\)])^)_)`)a)b)c)d)e)f)g)h)i)j)k)l)m)n)o)p)q)r)s)t)u)v)w)x)y)z){)|)})~))))r)s)v*************++,,,,,,,,,,,,,,,,----M----------`-V--u----------....../////////00000011111122222222222233333344566666666666666666667789999999:::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;; ; ; ; ; ;;;;;;;;;;;;;;;;;;; ;!;"<#=$=%=&='=(=)=*=+=,>>>>>->??.????/?0?1?@2@3@4@5@6@7@8@9@:@;@<@=@@@@>@?@@@A@B@C@DA-BEBFBBGBHCICJCKDELFFFMFNFFOFPFQGGRGaGbGhGeGnGSGTGUGVGWGXYZg[\]^_`abcdeHfHQHRHgHNHhHiHjHkHlHmHnHoHpHqHrHsHtHuHvHwHxHHyHzH{H|H}H~Hfh ]               ]                   ]^Z]]]]]WWWW W W W ] ] XXXXXXX}]  Y!Y"Y]Y#Y$Y%Y&Y'Y(Y)Y*Y+Y,Y-Y.Y/Y0Y1Y2Y3Y4Y5Y6Y7Y8Y9Y&Y:Y;Y<Y=Y>Y?Y@YAYBYCYDYEYFYGYHYIYJYKYLYMYNYOYPYQYRYSYTYUYVYWYXYYYZY[Y\Y]Y^Y_Y`YaYbYcYdYeYfYgYhYiYjYkYlYmYnYoYpYqYrYsYtYuYvYwYxYyYzY{|}~Z-]ZZZZZZZZ ZZZZZ-Z`ZaZcZdZeZfZhZiZmZnZ1ZVZ2Z4Z5Z6Z7Z8Z2Z3Z Z9Z$Z%Z:Z'Z;Z<ZZZZZ[-[-[`[a[c[d[e[f[h[i[m[n[1[V[2[4[5[6[7[2[3[ [9[$[%[:['[;[<[[CmU     ]\ !"#$%&'(!)!*$+$,]-.$/$0$1$$2$3$4$5$6$7$8&9&:&;&<&=&>&?&@&A&B&C&D&E&F&G&H&I&J&K&L&M&N&O&P&Q&R&S&T&U'V'W'X'Y'Z'['\']'^'_('(`(a+b+c+d,e,f,g,h,i,j,k,l,m,,,,n,o,p,q,r,s,t,u,v,w,x,y,z,{,|,|,},~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,-....///////////////00000000"0011111111111111133456666666666666666666666667 7 7 9 9 : : : : : < = = = = = = = = = = = = > >> > > > > >>>>>"> > > > > !> "> #> $> %> &> '> (? )? *? +@ ,@ -@ .@ /@ 0@ 1@ 2@ 3@ 4@ 5@ 6@ 7@ 8@ 9@ :@ ;@ <@ =@ >@ ?@ @@ A@ B@ C@ DA EA FB GB HB IB JB KB LB MB NBBBBC OC PC QC RC SC TC UC VC WC XC YC ZC [C \C ]C ^C _C `C aC bC cC dC eC fC gC PC hC iC jC kC lC mC nC oC pC qC rC sC tC uC vC wC xC yC zC {C |D E }F ~FVFWF[F F FZF\FXFYF]F F F^F_F F F F F F F F F F F F F Cabal-1.20.0.3Distribution.VersionDistribution.Simple.UtilsDistribution.Compat.ReadPDistribution.TestSuite$Distribution.Simple.PreProcess.Unlit%Distribution.PackageDescription.UtilsDistribution.Simple.CCompilerDistribution.TextDistribution.CompilerDistribution.LicenseDistribution.PackageDistribution.ModuleNameDistribution.SystemDistribution.Simple.InstallDirsLanguage.Haskell.ExtensionDistribution.PackageDescriptionDistribution.Simple.CompilerDistribution.ReadEDistribution.VerbosityDistribution.Compat.Exception%Distribution.PackageDescription.Parse!Distribution.InstalledPackageInfoDistribution.Simple.Command-Distribution.PackageDescription.Configuration%Distribution.PackageDescription.Check+Distribution.PackageDescription.PrettyPrint Distribution.Simple.PackageIndex Distribution.Simple.Program.Find!Distribution.Simple.Program.TypesDistribution.Simple.Program.Run!Distribution.Simple.Program.HcPkgDistribution.Simple.Program.LdDistribution.Simple.Program.Hpc"Distribution.Simple.Program.Script#Distribution.Simple.Program.BuiltinDistribution.Simple.Program.DbDistribution.Simple.ProgramDistribution.Simple.SetupDistribution.MakeDistribution.Simple.Program.GHC"Distribution.Simple.LocalBuildInfoDistribution.Simple.BuildPaths%Distribution.Simple.Build.PathsModuleDistribution.Simple.BuildTargetDistribution.Simple.Test.LogDistribution.Simple.JHCDistribution.Simple.LHCDistribution.Simple.NHCDistribution.Simple.UHC Distribution.Simple.HaskellSuiteDistribution.Simple.Hpc!Distribution.Simple.Program.StripDistribution.Simple.Program.ArDistribution.Simple.GHC Distribution.Simple.Build.MacrosDistribution.Compat.CreatePipeDistribution.Simple.Test.LibV09Distribution.Simple.PreProcessDistribution.Simple.UserHooksDistribution.Simple.BenchDistribution.Simple.SrcDistDistribution.Simple.HugsDistribution.Simple.RegisterDistribution.Simple.ConfigureDistribution.Simple.InstallDistribution.Simple.BuildDistribution.Simple.HaddockDistribution.Simple.Test.ExeV10Distribution.Simple.TestDistribution.Simple Paths_CabalDistribution.GetOptSystem.EnvironmentgetArgs simpleParse Data.FoldableFoldableData.Traversable Traversable Data.FunctorFunctor GHC.GenericsGenericGeneric1 Data.GenericsDataDistribution.Compat.TempFileDistribution.Compat.CopyFileDistribution.ParseUtilsDistribution.Simple.GHC.IPI642Distribution.Simple.GHC.IPI641Distribution.Compat.Environmentbase Data.Version versionTags versionBranchVersion Data.List intercalateText.ParserCombinators.ReadPReadSResultErrorFailPassProgressFinishedOptionsTest ExtraOptionsGroup groupName concurrently groupTests OptionType OptionRngSeed OptionSet OptionEnum OptionBool OptionNumberoptionNumberIsIntoptionNumberBounds OptionStringoptionStringMultiline OptionFileoptionFileMustExistoptionFileIsDiroptionFileExtensions OptionDescr optionNameoptionDescription optionType optionDefault TestInstancerunnametagsoptions setOption testGroupplainunlituserBugcabalBugCDialectObjectiveCPlusPlus CPlusPlus ObjectiveCCcSourceExtensionscDialectFilenameExtensionfilenameCDialectReadPgetlookpfail+++<++gathersatisfycharstringmunchmunch1choice skipSpacescountbetweenoptionoptionalmanymany1skipMany skipMany1sepBysepBy1endByendBy1chainrchainlchainr1chainl1manyTill readP_to_S readS_to_PTextdispparsedisplayBoundInclusiveBoundExclusiveBound UpperBound NoUpperBound LowerBoundVersionIntervalVersionIntervals VersionRangeVersionRangeParensIntersectVersionRangesUnionVersionRangesWildcardVersionEarlierVersion LaterVersion ThisVersion AnyVersion anyVersion noVersion thisVersionnotThisVersion laterVersionorLaterVersionearlierVersionorEarlierVersionunionVersionRangesintersectVersionRanges withinVersionbetweenVersionsInclusiveremoveUpperBoundfoldVersionRangefoldVersionRange' withinRangeasVersionIntervals isAnyVersion isNoVersionisSpecificVersionsimplifyVersionRangeversionIntervalsmkVersionIntervalswithinIntervalstoVersionIntervalsfromVersionIntervalsunionVersionIntervalsintersectVersionIntervals CompilerIdCompilerFlavor OtherCompiler HaskellSuiteUHCLHCJHCHeliumHBCHugsYHCNHCGHCparseCompilerFlavorCompatbuildCompilerFlavorbuildCompilerIddefaultCompilerFlavorLicenseUnknownLicense OtherLicenseAllRightsReserved PublicDomainApacheMPLMITBSD4BSD3BSD2LGPLAGPLGPL knownLicensesPackageFixedDepsdependsPackage packageId DependencyInstalledPackageIdPackageIdentifierpkgName pkgVersion PackageId PackageNamethisPackageVersionnotThisPackageVersionsimplifyDependency packageNamepackageVersion ModuleNamesimple fromStringmain components toFilePathPlatformArch OtherArchVaxM68kRs6000HppaAlphaS390IA64SHMipsArmSparcPPC64PPCX86_64I386OSOtherOSIOSHaLVMIRIXHPUXAIXSolaris DragonFlyNetBSDOpenBSDFreeBSDOSXWindowsLinuxbuildOS buildArch buildPlatformplatformFromTriplePathTemplateEnvPathTemplateVariableBenchmarkNameVarTestSuiteResultVarTestSuiteNameVarExecutableNameVarArchVarOSVar CompilerVarPkgIdVar PkgVerVar PkgNameVar HtmldirVar DocdirVar DatasubdirVar DatadirVar LibsubdirVar LibdirVar BindirVar PrefixVar PathTemplateCopyDestCopyTo NoCopyDestInstallDirTemplates InstallDirsprefixbindirlibdir libsubdir dynlibdir libexecdirprogdir includedirdatadir datasubdirdocdirmandirhtmldir haddockdir sysconfdircombineInstallDirsdefaultInstallDirssubstituteInstallDirTemplatesabsoluteInstallDirsprefixRelativeInstallDirstoPathTemplatefromPathTemplatesubstPathTemplateinitialPathTemplateEnvpackageTemplateEnvcompilerTemplateEnvplatformTemplateEnvinstallDirsTemplateEnvKnownExtensionAllowAmbiguousTypesExplicitNamespacesNullaryTypeClasses NumDecimalsBinaryLiteralsNegativeLiteralsAutoDeriveTypeable EmptyCaseOverloadedListsRoleAnnotationsParallelArrays DataKinds PolyKindsConstraintKindsUnsafe TrustworthySafe SafeImportsNondecreasingIndentationDeriveFoldableDeriveTraversable DeriveFunctorMonoLocalBindsDatatypeContextsExplicitForAllRebindableSyntax LambdaCase MultiWayIfDoAndIfThenElseNPlusKPatternsGHCForeignImportPrim TupleSectionsRegularPatterns XmlSyntax ViewPatternsMonadComprehensionsTransformListComp QuasiQuotesPostfixOperatorsNewQualifiedOperatorsImpredicativeTypesPackageImportsConstrainedClassMethods InstanceSigsDefaultSignatures DeriveGenericDeriveDataTypeable UnboxedTuplesExtendedDefaultRulesRelaxedPolyRec MonoPatBinds GADTSyntaxGADTsOverloadedStringsTraditionalRecordSyntaxDisambiguateRecordFields RecordPunsRecordWildCards TypeOperatorsLiberalTypeSynonymsCApiFFIInterruptibleFFIUnliftedFFITypes UnicodeSyntaxStandaloneDeriving TypeFamilies MagicHash HereDocumentsRestrictedTypeSynonymsExtensibleRecordsGeneralizedNewtypeDeriving PatternGuardsNamedFieldPunsImplicitPreludeGenericsArrowsForeignFunctionInterfaceTemplateHaskellTypeSynonymInstances BangPatternsKindSignaturesCPPEmptyDataDeclsFlexibleInstancesFlexibleContextsImplicitParamsPatternSignaturesScopedTypeVariablesExistentialQuantificationPolymorphicComponents RankNTypes Rank2TypesFunctionalDependenciesMonomorphismRestrictionMultiParamTypeClassesParallelListComp RecursiveDoDoRecIncoherentInstancesUndecidableInstancesOverlappingInstances ExtensionUnknownExtensionDisableExtensionEnableExtensionLanguageUnknownLanguage Haskell2010 Haskell98knownLanguagesknownExtensionsdeprecatedExtensionsCondTreeCondNode condTreeDatacondTreeConstraintscondTreeComponents ConditionCAndCOrCNotLitVarConfVarImplFlagFlagAssignmentFlagNameMkFlagflagNameflagDescription flagDefault flagManualGenericPackageDescriptionpackageDescriptiongenPackageFlags condLibrarycondExecutablescondTestSuitescondBenchmarksRepoType OtherRepoTypeMonotoneBazaarGnuArch MercurialCVSSVNGitDarcsRepoKindRepoKindUnknownRepoThisRepoHead SourceReporepoKindrepoType repoLocation repoModule repoBranchrepoTag repoSubdirHookedBuildInfo BuildInfo buildable buildTools cppOptions ccOptions ldOptionspkgconfigDepends frameworkscSources hsSourceDirs otherModulesdefaultLanguageotherLanguagesdefaultExtensionsotherExtensions oldExtensions extraLibs extraLibDirs includeDirsincludesinstallIncludesghcProfOptionsghcSharedOptionscustomFieldsBItargetBuildDepends BenchmarkTypeBenchmarkTypeUnknownBenchmarkTypeExeBenchmarkInterfaceBenchmarkUnsupportedBenchmarkExeV10 Benchmark benchmarkNamebenchmarkInterfacebenchmarkBuildInfobenchmarkEnabledTestTypeTestTypeUnknown TestTypeLib TestTypeExeTestSuiteInterfaceTestSuiteUnsupportedTestSuiteLibV09TestSuiteExeV10 TestSuitetestName testInterface testBuildInfo testEnabled ExecutableexeName modulePath buildInfoLibraryexposedModules libExposed libBuildInfo BuildTypeUnknownBuildTypeCustomMake ConfigureSimplePackageDescriptionpackagelicense licenseFiles copyright maintainerauthor stability testedWithhomepagepkgUrl bugReports sourceRepossynopsis descriptioncategorycustomFieldsPD buildDependsspecVersionRaw buildTypelibrary executables testSuites benchmarks dataFilesdataDir extraSrcFiles extraTmpFiles extraDocFiles specVersiondescCabalVersionemptyPackageDescriptionknownBuildTypes emptyLibraryhasLibswithLib libModulesemptyExecutablehasExeswithExe exeModulesemptyTestSuitehasTests enabledTestswithTest testModulesknownTestTypestestTypeemptyBenchmark hasBenchmarksenabledBenchmarks withBenchmarkbenchmarkModulesknownBenchmarkTypes benchmarkTypeemptyBuildInfo allBuildInfo allLanguages allExtensionsusedExtensionsemptyHookedBuildInfo hcOptionsknownRepoTypesupdatePackageDescriptionOptimisationLevelMaximumOptimisationNormalOptimisationNoOptimisationPackageDBStack PackageDBSpecificPackageDB UserPackageDBGlobalPackageDBCompiler compilerIdcompilerLanguagescompilerExtensionscompilerPropertiesshowCompilerIdcompilerFlavorcompilerVersionregistrationPackageDBabsolutePackageDBPathsabsolutePackageDBPathflagToOptimisationLevelunsupportedLanguageslanguageToFlagsunsupportedExtensionsextensionsToFlagsparmakeSupportedReadErunReadE succeedReadE failReadE parseReadE readEOrFail readP_to_E Verbositysilentnormalverbose deafening moreVerbose lessVerboseintToVerbosityflagToVerbosity showForCabal showForGHCtryIOcatchIO catchExitsetFileOrdinarysetFileExecutableTempFileOptionsoptKeepTempFilesFileGlobNoGlob cabalVersiondieWithLocationdietopHandlerWith topHandlerwarnnotice setupMessageinfodebug debugNoWrap chattyTrywrapTextwrapLine maybeExit rawSystemExitrawSystemExitCoderawSystemExitWithEnvrawSystemIOWithEnvrawSystemStdoutrawSystemStdInOutfindProgramLocationfindProgramVersionxargsfindFilefindFileWithExtensionfindFileWithExtension' findFirstFilefindModuleFilesfindModuleFilegetDirectoryContentsRecursiveisInSearchPath parseFileGlob matchFileGlobmatchDirFileGlobmoreRecentFileexistsAndIsMoreRecentThancreateDirectoryIfMissingVerbosecopyFileVerboseinstallOrdinaryFileinstallExecutableFileinstallMaybeExecutableFile copyFileTo copyFilesinstallOrdinaryFilesinstallExecutableFilesinstallMaybeExecutableFilesinstallDirectoryContentsdoesExecutableExistsmartCopySourcescopyDirectoryRecursiveVerbosedefaultTempFileOptions withTempFilewithTempFileExwithTempDirectorywithTempDirectoryExwithFileContentswriteFileAtomic rewriteFile currentDirdefaultPackageDescfindPackageDesctryFindPackageDescdefaultHookedPackageDescfindHookedPackageDescfromUTF8toUTF8 readUTF8FilewithUTF8FileContents writeUTF8FilenormaliseLineEndingsequating comparing isInfixOf lowercase FieldDescr fieldNamefieldGetfieldSet ParseResultParseOk ParseFailedPWarningPError FromString TabsErrorNoParseAmbiguousParseLineNoInstalledPackageInfoInstalledPackageInfo_installedPackageIdsourcePackageIdexposed hiddenModulestrusted importDirs libraryDirs hsLibrariesextraLibrariesextraGHCiLibraries hugsOptions frameworkDirshaddockInterfaces haddockHTMLsemptyInstalledPackageInfoparseInstalledPackageInfoshowInstalledPackageInfoshowInstalledPackageInfoField#showSimpleInstalledPackageInfoFieldfieldsInstalledPackageInfoCommand CommandParseCommandReadyToGo CommandErrors CommandList CommandHelp MkOptDescrArgPlaceHolderOptFlagsLFlagsSFlagsOptDescrBoolOpt ChoiceOptOptArgReqArg OptionField optionDescr DescriptionNameShowOrParseArgs ParseArgsShowArgs CommandUI commandNamecommandSynopsis commandUsagecommandDescriptioncommandDefaultFlagscommandOptions multiOptionreqArgoptArgreqArg'optArg'noArgboolOptboolOpt' choiceOptchoiceOptFromEnumviewAsFieldDescr liftOptioncommandShowOptions makeCommandcommandParseArgs hiddenCommandcommandAddAction commandsRun noExtraFlagsparseCondition mapCondTreemapTreeConstrs mapTreeConds mapTreeDatafreeVarsfinalizePackageDescriptionflattenPackageDescriptionCheckPackageContentOps doesFileExistdoesDirectoryExist PackageCheckPackageDistInexcusablePackageDistSuspiciousPackageBuildWarningPackageBuildImpossible explanation checkPackagecheckConfiguredPackagecheckPackageFilescheckPackageContentcheckPackageFileNamespkgDescrFieldDescrslibFieldDescrsexecutableFieldDescrstestSuiteFieldDescrsbinfoFieldDescrsflagFieldDescrssourceRepoFieldDescrsreadHookedBuildInforeadPackageDescriptionparsePackageDescriptionparseHookedBuildInfowritePackageDescriptionshowPackageDescriptionwriteHookedBuildInfoshowHookedBuildInfowriteGenericPackageDescriptionshowGenericPackageDescription SearchResult Ambiguous UnambiguousNone PackageIndexfromListmergeinsertdeleteInstalledPackageIddeleteSourcePackageIddeletePackageName allPackagesallPackagesByNameallPackagesBySourcePackageIdlookupInstalledPackageIdlookupSourcePackageIdlookupPackageNamelookupDependency searchByNamesearchByNameSubstringdependencyCyclesbrokenPackagesdependencyClosurereverseDependencyClosuretopologicalOrderreverseTopologicalOrderdependencyGraphdependencyInconsistenciesmoduleNameIndexProgramSearchPathEntryProgramSearchPathDefaultProgramSearchPathDirProgramSearchPathdefaultProgramSearchPathfindProgramOnSearchPathprogramSearchPathAsPATHVarProgramLocation FoundOnSystem UserSpecified locationPathConfiguredProgram programIdprogramVersionprogramDefaultArgsprogramOverrideArgsprogramOverrideEnvprogramLocationProgArgProgram programNameprogramFindLocationprogramFindVersionprogramPostConf programPathsuppressOverrideArgs simpleProgramsimpleConfiguredProgram IOEncodingIOEncodingUTF8IOEncodingTextProgramInvocationprogInvokePathprogInvokeArgs progInvokeEnv progInvokeCwdprogInvokeInputprogInvokeInputEncodingprogInvokeOutputEncodingemptyProgramInvocationsimpleProgramInvocationprogramInvocationrunProgramInvocationgetProgramInvocationOutputgetEffectiveEnvironmentmultiStageProgramInvocationinitinvokeregister reregister unregisterexposehidedumplistinitInvocationregisterInvocationreregisterInvocationunregisterInvocationexposeInvocationhideInvocationdumpInvocationlistInvocationcombineObjectFilesmarkupunioninvocationAsSystemScriptinvocationAsShellScriptinvocationAsBatchFilebuiltinPrograms ghcProgram ghcPkgProgram lhcProgram lhcPkgProgram nhcProgram hmakeProgram jhcProgram uhcProgram hpcProgram hugsProgramffihugsProgramhaskellSuiteProgramhaskellSuitePkgProgram happyProgram alexProgram gccProgram arProgram stripProgram hsc2hsProgram c2hsProgram cpphsProgramhscolourProgramhaddockProgramgreencardProgram ldProgram tarProgram cppProgrampkgConfigProgram ProgramDbemptyProgramDbdefaultProgramDbrestoreProgramDbaddKnownProgramaddKnownProgramslookupKnownProgram knownProgramsgetProgramSearchPathsetProgramSearchPathuserSpecifyPathuserMaybeSpecifyPathuserSpecifyArgsuserSpecifyPathsuserSpecifyArgssuserSpecifiedArgs lookupProgram updateProgramconfiguredProgramsconfigureProgramconfigureAllKnownProgramsreconfigureProgramsrequireProgramrequireProgramVersionProgramConfiguration runProgramgetProgramOutput runDbProgramgetDbProgramOutputrawSystemProgramrawSystemProgramStdoutrawSystemProgramConfrawSystemProgramStdoutConfemptyProgramConfigurationdefaultProgramConfigurationrestoreProgramConfigurationfindProgramOnPathBenchmarkFlagsbenchmarkDistPrefbenchmarkVerbositybenchmarkOptions TestFlags testDistPref testVerbosity testHumanLogtestMachineLogtestShowDetails testKeepTixtestList testOptionsTestShowDetails StreamingAlwaysFailuresNever ReplFlagsreplProgramPathsreplProgramArgs replDistPref replVerbosity replReload BuildFlagsbuildProgramPathsbuildProgramArgs buildDistPrefbuildVerbosity buildNumJobs buildArgs CleanFlags cleanSaveConf cleanDistPrefcleanVerbosity HaddockFlagshaddockProgramPathshaddockProgramArgs haddockHoogle haddockHtmlhaddockHtmlLocationhaddockExecutableshaddockTestSuiteshaddockBenchmarkshaddockInternal haddockCsshaddockHscolourhaddockHscolourCsshaddockContentshaddockDistPrefhaddockKeepTempFileshaddockVerbosity HscolourFlags hscolourCSShscolourExecutableshscolourTestSuiteshscolourBenchmarkshscolourDistPrefhscolourVerbosity RegisterFlags regPackageDB regGenScript regGenPkgConf regInPlace regDistPref regVerbosity SDistFlags sDistSnapshotsDistDirectory sDistDistPrefsDistListSourcessDistVerbosity InstallFlagsinstallPackageDBinstallDistPrefinstallUseWrapperinstallInPlaceinstallVerbosity CopyFlagscopyDest copyDistPref copyVerbosity ConfigFlagsconfigProgramsconfigProgramPathsconfigProgramArgsconfigProgramPathExtraconfigHcFlavor configHcPath configHcPkgconfigVanillaLib configProfLibconfigSharedLib configDynExe configProfExeconfigConfigureArgsconfigOptimizationconfigProgPrefixconfigProgSuffixconfigInstallDirsconfigScratchDirconfigExtraLibDirsconfigExtraIncludeDirsconfigDistPrefconfigVerbosityconfigUserInstallconfigPackageDBs configGHCiLibconfigSplitObjsconfigStripExesconfigStripLibsconfigConstraintsconfigDependenciesconfigConfigurationsFlags configTestsconfigBenchmarksconfigLibCoverageconfigExactConfiguration GlobalFlags globalVersionglobalNumericVersionNoFlagdefaultDistPreftoFlagfromFlagfromFlagOrDefault flagToMaybe flagToListdefaultGlobalFlags globalCommandemptyGlobalFlagsconfigAbsolutePathsdefaultConfigFlagsconfigureCommandconfigureOptionsreadPackageDbListshowPackageDbListinstallDirsOptionsemptyConfigFlagsdefaultCopyFlags copyCommandemptyCopyFlagsdefaultInstallFlagsinstallCommandemptyInstallFlagsdefaultSDistFlags sdistCommandemptySDistFlagsdefaultRegisterFlagsregisterCommandunregisterCommandemptyRegisterFlagsemptyHscolourFlagsdefaultHscolourFlagshscolourCommanddefaultHaddockFlagshaddockCommandhaddockOptionsemptyHaddockFlagsdefaultCleanFlags cleanCommandemptyCleanFlags buildVerbosedefaultBuildFlags buildCommand buildOptionsemptyBuildFlagsdefaultReplFlags replCommanddefaultTestFlags testCommandemptyTestFlagsdefaultBenchmarkFlagsbenchmarkCommandemptyBenchmarkFlagsprogramConfigurationPaths'programConfigurationOptionstrueArgfalseArgoptionVerbosity optionNumJobs configureArgsconfigureCCompilerconfigureLinker defaultMaindefaultMainArgsdefaultMainNoReadGhcDynLinkModeGhcStaticAndDynamicGhcDynamicOnly GhcStaticOnlyGhcOptimisationGhcSpecialOptimisationGhcMaximumOptimisationGhcNormalOptimisationGhcNoOptimisationGhcModeGhcModeAbiHashGhcModeInteractive GhcModeMake GhcModeLinkGhcModeCompile GhcOptions ghcOptMode ghcOptExtraghcOptExtraDefaultghcOptInputFilesghcOptInputModulesghcOptOutputFileghcOptOutputDynFileghcOptSourcePathClearghcOptSourcePathghcOptPackageNameghcOptPackageDBsghcOptPackagesghcOptHideAllPackagesghcOptNoAutoLinkPackagesghcOptLinkLibsghcOptLinkLibPathghcOptLinkOptionsghcOptLinkFrameworks ghcOptNoLinkghcOptLinkNoHsMainghcOptCcOptionsghcOptCppOptionsghcOptCppIncludePathghcOptCppIncludesghcOptFfiIncludesghcOptLanguageghcOptExtensionsghcOptExtensionMapghcOptOptimisationghcOptProfilingModeghcOptSplitObjs ghcOptNumJobsghcOptGHCiScriptsghcOptHiSuffixghcOptObjSuffixghcOptDynHiSuffixghcOptDynObjSuffix ghcOptHiDir ghcOptObjDirghcOptOutputDir ghcOptStubDirghcOptDynLinkMode ghcOptShared ghcOptFPicghcOptDylibNameghcOptVerbosity ghcOptCabalrunGHC ghcInvocationrenderGhcOptionsComponentDisabledReasonDisabledAllBenchmarksDisabledAllTestsDisabledComponent LibraryNameComponentLocalBuildInfoBenchComponentLocalBuildInfoTestComponentLocalBuildInfoExeComponentLocalBuildInfoLibComponentLocalBuildInfocomponentPackageDepscomponentLibraries ComponentName CBenchName CTestNameCExeNameCLibName ComponentCBenchCTestCExeCLibLocalBuildInfo configFlagsextraConfigArgsinstallDirTemplatescompiler hostPlatformbuildDir scratchDircomponentsConfigs installedPkgs pkgDescrFile localPkgDescr withPrograms withPackageDBwithVanillaLib withProfLib withSharedLib withDynExe withProfExewithOptimization withGHCiLib splitObjs stripExes stripLibs progPrefix progSuffixexternalPackageDepsinplacePackageIdshowComponentName foldComponentcomponentBuildInfo componentName pkgComponentspkgEnabledComponentscomponentEnabledcomponentDisabledReasonlookupComponent getComponentgetComponentLocalBuildInfo withLibLBI withExeLBI withTestLBIwithComponentsLBIwithAllComponentsInBuildOrderwithComponentsInBuildOrderallComponentsInBuildOrdercomponentsInBuildOrdercheckComponentsCyclicsrcPref hscolourPref haddockPrefautogenModulesDir cppHeaderNameautogenModuleName haddockName mkLibName mkProfLibNamemkSharedLibName exeExtension objExtension dllExtensiongenerate pkgPathEnvVarBuildTargetProblemBuildTargetAmbigiousBuildTargetNoSuchBuildTargetExpectedUserBuildTargetProblemUserBuildTargetUnrecognised BuildTargetBuildTargetFileBuildTargetModuleBuildTargetComponentUserBuildTargetreadBuildTargetsreadUserBuildTargetsreportUserBuildTargetProblemsresolveBuildTargetsreportBuildTargetProblemsTestLogs GroupLogsTestLogtestOptionsReturned testResult TestSuiteLog testSuiteNametestLogslogFile PackageLogplatformlocalPackageLogcountTestResults suitePassed suiteFailed suiteErrortestSuiteLogPathsummarizePackage summarizeTestsummarizeSuiteFinishsummarizeSuiteStart configuregetInstalledPackagesbuildLibbuildExe installLib installExeghcVerbosityOptions ghcOptionsregisterPackage hstoolVersionnumericVersiongetCompilerVersion getExtensions getLanguages initPackageDB packageDbOptenableCoveragetixDir tixFilePathhtmlDir markupTest markupPackagestripExestripLibcreateArLibArchive getGhcInfogetPackageDBContents ghcLibDirghcGlobalPackageDBreplLibstartInterpreterreplExe libAbiHashcomponentGhcOptions invokeHcPkg ghcDynamicgeneratePackageVersionMacros createPiperunTeststubName stubFilePathwriteSimpleTestStubsimpleTestStubstubMain stubWriteLogPPSuffixHandler PreProcessorplatformIndependentrunPreProcessormkSimplePreProcessorrunSimplePreProcessorpreprocessComponent ppGreenCardppUnlitppCppppCpp'ppHsc2hsppC2hsplatformDefinesppHappyppAlex ppSuffixesknownSuffixHandlers UserHooksrunTestsreadDeschookedPreProcessorshookedProgramspreConfconfHookpostConfpreBuild buildHook postBuildpreReplreplHookpostReplpreClean cleanHook postCleanpreCopycopyHookpostCopypreInstinstHookpostInstpreSDist sDistHook postSDistpreRegregHookpostRegpreUnreg unregHook postUnreg preHscolour hscolourHook postHscolour preHaddock haddockHook postHaddockpreTesttestHookpostTestpreBench benchHook postBenchArgsemptyUserHooksbenchsdistlistPackageSources prepareTreeprepareSnapshotTreesnapshotPackagesnapshotVersiondateToSnapshotNumber createArchiveprintPackageProblemsinstallgenerateRegistrationInfogeneralInstalledPackageInfoinplaceInstalledPackageInfoabsoluteInstalledPackageInfoConfigStateFileErrorConfigStateFileErrorTypeConfigStateFileBadVersionConfigStateFileMissingConfigStateFileCantParsetryGetConfigStateFiletryGetPersistBuildConfiggetPersistBuildConfigmaybeGetPersistBuildConfigwritePersistBuildConfigcheckPersistBuildConfigOutdatedlocalBuildInfoFileinterpretPackageDbFlagsccLdOptionsBuildInfoconfigCompilerAuxExconfigCompilerExconfigCompilerconfigCompilerAuxcheckForeignDepsbuildreplinitialBuildStepswriteAutogenFileshaddockhaddockPackagePathshscolourtestdefaultMainWithHooksdefaultMainWithHooksArgssimpleUserHooksdefaultUserHooksautoconfUserHooksversion getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName ClassifiedCommentEndCode BeginCodeLineOrdinaryBlank BirdTrackclassify unclassify reclassifyinlines internalErrorArgDescrNoArgOptionArgOrder ReturnInOrderPermute RequireOrder usageInfogetOptgetOpt'OptKindOptErr EndOfOptsNonOptUnreqOptOptfmtOptfmtShortfmtLonggetNextlongOptshortOpterrAmbigerrReqerrUnrecerrNoArg$fMonoidCDialectParserRPFinalLookGetfinal $fMonadParser$fApplicativeParser$fFunctorParser $fMonadPlusP$fAlternativeP$fMonadP$fApplicativeP $fFunctorP $fTextVersion $fTextBooldoesNotIntersectwildcardUpperBoundisWildcardRange minLowerBound isVersion0 invariantcheckInvariant validVersion validIntervalnonEmpty doesNotTouch unionIntervalintersectInterval$fTextVersionRange$fOrdUpperBound$fOrdLowerBoundclassifyCompilerFlavor Data.MaybeNothingknownCompilerFlavorsbuildCompilerVersion$fTextCompilerId$fTextCompilerFlavordispOptVersion dispVersion $fTextLicense$fPackagePackageIdentifier$fTextDependency$fTextInstalledPackageId$fNFDataPackageIdentifier$fTextPackageIdentifier$fNFDataPackageName$fTextPackageNameGHC.BaseStringvalidModuleCharvalidModuleComponent$fTextModuleNameClassificationStrictnessCompatStrict PermissiveknownOSs osAliases classifyOS knownArches archAliases classifyArchident$fTextPlatform $fTextArch$fTextOSGHC.IOFilePath PathComponentVariable appendSubdirscombinePathTemplategetWindowsProgramFilesDir$fReadPathTemplate$fShowPathTemplate$fReadPathComponent$fShowPathComponent$fReadPathTemplateVariable$fShowPathTemplateVariable$fMonoidInstallDirs$fFunctorInstallDirsGHC.NumNumghc-prim GHC.TypesInt integer-gmpGHC.Integer.TypeIntegerData.Typeable.InternalTypeableGHC.ListzipWithclassifyKnownExtension Text.ReadreadclassifyLanguageclassifyExtensionknownExtensionTable$fTextKnownExtension$fTextExtension$fTextLanguageBool maybeHasLibsMaybestdParserepoTypeAliasesclassifyRepoType"$fPackageGenericPackageDescription$fTextRepoType$fTextRepoKind$fMonoidBuildInfo$fTextBenchmarkType$fMonoidBenchmarkInterface$fMonoidBenchmark$fTextTestType$fMonoidTestSuiteInterface$fMonoidTestSuite$fMonoidExecutable$fMonoidLibrary$fTextBuildType$fPackagePackageDescriptionlanguageToFlagextensionToFlagErrorMsg$fFunctorReadE DeafeningVerboseNormalSilentopenNewBinaryFile pathSeparator std_flags output_flagsrw_flagscreateTempDirectory mkPrivateDir System.IOopenBinaryTempFile openTempFilecopyFilecopyFileChanged filesEqualcopyOrdinaryFilecopyExecutableFile setFileModesetDirOrdinary copyFilesWithdirectory-1.2.1.0System.Directory ignoreBOMreadFileprintRawCommandAndArgsprintRawCommandAndArgsAndEnv syncProcesscreateDirectoryVerbose buildInfoExtTokenSpanIfBlockSectionFUnrecFieldParser warnUnrec ignoreUnrec tokeniseLinemkTreelayoutbracesmkFieldifelseparseModuleNameQ showFreeTextlines_ indentWith SyntaxTreeHasTabsIndent CloseBracket OpenBracketField UTFWarning Separator showPWarningcatchParseError parseFailrunPrunE utf8WarningslocatedErrorMsg syntaxError tabsErrorwarningfield liftField simpleFieldcommaListFieldWithSepcommaListFieldcommaNewLineListFieldspaceListFieldlistFieldWithSep listField optsField boolFieldppFieldsppField showFieldsshowSingleNamedFieldshowSimpleSingleNamedField parseFieldsparseFieldsFlat accumFieldslineNofName readFieldsreadFieldsFlat trimLinestokeniseLineFlat trimLeading trimTrailingparseFilePathQ betweenSpacesparseBuildToolparseBuildToolNameQparseBuildToolNameparsePkgconfigDependencyparsePackageNameQparseVersionRangeQparseOptVersionparseTestedWithQ parseLicenseQparseLanguageQparseExtensionQparseHaskellString parseTokenQ parseTokenQ' parseSepListparseSpaceListparseCommaListparseOptCommaList parseQuoted parseFreeText showFilePath showTokenshowTestedWith$fMonadParseResult$fApplicativeParseResult$fFunctorParseResultbasicFieldDescrsinstalledFieldDescrs$fPackageInstalledPackageInfo_GHC.ReadReadconvertPackageIdmkInstalledPackageIdconvertModuleNameconvertLicense toCurrent CommonFlag commandHelp CommandType HiddenCommand NormalCommandListOptionsFlagHelpFlagcommandGetOpts viewAsGetOptgetChoiceByLongFlaggetCurrentChoice liftOptDescrliftSetcommandListOptions commonFlagsaddCommonFlags$fFunctorCommandParse TargetSet DependencyMap DepTestRsltsimplifyConditionsimplifyWithSysParamsresolveWithFlagsignoreConditionsoverallDependenciesflattenTaggedTargetsPDTaggedPDNullBenchExeLibunDependencyMapBTBTBBTN MissingDepsDepOktoDepMap fromDepMapsimplifyCondTree constrainBylibFillInDefaultsexeFillInDefaultstestFillInDefaultsbenchFillInDefaultsbiFillInDefaults$fMonoidPDTagged$fMonoidDependencyMap$fMonoidDepTestRslt checkSanitycheckCabalVersiondisplayRawVersionRangecheckPackageVersions checkTarPathcheckcheckSpecVersion checkLibrarycheckExecutablecheckTestSuitecheckBenchmark checkFields checkLicensecheckSourceReposcheckGhcOptionscheckCCOptionscheckCPPOptionscheckAlternatives checkPathsdisplayRawDependencycheckConditionalscheckLicensesExistcheckSetupExistscheckConfigureExistscheckLocalPathsExistcheckMissingVcsInforepoTypeDirnamecheckWindowsPathquotecommaSepdupsfileExtensionSupportedLanguage$fShowPackageCheckBenchmarkStanzaTestSuiteStanzastoreXFieldsPDreadAndParseFilePMStTrunStTbenchmarkStanzaBenchmarkTypebenchmarkStanzaMainIsbenchmarkStanzaBenchmarkModulebenchmarkStanzaBuildInfotestStanzaTestTypetestStanzaMainIstestStanzaTestModuletestStanzaBuildInfostoreXFieldsLibstoreXFieldsExeemptyTestStanzastoreXFieldsTestvalidateTestSuiteemptyBenchmarkStanzabenchmarkFieldDescrsstoreXFieldsBenchmarkvalidateBenchmarkstoreXFieldsBIstanzasisStanzaHeadermapSimpleFieldsconstraintFieldNamesparseConstraint libFieldNamesbuildInfoNamesmodifyliftevalStT peekField skipField parseFielddeprecatedFieldsdeprecatedFieldsPkgDescrdeprecatedFieldsBuildInfo deprecFieldppCustomFields ppCustomFieldfindIndentTabs $fMonadStT$fApplicativeStT $fFunctorStTsimplifiedPrintingppGenericPackageDescriptionppPackageDescription ppSourceRepos ppSourceRepo ppDiffFieldsppGenPackageFlagsppFlag ppLibrary ppExecutables ppTestSuites ppBenchmarks ppCondition ppConfVar ppFlagName ppCondTreeppDeps emptyLine Data.MonoidmappendmkPackageIndex$fMonoidPackageIndexgetEnvironmentfindExecutablemaxCommandLineSizemungePackagePathssetInstalledPackageIdregisterInvocation'packageDbStackOpts packageDbFlag packageDbOpts verbosityOpts legacyVersionmarkupInvocationunionInvocationuserSpecifiedPathconfigurePrograms Control.MonadfoldMConfiguredProgsUnconfiguredProgsUnconfiguredProgramunconfiguredProgsprogSearchPathconfiguredProgsupdateUnconfiguredProgsupdateConfiguredProgs$fReadProgramDb$fShowProgramDbprogramConfigurationPathsprogramConfigurationOption splitArgsallFlagsparseDependencyknownTestShowDetailsprogramFlagsDescription reqArgFlagoptionDistPref configureProg$fMonoidBenchmarkFlags$fMonoidTestFlags$fMonoidTestShowDetails$fTextTestShowDetails$fMonoidReplFlags$fMonoidBuildFlags$fMonoidCleanFlags$fMonoidHaddockFlags$fMonoidHscolourFlags$fMonoidRegisterFlags$fMonoidSDistFlags$fMonoidInstallFlags$fMonoidCopyFlags$fMonoidConfigFlags$fMonoidGlobalFlags $fEnumFlag $fBoundedFlag $fMonoidFlag $fFunctorFlagdefaultMainHelperconfigureAction copyAction installAction haddockAction buildAction cleanAction sdistActionregisterActionunregisterAction packageDbArgs$fMonoidGhcOptionsget_prefix_win32get_prefix_hugsfilename_stuffMatchmatchInexactly findMatchUserBuildTargetDoubleUserBuildTargetSingle matchPlusmatchPlusShadowing exactMatchesinexactMatchesMaybeAmbigious MatchErrorMatchErrorNoSuchMatchErrorExpected Confidence InexactMatch ExactMatchNoMatch ComponentKind BenchKindTestKindExeKindLibKindComponentStringName ComponentInfo cinfoName cinfoStrName cinfoSrcDirs cinfoModules cinfoHsFiles cinfoCFiles QualLevelQL3QL2QL1UserBuildTargetTriplecheckTargetExistsAsFilereadUserBuildTargetshowUserBuildTargetresolveBuildTargetdisambiguateBuildTargetsrenderBuildTargetmatchBuildTargetmatchBuildTarget1matchBuildTarget2matchBuildTarget3pkgComponentInfocomponentStringNamecomponentModulescomponentHsFiles componentKind cinfoKindmatchComponentKindshowComponentKindshowComponentKindShortmatchComponent1matchComponent2guardComponentNamematchComponentNamematchComponentKindAndName matchModule1 matchModule2 matchModule3guardModuleNamematchModuleName matchFile1 matchFile2 matchFile3matchComponentFilematchFileExistsmatchModuleFileUnrootedmatchModuleFileRootedmatchModuleFileStemmatchOtherFileRootedmatchOtherFileUnrooted matchFilematchDirectoryPrefix matchZeroaddDepth forceInexactmatchErrorExpectedmatchErrorNoSuch expecting orNoSuchThingincreaseConfidenceincreaseConfidenceFor nubMatchesnubMatchErrorstryEachcaseFold $fMonadMatch$fApplicativeMatch$fFunctorMatch$fMonadPlusMatch$fAlternativeMatchTrueFalse resultStringjhcLanguageExtensions jhcLanguagesconstructJHCCmdLine jhcPkgConfconfigureToolchaingetInstalledPackages'hackThreadedFlagcheckPackageDbStack substTopDirgetHaskellObjectsconstructGHCCmdLineghcPackageFlagsghcPackageDbOptionsconstructCcCmdLine ghcCcOptions mkGHCiLibNamenhcLanguageExtensionsgetPhonyInstalledPackageInfo nhcLanguagespackageDbPathsgetPackageDbDirsgetInstalledPackagegetFullInstalledPackageInfonhcVerbosityOptionsgetModulePathsuhcLanguageExtensionsaddBuiltinVersionsinstalledPkgConfigisPkgDirmkInstalledPackageInfo uhcLanguagesgetUserPackageDir parsePackageconstructUHCCmdLineuhcPackageDbOptions uhcTargetuhcTargetVariant uhcPackageDiruhcPackageSubDirhpcDirmixDirrunStrip wipeMetadataguessToolFromGhcPathguessGhcPkgFromGhcPathguessHsc2hsFromGhcPatholdLanguageExtensionstoPackageIndexfilterGhciFlagstargetPlatform ghcLibDir'checkPackageDbEnvVarremoveMingwIncludeDirbuildOrReplLibbuildOrReplExecomponentCcGhcOptionsghcLookupPropertyghcSupportsDynamicToogenerateToolVersionMacrosgenerateMacrosfixchar stubRunTests testOptionpreprocessFileppGhcCppppCpphs getCppOptions standardPP benchOptionCreateArchiveFun!listPackageSourcesMaybeExecutablelistPackageSourcesOrdinary findSetupFilemaybeCreateDefaultSetupScriptfindMainExeFilefindIncludeFilefilterAutogenModuleallSourcesBuildInfo tarBallNameoverwriteSnapshotPackageDescmapAllBuildInfohugsLanguageExtensionsgetOptionsFromSource stripCommentshugsMainFilename getVersion hugsLanguagescompileBuildInfosuffixes copyModule compileFilestestFFI compileFFI includeOpts getCFilessymbolswithHaskellFile takeWhileJusthugsInstallSuffixeswriteHcPkgRegisterScriptregScriptFileNameunregScriptFileNameselectDependencycheckPackageProblemsFailedDependencyDependencyNoVersionDependencyNotExistsResolvedDependencyInternalDependencyExternalDependency showHeadercurrentCabalIdcurrentCompilerId parseHeadermkProgramsConfig reportProgram hackageUrlreportSelectedDependenciesreportFailedDependencies!newPackageDepsBehaviourMinVersionnewPackageDepsBehaviourcombinedConstraintsconfigureRequiredProgramsconfigureRequiredProgramconfigurePkgconfigPackagesmkComponentsLocalBuildInforeportComponentCycleinstallDataFilesinstallIncludeFilestestSuiteExeV10AsExetestSuiteLibV09AsLibAndExebenchmarkExeV10asExecreateInternalPackageDBcheckBuildTargetsbuildComponent replComponentaddInternalBuildTools Directory HaddockArgsargInterfaceFileargPackageNameargHideModulesargIgnoreExports argLinkSource argCssFile argContents argOutput argInterfaces argOutputDirargTitle argPrologue argGhcOptions argGhcLibDir argTargets runHaddock exeBuildDirOutputHoogleHtmlTemplateDirunDir' argVerboseunDir fromFlagsfromPackageDescription fromLibraryfromExecutable compToExe getInterfaces getGhcCppOpts getGhcLibDir renderArgsrenderPureArgshaddockPackageFlagshaddockTemplateEnv hscolour'haddockToHscolourgetLibSourceFilesgetExeSourceFilesgetSourceFiles$fMonoidDirectory$fMonoidHaddockArgspackageLogPathallSuffixHandlers replActionhscolourAction testAction benchAction hookedActionhookedActionWithArgssanityCheckHookedBuildInfogetBuildConfigcleanrunConfigureScriptgetHookedBuildInfodefaultTestHookdefaultBenchHookdefaultInstallHookdefaultBuildHookdefaultReplHookdefaultRegHook