<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">

<title>WTP Downloads</title>


<?php

$buildBranch="@buildBranch@";
$build="@build@";
$type="@type@";
$builddate="@date@";

$eclipseMirrorPrefixuri="@eclipse.mirror.prefixuri@";
$eclipseFSpathPrefix="@eclipse.fspath.prefix@";

$eclipsefilelinux="@eclipsefilelinux@";
$eclipsefilewindows="@eclipsefilewindows@";
$eclipsefilemacosx="@eclipsefilemacos@";

$eclipseURL="@eclipseURL@";
$eclipseFile="@eclipseFile@";
$eclipseBuildURL="@eclipseBuildURL@";
$eclipseBuildHome="@eclipseBuildHome@";
$testURL="@testURL@";
$testFile="@testFile@";

$wstURL="@wstURL@";
$wstFile="@wstFile@";
$wstMirrorPrefixuri="@wst.mirror.prefixuri@";
$wstBuildHome="@wstBuildHome@";


$gefURL="@gefURL@";
$gefFile="@gefFile@";
$gefMirrorPrefixuri="@gef.mirror.prefixuri@";
$gefBuildHome="@gefBuildHome@";

$emfURL="@emfURL@";
$emfFile="@emfFile@";
$emfMirrorPrefixuri="@emf.mirror.prefixuri@";
$emfBuildHome="@emfBuildHome@";
$emfName="@emfName@";
$emfDescription="@emfDescription@";

$emfsourceURL="@emfsourceURL@";
$emfsourceFile="@emfsourceFile@";
$emfsourceMirrorPrefixuri="@emfsource.mirror.prefixuri@";
$emfsourceBuildHome="@emfsourceBuildHome@";
$emfsourceName="@emfsourceName@";
$emfsourceDescription="@emfsourceDescription@";

$emfxsdURL="@emfxsdURL@";
$emfxsdFile="@emfxsdFile@";
$emfxsdMirrorPrefixuri="@emfxsd.mirror.prefixuri@";
$emfxsdBuildHome="@emfxsdBuildHome@";
$emfxsdName="@emfxsdName@";
$emfxsdDescription="@emfxsdDescription@";

$emfxsdsourceURL="@emfxsdsourceURL@";
$emfxsdsourceFile="@emfxsdsourceFile@";
$emfxsdsourceMirrorPrefixuri="@emfxsdsource.mirror.prefixuri@";
$emfxsdsourceBuildHome="@emfxsdsourceBuildHome@";
$emfxsdsourceName="@emfxsdsourceName@";
$emfxsdsourceDescription="@emfxsdsourceDescription@";

$dtpURL="@dtpURL@";
$dtpFile="@dtpFile@";
$dtpMirrorPrefixuri="@dtp.mirror.prefixuri@";
$dtpBuildHome="@dtpBuildHome@";


$eclipserelengFile="@eclipserelengFile@";
$eclipserelengURL="@eclipserelengURL@";
$orbitthirdpartyzipFile="@orbitthirdpartyzipFile@";
$orbitthirdpartyzipURL="@orbitthirdpartyzipURL@";
$orbitthirdpartyzipBuildHome="@orbitthirdpartyzipBuildHome@";
$orbitthirdpartyzipMirrorPrefixuri="@orbitthirdpartyzip.mirror.prefixuri@";




include("miscUtil.php");



//ini_set("display_errors", "true");
//error_reporting (E_ALL);


$debugScript = false;
$debugFunctions = false;

$defaultMirrorScript="";
$defaultWTPMirrorPrefix="./";

$eclipseMirrorScript="http://www.eclipse.org/downloads/download.php?file=";

// TODO: improve so this hard coding isn't required.
// This depends on the declare script changing webtools/committers to webtools/downloads
// And, the logic is such that if it is not mirrored, this URI is not used at all, just
// a relative reference only
$eclipseWTPMirrorPrefix="/webtools/committers/drops/$buildBranch/$build/";


$mirrorScript=$defaultMirrorScript;
$downloadprefix=$defaultWTPMirrorPrefix;


