Documentation

The representation of Makefile variable

Recipe answers to the question 'How to build the targets'. Internally, it contains sets of targets and prerequisites, as well as shell commands required to build former from latter

Class of things which may be referenced using '$(expr)' from inside of quasy-quoted shell expressions

Class of things which may be referenced using '@(expr)' syntax of the quasi-quoted shell expressions.

Simple wrapper for strings, a target for various typeclass instances.

An alias to CakeString constructor

Verison of Action monad with fixed parents

Render the Makefile. Return either the content (Right), or error messages (Left).

A General Make runner. Executes the monad, returns the Makefile as a String. Errors go to stdout. fail is possible.

Execute the Make monad, build the Makefile, write it to the output file. Also note, that errors (if any) go to the stderr. fail will be executed in such cases

Add 'include ...' directive to the final Makefile for each input file.

A Monad providing access to MakeState. TODO: not mention IO here.

A version of rule2. Rule places it's recipe above all recipies defined so far.

Build a Recipe using the builder provided and record it to the MakeState. Return the copy of Recipe (which should not be changed in future) and the result of recipe builder. The typical recipe builder result is the list of it's targets.

Example Lets declare a rule which builds "main.o" out of "main.c" and CFLAGS variable

let c = file "main.c"
rule $ shell [cmd| gcc -c $(extvar "CFLAGS") -o @(c.="o") $c |]

A version of rule, without monad set explicitly

Adds the phony target for a rule. Typical usage:

rule $ do
 phony "clean"
 unsafeShell [cmd|rm $elf $os $d|]

Add it's argument to the list of dependencies (prerequsites) of a current recipe under construction

Declare that current recipe produces some producable item.

Modifie the recipe builder: ignore all the dependencies

Add prebuild command

Add prebuild command

Simple wrapper for FilePath.

Alias for replaceExtension

Redefine standard / operator to work with Files

Convert File back to FilePath

Obtain the contents of a File. Note, that this generally means, that Makefile should be regenerated each time the File is changed.

Get a list of prerequisites added so far

Apply the recipe builder to the current recipe state. Return the list of targets of the current Recipe under construction

Version of shell which doesn't track it's dependencies

Has effect of a function QQ -> CommandGen where QQ is a string supporting the following syntax:

• $(expr) evaluates to expr and adds it to the list of dependencies (prerequsites)
• @(expr) evaluates to expr and adds it to the list of targets
• $$ and @@ evaluates to $ and @

Example

[cmd|gcc $flags -o @file|]

is equivalent to

  return $ CommandGen $ do
    s1 <- refInput "gcc "
    s2 <- refInput (flags :: Variable)
    s3 <- refInput " -o "
    s4 <- refOutput (file :: File)
    return (s1 ++ s2 ++ s3 ++ s4)

Later, this command may be examined or passed to the shell function to apply it to the recipe

Declare the variable which is defined in the current Makefile and has it's default value

Declare the variable which is not defined in the target Makefile

CommandGen is a recipe-builder packed in the newtype to prevent partial expantion of it's commands

Special variable $(MAKE)