Gradle User Guide

Version 4.3.1

Copies of this document may be made for your own use and for distribution to others, provided that you do not charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether distributed in print or electronically.

Table of Contents

I. About Gradle
1. Introduction
2. Overview
II. Working with existing builds
3. Installing Gradle
4. Using the Gradle Command-Line
5. The Gradle Console
6. The Gradle Wrapper
7. The Gradle Daemon
8. Dependency Management Basics
9. Introduction to multi-project builds
10. Continuous build
11. Composite builds
12. The Build Environment
13. Troubleshooting
14. Embedding Gradle using the Tooling API
15. Build Cache
III. Writing Gradle build scripts
16. Build Script Basics
17. Build Init Plugin
18. Writing Build Scripts
19. More about Tasks
20. Working With Files
21. Using Ant from Gradle
22. The Build Lifecycle
23. Wrapper Plugin
24. Logging
25. Dependency Management
26. Multi-project Builds
27. Gradle Plugins
28. Standard Gradle plugins
29. The Project Report Plugin
30. The Build Dashboard Plugin
31. Comparing Builds
32. Publishing artifacts
33. The Maven Plugin
34. The Signing Plugin
35. Ivy Publishing (new)
36. Maven Publishing (new)
37. The Distribution Plugin
38. The Announce Plugin
39. The Build Announcements Plugin
IV. Extending the build
40. Writing Custom Task Classes
41. Writing Custom Plugins
42. The Java Gradle Plugin Development Plugin
43. Organizing Build Logic
44. Initialization Scripts
45. The Gradle TestKit
V. Building JVM projects
46. Java Quickstart
47. The Java Plugin
48. The Java Library Plugin
49. Web Application Quickstart
50. The War Plugin
51. The Ear Plugin
52. The Jetty Plugin
53. The Application Plugin
54. The Java Library Distribution Plugin
55. Groovy Quickstart
56. The Groovy Plugin
57. The Scala Plugin
58. The ANTLR Plugin
59. The Checkstyle Plugin
60. The CodeNarc Plugin
61. The FindBugs Plugin
62. The JDepend Plugin
63. The PMD Plugin
64. The JaCoCo Plugin
65. The OSGi Plugin
66. The Eclipse Plugins
67. The IDEA Plugin
VI. The Software model
68. Rule based model configuration
69. Software model concepts
70. Implementing model rules in a plugin
71. Building Java Libraries
72. Building Play applications
73. Building native software
74. Extending the software model
VII. Appendix
A. Gradle Samples
B. Potential Traps
C. The Feature Lifecycle
D. Gradle Command Line
E. Documentation licenses

List of Examples

