<HTML>
<HEAD>
<TITLE>NetBeans Source Organization</TITLE>
<META NAME="description" CONTENT="A description of the structure of the NetBeans sources in Mercurial">
<META NAME="AUDIENCE" CONTENT="NBDEVELOPER">
<META NAME="TYPE" CONTENT="ARTICLE">
<META NAME="TOPIC" CONTENT="NB_ORG">
<meta name="nav_link" content="Structure">
<meta name="nav_priority" content="3">
<link rel="stylesheet" type="text/css" HREF="../../netbeans.css">
</HEAD>

<BODY>

<h1>Mercurial Repositories</h1>

<p>The NetBeans source is organized into <A HREF="hg.html">Mercurial</a>
repositories. Currently the interesting ones are:</p>

<UL>

<LI> The Mercurial <code>main</code> repository. Now and in the future, new
functionality that is reasonably stable (does not break anything else) goes into
the trunk. This code is used to make regular daily development builds.

<LI> Milestone branches. Periodically between major release a build is made
which has been vetted for quality. Each such milestone build gets its own
Mercurial repository, which usually diverges from the trunk in only a few files
which needed to be patched to fix high-impact bugs.

</ul>

<p>Older versions of NetBeans are kept in CVS (on <code>cvs.netbeans.org</code>)
with the following branch names:</p>

<ul>

<li>NetBeans Release 6.0: the CVS branch <code>release60</code> holds sources
for the NetBeans 6.0 stable release.

<li>NetBeans Release 5.5: the CVS branch <code>release55</code> holds sources
for the NetBeans 5.5 stable release.

<li>NetBeans Release 5.0: the CVS branch <code>release41</code> holds sources
for the NetBeans 5.0 stable release.

<li>NetBeans Release 4.1: the CVS branch <code>release41</code> holds sources
for the NetBeans 4.1 stable release.

<li>NetBeans Release 4.0: the CVS branch <code>release40</code> holds sources
for the NetBeans 4.0 stable release.

<li>NetBeans Release 3.6: the CVS branch <code>release36</code> holds sources
for the NetBeans 3.6 stable release.

<li>NetBeans Release 3.5: the CVS branch <code>release35</code> holds sources
for the NetBeans 3.5 stable release.

<li>NetBeans Release 3.4.1: the CVS branch <code>release341</code> holds sources
for the NetBeans 3.4.1 stable release.

<li>NetBeans Release 3.4: the CVS branch <code>release34</code> holds sources
for the NetBeans 3.4 stable release.

<LI> Sun ONE Studio (formerly Forte for Java) 4.0: the CVS branch <CODE>orion_fcs</CODE> is used
for Sun's Sun ONE Studio (Forte for Java) Community Edition 4.0. This branch is almost identical
to <CODE>release33</CODE> (below) for most modules.
<code>sierra</code> is used for 4.1.

<LI> NetBeans Release 3.3.x: the CVS branch <CODE>release33</CODE> holds sources
for the NetBeans 3.3.x stable releases.

<LI> Sun's Forte for Java 3.0: the CVS branch <CODE>pilsen</CODE> holds sources
for Sun's Forte for Java Community Edition 3.0. For most modules, this
is based off of NetBeans Release 3.2 (below) with no or very limited changes.
For <CODE>web</CODE>, <CODE>j2eeserver</CODE>, and <CODE>logger</CODE> modules
this branch contains distinct lines of development.

<LI> NetBeans Release 3.2.x: the CVS branch <CODE>release32</CODE> holds sources
for the NetBeans 3.2 and 3.2.1 releases.

<LI> NetBeans Release 3.1: the CVS branch <CODE>release31</CODE> holds sources
for the 3.1 release of NetBeans.

<LI> NetBeans Release 3.0: the CVS branch <CODE>stable30</CODE> holds
the source for a former stable NetBeans release.  It is based off
of the <CODE>postfcs</CODE> branch, below.

<LI> Sun's "Boston" branch: the CVS branch <CODE>boston</CODE> was
reserved for stabilization of the FFJ 2.0 release.

