Safe Haskell	None
Language	Haskell98

Development.Shake.Language.C.BuildFlags

Contents

Source Language
Build flags
- Working with config files
Utilities

Description

The BuildFlags record is an abstraction for various toolchain flags for building executables and libraries from source files in a C-based language. It's intended to be toolchain-independent, but currently there's a bias towards binutils/gcc/clang toolchains.

Synopsis

Source Language

data Language #

Source language.

Currently something derived from C.

Constructors

C	Plain old C
Cpp	C++
ObjC	Objective-C
ObjCpp	Objective-C with C++ (Apple extension)

Instances

Enum Language #
Methods succ :: Language -> Language # pred :: Language -> Language # toEnum :: Int -> Language # fromEnum :: Language -> Int # enumFrom :: Language -> [Language] # enumFromThen :: Language -> Language -> [Language] # enumFromTo :: Language -> Language -> [Language] # enumFromThenTo :: Language -> Language -> Language -> [Language] #
Eq Language #
Methods (==) :: Language -> Language -> Bool # (/=) :: Language -> Language -> Bool #
Show Language #
Methods showsPrec :: Int -> Language -> ShowS # show :: Language -> String # showList :: [Language] -> ShowS #

Build flags

data BuildFlags #

Record type for abstracting various toolchain command line flags.

BuildFlags is an instance of Default, you can create a default record with def. BuildFlags is also an instance Monoid, you can create an empty record with mempty and append flags with mappend. def and mempty are synonyms:

>>> (def :: BuildFlags) == (mempty :: BuildFlags)
True

Record accessors are Lenses from the fclabels package, which makes accessing and modifying record fields a bit more convenient. fclabels was chosen over lens because it has far fewer dependencies, which is convenient when installing the Shake build system in a per-project cabal sandbox. We might switch to lens when it gets included in the Haskell platform.

There are two convenience functions for working with BuildFlags record fields containing lists of flags, append and prepend. Since most combinators in this library expect a function BuildFlags -> BuildFlags, the following is a common idiom:

buildFlags . append systemIncludes ["path"]

Note that when modifying the same record field, order of function composition matters and you might want to use the arrow combinator >>> for appending in source statement order:

>>> :{
  get systemIncludes
    $ append systemIncludes ["path1"] . append systemIncludes ["path2"]
    $ mempty
:}
["path2","path1"]

>>> :{
  get systemIncludes
    $ append systemIncludes ["path1"] >>> append systemIncludes ["path2"]
    $ mempty
:}
["path1","path2"]

See Development.Shake.Language.C.Rules for how to use BuildFlags in build product rules.

Instances

Eq BuildFlags #
Methods (==) :: BuildFlags -> BuildFlags -> Bool # (/=) :: BuildFlags -> BuildFlags -> Bool #
Show BuildFlags #
Methods showsPrec :: Int -> BuildFlags -> ShowS # show :: BuildFlags -> String # showList :: [BuildFlags] -> ShowS #
Monoid BuildFlags #
Methods mempty :: BuildFlags # mappend :: BuildFlags -> BuildFlags -> BuildFlags # mconcat :: [BuildFlags] -> BuildFlags #
Default BuildFlags #
Methods def :: BuildFlags #

systemIncludes :: forall cat. ArrowApply cat => Lens cat BuildFlags [FilePath] #

System include directories, referenced by #include <...> in code and usually passed to the compiler with the -isystem flag.

userIncludes :: forall cat. ArrowApply cat => Lens cat BuildFlags [FilePath] #

User include directories, referenced by #include "..." in code and usually passed to the compiler with the -I flag.

defines :: forall cat. ArrowApply cat => Lens cat BuildFlags [(String, Maybe String)] #

Preprocessor defines, a list of pairs of names with or without a value.

preprocessorFlags :: forall cat. ArrowApply cat => Lens cat BuildFlags [String] #

Other preprocessor flags.

compilerFlags :: forall cat. ArrowApply cat => Lens cat BuildFlags [(Maybe Language, [String])] #

Compiler flags, either generic ones or for a specific source Language.

libraryPath :: forall cat. ArrowApply cat => Lens cat BuildFlags [FilePath] #

Linker search path for libraries.

libraries :: forall cat. ArrowApply cat => Lens cat BuildFlags [String] #

List of libraries to link against. Note that you should use the library name without the lib prefix and without extension.

linkerFlags :: forall cat. ArrowApply cat => Lens cat BuildFlags [String] #

Flags passed to the linker.

localLibraries :: forall cat. ArrowApply cat => Lens cat BuildFlags [FilePath] #

Locally built static libraries to be linked against. See also the corresponding section in the manual.

archiverFlags :: forall cat. ArrowApply cat => Lens cat BuildFlags [String] #

Flags passed to the object archiver. ** Utilities for toolchain writers

defineFlags :: BuildFlags -> [String] #

Construct preprocessor flags from the defines field of BuildFlags.

compilerFlagsFor :: Maybe Language -> BuildFlags -> [String] #

Return a list of compiler flags for a specific source language.

Working with config files

fromConfig :: (Functor m, Monad m) => (String -> m (Maybe String)) -> m (BuildFlags -> BuildFlags) #

Construct a BuildFlags modifier function from a config file.

Utilities

(>>>=) :: Monad m => m (a -> b) -> m (b -> c) -> m (a -> c) #

Utility function for composing functions in a monad.

append #

Arguments

:: Monoid a
=> (f :-> a)	lens
-> a	stuff to append
-> f	original record
-> f	modified record

Append stuff to the Monoid in record field specified by lens.

prepend #

Arguments

:: Monoid a
=> (f :-> a)	lens
-> a	stuff to prepend
-> f	original record
-> f	modified record

Prepend stuff to the Monoid in record field specified by lens.