$keytestMirrorString=$eclipseMirrorScript . "$eclipseWTPMirrorPrefix/wtp-sdk-$build.zip";
if (isMirrored($keytestMirrorString) ) {
    $mirrorScript=$eclipseMirrorScript;
    $downloadprefix="${mirrorScript}${eclipseWTPMirrorPrefix}";
}

if ($debugScript)  {
    echo "inferred platform: " . getPlatform();
}


// our summary results handling requires php 5 (for simple xml file loading)
// so, if not php 5, just don't display any summary results
// This was found to be required, since some mirror our whole site (e.g. IBM)
// and not all mirrors use PHP 5
$displayTestSummary=false;
if (phpversion() >= 5) {

    $displayTestSummary=true;
    // expecting grandTotalErrors and grandTotalTests
    $filename = "unitTestsSummary.xml";
    if (file_exists($filename)) {
        $prefix = "unitTests_";
        $unitTestsSummary = simplexml_load_file($filename);
        foreach ($unitTestsSummary->summaryItem as $summaryItem) {
            $name = $summaryItem->name;
            $value = $summaryItem->value;
            $code= "\$" . $prefix . $name . " = " . $value . ";";
            //echo "<br />code: " . $code;
            eval($code);
        }
    }

    $filename = "compilelogsSummary.xml";
    $prefix = "code_";
    $compileSummary = simplexml_load_file($filename);
    foreach ($compileSummary->summaryItem as $summaryItem) {
        $name = $summaryItem->name;
        $value = $summaryItem->value;
        $code= "\$" . $prefix . $name . " = " . $value . ";";
        //echo "<br />code: " . $code;
        eval($code);
    }

    $filename = "testcompilelogsSummary.xml";
    $prefix = "test_";
    $compileSummary = simplexml_load_file($filename);
    foreach ($compileSummary->summaryItem as $summaryItem) {
        $name = $summaryItem->name;
        $value = $summaryItem->value;
        $code= "\$" . $prefix . $name . " = " . $value . ";";
        //echo "<br />code: " . $code;
        eval($code);
    }
}


?>


</head>

<body>

<?php

// tiny banner to remind when looking at "local" machine results
$serverName = $_SERVER["SERVER_NAME"];

if (!stristr($serverName, "eclipse.org") && !stristr($serverName,"you.are.at.eclipsecon.org")) {
    echo '<center>
          <p>
          Reminder: this is <font color="#FF0000">' . 
    $serverName .
    '</font>
          See also 
          <a href="http://download.eclipse.org/webtools/downloads" target="_top">the live public Eclipse site</a>.
          </p>
          <hr />
          </center>';

}
?>
<table BORDER=0 CELLSPACING=2 CELLPADDING=2 WIDTH="100%">
	<tr>
		<td ALIGN=left><font face="'Bitstream Vera',Helvetica,Arial" size="+2"><b><?php echo "$type";?>
		Build: <?php echo "$build";?></b></font></td>
	
	
	<tr>
		<td><font size="-1"><?php echo "$builddate";?></font></td>
	</tr>
	<tr>
		<td>
		<p>The Eclipse Web Tools Platform Project provides tools for Web
		Development, and is a platform for adopters making add-on tools for
		Web Development.</p>
		</td>
	</tr>
</table>

<!-- ***********  Required Prerequisites **************  -->
<table border=0 cellspacing=2 cellpadding=2 width="100%">
  <tr>
    <td align="left" valign="top" bgcolor="#0080C0"><font
      face="'Bitstream Vera',Helvetica,Arial" color="#FFFFFF">All-in-one Packages</font></td>
  </tr>
  <tr>
    <td>
    <p>For most uses, we recommend web-developers download the "all-in-one" package, <a href="http://www.eclipse.org/downloads/">Eclipse IDE for Java EE Developers</a>, from the main Eclipse download site. 
    </p>
    tr>
</table>


