 ------
 Introduction
 ------
 Edwin Punzalan
 ------
 2013-07-22
 ------

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

${project.name}

  The Compiler Plugin is used to compile the sources of your project. Since 3.0, the
  default compiler is javax.tools.JavaCompiler (if you are using java 1.6) and is used to compile Java sources.
  If you want to force the plugin using  <<<javac>>>, you must configure the plugin option {{{./compile-mojo.html#forceJavacCompilerUse}<<<forceJavacCompilerUse>>>}}.

  Also note that at present the default <<<source>>> setting is <<<1.7>>> and the default <<<target>>>
  setting is <<<1.7>>>, independently of the JDK you run Maven with.
  You are highly encouraged to change these defaults by setting <<<source>>> and <<<target>>>
  as described in
  {{{./examples/set-compiler-source-and-target.html}Setting the -source and -target of the Java Compiler}}.

  Other compilers than <<<javac>>> can be used and work has already started
  on AspectJ, .NET, and C#.

  <<NOTE:>> <To know more about the JDK javac, please see:
  {{https://docs.oracle.com/javase/8/docs/technotes/tools/windows/javac.html}}.>

* Goals Overview

  The Compiler Plugin has two goals.  Both are already bound to their proper
  phases within the Maven Lifecycle and are therefore, automatically executed
  during their respective phases.

  * {{{./compile-mojo.html}compiler:compile}} is bound to the compile phase and
  is used to compile the main source files.

  * {{{./testCompile-mojo.html}compiler:testCompile}} is bound to the
  test-compile phase and is used to compile the test source files.

* Usage

  General instructions on how to use the Compiler Plugin can be found on the {{{./usage.html}usage page}}. Some more
  specific use cases are described in the examples given below.

  In case you still have questions regarding the plugin's usage, please have a look at the {{{./faq.html}FAQ}} and feel
  free to contact the {{{./mailing-lists.html}user mailing list}}. The posts to the mailing list are archived and could
  already contain the answer to your question as part of an older thread. Hence, it is also worth browsing/searching
  the {{{./mailing-lists.html}mail archive}}.

  If you feel like the plugin is missing a feature or has a defect, you can fill a feature request or bug report in our
  {{{./issue-management.html}issue tracker}}. When creating a new issue, please provide a comprehensive description of your
  concern. Especially for fixing bugs it is crucial that the developers can reproduce your problem. For this reason,
  entire debug logs, POMs or most preferably little demo projects attached to the issue are very much appreciated.
  Of course, patches are welcome, too. Contributors can check out the project from our
  {{{./scm.html}source repository}} and will find supplementary information in the
  {{{http://maven.apache.org/guides/development/guide-helping.html}guide to helping with Maven}}.

* Examples

  To provide you with better understanding on some usages of the Compiler
  Plugin, you can take a look into the following examples:

  * {{{./examples/compile-using-different-jdk.html}Compile Using A Different JDK}}

  * {{{./examples/set-compiler-source-and-target.html}Compile Using -source and -target javac Options}}

  * {{{./examples/set-compiler-release.html}Compile Using the --release javac Option (supported since JDK 9)}}

  * {{{./examples/compile-with-memory-enhancements.html}Compile Using Memory Allocation Enhancement}}

  * {{{./examples/pass-compiler-arguments.html}Pass Compiler Arguments}}

  []