4.1. Executing multiple tasks
4.2. Excluding tasks
4.3. Abbreviated task name
4.4. Abbreviated camel case task name
4.5. Selecting the project using a build file
4.6. Selecting the project using project directory
4.7. Forcing tasks to run
4.8. Obtaining information about projects
4.9. Providing a description for a project
4.10. Obtaining information about tasks
4.11. Changing the content of the task report
4.12. Obtaining more information about tasks
4.13. Obtaining detailed help for tasks
4.14. Obtaining information about dependencies
4.15. Filtering dependency report by configuration
4.16. Getting the insight into a particular dependency
4.17. Information about properties
6.1. Running the Wrapper task
6.2. Wrapper task
6.3. Wrapper generated files
6.4. Specifying the HTTP Basic Authentication credentials using system properties
6.5. Specifying the HTTP Basic Authentication credentials in distributionUrl
6.6. Configuring SHA-256 checksum verification
8.1. Declaring dependencies
8.2. Definition of an external dependency
8.3. Shortcut definition of an external dependency
8.4. Usage of Maven central repository
8.5. Usage of JCenter repository
8.6. Usage of a remote Maven repository
8.7. Usage of a remote Ivy directory
8.8. Usage of a local Ivy directory
8.9. Publishing to an Ivy repository
8.10. Publishing to a Maven repository
9.1. Listing the projects in a build
11.1. Dependencies of my-app
11.2. Declaring a command-line composite
11.3. Declaring a separate composite
11.4. Depending on task from included build
11.5. Build that does not declare group attribute
11.6. Declaring the substitutions for an included build
11.7. Depending on a single task from an included build
11.8. Depending on a tasks with path in all included builds
12.1. Setting properties with a file
12.2. Configuring an HTTP proxy
12.3. Configuring an HTTPS proxy
14.1. Using the tooling API
15.1. Pull from HttpBuildCache
15.2. Allow untrusted SSL certificate for HttpBuildCache
15.3. Recommended setup for CI push use case
15.4. Consistent setup for buildSrc and main build
15.5. Configure built-in build caches
15.6. Init script to configure the build cache
16.1. Your first build script
16.2. Execution of a build script
16.3. A task definition shortcut
16.4. Using Groovy in Gradle's tasks
16.5. Using Groovy in Gradle's tasks
16.6. Declaration of task that depends on other task
16.7. Lazy dependsOn - the other task does not exist (yet)
16.8. Dynamic creation of a task
16.9. Accessing a task via API - adding a dependency
16.10. Accessing a task via API - adding behaviour
16.11. Accessing task as a property of the build script
16.12. Adding extra properties to a task
16.13. Using AntBuilder to execute ant.loadfile target
16.14. Using methods to organize your build logic
16.15. Defining a default task
16.16. Different outcomes of build depending on chosen tasks
18.1. Accessing property of the Project object
18.2. Using local variables
18.3. Using extra properties
18.4. Configuring arbitrary objects
18.5. Configuring arbitrary objects using a script
18.6. Groovy JDK methods
18.7. Property accessors
18.8. Method call without parentheses
18.9. List and map literals
18.10. Closure as method parameter
18.11. Closure delegates
19.1. Defining tasks
19.2. Defining tasks - using strings for task names
19.3. Defining tasks with alternative syntax
19.4. Accessing tasks as properties
19.5. Accessing tasks via tasks collection
19.6. Accessing tasks by path
19.7. Creating a copy task
19.8. Configuring a task - various ways
19.9. Configuring a task - with closure
19.10. Defining a task with closure
19.11. Adding dependency on task from another project
19.12. Adding dependency using task object
19.13. Adding dependency using closure
19.14. Adding a 'must run after' task ordering
19.15. Adding a 'should run after' task ordering
19.16. Task ordering does not imply task execution
19.17. A 'should run after' task ordering is ignored if it introduces an ordering cycle
19.18. Adding a description to a task
19.19. Overwriting a task
19.20. Skipping a task using a predicate
19.21. Skipping tasks with StopExecutionException
19.22. Enabling and disabling tasks
19.23. Custom task class
19.24. Ad-hoc task
19.25. Ad-hoc task declaring a destroyable
19.26. Using runtime API with custom task type
19.27. Using skipWhenEmpty() via the runtime API
19.28. Inferred task dependency via task outputs
19.29. Inferred task dependency via a task argument
19.30. Declaring a method to add task inputs
19.31. Declaring a method to add a task as an input
19.32. Failed attempt at setting up an inferred task dependency
19.33. Setting up an inferred task dependency between output dir and input files
19.34. Setting up an inferred task dependency with files()
19.35. Setting up an inferred task dependency with builtBy()
19.36. Ignoring up-to-date checks
19.37. Runtime classpath normalization
19.38. Task rule
19.39. Dependency on rule based tasks
19.40. Adding a task finalizer
19.41. Task finalizer for a failing task
20.1. Locating files
20.2. Creating a file collection
20.3. Using a file collection
20.4. Implementing a file collection
20.5. Creating a file tree
20.6. Using a file tree
20.7. Using an archive as a file tree
20.8. Specifying a set of files
20.9. Copying files using the copy task
20.10. Specifying copy task source files and destination directory
20.11. Selecting the files to copy
20.12. Copying files using the copy() method without up-to-date check
20.13. Copying files using the copy() method with up-to-date check
20.14. Renaming files as they are copied
20.15. Filtering files as they are copied
20.16. Nested copy specs
20.17. Using the Sync task to copy dependencies
20.18. Creating a ZIP archive
20.19. Creation of ZIP archive
20.20. Configuration of archive task - custom archive name
20.21. Configuration of archive task - appendix & classifier
20.22. Activating reproducible archives
21.1. Using an Ant task
21.2. Passing nested text to an Ant task
21.3. Passing nested elements to an Ant task
21.4. Using an Ant type
21.5. Using a custom Ant task
21.6. Declaring the classpath for a custom Ant task
21.7. Using a custom Ant task and dependency management together
21.8. Importing an Ant build
21.9. Task that depends on Ant target
21.10. Adding behaviour to an Ant target
21.11. Ant target that depends on Gradle task
21.12. Renaming imported Ant targets
21.13. Setting an Ant property
21.14. Getting an Ant property
21.15. Setting an Ant reference
21.16. Getting an Ant reference
21.17. Fine tuning Ant logging
22.1. Single project build
22.2. Hierarchical layout
22.3. Flat layout
22.4. Modification of elements of the project tree
22.5. Adding of test task to each project which has certain property set
22.6. Notifications
22.7. Setting of certain property to all tasks
22.8. Logging of start and end of each task execution
24.1. Using stdout to write log messages
24.2. Writing your own log messages
24.3. Using SLF4J to write log messages
24.4. Configuring standard output capture
24.5. Configuring standard output capture for a task
24.6. Customizing what Gradle logs
25.1. Definition of a configuration
25.2. Accessing a configuration
25.3. Configuration of a configuration
25.4. Module dependencies
25.5. Artifact only notation
25.6. Dependency with classifier
25.7. Iterating over a configuration
25.8. Client module dependencies - transitive dependencies
25.9. Project dependencies
25.10. File dependencies
25.11. Generated file dependencies
25.12. Gradle API dependencies
25.13. Gradle's Groovy dependencies
25.14. Excluding transitive dependencies
25.15. Optional attributes of dependencies
25.16. Collections and arrays of dependencies
25.17. Dependency configurations
25.18. Dependency configurations for project
25.19. Configuration.copy
25.20. Accessing declared dependencies
25.21. Configuration.files
25.22. Configuration.files with spec
25.23. Configuration.copy
25.24. Configuration.copy vs. Configuration.files
25.25. Adding central Maven repository
25.26. Adding Bintray's JCenter Maven repository
25.27. Using Bintrays's JCenter with HTTP
25.28. Adding Google Maven repository
25.29. Adding the local Maven cache as a repository
25.30. Adding custom Maven repository
25.31. Adding additional Maven repositories for JAR files
25.32. Accessing password protected Maven repository
25.33. Flat repository resolver
25.34. Ivy repository
25.35. Ivy repository with named layout
25.36. Ivy repository with pattern layout
25.37. Ivy repository with multiple custom patterns
25.38. Ivy repository with Maven compatible layout
25.39. Ivy repository
25.40. Declaring a Maven and Ivy repository
25.41. Providing credentials to a Maven and Ivy repository
25.42. Declaring a S3 backed Maven and Ivy repository
25.43. Declaring a S3 backed Maven and Ivy repository using IAM
25.44. Declaring a Google Cloud Storage backed Maven and Ivy repository using default application credentials
25.45. Configure repository to use only digest authentication
25.46. Configure repository to use preemptive authentication
25.47. Accessing a repository
25.48. Configuration of a repository
25.49. Definition of a custom repository
25.50. Forcing consistent version for a group of libraries
25.51. Using a custom versioning scheme
25.52. Blacklisting a version with a replacement
25.53. Changing dependency group and/or name at the resolution
25.54. Substituting a module with a project
25.55. Substituting a project with a module
25.56. Conditionally substituting a dependency
25.57. Specifying default dependencies on a configuration
25.58. Enabling dynamic resolve mode
25.59. 'Latest' version selector
25.60. Custom status scheme
25.61. Custom status scheme by module
25.62. Ivy component metadata rule
25.63. Rule source component metadata rule
25.64. Component selection rule
25.65. Component selection rule with module target
25.66. Component selection rule with metadata
25.67. Component selection rule using a rule source object
25.68. Declaring module replacement
25.69. Dynamic version cache control
25.70. Changing module cache control
26.1. Multi-project tree - water & bluewhale projects
26.2. Build script of water (parent) project
26.3. Multi-project tree - water, bluewhale & krill projects
26.4. Water project build script
26.5. Defining common behavior of all projects and subprojects
26.6. Defining specific behaviour for particular project
26.7. Defining specific behaviour for project krill
26.8. Adding custom behaviour to some projects (filtered by project name)
26.9. Adding custom behaviour to some projects (filtered by project properties)
26.10. Running build from subproject
26.11. Evaluation and execution of projects
26.12. Evaluation and execution of projects
26.13. Running tasks by their absolute path
26.14. Dependencies and execution order
26.15. Dependencies and execution order
26.16. Dependencies and execution order
26.17. Declaring dependencies
26.18. Declaring dependencies
26.19. Cross project task dependencies
26.20. Configuration time dependencies
26.21. Configuration time dependencies - evaluationDependsOn
26.22. Configuration time dependencies
26.23. Dependencies - real life example - crossproject configuration
26.24. Project lib dependencies
26.25. Project lib dependencies
26.26. Fine grained control over dependencies
26.27. Build and Test Single Project
26.28. Partial Build and Test Single Project
26.29. Build and Test Depended On Projects
26.30. Build and Test Dependent Projects
27.1. Applying a script plugin
27.2. Applying a core plugin
27.3. Applying a community plugin
27.4. Applying plugins only on certain subprojects.
27.5. Using plugins from custom plugin repositories.
27.6. Plugin resolution strategy.
27.7. Complete Plugin Publishing Sample
27.8. Applying a binary plugin
27.9. Applying a binary plugin by type
27.10. Applying a plugin with the buildscript block
30.1. Using the Build Dashboard plugin
32.1. Defining an artifact using an archive task
32.2. Defining an artifact using a file
32.3. Customizing an artifact
32.4. Map syntax for defining an artifact using a file
32.5. Configuration of the upload task
33.1. Using the Maven plugin
33.2. Creating a standalone pom.
33.3. Upload of file to remote Maven repository
33.4. Upload of file via SSH
33.5. Customization of pom
33.6. Builder style customization of pom
33.7. Modifying auto-generated content
33.8. Customization of Maven installer
33.9. Generation of multiple poms
33.10. Accessing a mapping configuration
34.1. Using the Signing plugin
34.2. Signing a configuration
34.3. Signing a configuration output
34.4. Signing a task
34.5. Signing a task output
34.6. Conditional signing
34.7. Signing a POM for deployment
35.1. Applying the “ivy-publish” plugin
35.2. Publishing a Java module to Ivy
35.3. Publishing additional artifact to Ivy
35.4. customizing the publication identity
35.5. Customizing the module descriptor file
35.6. Publishing multiple modules from a single project
35.7. Declaring repositories to publish to
35.8. Choosing a particular publication to publish
35.9. Publishing all publications via the “publish” lifecycle task
35.10. Generating the Ivy module descriptor file
35.11. Publishing a Java module
35.12. Example generated ivy.xml
36.1. Applying the 'maven-publish' plugin
36.2. Adding a MavenPublication for a Java component
36.3. Adding additional artifact to a MavenPublication
36.4. customizing the publication identity
36.5. Modifying the POM file
36.6. Publishing multiple modules from a single project
36.7. Declaring repositories to publish to
36.8. Publishing a project to a Maven repository
36.9. Publish a project to the Maven local repository
36.10. Generate a POM file without publishing
37.1. Using the distribution plugin
37.2. Adding extra distributions
37.3. Configuring the main distribution
37.4. publish main distribution
38.1. Using the announce plugin
38.2. Configure the announce plugin
38.3. Using the announce plugin
39.1. Using the build announcements plugin
39.2. Using the build announcements plugin from an init script
40.1. Defining a custom task
40.2. A hello world task
40.3. A customizable hello world task
40.4. A build for a custom task
40.5. A custom task
40.6. Using a custom task in another project
40.7. Testing a custom task
40.8. Defining an incremental task action
40.9. Running the incremental task for the first time
40.10. Running the incremental task with unchanged inputs
40.11. Running the incremental task with updated input files
40.12. Running the incremental task with an input file removed
40.13. Running the incremental task with an output file removed
40.14. Running the incremental task with an input property changed
40.15. Creating a unit of work implementation
40.16. Submitting a unit of work for execution
40.17. Waiting for asynchronous work to complete
40.18. Submitting an item of work to run in a worker daemon
41.1. A custom plugin
41.2. A custom plugin extension
41.3. A custom plugin with configuration closure
41.4. Evaluating file properties lazily
41.5. Mapping extension properties to task properties
41.6. A build for a custom plugin
41.7. Wiring for a custom plugin
41.8. Using a custom plugin in another project
41.9. Applying a community plugin with the plugins DSL
41.10. Testing a custom plugin
41.11. Using the Java Gradle Plugin Development plugin
41.12. Nested DSL elements
41.13. Managing a collection of objects
42.1. Using the Java Gradle Plugin Development plugin
42.2. Using the gradlePlugin {} block.
43.1. Using inherited properties and methods
43.2. Using injected properties and methods
43.3. Configuring the project using an external build script
43.4. Custom buildSrc build script
43.5. Adding subprojects to the root buildSrc project
43.6. Running another build from a build
43.7. Declaring external dependencies for the build script
43.8. A build script with external dependencies
43.9. Ant optional dependencies
44.1. Using init script to perform extra configuration before projects are evaluated
44.2. Declaring external dependencies for an init script
44.3. An init script with external dependencies
44.4. Using plugins in init scripts
45.1. Declaring the TestKit dependency
45.2. Declaring the JUnit dependency
45.3. Using GradleRunner with JUnit
45.4. Using GradleRunner with Spock
45.5. Making the code under test classpath available to the tests
45.6. Injecting the code under test classes into test builds
45.7. Injecting the code under test classes into test builds for Gradle versions prior to 2.8
45.8. Using the Java Gradle Development plugin for generating the plugin metadata
45.9. Automatically injecting the code under test classes into test builds
45.10. Reconfiguring the classpath generation conventions of the Java Gradle Development plugin
45.11. Specifying a Gradle version for test execution
45.12. Testing cacheable tasks
46.1. Using the Java plugin
46.2. Building a Java project
46.3. Adding Maven repository
46.4. Adding dependencies
46.5. Customization of MANIFEST.MF
46.6. Adding a test system property
46.7. Publishing the JAR file
46.8. Eclipse plugin
46.9. Java example - complete build file
46.10. Multi-project build - hierarchical layout
46.11. Multi-project build - settings.gradle file
46.12. Multi-project build - common configuration
46.13. Multi-project build - dependencies between projects
46.14. Multi-project build - distribution file
47.1. Using the Java plugin
47.2. Custom Java source layout
47.3. Accessing a source set
47.4. Configuring the source directories of a source set
47.5. Defining a source set
47.6. Defining source set dependencies
47.7. Compiling a source set
47.8. Assembling a JAR for a source set
47.9. Generating the Javadoc for a source set
47.10. Running tests in a source set
47.11. Declaring annotation processors
47.12. Filtering tests in the build script
47.13. JUnit Categories
47.14. Grouping TestNG tests
47.15. Preserving order of TestNG tests
47.16. Grouping TestNG tests by instances
47.17. Creating a unit test report for subprojects
47.18. Customization of MANIFEST.MF
47.19. Creating a manifest object.
47.20. Separate MANIFEST.MF for a particular archive
47.21. Configure Java 6 build
48.1. Using the Java Library plugin
48.2. Declaring API and implementation dependencies
48.3. Making the difference between API and implementation
48.4. Declaring API and implementation dependencies
48.5. Configuring the Groovy plugin to work with Java Library
49.1. War plugin
49.2. Running web application with Gretty plugin
50.1. Using the War plugin
50.2. Customization of war plugin
51.1. Using the Ear plugin
51.2. Customization of ear plugin
53.1. Using the application plugin
53.2. Configure the application main class
53.3. Configure default JVM settings
53.4. Include output from other tasks in the application distribution
53.5. Automatically creating files for distribution
54.1. Using the Java library distribution plugin
54.2. Configure the distribution name
54.3. Include files in the distribution
55.1. Groovy plugin
55.2. Dependency on Groovy
55.3. Groovy example - complete build file
56.1. Using the Groovy plugin
56.2. Custom Groovy source layout
56.3. Configuration of Groovy dependency
56.4. Configuration of Groovy test dependency
56.5. Configuration of bundled Groovy dependency
56.6. Configuration of Groovy file dependency
56.7. Configure Java 6 build for Groovy
57.1. Using the Scala plugin
57.2. Custom Scala source layout
57.3. Declaring a Scala dependency for production code
57.4. Declaring a Scala dependency for test code
57.5. Declaring a version of the Zinc compiler to use
57.6. Forcing a scala-library dependency for all configurations
57.7. Forcing a scala-library dependency for the zinc configuration
57.8. Adjusting memory settings
57.9. Forcing all code to be compiled
57.10. Configure Java 6 build for Scala
57.11. Explicitly specify a target IntelliJ IDEA version
58.1. Using the ANTLR plugin
58.2. Declare ANTLR version
58.3. setting custom max heap size and extra arguments for ANTLR
59.1. Using the Checkstyle plugin
59.2. Using the config_loc property
59.3. Customizing the HTML report
60.1. Using the CodeNarc plugin
61.1. Using the FindBugs plugin
61.2. Customizing the HTML report
62.1. Using the JDepend plugin
63.1. Using the PMD plugin
64.1. Applying the JaCoCo plugin
64.2. Configuring JaCoCo plugin settings
64.3. Configuring test task
64.4. Configuring violation rules
64.5. Configuring test task
64.6. Using application plugin to generate code coverage data
64.7. Coverage reports generated by applicationCodeCoverageReport
65.1. Using the OSGi plugin
65.2. Configuration of OSGi MANIFEST.MF file
66.1. Using the Eclipse plugin
66.2. Using the Eclipse WTP plugin
66.3. Partial Overwrite for Classpath
66.4. Partial Overwrite for Project
66.5. Export Dependencies
66.6. Customizing the XML
67.1. Using the IDEA plugin
67.2. Partial Rewrite for Module
67.3. Partial Rewrite for Project
67.4. Export Dependencies
67.5. Customizing the XML
68.1. applying a rule source plugin
68.2. a model creation rule
68.3. a model mutation rule
68.4. creating a task
68.5. a managed type
68.6. a String property
68.7. a File property
68.8. a Long property
68.9. a boolean property
68.10. an int property
68.11. a managed property
68.12. an enumeration type property
68.13. a managed set
68.14. strongly modelling sources sets
68.15. a DSL example applying a rule to every element in a scope
68.16. DSL configuration rule
68.17. Configuration run when required
68.18. Configuration not run when not required
68.19. DSL creation rule
68.20. DSL creation rule without initialization
68.21. Initialization before configuration
68.22. Nested DSL creation rule
68.23. Nested DSL configuration rule
68.24. DSL configuration rule for each element in a map
68.25. Nested DSL property configuration
68.26. a DSL example showing type conversions
68.27. a DSL rule using inputs
68.28. model task output
71.1. Using the Java software plugins
71.2. Creating a java library
71.3. Configuring a source set
71.4. Creating a new source set
71.5. The components report
71.6. Declaring a dependency onto a library
71.7. Declaring a dependency onto a project with an explicit library
71.8. Declaring a dependency onto a project with an implicit library
71.9. Declaring a dependency onto a library published to a Maven repository
71.10. Declaring a module dependency using shorthand notation
71.11. Configuring repositories for dependency resolution
71.12. Specifying api packages
71.13. Specifying api dependencies
71.14. Main sources
71.15. Client component
71.16. Broken client component
71.17. Recompiling the client
71.18. Declaring target platforms
71.19. Declaring binary specific sources
71.20. Declaring target platforms
71.21. Using the JUnit plugin
71.22. Executing the test suite
71.23. Executing the test suite
71.24. Declaring a component under test
71.25. Declaring local Java installations
72.1. Using the Play plugin
72.2. The components report
72.3. Selecting a version of the Play Framework
72.4. Adding dependencies to a Play application
72.5. Adding extra source sets to a Play application
72.6. Configuring Scala compiler options
72.7. Configuring routes style
72.8. Configuring a custom asset pipeline
72.9. Configuring dependencies on Play subprojects
72.10. Add extra files to a Play application distribution
72.11. Applying both the Play and IDEA plugins
73.1. Defining a library component
73.2. Defining executable components
73.3. Sample build
73.4. Dependent components report
73.5. Dependent components report
73.6. Report of components that depends on the operators component
73.7. Report of components that depends on the operators component, including test suites
73.8. Assemble components that depends on the passing/static binary of the operators component
73.9. Build components that depends on the passing/static binary of the operators component
73.10. Adding a custom check task
73.11. Running checks for a given binary
73.12. The components report
73.13. The 'cpp' plugin
73.14. C++ source set
73.15. The 'c' plugin
73.16. C source set
73.17. The 'assembler' plugin
73.18. The 'objective-c' plugin
73.19. The 'objective-cpp' plugin
73.20. Settings that apply to all binaries
73.21. Settings that apply to all shared libraries
73.22. Settings that apply to all binaries produced for the 'main' executable component
73.23. Settings that apply only to shared libraries produced for the 'main' library component
73.24. The 'windows-resources' plugin
73.25. Configuring the location of Windows resource sources
73.26. Building a resource-only dll
73.27. Providing a library dependency to the source set
73.28. Providing a library dependency to the binary
73.29. Declaring project dependencies
73.30. Creating a precompiled header file
73.31. Including a precompiled header file in a source file
73.32. Configuring a precompiled header
73.33. Defining build types
73.34. Configuring debug binaries
73.35. Defining platforms
73.36. Defining flavors
73.37. Targeting a component at particular platforms
73.38. Building all possible variants
73.39. Defining tool chains
73.40. Reconfigure tool arguments
73.41. Defining target platforms
73.42. Registering CUnit tests
73.43. Running CUnit tests
73.44. Registering GoogleTest tests
74.1. an example of using a custom software model
74.2. Declare a custom component
74.3. Register a custom component
74.4. Declare a custom binary
74.5. Register a custom binary
74.6. Declare a custom source set
74.7. Register a custom source set
74.8. Generates documentation binaries
74.9. Generates tasks for text source sets
74.10. Register a custom source set
74.11. an example of using a custom software model
74.12. components report
74.13. public type and internal view declaration
74.14. type registration
74.15. public and internal data mutation
74.16. example build script and model report output
B.1. Variables scope: local and script wide
B.2. Distinct configuration and execution phase