<!-- ***********  Required Prerequisites **************  -->
<table border=0 cellspacing=2 cellpadding=2 width="100%">
	<tr>
		<td align="left" valign="top" bgcolor="#0080C0"><font
			face="'Bitstream Vera',Helvetica,Arial" color="#FFFFFF">Required
		Prerequisites and Handy Extras</font></td>
	</tr>
	<tr>
		<td>
		<p>These are the prerequisites to install and run the Web Tools
		Platform. Also listed are some frequently needed links for
		committer-required packages when creating new developmnet
		environmnets, or targets to run against.</p>
		<p>Note that WTP requires Java 5 or higher (and, for some things,
		actually requires a JDK rather than only a JRE) even though many other
		<a href="http://www.eclipse.org/downloads/">Eclipse Projects</a> can
		run with <a href="http://www.eclipse.org/downloads/moreinfo/jre.php">other
		JRE levels</a>.</p>
		</td>
	</tr>
	<tr>
		<td>
		<table border=0 cellspacing=1 cellpadding=1 width="90%" align="center">
			<tr valign="top">
				<td width="10%"></td>
				<td width="55%">Eclipse Platform (Platform, JDT)</td>
				<?php
				//customize page depending on user's browser/platform, if we can detect it
				$usersPlatform = getPlatform();
				// assume windows by default, since likely most frequent, even for cases where
				// platform is "unknown". I've noticed Opera reports 'unknown' :(
				$recommendedFile=$eclipsefilewindows;
				if (strcmp($usersPlatform,"linux")== 0) {
				    $recommendedFile=$eclipsefilelinux;
				} else if (strcmp($usersPlatform,"mac") == 0) {
				    $recommendedFile=$eclipsefilemacosx;
				}
				?>
				<td align="right" width="35%"><?php
				echo getPrereqReferenceOrName($eclipseMirrorScript, $eclipseMirrorPrefixuri, $eclipseURL, $recommendedFile, $eclipseFSpathPrefix);
				echo " or <a href=\"" . $eclipseBuildURL . "\">appropriate platform</a>";
				echo " or <a href=\"" . $eclipseBuildHome . "\">equivalent</a></td>";
				?>
			</tr>

			<tr valign="top">
				<td width="10%"></td>
				<td><?php echo "$emfName $emfDescription" ?></td>
				<td align="right"><?php
				echo getPrereqReferenceOrName($eclipseMirrorScript, $emfMirrorPrefixuri, $emfURL, $emfFile, $eclipseFSpathPrefix);
				echo " or <a href=\"" . $emfBuildHome . "\">equivalent</a></td>";
				?>			
			</tr>
      <tr valign="top">
        <td width="10%"></td>
        <td><?php echo "$emfxsdName $emfxsdDescription" ?></td>
        <td align="right"><?php
        echo getPrereqReferenceOrName($eclipseMirrorScript, $emfxsdMirrorPrefixuri, $emfxsdURL, $emfxsdFile, $eclipseFSpathPrefix);
        echo " or <a href=\"" . $emfxsdBuildHome . "\">equivalent</a></td>";
        ?>      
      </tr>

			<tr valign="top">
				<td width="10%"></td>
				<td>Graphical Editing Framework (GEF)</td>
				<td align="right"><?php
				echo getPrereqReferenceOrName($eclipseMirrorScript, $gefMirrorPrefixuri, $gefURL, $gefFile, $eclipseFSpathPrefix);
				echo " or <a href=\"" . $gefBuildHome . "\">equivalent</a></td>";
				?>
			</tr>

			<tr valign="top">
				<td width="10%"></td>
				<td>Data Tools Platform (DTP) (required only for EJB or JPT
				development)</td>
				<td align="right"><?php
				echo getPrereqReferenceOrName($eclipseMirrorScript, $dtpMirrorPrefixuri, $dtpURL, $dtpFile, $eclipseFSpathPrefix);
				echo " or <a href=\"" . $dtpBuildHome . "\">equivalent</a></td>";
				?>
			</tr>

      <tr valign="middle">
         <td colspan="3"><hr /></td>
      </tr> 

      <tr valign="top">
        <td width="10%"></td>
        <td><?php echo "$emfsourceName $emfsourceDescription" ?></td>
        <td align="right"><?php
        echo getPrereqReferenceOrName($eclipseMirrorScript, $emfsourceMirrorPrefixuri, $emfsourceURL, $emfsourceFile, $eclipseFSpathPrefix);
        echo " or <a href=\"" . $emfsourceBuildHome . "\">equivalent</a></td>";
        ?>      
      </tr>

      <tr valign="top">
        <td width="10%"></td>
        <td><?php echo "$emfxsdsourceName $emfxsdsourceDescription" ?></td>
        <td align="right"><?php
        echo getPrereqReferenceOrName($eclipseMirrorScript, $emfxsdsourceMirrorPrefixuri, $emfxsdsourceURL, $emfxsdsourceFile, $eclipseFSpathPrefix);
        echo " or <a href=\"" . $emfxsdsourceBuildHome . "\">equivalent</a></td>";
        ?>      
      </tr>
      
			<tr valign="top">
				<td width="10%"></td>
				<td>Eclipse Test Framework (required only for Automated JUnit tests)</td>
				<td align="right"><?php
				echo getPrereqReferenceOrName($eclipseMirrorScript, $eclipseMirrorPrefixuri, $testURL, $testFile, $eclipseFSpathPrefix);
				echo " or <a href=\"" . $eclipseBuildHome . "\">equivalent</a></td>";
				?>
			
			</tr>

			<tr valign="top">
				<td width="10%"></td>
				<td>Eclipse releng tool (required only for committers to more easily
				"release" code to a build)</td>
				<td align="right"><?php
				echo getPrereqReferenceOrName($eclipseMirrorScript, $eclipseMirrorPrefixuri, $eclipserelengURL, $eclipserelengFile, $eclipseFSpathPrefix);
				echo " or <a href=\"" . $eclipseBuildHome . "\">equivalent</a></td>";
				?>
			
			</tr>

			<tr valign="top">
				<td width="10%"></td>
				<td>Third Party code from Orbit. Not required and is currently much more than needed for WTP, but some committers like using to create a PDE target.</td>
				<td align="right"><?php
				echo getPrereqReferenceOrName($eclipseMirrorScript, $orbitthirdpartyzipMirrorPrefixuri, $orbitthirdpartyzipURL, $orbitthirdpartyzipFile,$eclipseFSpathPrefix);
				echo " or <a href=\"" . $orbitthirdpartyzipBuildHome . "\">equivalent</a></td>";
				?>
			
			</tr>

		</table>
		</td>
	</tr>