<LI> Sun's post-FCS branch: the CVS branch <CODE>postfcs</CODE> is
reserved for the code line used for the 1.0.x versions of
FFJ, including a number of module updates.

<LI> <CODE>gandalf</CODE> branch represents the 1.0 released IDE,
pre-updates.

</UL>

<P>General principles of using branches:

<UL>

<LI>The <code>main</code> repository (or <dfn>trunk</dfn>)
should be used for ongoing development of the IDE. Code checked into
the trunk should be reasonably stable (i.e. it should compile and at
runtime should not cause the IDE to be unusable, especially in terms
of interfering with other modules or components of the IDE). It need
not be perfect.

<LI> Branches may be created by developers for purposes of
checkpointing experimental code which is not expected to be stable for
a long period of time. These branches may be created as needed,
possibly on a per-module basis. Module pages should document branches
they are using.

<LI> Stabilization branches, which should be documented here, and are
used to stabilize the entire IDE in preparation for an official
release of some sort. Commits to these branches should be to fix
important bugs, not to add new functionality; and such bugfixes should
be also applied immediately to the trunk (assuming they apply). The
NetBeans team may create such branches and other parties who are
interested in producing a release may also create them. Since
stabilization branches exist in the public repository, anyone can take
advantage of testing and fixes done on these branches.

</UL>

<P> If you <A HREF="../contribute/hg.html">get access</A> to the Mercurial server
  for pushes, please make sure you understand what the different branches are
  being used for, and check in onto the appropriate branch, with an appropriate
  amount of pre-checkin testing.

<P><h2>Directory Structure</h2>

<BR>The NetBeans Mercurial repository is organized by "modules". Refer to
the <A HREF="https://netbeans.org/projects/">modules list</A> for a complete list of
these modules.

<P>Within a module, there can be various files and subdirectories.
There are certain special naming conventions used mainly to increase
clarity and familiarity of the source organization.
A module may have any of the following subcomponents:

<UL>

<LI> <CODE>src/</CODE> - the Java source code for a module. This is
arranged in a package hierarchy. For example, the Form Editor module
contains a source file in the path
<CODE>form/src/org/netbeans/modules/form/FormEditorModule.java</CODE>.

<LI> <CODE>manifest.mf</CODE> - the JAR manifest for the module. It
contains special attributes informing the IDE of what the module
contains, as well as metainformation such as name and version.

<LI> <CODE>javahelp/</CODE> - JavaHelp files and HTML for online
documentation for the module. In a
package hierarchy. This may be placed inside the module JAR, or in the
<CODE>docs/</CODE> directory in an IDE installation. For example,
<CODE>crosscompile/javahelp/org/netbeans/modules/crosscompile/CCHelpSet.hs</CODE>.

<LI> <CODE>build.xml</CODE> - <A HREF="https://netbeans.org/projects/ide/ant.html">Ant-based</A> build script
for the module.

<LI> <CODE>test/</CODE> - test suites, probably using
<A HREF="https://netbeans.org/projects/obsolete/">XTest</A>.

<LI> <CODE>release/</CODE> - files to be placed in the IDE's
installation directory, rather than in the module JAR itself.
Subdirectories should match the installation structure. For example,
<CODE>form/release/beans/TimerBean.jar</CODE>.
Only used for <a href="https://netbeans.org/cddl-gplv2.html">Common Development and Distribution License (CDDL) v1.0 and the GNU General Public License (GPL) v2</a> covered files.

<li><code>external/</code> - third-party files not covered by the 
Common Development and Distribution License.

<li><code>apichanges.xml</code> - list of API changes made to the module,
in a standardized XML format

<LI> <CODE>src/.../package.html</CODE> and <code>src/.../doc-files/*.html</code> - documentation for the API.

<li><code>arch.xml</code> - architectural descriptions of a module in a standardized
XML questionnaire format

</UL>

<p>More standard names can of course be added if there is a conventional use for
them. The file <code>harness/README</code> in the IDE distribution has some more
details on module project organization.</p>

</BODY>
</HTML>
