<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Sources </title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" >
	<link rel="stylesheet" type="text/css" href="../../netbeans.css">
</head>

<body>
     

<H1>O C&oacute;digo Fonte</H1>
<p>O c&oacute;digo fonte do Netbeans
est&aacute; dispon&iacute;vel segundo os termos da licen&ccedil;a

<A HREF="../../about/legal/license.html">Common Development and
Distribution License</A> (CDDL). 
</P>
<p>O c&oacute;digo &eacute;
disponibilizado atrav&eacute;s de um reposit&oacute;rio Mercurial. Todo e
qualquer desenvolvimento do NetBeans ocorre fazendo uso do servidor
Mercurial deste site, as propostas de desenvolvimento e decis&otilde;es
ocorrem nas <A HREF="../lists/index.html">listas de discuss&atilde;o
p&uacute;blicas</A>. 
</P>
<p>Voc&ecirc; pode obter o c&oacute;digo
de v&aacute;rias formas. 

</P>
<UL>
	<LI><p>Atrav&eacute;s do Mercurial &ndash;
	veja a <A HREF="hg.html">p&aacute;gina do Mercurial</A> para saber mais
	detalhes; 
	</P>
	<LI><p>Descarregando um arquivo
	instant&acirc;neo (snapshot) a partir da <A HREF="../../downloads/index.html">p&aacute;gina
	de downloads</A>; </li>
	</P>

	<LI><p><A HREF="http://hg.netbeans.org/main/file/">Navegue
	online pelo c&oacute;digo</A> 
	</P>
</UL>
<p>Se estiver ineressado em efectuar uma
compila&ccedil;&atilde;o a partir do c&oacute;digo fonte, veja as
<A HREF="http://wiki.netbeans.org/WorkingWithNetBeansSources">p&aacute;ginas de
compila&ccedil;&atilde;o/instala&ccedil;&atilde;o</A>.
</P>
<H2>Ent&atilde;o, o que existe aqui efectivamente?</H2>

<p>O que se encontra aqui dispon&iacute;vel
&eacute; toda a &aacute;rvore de c&oacute;digo e o hist&oacute;rico
do NetBeans IDE. Geralmente, existe um ramo &quot;stable&quot;
(est&aacute;vel) e um ramo &quot;development&quot; (de
desenvolvimento). O ramo de desenvolvimento, tal como o nome indica,
&eacute; onde ocorre o processo cont&iacute;nuo de desenvolvimento &ndash;

este ser&aacute; mais ou menos est&aacute;vel, dependendo do ponto em
que se encontrar, no ciclo de lan&ccedil;amento de novas vers&otilde;es.
</P>
<p>Para obter uma descri&ccedil;&atilde;o
da organiza&ccedil;&atilde;o f&iacute;sica das fontes no reposit&oacute;rio
Mercurial, veja o documento <A HREF="structure.html">Ramos e Etiquetas Mercurial</A>.
</P>
<H2><A NAME="extbins"></A>Aquilo que est&aacute; aqui, &eacute; o
c&oacute;digo completo? Existe mais alguma coisa que n&atilde;o
esteja aqui?</H2>

<p>Existem algumas coisas que n&atilde;o
podem estar aqui, por raz&otilde;es de ordem legal. Existem algumas,
embora poucas, partes do NetBeans IDE que s&atilde;o de terceiros
(software propriet&aacute;rio), ou ent&atilde;o, est&atilde;o
sujeitos a uma licen&ccedil;a que n&atilde;o permite que o seu c&oacute;digo
fonte seja aqui disponibilizado publicamente. 
</P>
<p>Examplos dos items em quest&atilde;o
incluem: 
</P>
<UL>
	<LI><p><B>Compilador Java</B> &ndash; O
	parser Java do NetBeans &eacute; um &ldquo;wrapper&rdquo;

	(sobrecapa/implementa&ccedil;&atilde;o) do compilador da linguagem
	Java (javac). As fontes do javac s&atilde;o disponibilizadas sob a
	licen&ccedil;a GPL v2 no <A HREF="http://openjdk.dev.java.net/">site
	OpenJDK</A>. O NB 5.x e vers&otilde;es anteriores, usam uma vers&atilde;o
	mais antiga do compilador javac, sujeito &agrave; licen&ccedil;a Sun
	BCL, a qual &eacute; mais restritiva.</P>
	<LI><p><B>Parsers XML </B>(Xerces,
	Crimson, Xalan, DOM, SAX, JAXP, ...) - usados pelo IDE para
	&ldquo;parsing&rdquo; e manipula&ccedil;&atilde;o de XML.
	<A HREF="http://java.sun.com/xml/">http://java.sun.com/xml/</A> 
	</P>

	<LI><p><B>JavaHelp Runtime library 2.x</B>
	&ndash; O IDE usa JavaHelp para mostrar documenta&ccedil;&atilde;o
	online. Os bin&aacute;rios - extra distribui&ccedil;&atilde;o, podem
	tamb&eacute;m incluir a biblioteca JavaHelp development-time, para
	reconstru&ccedil;&atilde;o de bases de dados de pesquisa.
	<A HREF="http://java.sun.com/products/javahelp/index.html">http://java.sun.com/products/javahelp/index.html</A>
		</P>
	<LI><p><B>Apache Ant 1.6.x</B> &ndash;

	Uma ferramente baseada em Java, da qual depende o sistema de
	compila&ccedil;&atilde;o do NetBeans. <A HREF="http://ant.apache.org/">http://ant.apache.org/</A>
		</P>
	<LI><p><B>JUnit 3.8.x</B> - Uma
	framework usada para executar testes de unidade no NetBeans.
	<A HREF="http://www.junit.org/index.html">http://www.junit.org/index.html</A>
		</P>
	<LI><p><B>Tomcat 5.x.x</B> &ndash; Um
	&ldquo;recipiente embebido&rdquo; de servlet para Java Servlet e
	desenvolvimento JSP. <A HREF="http://jakarta.apache.org/tomcat/index.html">http://jakarta.apache.org/tomcat/index.html</A>

		</P>
	<LI><p><B>JSP Standard Tag Library
	(JSTL)</B> - <A HREF="http://java.sun.com/products/jsp/jstl/">http://java.sun.com/products/jsp/jstl/</A>
		</P>
</UL>
<p>Uma dada vers&atilde;o/distribui&ccedil;&atilde;o
do NetBeans pode ter mais ou menos ficheiros extra, cuja licen&ccedil;a
n&atilde;o seja a CDDL. Pergunte na <A HREF="../lists/top.html">lista
de discuss&atilde;o nbdev</A> para ter a certeza. 

</P>
<H2>Contribuir</H2>
<p>Veja a p&aacute;gina <A HREF="../contribute/index.html">como
contribuir</A>.
</P>
<!-- /Servlet-Specific template -->

<!-- end of right navigation -->

<!-- servlets and anything not on www or testwww -->




 
 
 

 
 




</body>
</html>