</table>

<!-- ***********  WTP **************  -->
<table border=0 cellspacing=2 cellpadding=2 width="100%">
	<tr>
		<td align=left valign=top colspan="5" bgcolor="#0080C0"><font
			face="'Bitstream Vera',Helvetica,Arial" color="#FFFFFF"> Web Tools
		Platform Complete</font></td>
	</tr>

	<tr>
		<td align="left" valign="top" colspan="5">
		<p>The WTP zip files includes the features and plugins from the WST,
		JST (including JSF), and JPT projects.</p>
		</td>
	</tr>
	<tr>
		<td>
		<table border=0 cellspacing=2 cellpadding=2 width="90%" align="center">


			<tr>
				<td align="left" valign="top" width="10%"><b>Web App Developers:</b></td>
				<td align="left" valign="top" width="55%">
				<p>This non-SDK package is for most users. It includes the runnable
				code and end-user documentation for those using the tools to develop
				web applications.</p>
				</td>
				<?php

				$zipfilename="wtp-$build";

				$filename=$zipfilename.".zip";
				$zipfilesize=fileSizeForDisplay($filename);
				$fileShortDescription="wtp";
				displayFileLine($downloadprefix, $filename, $zipfilesize, $fileShortDescription);
				?>
			</tr>

			
			
			<tr>
				<td align="left" valign="top" width="10%"><b>Tool Developers:</b></td>

				<td align="left" valign="top">
				<p>The SDK package includes source code and developer documentation
				for those using WTP as a platform to build more tools, as well as
				everything that is in the non-SDK version.</p>

				<?php

				$zipfilename="wtp-sdk-$build";

				$filename=$zipfilename.".zip";
				$zipfilesize=fileSizeForDisplay($filename);
				$fileShortDescription="wtp-sdk";
				displayFileLine($downloadprefix, $filename, $zipfilesize, $fileShortDescription);

				?>
			
			</tr>

			<tr>

				<td align="left" valign="top" width="10%"></td>
				<td align="left" valign="top">
				<p>The Automated Test zip contains the unit tests.</p>
				<?php

				$zipfilename="wtp-Automated-Tests-$build";

				$filename=$zipfilename.".zip";
				$zipfilesize=fileSizeForDisplay($filename);
				$fileShortDescription="wtp-Automated-Tests";
				displayFileLine($downloadprefix, $filename, $zipfilesize, $fileShortDescription);

				?>
			
			</tr>
		</table>
		</td>
	
	
	<tr>

