 ------
 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. The
  default compiler used to compile Java sources is javax.tools.JavaCompiler.
  If you want to force the plugin to use  <<<javac>>>, you must configure the plugin option {{{./compile-mojo.html#forceJavacCompilerUse}<<<forceJavacCompilerUse>>>}}.

  Also note that at present the default <<<source>>> setting is <<<1.8>>> and the default <<<target>>>
  setting is <<<1.8>>>, 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 the plugin is missing a feature or has a defect, you can file 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}}

  []