</table>


<!-- ***********  WST **************  -->
<table border=0 cellspacing=2 cellpadding=2 width="100%">
	<tr>
		<td align=left valign=top colspan="5" bgcolor="#0080C0"><font
			face="'Bitstream Vera',Helvetica,Arial" color="#FFFFFF"> Web Standard
		Tools</font></td>
	</tr>

	<tr>
		<td align="left" valign="top" colspan="5">
		<p>These zip files includes the features and plugins for (non-Java) Web Development.</p>
		<p>Note: you only need this zip file(s) if you want to use only this function. If 
		you download the WTP zip file, it is already included there.</p>
		</td>
	</tr>
	<tr>
		<td>
		<table border=0 cellspacing=2 cellpadding=2 width="90%" align="center">


			<tr>
				<td align="left" valign="top" width="10%"><b>Web App Developers:</b></td>
				<td align="left" valign="top">
				<p>This non-SDK package is for most users. It includes the runnable
				code and end-user documentation for those using the tools to develop
				web applications. In particular, non-Java oriented Web Apps (such as
				HTML, XML, CSS, etc).</p>
				</td>
				<?php

				$zipfilename="wtp-wst-$build";

				$filename=$zipfilename.".zip";
				$zipfilesize=fileSizeForDisplay($filename);
				$fileShortDescription="wst";
				displayFileLine($downloadprefix, $filename, $zipfilesize, $fileShortDescription);

				?>
			</tr>

			<tr>
			
			
			<tr>
				<td align="left" valign="top" width="10%"><b>Tool Developers:</b></td>

				<td align="left" valign="top">
				<p>The SDK package includes source code and developer documentation
				for those using WST as a platform to build more tools, as well as
				everything that is in the non-SDK version.</p>

				<?php

				$zipfilename="wtp-wst-sdk-$build";

				$filename=$zipfilename.".zip";
				$zipfilesize=fileSizeForDisplay($filename);
				$fileShortDescription="wtp-wst-sdk";
				displayFileLine($downloadprefix, $filename, $zipfilesize, $fileShortDescription);
				?>
			
			</tr>

			<tr>

				<td align="left" valign="top" width="10%"></td>
				<td align="left" valign="top">
				<p>The Automated Test zip contains the unit tests.</p>
				<?php

				$zipfilename="wtp-wst-Automated-Tests-$build";

				$filename=$zipfilename.".zip";
				$zipfilesize=fileSizeForDisplay($filename);
				$fileShortDescription="wtp-wst-Automated-Tests";
				displayFileLine($downloadprefix, $filename, $zipfilesize, $fileShortDescription);

				?>
			
			</tr>

		</table>
		</td>
	
	
	<tr>

</table>

<?php 

$bellwether_zipfilename="wtp-common-fproj-".$build.".zip";
if (file_exists($bellwether_zipfilename)) {
// if-then-include section
// include this whole section if (and only if) the bellwether file exists.
// For example, it may not exist on builds for "old" streams.
?>

<!-- ***********  Faceted Project Framework **************  -->
<table border=0 cellspacing=2 cellpadding=2 width="100%">
	<tr>
		<td align=left valign=top colspan="5" bgcolor="#0080C0"><font
			face="'Bitstream Vera',Helvetica,Arial" color="#FFFFFF">Faceted Project Framework</font></td>
	</tr>

	<tr>
		<td align="left" valign="top" colspan="5">
		<p>The Faceted Project Framework allows creation of modular projects in Eclipse so that
		the user can easily add and remove functionality. All WTP projects leverage this framework, but
		it can also be used independent of WTP.</p>
		<p>The JDT Enablement component extends the Faceted Project Framework to integrate with
		Java Development Tools. The component includes the Java facet, modeling of the JVM-based
		runtimes and tools for simplifying Java library management for facet authors.</p>
		<p>Note: you only need this zip file(s) if you want to use only this function. If 
    you download the WTP (or WST) zip file, it is already included there.</p>
		</td>
	</tr>
	<tr>
		<td>
		<table border=0 cellspacing=2 cellpadding=2 width="90%" align="center">


			<tr>
				<td align="left" valign="top" width="10%"><b>Framework</b></td>
				<td align="left" valign="top">
				<p>Runtime</p>
				</td>
				<?php

				$zipfilename="wtp-common-fproj-$build";

				$filename=$zipfilename.".zip";
				$zipfilesize=fileSizeForDisplay($filename);
				$fileShortDescription="wtp-common-fproj";
				displayFileLine($downloadprefix, $filename, $zipfilesize, $fileShortDescription);

				?>
			</tr>

			<tr>
				<td align="left" valign="top" width="10%"><b>&nbsp;</b></td>
				<td align="left" valign="top">
				<p>SDK</p>
				</td>
				<?php

				$zipfilename="wtp-common-fproj-sdk-$build";

				$filename=$zipfilename.".zip";
				$zipfilesize=fileSizeForDisplay($filename);
				$fileShortDescription="wtp-common-fproj-sdk";
				displayFileLine($downloadprefix, $filename, $zipfilesize, $fileShortDescription);

				?>
			</tr>

			<tr>
				<td align="left" valign="top" width="10%"><b>JDT Enablement</b></td>
				<td align="left" valign="top">
				<p>Runtime</p>
				</td>
				<?php

				$zipfilename="wtp-common-fproj-enablement-jdt-$build";

				$filename=$zipfilename.".zip";
				$zipfilesize=fileSizeForDisplay($filename);
				$fileShortDescription="wtp-common-fproj-enablement-jdt";
				displayFileLine($downloadprefix, $filename, $zipfilesize, $fileShortDescription);

				?>
			</tr>

			<tr>
				<td align="left" valign="top" width="10%"><b>&nbsp;</b></td>
				<td align="left" valign="top">
				<p>SDK</p>
				</td>
				<?php

				$zipfilename="wtp-common-fproj-enablement-jdt-sdk-$build";

				$filename=$zipfilename.".zip";
				$zipfilesize=fileSizeForDisplay($filename);
				$fileShortDescription="wtp-common-fproj-enablement-jdt-sdk";
				displayFileLine($downloadprefix, $filename, $zipfilesize, $fileShortDescription);

				?>
			</tr>

		</table>
		</td>
	
	<tr>

</table>

<?php
// end the if-then-include section
}
?>


<!-- ***********  Build Status **************  -->
<table border=0 cellspacing=2 cellpadding=2 width="100%">
	<tr>
		<td align=left valign=top bgcolor="#0080C0"><font
			face="'Bitstream Vera',Helvetica,Arial" color="#FFFFFF">Status, tests
		and other interesting details</font></td>
	</tr>
	<tr>
		<td>
		<table border=0 cellspacing=2 cellpadding=2 width="90%" align="center">

			<tr>
				<td><a href="buildNotes.php">Build notes</a> <br />
				<a href="directory.txt">map files</a> <br />
				<?php

				if ($displayTestSummary) {


				    if (isset($unitTests_grandTotalErrors)) {
				        $errorColor="green";
				        if ($unitTests_grandTotalErrors > 0) {
				            $errorColor="red";
				        }
				        echo "<a href=\"testResults.php\">Unit test results</a>&nbsp;";
				        echo "<img src=\"junit_err.gif\"/><font color=\"" . $errorColor . "\">" . $unitTests_grandTotalErrors . "</font>&nbsp;&nbsp;Total: " . $unitTests_grandTotalTests;
				    }
				    else {
				        echo "<br /><font color=\"orange\">Unit tests are pending</font>&nbsp;&nbsp;<img src=\"pending.gif\"/>";
				    }

				    echo "<br />";
				    echo "<a href=\"compileResults.php\">Compile logs: Code Bundles</a>";

				    echo "&nbsp;&nbsp;($code_totalBundles)&nbsp;&nbsp;";
				    echo "<img src=\"compile_err.gif\"/><font color=red>$code_totalErrors</font>&nbsp;";
				    echo "<img src=\"compile_warn.gif\"/><font color=orange>$code_totalWarnings</font>&nbsp;";
				    echo "<img src=\"access_err.gif\"/><font color=red>$code_totalforbiddenAccessWarningCount</font>&nbsp;";
				    echo "<img src=\"access_warn.gif\"/><font color=orange>$code_totaldiscouragedAccessWarningCount</font>&nbsp;";

				    echo "<br />";
				    echo "<a href=\"testCompileResults.php\">Compile logs: Test Bundles</a>";

				    echo "&nbsp;&nbsp;($test_totalBundles)&nbsp;&nbsp;";
				    echo "<img src=\"compile_err.gif\"/><font color=red>$test_totalErrors</font>&nbsp;";
				    echo "<img src=\"compile_warn.gif\"/><font color=orange>$test_totalWarnings</font>&nbsp;";
				    echo "<img src=\"access_err.gif\"/><font color=red>$test_totalforbiddenAccessWarningCount</font>&nbsp;";
				    echo "<img src=\"access_warn.gif\"/><font color=orange>$test_totaldiscouragedAccessWarningCount</font>&nbsp;";
				}

				?> <br />

				<?php
				if (file_exists("versioningReportName.php")) {
				    include "versioningReportName.php";
				    $fname="${versionReportFilename}.html";
				    if (file_exists($fname)) {
				        echo "<br /> <a href='$fname'>Versioning Information</a>";
				    }
}
?> <?php
echo "<br />";
if (file_exists("./apiresults/api-progress.html"))
{
    echo "<br /> <a href=\"apiresults/api-progress.html\">API Progress Report</a>";
}
if (file_exists("./apiresults/api-info-summary.html"))
{
    echo "<br /> <a href=\"apiresults/api-info-summary.html\">APIs Defined by Each Component</a>";
}
if (file_exists("./apiresults/api-ref-compatibility.html"))
{
    echo "<br /> <a href=\"apiresults/api-ref-compatibility.html\">Adopter Breakage Report</a>";
}
if (file_exists("./apiresults/api-violation-summary.html"))
{
    echo "<br /> <a href=\"apiresults/api-violation-summary.html\">API Violations</a>";
}
if (file_exists("./apiresults/component-api-violation-all.html"))
{
    echo "<br /> <a href=\"apiresults/component-api-violation-all.html\">Non-API dependencies</a>";
}
if (file_exists("./apiresults/api-tc-summary.html"))
{
    echo "<br /> <a href=\"apiresults/api-tc-summary.html\">API Test Coverage</a>";
}
if (file_exists("./apiresults/api-javadoc-summary.html"))
{
    echo "<br /> <a href=\"apiresults/api-javadoc-summary.html\">API Javadoc Coverage</a>";
}
if (file_exists("./apiresults/api-tc-summary.html"))
{
    echo "<br /><br /> <a href=\"apiresults/full_test_coverage/api-tc-summary.html\">Test Coverage for All Classes and Methods</a>";
}
?> <?php
if (file_exists("./perfresults/graph/performance.php"))
{
    echo "<br />";
    echo "<br /> <a href=\"perfresults/graph/performance.php\">Performance Results</a>";
    echo "<br />";
}
?></td>
			</tr>


		</table>
		</td>
	</tr>
</table>



<!-- footer -->
<center>
<hr>
<p>All downloads are provided under the terms and conditions of the <a
	href="http://www.eclipse.org/legal/notice.html">Eclipse.org Software
User Agreement</a> unless otherwise specified.</p>

<p>If you have problems downloading the drops, contact the <font
	face="'Bitstream Vera',Helvetica,Arial" size="-1"><a
	href="mailto:webmaster@eclipse.org">webmaster</a></font>.</p>

</center>
<!-- end footer -->


</body>
</html>
