

<form method="POST">

<div id="maincontent">
<div id="midcolumn">
<h1>IP Log for technology.linux-distros</h1>

<h2>Licenses</h2>
	<ul>
			<li>Eclipse Public License v1.0</li>
		</ul>

<h2>Third-Party Code</h2>

<h3>Pre-Req Dependencies</h3><table border="1" cellpadding="3" cellspacing="0" width="100%"><tr><th bordercolor="#7A79A7" bgcolor="#7A79A7">CQ</th><th bordercolor="#7A79A7" bgcolor="#7A79A7">Third-Party Code</th><th bordercolor="#7A79A7" bgcolor="#7A79A7">License</th><th bordercolor="#7A79A7" bgcolor="#7A79A7">Use</th></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3181">3181</a></td><td width="55%">SystemTapGui</td><td width="20%">Eclipse Public License</td><td width="20%"></td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3376">3376</a></td><td width="55%">Apache Commons Net Version: 2.0 (Subset) (using Orbit CQ3188)</td><td width="20%">Apache License, 2.0</td><td width="20%">unmodified source&nbsp;&amp;&nbsp;binary</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=4305">4305</a></td><td width="55%">Glibc Documentation 2.7 Subset (
 Manual Directory Texi Files only Excluding Examples Folder)</td><td width="20%">GNU Free Documentation License version 1.1</td><td width="20%">modified source&nbsp;&amp;&nbsp;binary</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=4742">4742</a></td><td width="55%">Apache Commons Net Version: 2.2</td><td width="20%">Apache License, 2.0</td><td width="20%">unmodified source&nbsp;&amp;&nbsp;binary</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=4828">4828</a></td><td width="55%">libmatthew-java Version: 0.7.2</td><td width="20%">Expat License (MIT Style)</td><td width="20%">unmodified binary </td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=5928">5928</a></td><td width="55%">SWTChart Version: 0.7.0</td><td width="20%">Eclipse Public License</td><td width="20%">unmodified binary </td></tr></table><h3>Exempt Pre-Req and Works With
  Dependencies</h3><table border="1" cellpadding="3" cellspacing="0" width="100%"><tr><th bordercolor="#7A79A7" bgcolor="#7A79A7">CQ</th><th bordercolor="#7A79A7" bgcolor="#7A79A7">Third-Party Code</th><th bordercolor="#7A79A7" bgcolor="#7A79A7">License</th><th bordercolor="#7A79A7" bgcolor="#7A79A7">Type</th></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2853">2853</a></td><td width="55%">Systemtap exempt third-party dependency Version: All</td><td width="20%">GNU General Public License (GPL)</td><td width="20%">exempt pre-req</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2965">2965</a></td><td width="55%">Linux Tools implied dependency:  rpm Version: 4.x</td><td width="20%">GPL v2</td><td width="20%">works with</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2966">2966</a></td><td width="55%">Linux Tools implied dependency: 
  rpmlint Version: any</td><td width="20%">GPL v2</td><td width="20%">works with</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2967">2967</a></td><td width="55%">Linux Tools implied dependency:  yum Version: any</td><td width="20%">GPL v2</td><td width="20%">works with</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2968">2968</a></td><td width="55%">Linux Tools implied dependency:  GNU Autotools Version: any</td><td width="20%">GPL v2</td><td width="20%">exempt pre-req</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3392">3392</a></td><td width="55%">lttng Version: all</td><td width="20%">GNU General Public License (GPL)</td><td width="20%">exempt pre-req</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3478">3478</a></td><td width="55%">systemtapguiserver Version: any</td>
 <td width="20%">Eclipse Public License</td><td width="20%">works with</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3706">3706</a></td><td width="55%">binutils Version: any</td><td width="20%">GNU General Public License (GPL)</td><td width="20%">exempt pre-req</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3707">3707</a></td><td width="55%">liblttvtraceread Version: 0.12 ? subset limited to LGPL licensed code</td><td width="20%">'Lesser' General Public License (LGPL) 2.1</td><td width="20%">exempt pre-req</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=4857">4857</a></td><td width="55%">devhelp Version: N/A</td><td width="20%">Various</td><td width="20%">works with</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=5195">5195</a></td><td width="55%">policykit Version: 0.98 a
 nd up</td><td width="20%">GNU Library General Public License Version 2</td><td width="20%">works with</td></tr></table><h3>Unused Approved Contributions</h3><table border="1" cellpadding="3" cellspacing="0" width="100%"><tr><th bordercolor="#7A79A7" bgcolor="#7A79A7">CQ</th><th bordercolor="#7A79A7" bgcolor="#7A79A7">Third-Party Code</th><th bordercolor="#7A79A7" bgcolor="#7A79A7">License</th><th bordercolor="#7A79A7" bgcolor="#7A79A7">Status</th></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3065">3065</a></td><td width="55%">Apache Jakarta Commons Net Library Version: 1.4.1 (PB CQ230) (using Orbit CQ2105)</td><td width="20%">Apache License, 2.0</td><td width="20%">obsolete: was used in the past but is not longer used</td></tr><tr><td align="right" width="5%"><a href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3066">3066</a></td><td width="55%">Apache Jakarta ORO Library Version: 2.0.8 (PB CQ232) (using Orbit CQ2104)</td>
 <td width="20%">Apache Software License 1.1</td><td width="20%">obsolete: was used in the past but is not longer used</td></tr></table><h2>Committers</h2>


<table border="1" cellpadding="3" cellspacing="0">
<tr><th colspan="3" bordercolor="#7A79A7" bgcolor="#7A79A7">Past and Present Active</th></tr>
<tr><th bordercolor="#7A79A7" bgcolor="#7A79A7">Name</th>
<th bordercolor="#7A79A7" bgcolor="#7A79A7">Organization</th>
<th bordercolor="#7A79A7" bgcolor="#7A79A7">&nbsp;</th>
</tr>
<tr>
	<td>Chris Aniszczyk</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Elliott Baron</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Nick Boldt</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>William Bourque</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Francois Chouinard</td>
	<td>Ericsson AB </td>
		<td></td>
		</tr>
	<tr>
	<td>Krzysztof Daniel</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Severin Gehwolf</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Roland Grunberg</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Daniel Henrique Barboza</td>
	<td>IBM </td>
		<td></td>
		</tr>
	<tr>
	<td>Bernd Hufmann</td>
	<td>Ericsson AB </td>
		<td></td>
		</tr>
	<tr>
	<td>Anithra P Janakiraman</td>
	<td>IBM </td>
		<td></td>
		</tr>
	<tr>
	<td>Jeff Johnston</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Matthew Khouzam</td>
	<td>Ericsson AB </td>
		<td></td>
		</tr>
	<tr>
	<td>Alexander Kurtakov</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Alexandre Montplaisir</td>
	<td>Ecole Polytechnique de Montreal </td>
		<td></td>
		</tr>
	<tr>
	<td>Phil Muldoon</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Otavio Pontes</td>
	<td>IBM </td>
		<td></td>
		</tr>
	<tr>
	<td>Xavier Raynaud</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Alvaro Sanchez-Leon</td>
	<td>Ericsson AB </td>
		<td></td>
		</tr>
	<tr>
	<td>Patrick Tasse</td>
	<td>Ericsson AB </td>
		<td></td>
		</tr>
	<tr>
	<td>Niels Thykier</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Alphonse Van Assche</td>
	<td> </td>
		<td></td>
		</tr>
	<tr>
	<td>Sami Wagiaalla</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	<tr>
	<td>Charley Wang</td>
	<td>Red Hat, Inc. </td>
		<td></td>
		</tr>
	</table>
<p>


<table border="1" cellpadding="3" cellspacing="0">
<tr><th colspan="3" bordercolor="#7A79A7" bgcolor="#7A79A7">Never Active</th></tr>
<tr><th bordercolor="#7A79A7" bgcolor="#7A79A7">Name</th>
<th bordercolor="#7A79A7" bgcolor="#7A79A7">Organization</th>
<th bordercolor="#7A79A7" bgcolor="#7A79A7">&nbsp;</th>
</tr>
<tr>
		<td>Andrew Overholt</td>
		<td> </td>
				<td></td>
				</tr>
			</table>
	<p>
	<h2>Contributors and Their Contributions</h2>
<table border="1" cellpadding="3" cellspacing="0">
<tr>
<th bordercolor="#7A79A7" bgcolor="#7A79A7">Ref</th>
<th bordercolor="#7A79A7" bgcolor="#7A79A7">Size</th>
<th bordercolor="#7A79A7" bgcolor="#7A79A7">Description</th>
</tr>
<tr><td colspan="3" style="background-color: #DDDDDD">rosaliam@linux.vnet.ibm.com</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=343025">343025</a></td>
		<td>2896 bytes</td>
		<td>Some of the event names in the OProfile profile configuration event tab are malformed<br/>Correct Bug fix: 343025 - Event names in the OProfile are malformed</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">mathieu.denis@polymtl.ca</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=352379">352379</a></td>
		<td>5151 bytes</td>
		<td>[LTTng] Statistics view - reset/update not performed when fast change of trace<br/>Dispose correctly of the loading experiment when another one is selected</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=355551">355551</a></td>
		<td>7469 bytes</td>
		<td>[LTTng] Statistics view - Correct calculation of cumulative CPU time<br/>Fix how the cumulative CPU time is updated</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">avkosinsky@yandex.ru</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=355385">355385</a></td>
		<td>2247 bytes</td>
		<td>Workaround ManParser problem for Windows/Cygwin<br/>ManParser.java</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Aaron&nbsp;Luchko (luchko.ca)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=76882">76882</a></td>
		<td>910 bytes</td>
		<td>RPM: Enhancement: automatically select current project in Export dialog<br/>changelog entry</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=78871">78871</a></td>
		<td>559 bytes</td>
		<td>Icon missing for oprofile launch<br/>Adds icons/ to the build.properties</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=82881">82881</a></td>
		<td>627 bytes</td>
		<td>Combo box should contain list of previous rpms opened<br/>changelog entry</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=83031">83031</a></td>
		<td>12199 bytes</td>
		<td>Fixing various naming problems in source<br/>le patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=83135">83135</a></td>
		<td>11014 bytes</td>
		<td>Option to export as configured project<br/>more patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=83150">83150</a></td>
		<td>1923 bytes</td>
		<td>[RPM} Incorrect path for diff<br/>patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alexander&nbsp;Kurtakov (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=207207">207207</a></td>
		<td>985 bytes</td>
		<td>Rpm editor do not accept valid values for Release:<br/>Possible fix</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=214217">214217</a></td>
		<td>565 bytes</td>
		<td>Source completion patch<br/>Changelog entry</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=215788">215788</a></td>
		<td>2729 bytes</td>
		<td>Support for adding directory to check for rpm macroses (e.g. /etc/rpm/macros.d)<br/>The proposed patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=217316">217316</a></td>
		<td>11316 bytes</td>
		<td>[Patch]Add interface to add directories to Macro completion list<br/>The patch containing the enhancement.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alexandre&nbsp;Montplaisir (voxpopuli.im)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=340700">340700</a></td>
		<td>1303 bytes</td>
		<td>[LTTng] File descriptors exhausted because traces are never closed<br/>Proposed fix</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=370501">370501</a></td>
		<td>9104 bytes</td>
		<td>[TMF] Generic State System<br/>Second part of the code contribution</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alexandre&nbsp;Montplaisir (polymtl.ca)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b64b4e3caac38ab55a5fd20a8daed92e3ca5c74">3b64b4</a></td>
		<td>111 lines</td>
		<td>Add method to get attributes with a wildcard in the path One can now use getQuarks(&quot;x&quot;, &quot;*&quot;, &quot;z&quot;), and it will return a List of all attribute quarks whose path matches the &quot;x&quot; and &quot;z&quot; parts. Not all edge cases have been tested (it fails if the * is a the end), but proper unit tests will be added shortly. It's also probably very slow and not yet completely optimized. Signed-off-by: Alexandre Montplaisir &lt;alexandre.montplaisir@polymtl.ca&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5dea65a54b20bdf792e4a5a901e3bf67c9eac34f">5dea65</a></td>
		<td>31 lines</td>
		<td>Add unit tests for the new getQuarks() method Also handle the case where the wildcard character is the last element of the array (which mimics the behaviour of getSubAttributes()) Signed-off-by: Alexandre Montplaisir &lt;alexandre.montplaisir@polymtl.ca&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e5945e9f37805b4e29b8873a736564a3359e5ac">7e5945</a></td>
		<td>43 lines</td>
		<td>Add option to retrieve sub-attributes recursively Signed-off-by: Alexandre Montplaisir &lt;alexandre.montplaisir@polymtl.ca&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b3a1756d657675294e3e1eb4c0c458237f73271a">b3a175</a></td>
		<td>48 lines</td>
		<td>Expose the getSubAttributes() method through the StateSystem Signed-off-by: Alexandre Montplaisir &lt;alexandre.montplaisir@polymtl.ca&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5698b3415b5c9682ec73eb50a2e433f6ea41c5b">e5698b</a></td>
		<td>7 lines</td>
		<td>Fix location of the new test trace file Signed-off-by: Alexandre Montplaisir &lt;alexandre.montplaisir@polymtl.ca&gt;</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alexandre&nbsp;Montplaisir (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=09303135edb89fad4ac52f0e5fdfc1d67a4ccadb">093031</a></td>
		<td>4753 lines</td>
		<td>Merge Generic State System core part</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2a5a7d97e0bafd32cd85337e103a691db28e5cf9">2a5a7d</a></td>
		<td>145 lines</td>
		<td>Don't catch the FileNotFound exception in CTF tests This just makes it more annoying when the file doesn't exist, which can easily happen since the test traces are not in the git tree itself.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=44b4b425f21cd19c0a3480c393511ae8a3aca821">44b4b4</a></td>
		<td>13 lines</td>
		<td>Update the CTF tests to the previous change</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4cc0a4c7e7e0f17b65f9ee96a7ae880f54e81f59">4cc0a4</a></td>
		<td>1280 lines</td>
		<td>Integrate CtfAdaptor package in TMF</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=512f28fdb0bdaaab2de9a034784c73a973e2af0e">512f28</a></td>
		<td>58 lines</td>
		<td>Start fixing GSS tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=563ee6fb6dc7e992a39f78d077edbf7ab4c0b555">563ee6</a></td>
		<td>92 lines</td>
		<td>Update State History construction tests to the newest test trace Also use assertEquals instead of assertTrue(x == y), it gives us a bit more information when the test fails.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5d5902a323109ca9ef4510593f762b82d133613d">5d5902</a></td>
		<td>49 lines</td>
		<td>Restore extra checks in SequenceDefinition's constructor</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9901a4af877c6d74fe200597b175dd8bf6caecfb">9901a4</a></td>
		<td>9 lines</td>
		<td>Avoid printing the exception when CtfTmfTrace.validate() fails It simply means the type of trace doesn't match, which can happen in normal conditions. Also made getCTFTrace() non-public, only CtfIterator uses it, and we don't want to pass on the CTFTrace dependency.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9c24c5ec351978e1ff45213a13a1594c877aff31">9c24c5</a></td>
		<td>45 lines</td>
		<td>GSS: Avoid doing time-range requests if one of the timestamps is invalid Thanks to the unit-test benchmarking for letting me know of this problem... Also exposed checkValidTime() through the IHistoryBackend interface, this can be useful, as we see here.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b5bf72ca186cc78f842e637580b64a74c36f38c4">b5bf72</a></td>
		<td>43 lines</td>
		<td>Use ITmfEvent in a couple more places</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b714e56f44c8b93dd4c944c0c245b27fa880e1e8">b714e5</a></td>
		<td>1245 lines</td>
		<td>Merge Kernel state system input provider which goes in the lttng2.kernel.core plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f1be1c40b328402d3c3ce52ac381c5aee5ad1451">f1be1c</a></td>
		<td>15 lines</td>
		<td>Make the Kernel event handler tests work again - Strip the underscores in CtfTmfEventField's. We need to save a value here (we can't use the parser's lookupDefinition()), so might as well save it with no underscore. - Use the getSource() as a way to get the event name. This is still waiting on the final trace model. We are bypassing the EventTypeManager for now - Use getTimestampValue() to check for a nullEvent, getTimestamp always return the ITmfTimestamp object now, so it's not null!</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alphonse&nbsp;Van&nbsp;Assche (fedoraproject.org)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=021d7d6608cdfcc76ea6fb521fd2bacc350aeeba">021d7d</a></td>
		<td>16 lines</td>
		<td>2007-06-20  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/RpmMacroOccurrencesUpdater.java (isDefineChar): Add '?' char as define limiter. * src/org/eclipse/linuxtools/rpm/ui/editor/PackageWordDetector.java (isWordPart): Add '+' char. * icons/occurence_obj.gif New file.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0a8d3f120b985559276faddad5f6e7e0e5e5a2f8">0a8d3f</a></td>
		<td>22 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0c1622d7c53babea40c1bc4aaefe5df02b3f2ca1">0c1622</a></td>
		<td>25 lines</td>
		<td>2007-09-16  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpmstubby/StubbyGenerator.java (generateSpecfile): Add eclipse_base define. * src/org/eclipse/linuxtools/rpmstubby/FeatureVisitor.java (visit): Cleanup javadoc. * src/org/eclipse/linuxtools/rpmstubby/StubbyPackageModel.java: Cleanup.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0c7c1aa8835badb4a8e4e58f1f2ac46f296003a0">0c7c1a</a></td>
		<td>470 lines</td>
		<td>2007-06-20  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/tests/AScannerTest.java: Abstract test case class for scanners. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/AllTests.java (suite): Add new test cases classes. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/SpecfileScannerTests.java: New tests. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/SpecfilePackagesScannerTests.java: New tests. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/SpecfileChangelogScannerTests.java: New tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0eede01ba8477d63ae3d1ac5ecc32eb0953e2234">0eede0</a></td>
		<td>240 lines</td>
		<td>2007-09-07  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpmstubby/StubbyGenerator.java (generateSpecfile): Fix inversion of URL and License tag and add Source0 tag when the specfile is generate with the fetch script. * src/org/eclipse/linuxtools/rpmstubby/StubbyPackageModel.java (getURL): Return FIXME instead of null if the feature URL field is empty. * .classpath: Add J2SE-1.4 preferred EE. * META-INF/MANIFEST.MF: Add J2SE-1.4 preferred EE. * src/org/eclipse/linuxtools/rpmstubby/popup/actions/StubifyAction.java: Restore accidentally removed file file.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=156b59c34e2f8569d5c733fc87a9d5aa6017a655">156b59</a></td>
		<td>9 lines</td>
		<td>2007-07-18  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/wizards/SpecfileNewWizardPage.java: (dialogChanged): Fix a little mistake with String#indexOf</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=173e0113e97f438c541445e813b706206ac79726">173e01</a></td>
		<td>176 lines</td>
		<td>2007-09-24  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/wizards/SpecfileNewWizardPage.java: Throw CoreException if /usr/share/doc or /etc/rpmdevtools dir are not found. * src/org/eclipse/linuxtools/rpm/ui/editor/Activator.java: Using SpecfileLog. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileSource.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileParser.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfilePackageContainer.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/actions/SpecfileChangelogFormatter.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/actions/SpecfileChangelogAction.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/URLHyperlinkWithMacroDetector.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfilePartitioner.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileFoldingStructureProvider.java: Li
 kewise. * src/org/eclipse/linuxtools/rpm/ui/ed</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=28ac63a64b312203d2a7457ee456a61fe6a82679">28ac63</a></td>
		<td>112 lines</td>
		<td>2007-10-14  Alphonse Van Assche &lt;alcapcom@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=206160">Bug 206160</a> * src/org/eclipse/linuxtools/rpm/ui/editor/Activator.java (start): Add sanity checks, at this time we only check if ~/.rpmmacros file exist and in the case at this file don't exist we run rpmdev-setuptree to create it. * src/org/eclipse/linuxtools/rpm/ui/editor/Utils.java: New File. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/PreferenceConstants.java (RPMMACRO_FILE): New Constant. Bug	https://bugzilla.redhat.com/show_bug.cgi?id=327101 * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileCompletionProcessor.java (computePatchesProposals): Remove accidentally added code.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e50f787e6102e28ef4344aa096e1b395f032e8b">2e50f7</a></td>
		<td>1069 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2ee8f7c335859094a00d398656eddd27d5b20211">2ee8f7</a></td>
		<td>35 lines</td>
		<td>2007-08-19  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * feature.xml: change version to 0.1.0</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=31c03502fc801eb44e528e9a0fc11b7f73cf7c3b">31c035</a></td>
		<td>58 lines</td>
		<td>2008-01-23  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/RpmPackageBuildProposalsJob.java Backup package list only if the file existing + strings cleanups. 2008-01-18  Alexander Kurtakov  &lt;akurtakov@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=215788">Bug 215788</a>, 215771 * src/org/eclipse/linuxtools/rpm/ui/editor/RpmMacroProposalsList.java: Handle directories with macros files. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileParser.java: Remove License from simple tags.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=357a30d3aebface2dd035991ecb7d46081c39c6d">357a30</a></td>
		<td>67 lines</td>
		<td>2009-07-08  Alphonse Van Assche  &lt;alcapcom@fedoraproject.org&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/scanners/SpecfileChangelogScanner.java (SpecfileChangelogScanner): Don't do unneeded stuff. * src/org/eclipse/linuxtools/rpm/ui/editor/scanners/SpecfilePackagesScanner.java: Remove unneded code + typo cleanups. * src/org/eclipse/linuxtools/rpm/ui/editor/scanners/SpecfilePartitionScanner.java: Use private static final + typo. * src/org/eclipse/linuxtools/rpm/ui/editor/scanners/SpecfileScanner.java: : Likewike.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=35d3ad83bc9ff0a8a817330aa8f92afe7f688343">35d3ad</a></td>
		<td>320 lines</td>
		<td>2007-07-17  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; Build RPM proposal list in a background task job, the list can be update when the plugin is loader or once a week or once a month. * src/org/eclipse/linuxtools/rpm/ui/editor/RpmPackageBuildProposalsJob.java: New Class that initialize and update the packages proposal list. * src/org/eclipse/linuxtools/rpm/ui/editor/Activator.java: Add property change listener and call RpmPackageBuildProposalsJob#update in the start method. * src/org/eclipse/linuxtools/rpm/ui/editor/RpmPackageProposalsList.java: Updating to use the new job to update package proposal list strategy. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/RpmProposalsPreferencePage.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/PreferenceInitializer.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/PreferenceConstants.java: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4458f28aef8fa0c6331e103df2ff775ba2688874">4458f2</a></td>
		<td>6 lines</td>
		<td>2007-06-22  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * META-INF/MANIFEST.MF: Add &quot;org.eclipse.ui.editors&quot; dependencie requiere by Ecliple 3.3</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=47bf3e92ed96dfb85c837b3e6096629d7486d774">47bf3e</a></td>
		<td>4 lines</td>
		<td>2007-06-22  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * .cvsignore: Add bin dir.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=499c174854f6f99f18d20d5b11fcd81df25312ef">499c17</a></td>
		<td>82 lines</td>
		<td>2007-06-05  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=182633">Bug 182633</a> * src/org/eclipse/linuxtools/rpm/ui/editor/Activator.java (getImage): New method. * src/org/eclipse/linuxtools/rpm/ui/editor/outline/SpecfileLabelProvider.java (PREAMBLE_ICON): New global var for icon. (SECTION_ICON): Likewise. (PACKAGES_ICON): Likewise. (PACKAGE_ICON): Likewise. (getImage): Take the above icons in account. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileCompletionProcessor.java (TEMPLATE_ICON): New global var for icon. (computeTemplateProposals): Using Activator.getImage() method. (computeRpmMacroProposals): Likewise. (computeRpmPackageProposals): Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4fc20823ff88bd38c1bf18efc07787cc01b58695">4fc208</a></td>
		<td>241 lines</td>
		<td>2007-11-28  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; Add support for URPM tool and cancel support to RpmPackageBuildProposalsJob. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/RpmProposalsPreferencePage.java (rpmtoolsRadioGroupFieldEditor): Add urpm support. (buildTimeListRateFieldEditor): Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/PreferenceConstants.java (DP_RPMTOOLS_URPM): New const. * src/org/eclipse/linuxtools/rpm/ui/editor/RpmPackageProposalsList.java: Using HashSet list to advoid duplicates package. * src/org/eclipse/linuxtools/rpm/ui/editor/RpmPackageBuildProposalsJob.java (update): Cancel support. (retrievePackageList): Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/Utils.java (copyFile): New mthod (fileExist): New method (pluginSanityCheck): Add package list preferences sanity checks.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=50164c317580e91c45862536b32714b235678ef4">50164c</a></td>
		<td>585 lines</td>
		<td>2007-07-14  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/wizards/SpecfileNewWizardPage.java: Replace String#contains by String#indexOf for JRE 1.4 compatibility. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileConfiguration.java: Moving Annotation Hover to derived package. * Too many files to list: Add contributor line.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=52ec6cd84fc6172ee50dfa44bd11c5dac38208ad">52ec6c</a></td>
		<td>6 lines</td>
		<td>2008-06-29  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * META-INF/MANIFEST.MF: bump to 0.4.0</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=564977038d2bf0313c2e76198b1ba084dd9a1233">564977</a></td>
		<td>635 lines</td>
		<td>2009-05-06  Alphonse Van Assche &lt;alcapcom@fedoraproject.org&gt; Convert tab by space (https://bugs.eclipse.org/bugs/show_bug.cgi?id=185227) * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileProjectionViewer.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileTabConverter.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/MainPreferencePage.java: Add a checkbox. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/PreferenceConstants.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/PreferenceInitializer.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/Messages.java: Externalize strings. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/messages.properties: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileEditor.java: add convert tab by space capability.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=582dbb70d82d02008f867cfa04d73f20921f9051">582dbb</a></td>
		<td>34 lines</td>
		<td>2007-07-18  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * META-INF/MANIFEST.MF: bump to 0.0.2 * src/org/eclipse/linuxtools/rpm/rpmlint/actions/ToggleRpmlintNatureAction.java (run): Generify. * src/org/eclipse/linuxtools/rpm/rpmlint/builder/RpmlintMarkerVisitor.java (visit): Likewise. * src/org/eclipse/linuxtools/rpm/rpmlint/builder/RpmlintNature.java (configure): Likewise. * src/org/eclipse/linuxtools/rpm/rpmlint/parser/RpmlintParser.java (getRealLineNbr): Likewise. (parseRpmlintOurput): Ignore rpmlint 0.83 summary line.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5f3f5cc5679df8d4ba273ca55de8a9d1d6ec468f">5f3f5c</a></td>
		<td>46 lines</td>
		<td>2007-09-09  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpmstubby/StubbyPackageModel.java (getLicense): Try to find the license in LicenseModel().getAnnotation() too. * src/org/eclipse/linuxtools/rpmstubby/StubbyPackageModel.java (getDescription): Each description line contain maximum 80 characters. * src/org/eclipse/linuxtools/rpmstubby/StubbyGenerator.java (generateSpecfile): Fix Specfile formating.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=667dc937e562738458d517d1bfc60815cdbd0e98">667dc9</a></td>
		<td>77 lines</td>
		<td>2007-09-24  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=204150">Bug 204150</a> (Clean fix) * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileCompletionProcessor.java (computePatchesProposals): New Method. (getDefines): Rename method. (getPatches): New Method. (computeCompletionProposals): Add patches proposals.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=673c1d377c351e96e8bfaabcaf382f681ce9716d">673c1d</a></td>
		<td>4 lines</td>
		<td>Fix version! to fit the RPM package ERV</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=681be6aed9e56d6c35709e4944a3f518d76bb212">681be6</a></td>
		<td>8 lines</td>
		<td>2007-06-04  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/actions/SpecfileChangelogFormatter.java Fix ChangeLog entry action. (formatDateLine): Add escape char in pattern %{?dist} tag.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=69047dc0b587b9a54e58355557d237a9b2b43e55">69047d</a></td>
		<td>61 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=199172">Bug 199172</a> * src/org/eclipse/linuxtools/rpm/ui/editor/actions/SpecfileChangelogFormatter.java: Add method required by ChangeLog HEAD.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6ded8a078837daa5c0aa1bd602f6c6db4150ffcf">6ded8a</a></td>
		<td>129 lines</td>
		<td>2009-05-08  Alphonse Van Assche  &lt;alcapcom@fedoraproject.org&gt; Add support for the new 'specfile-error' rpmlint error. This error is returned by rpmlint when it cannot parse a give .spec file using 'rpm -q --qf= --specfile file.spec' command. The output of the RPM parser give us some useful information about many .spec file syntax errors. * src/org/eclipse/linuxtools/rpm/rpmlint/parser/RpmlintParser.java: Parse rpm parser error message. * plugin.xml: Fix typo. * src/org/eclipse/linuxtools/rpm/rpmlint/builder/RpmlintMarkerVisitor.java: Likewise. * src/org/eclipse/linuxtools/rpm/rpmlint/parser/RpmlintItem.java: Likewise. * src/org/eclipse/linuxtools/rpm/rpmlint/resolutions/RpmlintMarkerResolutionGenerator.java: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f8bbd5ad89c70dbb700c405346f7ad448c5aa90">6f8bbd</a></td>
		<td>67 lines</td>
		<td>2007-06-20  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * META-INF/MANIFEST.MF: Add  org.eclipse.ui.ide package. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/AllTests.java (suite): Enable HyperlinkWithMacroTests. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/HyperlinkWithMacroTests.java (testMacroResolutionInUrl): Using org.eclipse.ui.ide.IDE.openEditor to get the editor instance. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/LicenseTagTest.java: (testMultipleLicenseTag): Disable this test case according with the current code.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f8f69ec92c0ca98c6687f30b855b147ecc24186">6f8f69</a></td>
		<td>6 lines</td>
		<td>2007-12-15  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * META-INF/MANIFEST.MF: Bump to 0.0.3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=752bd1126b2c5fca2b205225adc81319d5c6af09">752bd1</a></td>
		<td>22 lines</td>
		<td>2007-09-19  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * .settings/org.eclipse.jdt.ui.prefs: J2SE-1.4 preferred EE. * .settings/org.eclipse.jdt.core.prefs: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=777061bba3ba2fc658f780f6af0ee437057932c0">777061</a></td>
		<td>48 lines</td>
		<td>2007-06-25  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/rpmlint/builder/RpmlintBuilder.java: Cleanup some messages. * src/org/eclipse/linuxtools/rpm/rpmlint/Activator.java: Add license. * src/org/eclipse/linuxtools/rpm/rpmlint/RpmlintLog.java: Add license + cleanup the javadoc. * src/org/eclipse/linuxtools/rpm/rpmlint/parser/RpmlintParser.java: Remove unneeded stack traces printing.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7ccf329ff959bc28ff2694c33b03266aa9e9ee65">7ccf32</a></td>
		<td>33 lines</td>
		<td>2007-09-24  Alphonse Van Assche &lt;alcapcom@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=204150">Bug 204150</a> * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileCompletionProcessor.java (getDefinesName): Add completion for patches.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7f15e66a4f67273fe5099127118a3a79bc4e9191">7f15e6</a></td>
		<td>97 lines</td>
		<td>2007-07-16  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; Implement toggle comment like in JDT. * plugin.xml: Add comment toggle action. Add our document provider. * src/org/eclipse/linuxtools/rpm/ui/editor/actions/specfileEditorToggleCommentActionDelegate.java: New action.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=801d51045981c567755a59f0dbc44625819bb1af">801d51</a></td>
		<td>10 lines</td>
		<td>2009-07-07  Alphonse Van Assche  &lt;alcapcom@fedoraproject.org&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/RpmPackageBuildProposalsJob.java: Remove unneeded comments (we target 3.5 now).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=822b2f337ba1ee2e180ed1782748dcef32e94808">822b2f</a></td>
		<td>138 lines</td>
		<td>2007-06-25  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/wizards/SpecfileNewWizardPage.java: (dialogChanged): Forgot to add '&gt;' char as un-acceptable character for the Name tag.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=853db3413442e2f8de3cd312974765f3daaed9bd">853db3</a></td>
		<td>71 lines</td>
		<td>2008-05-14  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; Add folding on all complex sections. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/Specfile.java (getComplexSectionsAsList): New method. (addComplexSection): Likewise. (getComplexSections):Likewise. (getComplexSectionsElements): Likewise. (getSectionsAsList): Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileParser.java (parseSection): Add complex sections. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileFoldingStructureProvider.java (addFoldingRegions): Likewise. (createFoldingStructure): Likewise. (ElementByLineNbrComparator): New inner class.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=871cba766119ff5c0591ca75064f4a84b999e6da">871cba</a></td>
		<td>293 lines</td>
		<td>2009-07-07  Alphonse Van Assche  &lt;alcapcom@fedoraproject.org&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/actions/SpecfileChangelogAction.java: Removed unused action. * src/org/eclipse/linuxtools/rpm/ui/editor/actions/Messages.java: Remove no more needed messages. * src/org/eclipse/linuxtools/rpm/ui/editor/actions/SpecfileChangelogFormatter.java (formatDateLine): Resolve defines on the right place. * src/org/eclipse/linuxtools/rpm/ui/editor/hyperlink/SpecfileElementHyperlinkDetector.java (getDefineName): Fix null pointer exception. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileElement.java (resolve): Use of Utils.resolveDefines * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileHover.java (findWord): Fix hover bug on specfiles that begin with a define. (getHoverRegion): Use better var name. * src/org/eclipse/linuxtools/rpm/ui/editor/Utils.java: Typo cleanups.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8af86a9007c65236ca9ffb55e7c538034302f010">8af86a</a></td>
		<td>144 lines</td>
		<td>2007-09-24  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpmstubby/StubbyLog.java: New File. * src/org/eclipse/linuxtools/rpmstubby/StubbyPackageModel.java (StubbyPackageModel): Using StubbyLog. (getIncudedFeatures): Likewise. (resolveFeatureProperties): Likewise. * src/org/eclipse/linuxtools/rpmstubby/StubbyGenerator.java (generateSpecfile): Add missing %endif macro. (writeContent): Using StubbyLog. * src/org/eclipse/linuxtools/rpmstubby/SpecfileWriter.java (write): Using StubbyLog and print error mesage to stdout.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8cb2e88b3f2833870a44423011e75b505664857c">8cb2e8</a></td>
		<td>209 lines</td>
		<td>2008-04-27  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; IFileStore don't give possibility to mark resources or to get a IFile, so some functionality cannot be provided on file outside a workspace - The Java editor seem to do the same thing. * src/org/eclipse/linuxtools/rpm/ui/editor/hyperlink/SpecfileElementHyperlinkDetector.java (prepareHyperlink): Prepare links only for specfile inside the workspace. (detectHyperlinks): Only provides this functionality for existing patches and sources. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileElement.java (resolve): Don't throw unexpected exceptions. * src/org/eclipse/linuxtools/rpm/ui/editor/RpmMacroProposalsList.java (getValue): Generify. (getProposals): Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileCompletionProcessor.java (computeSourcesProposals): Likewise. (getSources): Likewise. (ProposalComparator): Likewise. (computeTemplateProposals): Likewise. (ProposalComparator.compare): Likewise. (getD
 efines): Likewise. (computePatchesProposals): </td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=95ae9f3ab33998e66b13e3cdf2963f4f37da4ff0">95ae9f</a></td>
		<td>146 lines</td>
		<td>2007-06-22  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * META-INF/MANIFEST.MF: Add new dependencie &quot;com.ibm.icu&quot; for LineBreakingReader derived class. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileErrorHandler.java: (setDocument): New method. It is used by the rpmlint Plug-In. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileErrorHandler.java: (setFile): Likewise. (parse): Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileHover.java: Using the derived HTMLTextPresenter class. That make the plugin compatible with both 3.2 and 3.3 Eclipse versions. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileConfiguration.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/derived/HTML2TextReader.java: New New derived class. * src/org/eclipse/linuxtools/rpm/ui/editor/derived/SubstitutionTextReader.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/derived/SingleCharReader.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/deri
 ved/LineBreakingReader.java: Likewise. * src/org/eclipse</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=975ebcea9e9e55f26bd290bb5052fad7eda05208">975ebc</a></td>
		<td>12 lines</td>
		<td>2007-07-18  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * META-INF/MANIFEST.MF: Remove unneeded deps.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e43847ee71d20afd9caf1faac181c096693a84d">9e4384</a></td>
		<td>715 lines</td>
		<td>2007-06-05  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=184955">Bug 184955</a> * plugin.xml: add org.eclipse.ui.editors.markerAnnotationSpecification extension point. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileHover.java (getHoverInfo): using new methods. (getSourceOrPatchValue): New method used by RpmMacroOccuencesUpdater. (getMacroValueFromMacroList): New method used by RpmMacroOccuencesUpdater. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileConfiguration.java (getAnnotationHover): overload of getAnnotationHover() method from SourceViewerConfiguration. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/Specfile.java (getDefinesAsList): New method. (getDefinesAsArray): New method. * src/org/eclipse/linuxtools/rpm/ui/editor/RpmMacroOccurrencesUpdater.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/AnnotationHover.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileEditor.java
  (setSpecfile): update macro occurences.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e44fc05ed4def9e296b02a292d2efa74aedc585">9e44fc</a></td>
		<td>141 lines</td>
		<td>2008-05-12  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; Add support to detect mail hyperlink. To make a try, just select a part of text in the specfile and &lt;ctrl&gt; + click on a mail address. * src/org/eclipse/linuxtools/rpm/ui/editor/hyperlink/MailHyperlink.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/hyperlink/MailHyperlinkDetector.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/hyperlink/URLHyperlinkWithMacroDetector.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/URLHyperlinkWithMacroDetector.java: Moved. * .classpath: add StandardVMType/J2SE-1.5. * META-INF/MANIFEST.MF: export hyperlink package. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileConfiguration.java (getPresentationReconciler): (getHyperlinkDetectors): Add mail detector. (getHyperlinkDetectorTargets): Add java doc. (getTextHover): likewise. (getDoubleClickStrategy): likewise. (getConfiguredContentTypes): likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a19d2ca4697c807b788d4ac681ed81fc9d99d008">a19d2c</a></td>
		<td>29 lines</td>
		<td>2007-09-12  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpmstubby/StubbyGenerator.java (generateSpecfile): Fix a specfile formating bug. * src/org/eclipse/linuxtools/rpmstubby/FeatureVisitor.java: Fix List naming. * src/org/eclipse/linuxtools/rpmstubby/StubbyPackageModel.java (getDescription): Add the last description token.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b7489b0b34f987e9faf07a2928535a9e41263e9d">b7489b</a></td>
		<td>21 lines</td>
		<td>2007-06-20  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileEditor.java (dispose): Set specfile field to null, useful for test cases. (getSpecfileSourceViewer): New method used by HyperlinkWithMacroTests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c7679673f590e6f72c6e96c55dfce32ab4c28ba6">c76796</a></td>
		<td>2 lines</td>
		<td>bump to version 0.0.2</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c7f91d13226193ba4d4a58b22d0a13e7ea0d88d3">c7f91d</a></td>
		<td>11 lines</td>
		<td>2007-06-26  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/rpmlint/builder/RpmlintDeltaVisitor.java: (visit): Remove old markers when a resource is modified.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cbfd44112379d3766332b0e66bc310407e348fd8">cbfd44</a></td>
		<td>6 lines</td>
		<td>Remove too stupid spelling fault.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ccb998b86fda10f2953cab12b7140931abf5e65c">ccb998</a></td>
		<td>89 lines</td>
		<td>2009-07-08  Alphonse Van Assche  &lt;alcapcom@fedoraproject.org&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/tests/scanners/SpecfilePackagesScannerTest.java : Fix disabled tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ceab2fc04ea45302ea320795b2a3bf34ba56f71d">ceab2f</a></td>
		<td>157 lines</td>
		<td>2007-07-17  Alphonse Van Assche   &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileCompletionProcessor.java: Add defines in proposals. Don't show templates in package context and retrieve proposals only when it's needed. Cleanup javadoc and remove some unneeded methods args. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileCompletionProcessor.java: (getDefinesName): New method. * src/org/eclipse/linuxtools/rpm/ui/editor/URLHyperlinkWithMacroDetector.java: Cleanup.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cfee5877ddedefb7a4a37880bd30bfea57f49c29">cfee58</a></td>
		<td>2 lines</td>
		<td>cleanups...</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d193eb1b031346b59f5d25e71f2a365e6ec1e319">d193eb</a></td>
		<td>168 lines</td>
		<td>2007-12-15  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=212781">Bug 212781</a> + some cleanups * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/MainPreferencePage.java: Add Changelog format preferences. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/PreferenceInitializer.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/preferences/PreferenceConstants.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileParser.java (parse): Remove existing markers only when SpecfileErrorHandler is instantiated. * src/org/eclipse/linuxtools/rpm/ui/editor/actions/SpecfileChangelogFormatter.java (formatDateLine): Changelog entry format based on prefs. * src/org/eclipse/linuxtools/rpm/ui/editor/Utils.java (resolveDefines): Copy from URLHyperlinkWithMacroDetector. * src/org/eclipse/linuxtools/rpm/ui/editor/URLHyperlinkWithMacroDetector.java: Move resolveDefines() to Utils. * src/org/eclipse
 /linuxtools/rpm/ui/editor/RpmPackageBuildProposalsJob.java (propertyListener): Run the job only when P_CURRENT_R</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1b7d721fbdce02df5df2fc4dc4dbc0e0604cc9b">d1b7d7</a></td>
		<td>239 lines</td>
		<td>2007-09-25  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; Add key bindings for Toggle Comment and Organize Patches actions. * src/org/eclipse/linuxtools/rpm/ui/editor/actions/SpecfileEditorToggleCommentActionDelegate.java: Implement IWorkbenchWindowActionDelegate interface. (selectionChanged): Set/update the editor member when the selection change. * src/org/eclipse/linuxtools/rpm/ui/editor/actions/SpecfileEditorOrganizePatchesActionDelegate.java Implement IWorkbenchWindowActionDelegate interface. (selectionChanged): Set/Update the editor member when the selection change. * src/org/eclipse/linuxtools/rpm/ui/editor/Activator.java (getActiveEditor): New method. * plugin.xml: Add extension points for these key bindings.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1e562271cdcd2cd1cce79bcb625c81e4a43afc4">d1e562</a></td>
		<td>634 lines</td>
		<td>Initial commit</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d2b1bf8541d4147cc30602901092791064c8a92a">d2b1bf</a></td>
		<td>24 lines</td>
		<td>2007-06-20  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/tests/RpmPackageProposalsListTests.java (tearDown): Remove method. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/SpecfileTestProject.java (dispose): Remove /tmp/pkglist file at the end of the test suite.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d47677a66fe04aaf0325b23f8be3337881aba6fd">d47677</a></td>
		<td>1504 lines</td>
		<td>2007-09-07  Alphonse Van Assche &lt;alcapcom@gmail.com&gt; - Add models that represent the package. - Generate specfile based on the model. - Generate fetch script based on the model. - Add Preference pages to configure the generator. * plugin.xml: Add properties pages extensions * META-INF/MANIFEST.MF: Add require bundle 'org.eclipse.ui.ide' * src/org/eclipse/linuxtools/rpmstubby/preferences/StubbyPreferencePage.java: New Class. * src/org/eclipse/linuxtools/rpmstubby/preferences/PreferenceInitializer.java: Likewise. * src/org/eclipse/linuxtools/rpmstubby/preferences/PreferenceConstants.java: Likewise. * src/org/eclipse/linuxtools/rpmstubby/popup/actions/StubifyAction.java: Likewise. * src/org/eclipse/linuxtools/rpmstubby/model/SubPackage.java: Likewise. * src/org/eclipse/linuxtools/rpmstubby/model/PackageItem.java: Likewise. * src/org/eclipse/linuxtools/rpmstubby/model/MainPackage.java: Likewise. * src/org/eclipse/linuxtools/rpmstubby/model/IPackagePreamble.java: Likew
 ise. * src/org/eclipse/linuxtools/rpmstubby/mo</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dce5297779053ba31c71def6a943286a1b8a3426">dce529</a></td>
		<td>371 lines</td>
		<td>2007-06-25  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; Add a wizard for new specfile based on a template provided by the rpmdevtools package. * src/org/eclipse/linuxtools/rpm/ui/editor/wizards/SpecfileNewWizard.java: New File. * src/org/eclipse/linuxtools/rpm/ui/editor/wizards/SpecfileNewWizardPage.java: Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileLog.java: Likewise, The logger of convenience for the Specfile Plug-In. * plugin.xml: Add extensions points for the wizard.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e1fc0f9bf3f5620814e6b079a72d49abe2dd2637">e1fc0f</a></td>
		<td>16 lines</td>
		<td>2009-05-08  Alphonse Van Assche &lt;alcapcom@fedoraproject.org&gt; Remove 'No value name after define.' parsing error, this error is now throw by RPM parser through rpmlint. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileParser.java: Remove no more needed code. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/message.properties Remove above message string.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f922f9a911572308f6a237e273d89a72319565ed">f922f9</a></td>
		<td>68 lines</td>
		<td>2007-06-04  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileParser.java (parsePatch): Parse %patch macro and Patch: directive without trailing number. (parseComplexDefinition): Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileSource.java (changeReferences): Likewise. (changeDeclaration): Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileScanner.java (SpecfileScanner): Scan %patch macro without trailing number. * src/org/eclipse/linuxtools/rpm/ui/editor/URLHyperlinkWithMacroDetector.java (detectHyperlinks): Check if IHyperlink[] is not null before try to get the lenght of it.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fad1dd1609a4b37badb2f713006ef69213f6c134">fad1dd</a></td>
		<td>18 lines</td>
		<td>2007-09-24  Alphonse Van Assche &lt;alcapcom@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=204146">Bug 204146</a> * src/org/eclipse/linuxtools/rpm/ui/editor/outline/SpecfileContentOutlinePage.java (selectionChanged): Set the length parameter of editor#setHighlightRange method to 1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fc8a7114c6efa9dc0fc057b7a7aaf1314b5b6082">fc8a71</a></td>
		<td>36 lines</td>
		<td>2009-05-08  Alphonse Van Assche &lt;alcapcom@fedoraproject.org&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/tests/parser/SpecfileDefineTest.java: Disable test define without value, because of the fact that this error is no more managed by our internal parser.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alphonse&nbsp;Van&nbsp;Assche (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=177220">177220</a></td>
		<td>108450 bytes</td>
		<td>Some patches for the specfile editor<br/>foldind-hover-completions </td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181110">181110</a></td>
		<td>7680 bytes</td>
		<td>Should SpecfileReconcilingStrategy#updateEditor be empty?<br/>Update the editor without saving the file</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181236">181236</a></td>
		<td>6531 bytes</td>
		<td>Write tests for new editor functionality (folding, hover, completion)<br/>RpmMacroProposalsList and RpmPackageProposalsList test</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181245">181245</a></td>
		<td>19179 bytes</td>
		<td>[PATCH] RPM packages coloration and hover support<br/>packages coloration, hover and completion support</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181395">181395</a></td>
		<td>803 bytes</td>
		<td>[PATCH] RpmMacroProposalsList replaceAll fix<br/>fix replaceAll() another replaceAll() bug in RpmMacroProposalsList</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181747">181747</a></td>
		<td>6788 bytes</td>
		<td>Hyperlink with macro detector<br/>URLHyperlinkWithMacroDetector</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=182302">182302</a></td>
		<td>1741 bytes</td>
		<td>[PATCH] some display fixes<br/>Fix: package names as sub-names of other package names</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=182633">182633</a></td>
		<td>5832 bytes</td>
		<td>Add outline icons<br/>Outline and completion icons</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=184955">184955</a></td>
		<td>30362 bytes</td>
		<td>[PATCH] specfile editor - macro occurences annotations<br/>macro occurences annotations</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185227">185227</a></td>
		<td>18007 bytes</td>
		<td>Specfile plugin - convert tab to spaces<br/>convert tab by spaces</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Alvaro&nbsp;Sanchez-Leon (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=290250">290250</a></td>
		<td>323705 bytes</td>
		<td>[LTTng] Integrate LTTng UI State Views (controlflow, resources and statistics)<br/>patch uggraded to svn latest Sept 25 09</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=290968">290968</a></td>
		<td>62505 bytes</td>
		<td>[Lttng] Refactor state views to use common code to handle Data Requests + others<br/>patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=291097">291097</a></td>
		<td>86856 bytes</td>
		<td>[LTTng] Align process creation with C-code implementation<br/>udpated to  HEAD</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=291981">291981</a></td>
		<td>17713 bytes</td>
		<td>[LTTng] Switching between Experiments needs to clear old experiment data<br/>Patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=292393">292393</a></td>
		<td>30833 bytes</td>
		<td>[LTTng] Improve search of a process within the State model<br/>re-created</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=292397">292397</a></td>
		<td>29811 bytes</td>
		<td>[LTTng] Control Flow View - Improve the search of Local UI model Process<br/>Patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=296266">296266</a></td>
		<td>1532 bytes</td>
		<td>[LTTng] Processes may be created without a valid traceID<br/>patch - state processes shall always have a valid traceID</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=297086">297086</a></td>
		<td>853 bytes</td>
		<td>[LTTng] Resources view not showing all information<br/>patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Andrew&nbsp;Overholt (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=00f62ca8526f2d6b4eec1250bb1c8c09d7d3b201">00f62c</a></td>
		<td>4 lines</td>
		<td>2010-07-28  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Use bootstrap JARs to build Equinox Initializer.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0242d663a42bfb4824daf81588af134a6d69e2e4">0242d6</a></td>
		<td>10 lines</td>
		<td>2009-10-06  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=291504">Bug 291504</a> * build.xml: Apply patch from Benjamin Drung to add link to the launcher binary in the installation directory.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=03434c58ed10f72d14b75f528333be2999569c30">03434c</a></td>
		<td>14 lines</td>
		<td>2009-11-03  Matthias Klose  &lt;doko@ubuntu.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=293951">Bug 293951</a> * build.sh: Add MIPS and PA_RISC.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=052b2665b24b6d83b601d2c2d823c7034bdc0567">052b26</a></td>
		<td>14 lines</td>
		<td>2009-07-21  Andrew Overholt  &lt;overholt@redhat.com&gt; * publishProduct.xml: Initial commit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0630e537db846a17f6774e7ec4ad51b8b6994681">0630e5</a></td>
		<td>313 lines</td>
		<td>Start of work on fetching e4 sources.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=069141d4047c843a167786da0fc681d3d1830e48">069141</a></td>
		<td>35 lines</td>
		<td>2009-08-27  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=286824">Bug 286824</a> * build.xml: Re-name &quot;init&quot; target to &quot;unpack&quot;.  Add stamp files to allow skipping previously-done targets.  Comment out some JVM args for director call that caused issues on Debian.  All courtesy Niels Thykier.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=06cb7a018137f85b723fd3f50d69f2ccb16888bd">06cb7a</a></td>
		<td>186 lines</td>
		<td>2009-09-23  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Pass in a timestamp when running the tests.  Copy final test results to ${basedir}/testResults-${timestamp}.  Copy vncpwd file for use. * runtests.sh: Rename genReport function to genHtml.  Handle test suites with multiple XML output files.  Add ability to pass in timestamp. Document VNC password. * junitHelper.xml: Rename from genReport.xml. * eclipse-tests-vncpwd: Initial checkin.  Default VNC password of VNCpassword1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0801fcc34bdcfc97048fd81e3db9606f9efb9a69">0801fc</a></td>
		<td>14 lines</td>
		<td>2010-04-13  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=308267">Bug 308267</a> * build.xml: Apply patch to allow specification of another sysconf dir (as opposed to /etc).  /etc is the still the default.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0c0b82faec30317cb93fd568f935ee15b5d2b553">0c0b82</a></td>
		<td>53 lines</td>
		<td>2011-01-18  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=334716">Bug 334716</a> * build.xml: Provision SDK and test framework for use by tests. * runtests.sh: Use SDK and test framework provisioned by build.xml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0c63827f68ed2e2abb0e910d24f4970e4046d3e9">0c6382</a></td>
		<td>11 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0d019b24a78655f4fcc685b6b3c1101c11efabac">0d019b</a></td>
		<td>74 lines</td>
		<td>2009-10-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=291531">Bug 291531</a> - Work courtesy Niels Thykier * swt_bundle.sh: Initial checkin (Niels Thykier). * build.xml: Add target to call script to extract SWT bundle for standalone packaging (Niels Thykier).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0da0010f6616bd6fa9912675752fa7cbfe95aae4">0da001</a></td>
		<td>15 lines</td>
		<td>Add patch to allow compilation of XULRunner bits with XR 5</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0f1c6317a1a3b99e9efa991edeb6f5057a8c4fd6">0f1c63</a></td>
		<td>15 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=319474">Bug 319474</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0f517d309e02a1c3089f814919db9e92d77bd8ef">0f517d</a></td>
		<td>110 lines</td>
		<td>2009-08-24  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=286826">Bug 286826</a> * build.sh: Apply patch to tee to a log file from Niels Thykier.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=10b3bc44277a11212110db09ffa73f197e8fac17">10b3bc</a></td>
		<td>16 lines</td>
		<td>2009-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * patches/eclipse-jdt_launch-customBuild.patch: Correct offset. * patches/eclipse-addArchesAnd64bitSWT.patch: Fix end of file. * patches/eclipse-add-archs-executable.patch: Likewise. * build.xml: File strip level for above patch (5 -&gt; 6).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=11fbfa9072146d4acc8fb4365fed26626a81f5c9">11fbfa</a></td>
		<td>24 lines</td>
		<td>2009-11-03  Matthias Klose  &lt;doko@ubuntu.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=293951">Bug 293951</a> * build.properties: Add MIPS and PA_RISC. * productFiles/rcpConfig/build.properties: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=1430587c6978053dd262900469e8a17c19bf4d82">143058</a></td>
		<td>12 lines</td>
		<td>2009-09-24  Andrew Overholt  &lt;overholt@redhat.com&gt; * runtests.sh: Define &quot;plugin-path&quot; for SWT tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=14f1a208c4b865436765e03df7534b0be8293a88">14f1a2</a></td>
		<td>61 lines</td>
		<td>2010-08-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=321660">Bug 321660</a> * build.xml: Remove sdk-tests.properties in clean-sdk task and tests_* in distclean task.  Clean up formatting a bit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=157506ede95bb519eead1b54e24257d4383a246a">157506</a></td>
		<td>80 lines</td>
		<td>2010-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * patches/swt<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=290395">Bug 290395</a>-updatedialog.patch: Backport patch from 3.5 maintenance branch. * patches/swt<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=296284">Bug 296284</a>-xulrunner192.patch: Likewise. * build.xml: Add above 2 patches.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=1784a746d5a812914a9f8a0eb38250e33c52bf62">1784a7</a></td>
		<td>440 lines</td>
		<td>2009-06-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * allElements.xml: Initial checkin. * customTargets.xml: Likewise. * customAssembly.xml: Likewise. * build.properties: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=17d5f0ca0e7335cb676a96b236287c0281c1b388">17d5f0</a></td>
		<td>22 lines</td>
		<td>Compute PDE Build JAR path in its own task This way, the property pointing to the PDE Build JAR can be re-used.  Use this property when building EMF and the SDK tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=18250806eeda5ab5153269844fe0c0d2061fa91f">182508</a></td>
		<td>376 lines</td>
		<td>2009-06-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * productFiles/platform/p2.inf: Initial checkin. * productFiles/platform/platform.product: Likewise. * productFiles/platform.sdk/p2.inf: Likewise. * productFiles/platform.sdk/platform.product:Likewise. * productFiles/rcp/rcp.product: Likewise. * productFiles/rcp.sdk/rcp.product: Likewise. * productFiles/sdk/p2.inf: Likewise. * productFiles/sdk/sdk.product: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=186bc7086a5738ad0831d23b4127db6eb8d9523d">186bc7</a></td>
		<td>4 lines</td>
		<td>Commit ChangeLog addition from yesterday.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=18d8762faaf840b31f488971a5930c6e59e490e4">18d876</a></td>
		<td>9 lines</td>
		<td>Merge 3.5.2 branch.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=195e21861933c8d3fa0d28e5705768180e279f79">195e21</a></td>
		<td>12 lines</td>
		<td>2009-09-23  Andrew Overholt  &lt;overholt@redhat.com&gt; * runtests.sh: Try to clean up between runs of each suite.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=19a63b8942438258dc60078dab9d913ebddf3e4c">19a63b</a></td>
		<td>18 lines</td>
		<td>2010-08-06  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=286825">Bug 286825</a> * patches/donotstorebuildlogsinfiles.patch: Output SWT build information to stdout and not a log file (Niels Thykier).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=1a0186450b90bc5187c3f2b8983a9d69c450fdeb">1a0186</a></td>
		<td>5 lines</td>
		<td>2010-07-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Remove svn:executable property. * feature.xml: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=1b9ddfb5140079f7ad1987571331c9cd29ed30ff">1b9ddf</a></td>
		<td>338 lines</td>
		<td>Move pdebuild.xml to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=1dda291b4bfe08129198ea2b9dd1faf3254588b3">1dda29</a></td>
		<td>55 lines</td>
		<td>Move things to bootstrap/configuration and bootstrap/plugins to have a more &quot;traditional&quot; shape allowing us to minimize variables in config.ini.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=1f80f29899faccf5dc6b3ac9423227f1ee51d56d">1f80f2</a></td>
		<td>139 lines</td>
		<td>2009-09-29  Andrew Overholt  &lt;overholt@redhat.com&gt; * buildSDKSource.sh: Update for 3.5.1.  Use local Orbit and ECF dumps if present.  Check out a version of eclipsebuilder (not HEAD).  Don't generate bootstrap build.xml files as part of source fetching.  Fetch ECF sources. * build.xml: Use testsBuildLabel and p2.director.version properties from build.properties. * build.properties: Move testsBuildLabel and p2.director.version here. Update default buildId. * patches/eclipse-useLocalECFBundles.patch: Initial check-in. Use local ECF bundles instead of hitting eclipse.org where possible. * patches/eclipse-dontusefullmoonformaster.patch: Initial check-in. Don't use internal IBM mirror. 2009-09-25  Andrew Overholt  &lt;overholt@redhat.com&gt; * eclipse.desktop: Remove Encoding (see http://standards.freedesktop.org/desktop-entry-spec/1.0/apc.html).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=20eda5acb39986727bec2ea27f860a7786db9c59">20eda5</a></td>
		<td>84 lines</td>
		<td>2009-08-27  Andrew Overholt  &lt;overholt@redhat.com&gt; Bug # 287758 * build.properties: Add default-java JVM path for Debian (courtesy Benjamin Drung). * pdebuild.properties: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=225d44cb5d22c351147a4ddd9afea87acb4c2d8e">225d44</a></td>
		<td>8 lines</td>
		<td>2010-07-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * additionalArchs/rename.sh: Add svn:executable property. * pdebuild/eclipse-copy-platform.sh: Likewise. * regenerateBootstrapFiles.sh: Likewise. * runtests.sh: Likewise. * swt_bundle.sh: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=2bf1e78c52521f9ad31687ca43a0c07ebbb628ca">2bf1e7</a></td>
		<td>54 lines</td>
		<td>Updates to p2.inf for Juno (4.2) data</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=2ed7bf0871e13ab4e3ce06578204678c517fe1e3">2ed7bf</a></td>
		<td>41 lines</td>
		<td>Update ant tests patches to look for &quot;1.8.2&quot; instead of &quot;1.7.1&quot; This fixes <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=350619">Bug 350619</a>: ant.tests.ui compilation error.  The patches (one for .ui and one for .core) fix the ant tests to look for version strings beginning with the same version number and not exact matches since the Linux distribution version strings don't match the Apache binary strings exactly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=2edc608c0bd9817f0964c888ae34618931e134dc">2edc60</a></td>
		<td>11 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=342287">Bug 342287</a> [eclipse-build] Drop startup.jar symlink</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=2f1074ebdd4c9c0796892106bab05d5bd6cffa84">2f1074</a></td>
		<td>4 lines</td>
		<td>Fix broken dependency chain.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=2fc4acedbcf0b8e5183eb5a9cc55853fd7a7c2c4">2fc4ac</a></td>
		<td>161 lines</td>
		<td>Create properties for bootstrap bundles pdebuild.xml:  To make it easier to have re-usable filesets of the bootstrap bundles, make properties and then create filelists from the properties so nothing else needs to be changed.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=30ae175e2ae309600f17af4089ff4d1a0188bed6">30ae17</a></td>
		<td>2 lines</td>
		<td>Update build ID to 4.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=333d268191290a37eb272b31ca6bc8a553354442">333d26</a></td>
		<td>50 lines</td>
		<td>2009-05-25  Andrew Overholt  &lt;overholt@redhat.com&gt; * buildSource.sh: Simple testing script to follow upstream procedures. *Very* preliminary.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=35ff16afb6559d7f3fe8c9c018f47b69b83be0c6">35ff16</a></td>
		<td>2 lines</td>
		<td>Update build ID to 4.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=37f193229bc07cadd4b63cc2a2dc451861a3d78b">37f193</a></td>
		<td>313 lines</td>
		<td>Start of work on fetching e4 sources.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=39716d6f58e2c781b57d014264ed81ff4910cdf7">39716d</a></td>
		<td>6 lines</td>
		<td>2010-03-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * buildEclipseBuildSource.sh: Remove .settings and .project when creating eclipse-build tarball.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=39e5c0de541a642990e55a9d9c22b403547f2cb2">39e5c0</a></td>
		<td>206 lines</td>
		<td>2011-01-11  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=319476">Bug 319476</a> * patches/bz319476-compile-jar-in-jar-loader.patch: Backport patch to build jar-in-jar-loader in JDT UI (bz324794). * build.xml: Add patch to build jar-in-jar-loader.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=3a000ab235d46c6d6b124b14b59d1d04e3679903">3a000a</a></td>
		<td>25 lines</td>
		<td>Remove pre-generated build.xml files after bootstrap pdebuild.xml:  So that they will be cleanly re-generated by PDE Build during the build process, delete all pre-generated build.xml files following bootstrapping.  A few must remain around due to them either being custom build.xml files or being used for native fragment compilation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=3a2cad6e2a83f1c643602361e41f2d9a8f471a04">3a2cad</a></td>
		<td>146 lines</td>
		<td>Move bootstrap folder to eclipse-build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=3be4f44fa30352a69a01bc74725cfffc12ed34a4">3be4f4</a></td>
		<td>103 lines</td>
		<td>2009-06-23  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Remove unused targets.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=3e48643139086d7c1582aa979e27f3381143d2fc">3e4864</a></td>
		<td>6 lines</td>
		<td>2009-07-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * productFiles/rcpConfig/buildConfiguration.xml: Remove extraneous debugging statement.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=3ec0a03ec0da1393d1f69055269c9aa9376c8c8c">3ec0a0</a></td>
		<td>8 lines</td>
		<td>2009-11-11  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=294877">Bug 294877</a> * productFiles/sdk/sdk.product: Set HotSpot JIT excludes to avoid crashes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=3f526e5b655e271c9470d1c64f6aee535e5fd626">3f526e</a></td>
		<td>8276 lines</td>
		<td>Remove 3.5 manifests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=3fd18b92263e290f063a71111c2a4f454d18a75b">3fd18b</a></td>
		<td>4465 lines</td>
		<td>Add 3.6 manifests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=401d4c0ebc11c9c16a80ce05af180604fb8e9d5b">401d4c</a></td>
		<td>8 lines</td>
		<td>2009-09-30  Andrew Overholt  &lt;overholt@redhat.com&gt; * buildSDKSource.sh: Don't use &quot;v&quot; prefix for tag of tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=40626d78a54a4a727e494276792b6398a9d06151">40626d</a></td>
		<td>782 lines</td>
		<td>Move ChangeLog to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=453722f807208f5c9b215f6cd323dd04da27e5ce">453722</a></td>
		<td>38 lines</td>
		<td>2009-08-27  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=287753">Bug 287753</a> * build.xml: Add patch to not modify JAVA_HOME and to optimize compilation of liblocalfile.so (from Benjamin Drung).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=46b4a2fa3c0f546e1933ec71e92903db21be5c5b">46b4a2</a></td>
		<td>52 lines</td>
		<td>2009-07-22  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=280686">Bug 280686</a> * build.sh: Wrap ant call with arch-finding logic.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=47fac12bd92c83b14086d2e23d2b1210b8ec4da2">47fac1</a></td>
		<td>6 lines</td>
		<td>2011-01-19  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Aggregate test results with proper JUNIT.XSL.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=487af3183c57c18b5ca01e68ac0c2b448b3f247a">487af3</a></td>
		<td>54 lines</td>
		<td>Updates to p2.inf for Juno (4.2) data</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=4d14b1e2fa3ddd2c20c8a3a64fa75db0af065ff7">4d14b1</a></td>
		<td>114 lines</td>
		<td>2009-08-14  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=286571">Bug 286571</a> * buildEclipseBuildSource.sh: Apply fixes from nthykier for bash-isms. * buildSDKSource.sh: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=5100a254827c3caed348f8b7fb70f6dcfb36771b">5100a2</a></td>
		<td>5 lines</td>
		<td>2009-09-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * runtests.sh: Add FIXME to remember to deal with plugins that have multiple suites.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=5116884f1a309bac602709f7d26e096091a6e2a0">511688</a></td>
		<td>9 lines</td>
		<td>2009-06-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * buildSource.sh: Generate tarballs for builder and feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=518a9415fcfe53a1370d97aca58971746319b413">518a94</a></td>
		<td>2 lines</td>
		<td>Remove extraneous -x being passed to bash interpreter in runtests.sh</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=52dd2207a6c17cf38b5c641d26ba7bf242c391d9">52dd22</a></td>
		<td>42 lines</td>
		<td>Move build.sh to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=54834cf3fc8d2dd657166a7c406d286a82b49e7b">54834c</a></td>
		<td>5 lines</td>
		<td>Add encoding.  Fix comment to be more generic (not just &quot;develop applications&quot;).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=5494a97587dc5153e18fdc57dbb5487f9e7a1069">5494a9</a></td>
		<td>83 lines</td>
		<td>2010-04-13  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=308247">Bug 308247</a> * pdebuild.properties: Apply patch to allow building against Sun JVM. * build.properties: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=54ddf0f29a59c9d288d14852644fd12f79398608">54ddf0</a></td>
		<td>38 lines</td>
		<td>2010-04-23  Andrew Overholt  &lt;overholt@redhat.com&gt; * patches/tests-org.eclipse.ant.tests.ui.patch: Better change to only check start of version string.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=54e1a26095bb53fb0b0e9ac3c545a394c5705ebc">54e1a2</a></td>
		<td>638 lines</td>
		<td>Move build.xml to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=54e54975d0deb35ceb0e186eb749be9968b023ee">54e549</a></td>
		<td>33 lines</td>
		<td>2009-05-15  Andrew Overholt  &lt;overholt@redhat.com&gt; * README.mediawiki: Fix some typos. * ABOUT.mediawiki: Some cleanups.  Make lines &lt; 80 characters. * build.sh: Fix typo.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=555ae0ae210041cee2f9659262d6d71bc5ca9f83">555ae0</a></td>
		<td>99 lines</td>
		<td>2009-10-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * runtests.sh: Move option parsing out of function. * build.xml: Generate top-level test report HTML file.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=56106eafe77c22099f1d268cc93b354930b0e7a0">56106e</a></td>
		<td>66 lines</td>
		<td>2010-04-23  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=309993">Bug 309993</a> * build.xml: Apply patch to make ant ui tests work with different ant build dates.  Fix patch application root for ant core tests patch. * patches/tests-org.eclipse.ant.tests.ui.patch: New file. * patches/tests-org.eclipse.ant.tests.core.patch: Fix patch root.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=56f7f43fee348fc1ad0cd8e4d13e63b7682dd3dc">56f7f4</a></td>
		<td>39 lines</td>
		<td>Re-arrange provisionSDKinDropins task</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=58897c2141f89e35976c109df78b4d9bef6d6319">58897c</a></td>
		<td>23 lines</td>
		<td>2010-03-10  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=305002">Bug 305002</a> * patches/addEcfQualifiers.patch: New file.  Make ECF plugins have qualifiers matching upstream. * build.xml: Apply above patch.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=5d4ca667bc3a2013a40a8e43b4ec9ef955c35d55">5d4ca6</a></td>
		<td>538 lines</td>
		<td>Merge 3.5.2 branch.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=5f7e586878c3a22e4865d845a8ee64312a8d0a33">5f7e58</a></td>
		<td>451 lines</td>
		<td>2009-06-23  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Fail if source tarball not present.  Copy build config and feature instead of untarring (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=281135">Bug 281135</a>). * build.properties: Don't set buildDirectory here.  Do it in build.xml instead.  Define featureToBuild here. * buildSource.sh: Run both SDK source fetching and eclipse-build fetching. * buildSDKSource.sh: Re-name buildSource.sh to indicate just fetching of SDK sources.  Default to $(pwd) instead of /tmp/eclipseSDKBuild.  Don't fetch tests by default. * buildEclipseBuildSource.sh: New file.  Create tarball of eclipse-build source. * README.mediawiki: Update a bit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=61b84843070ae7a4a0beaed131027ff1f2424b14">61b848</a></td>
		<td>44 lines</td>
		<td>2009-11-02  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=292475">Bug 292475</a> (Benjamin Drung) * build.xml: Support build with extracted source (not just with tarball).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=6253933588a777925dec636b5c03474f0aab5adf">625393</a></td>
		<td>144 lines</td>
		<td>2009-09-15  Andrew Overholt  &lt;overholt@redhat.com&gt; * patches/tests-noapttests.patch: New file.  Patch for eclipse <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=244178">Bug 244178</a>. * build.xml: Fix &quot;scriptsPreset&quot; typo.  Build test framework and SDK tests. * buildSDKSource.sh: Add fetching of test scripts not included elsewhere.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=627b5f8702211471ab373407d82065b0889dfa41">627b5f</a></td>
		<td>1189 lines</td>
		<td>Make build label, ID and tag be 3.7.0; for tests, too</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=6351584af4ecc7d4188668c1688bea377e24df5f">635158</a></td>
		<td>25 lines</td>
		<td>Remove pre-generated build.xml files after bootstrap pdebuild.xml:  So that they will be cleanly re-generated by PDE Build during the build process, delete all pre-generated build.xml files following bootstrapping.  A few must remain around due to them either being custom build.xml files or being used for native fragment compilation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=63798371a9399627a78ed8b3cafeeb140648608c">637983</a></td>
		<td>378 lines</td>
		<td>Move patches directory.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=64fc25e5b765185176e87dbbec73b36dc7805636">64fc25</a></td>
		<td>38 lines</td>
		<td>2009-09-21  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=289938">Bug 289938</a> * build.xml: Add install target to install provisioned SDK (courtesy Benjamin Drung). * eclipse.desktop: Initial checking (courtesy Benjamin Drung).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=6540c2f81384b6f98f64c79e33a91df6e9412925">6540c2</a></td>
		<td>194 lines</td>
		<td>2010-07-28  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Property-ify test framework. * build.xml: Use variables for provision and installation directories. Build Equinox Initializer application in build target and not in provision.sdk target.  Pass tests build directory and provisioned SDK directory to runtests.sh. * runtests.sh: Take passed-in tests build directory and provisioned SDK directory.  Pass testframework variable to runtests.sh. * junitHelper.xml: Use property of testframework.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=662dd71f898964f4acfcc26aadb31cddce41e140">662dd7</a></td>
		<td>42 lines</td>
		<td>2009-09-23  Andrew Overholt  &lt;overholt@redhat.com&gt; * runtests.sh: Add some information about failing tests.  Run with os/ws/arch specified (at least os is needed for SWT tests).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=66c63974f83ca4c1468d450ceb878aa45db4d61c">66c639</a></td>
		<td>85 lines</td>
		<td>2008-11-19  Andrew Overholt  &lt;overholt@redhat.com&gt; * generatebuild.xml: Fix path to include bootstrap/plugins. * pdebuild.xml: Move things to SDK directory. * fetch-sources.sh: Likewise. * bootstrap: New directory. * bootstrap/configuration/config.ini: Fix up osgi.bundles and set osgi.install.area. * eclipse.ini: Remove for now (we don't need it).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=6a01e77f903b9e4b5ffb93ab31f8fd1fc6a7828d">6a01e7</a></td>
		<td>16 lines</td>
		<td>2009-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=292706">Bug 292706</a> * buildSDKSource.sh: Apply patch from Benjamin Drung to remove binaries and CVS files from source tarball.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=6b5232151309219bc9d43543b0109706e2520350">6b5232</a></td>
		<td>1457 lines</td>
		<td>Merge 3.5.2 branch.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=6c530c138ee0579cc346785a74d58db2becde012">6c530c</a></td>
		<td>154 lines</td>
		<td>Move fetch.xml to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=6e8da2d8573d789b956352740ed474b003cd6c2d">6e8da2</a></td>
		<td>151 lines</td>
		<td>2009-05-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * patches/eclipse-addFetchMasterAndTestsTargets.patch: Initial commit. Adds targets to org.eclipse.releng.eclipsebuilder/buildAll.xml * buildSource.sh: Cleanups.  Fetch both the master feature and the SDK tests feature.  Build .tar.bz2 files for both fetches.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=6ebd3164481cdecd633970964163e19894947420">6ebd31</a></td>
		<td>16 lines</td>
		<td>2009-07-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Add some debugging of content.{xml,jar}.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=6f4b39537f5da0a7589ead2a96dfb0ce94898c0a">6f4b39</a></td>
		<td>105 lines</td>
		<td>2008-11-19  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.properties: New file. * bootstrap/configuration/config.ini: Add com.ibm.icu, org.apache.ant, org.eclipse.update.configurator and org.junit to osgi.bundles. Could perhaps be trimmed. * generatebuild.xml: Refactor a bit. Generate a feature before generating plugin build.xml files. * pdebuild.xml: Organize and clean up depsDirs. Add Orbit deps like JUnit and ICU4J. Build in a 'build' directory and clean it beforehand.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=71a8c8240b830a894125b4ac9b8437a5f9a2da34">71a8c8</a></td>
		<td>2 lines</td>
		<td>Re-add dependency between p2prep and build targets.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=71ec22a916b5056b45e67625b9c3f8afd0d6c2f5">71ec22</a></td>
		<td>9 lines</td>
		<td>2009-06-23  Andrew Overholt  &lt;overholt@redhat.com&gt; * README.mediawiki: Assume tarball usage.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7582ad227eaf702a549a21531803119d00c15445">7582ad</a></td>
		<td>8 lines</td>
		<td>2009-06-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Explicitly enable flattenDependencies and parallelCompilation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=75b607f822a22648f492ad229baa121cb264b928">75b607</a></td>
		<td>233 lines</td>
		<td>2009-06-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * patches/cleanupMaster.patch: Remove. * build.xml: Set eclipse.pdebuild.scripts property.  Use &quot;eclipse-build-feature&quot; feature and builder.  Use a fake home directory for the builds.  Change buildID to buildId everywhere.  Remove unnecessary cleanupMaster patch.  Pass property file to antRunner calls.  Build with antRunner and not plain ant.  Temporarily make assemble not depend upon compilelibs (for testing). * build.properties: Change buildID to buildId.  Remove parallel compilation and flattenDependencies for now.  Don't generate API descriptions. Fully-expand bootclasspath (need to be more generic here).  Add OSGi/Minimum-1.2 BREE.  Full expand BREEs for use with antRunner (somehow it doesn't expand in-file properties).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7824b31e5810a3774d2613fa9e30ead330a4ae31">7824b3</a></td>
		<td>72 lines</td>
		<td>Move generatebuild.xml to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7abc40bd18e1ad467539ff37675e776504e9ffbf">7abc40</a></td>
		<td>27 lines</td>
		<td>2009-07-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * productFiles/rcpConfig/buildConfiguration.xml: Don't try to use undefined buildDirectory property for launcher.paths property.  Add some debugging statements.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7af04fa6af58a878f961743dfcae413c848e3542">7af04f</a></td>
		<td>25 lines</td>
		<td>2010-07-27  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=320328">Bug 320328</a> * pdebuild.xml: Use ${label} instead of hard-coding &quot;3.5.0&quot;. * build.xml: Use PDE Build of built SDK to build SDK tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7b22905b6293b953d48b158d0c17fe2bcd96fc40">7b2290</a></td>
		<td>28 lines</td>
		<td>2010-04-22  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=309992">Bug 309992</a> * build.xml: Apply patch to make ant core tests work with different ant build dates (Chris Aniszczyk).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7c31c5acc6bdcb446b8cea70696c5751b5308776">7c31c5</a></td>
		<td>2 lines</td>
		<td>Add missing &quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7c982323e661fba20395d265469828da0cfc1fa1">7c9823</a></td>
		<td>2 lines</td>
		<td>Add SDK tests scripts (and scripts tarball) to gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7d2e17dcd10fe4c8dbc253406dc9926f0927d0d5">7d2e17</a></td>
		<td>17 lines</td>
		<td>2009-10-30  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=292610">Bug 292610</a> (Benjamin Drung) * build.xml: Apply patches from Benjamin Drung to maintain permissions upon installation.  Also give executable bit to package-build shell scripts.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7f4aa716a15ad377cb0fea19a90e49a2e94991b0">7f4aa7</a></td>
		<td>137 lines</td>
		<td>2009-07-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * pdebuild.properties: Hard-code build ID.  Don't use ecj for bootstrapping since we don't necessarily have it around. * build.xml: Default to bootstrapping. Use bootstrapped launcher jar by default. * pdebuild.xml: Add bundles required by director app to list of bundles to bootstrap. Zip and symlink base framework plugins.  Add target for generating bootstrapping build scripts. * bootstrap/configuration/config.ini: Add bundles required by director app to osgi.bundles. Remove unnecessary osgi.framework properties. Add eof property. * eclipse-build-generatedScripts.tar.bz2: Initial checkin of generated build scripts for bootstrapping.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=80619775eb1eceb8787679807174a85b8eefdfe2">806197</a></td>
		<td>4 lines</td>
		<td>Rename 'javaHomeDoesNotExists' for clarity Call the variable 'javaHomeExists' instead.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=8088d9ad59c4b26072ef6b323944a3772c002a14">8088d9</a></td>
		<td>19 lines</td>
		<td>2009-05-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * buildSource.sh: Name tarballs and contained directories better.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=810374ad21015645e9c757b77aed70cdd8ed2e09">810374</a></td>
		<td>114 lines</td>
		<td>Remove unnecessary files.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=8146b89e40622e755c71d67e71c140a8ffcd9b2f">8146b8</a></td>
		<td>39 lines</td>
		<td>2010-07-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=319473">Bug 319473</a> * build.xml: Apply patch from Benjamin Drung to extract SWT .so files. * extract_patterns.txt: New file.  Filename patterns to extract (&quot;initialize&quot;) from bundle JARs.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=81694631f1beed4c56908442ca6456cebd7ca699">816946</a></td>
		<td>53 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=363027">Bug 363027</a>: Please add license feature to eclipse-build Apply patch from Andrew Robinson to add the common license feature to the Eclipse SDK builds used by Linux Distributions.  Also make this feature usable by features built using pdebuild.sh.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=853255b41b3c8993d16b6e3a47e7b78842879b28">853255</a></td>
		<td>29 lines</td>
		<td>2010-07-27  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=295098">Bug 295098</a> * patches/org.eclipse.pde.ui.tests-LocalTargetDefinitionTests.patch: New file.  Patch out checking for source bundles not likely to be present in distros. * build.xml: Apply above patch to tests. * symlinks-stamp: Add to svn:ignore. * task-bin: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=855209e15aab31cc06f382b73fd08c1732906133">855209</a></td>
		<td>24 lines</td>
		<td>Merge 3.5.2 branch.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=85961197f743b2c3d9e65cd1faf25efda93e2dd6">859611</a></td>
		<td>40 lines</td>
		<td>2010-07-29  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=319479">Bug 319479</a> * patches/eclipse-swt-compile-xpt.patch: New file.  Patch from Benjamin Drung to build .xpt file for SWT. * build.xml: Apply above patch.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=8640178a2779bcbb9bc04e6fb78a8334c2c350db">864017</a></td>
		<td>434 lines</td>
		<td>Generate EMF source tarball while generating e4 source tarball.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=8674690c27fdaeeb07071a53669b7810506573c2">867469</a></td>
		<td>286 lines</td>
		<td>Move directory.txt to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=872404ee06f34c2867da7345376be96a0330eab0">872404</a></td>
		<td>38 lines</td>
		<td>2009-12-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * patches/swt<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=291128">Bug 291128</a>.patch: Add back-ported patch from <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=291128">Bug 291128</a>. * build.xml: Add above patch.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=873302e30e593170bd39dcd6b22cc614a3354ff4">873302</a></td>
		<td>9 lines</td>
		<td>2009-09-30  Andrew Overholt  &lt;overholt@redhat.com&gt; * productFiles/sdk/sdk.product: Update for 3.5.1. * productFiles/rcp.sdk/rcp.product: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=88fb03932aedc2882dc2cc0ef6612951ba9ba903">88fb03</a></td>
		<td>111 lines</td>
		<td>2010-08-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=321612">Bug 321612</a> * build.xml: Add ability to pass through -v and -d flags to runtests.sh. Use -DdebugTests=true or -DverboseTests=true. * runtests.sh: Add verbose option (-v).  Pass -data option to test runs.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=8a85bcac84ff503c547d474e1bf5f8563dc17b39">8a85bc</a></td>
		<td>140 lines</td>
		<td>Format build.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=8baefa56c76709efea043fd5fbf41cf58424f7ce">8baefa</a></td>
		<td>264 lines</td>
		<td>Move buildSource.sh to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=8ca5b1430040045314d18311ddd8eaafe1bf1daa">8ca5b1</a></td>
		<td>4 lines</td>
		<td>3.5 -&gt; 3.5.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=8e0b2f686b6f601e8c586566d7b74d362075e36d">8e0b2f</a></td>
		<td>8 lines</td>
		<td>2009-07-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * productFiles/rcpConfig/buildConfiguration.xml: Pass buildDirectory to buildConfiguration.xml call.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=8e5e751bb21adbd4d2756d720a6ffdb5018f23ea">8e5e75</a></td>
		<td>56 lines</td>
		<td>Build EMF features that e4 needs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=914dc6de2bfc5ee5819a229cf4877f7043040a92">914dc6</a></td>
		<td>5 lines</td>
		<td>Update platform.product to have 2011 Eclipse SUA</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=927dbddd534b24d86ddf3e0d3462cc92b58bdf35">927dbd</a></td>
		<td>142 lines</td>
		<td>2009-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=293952">Bug 293952</a> (Matthias Klose) * build.properties.in: Re-name from build.properties and copy to build.properties at build time.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=93bacd88d164adac6cf91057ca05703bc471f72a">93bacd</a></td>
		<td>240 lines</td>
		<td>2009-06-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Build directly from build config. Do p2 director installation. * generatebuild.xml: Explicitly enable flattenDependencies and parallelCompilation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=940c46a54aa0f94358146fe17c2d727c5d3ed3c2">940c46</a></td>
		<td>748 lines</td>
		<td>Merge e3.6 branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=94da9542fcc1ae97be9532b0cd98a4090c7da169">94da95</a></td>
		<td>27 lines</td>
		<td>2010-07-28  Andrew Overholt  &lt;overholt@redhat.com&gt; * runtests.sh: Properly canonicalize test build and installation directories.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9619f24068f17e9a00552b951d13a73d4482a7b0">9619f2</a></td>
		<td>7 lines</td>
		<td>2010-08-11  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Make symlink to eclipse.ini relative. * Xvnc.cfg: Add to svn:ignore.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=97c4dd609d4b63e60ef8c149ebec3ade0a7cd9fa">97c4dd</a></td>
		<td>106 lines</td>
		<td>Use ant's &lt;present&gt; task instead of commandline diff</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=986beaab83ff38db66344549d80d977d161d5508">986bea</a></td>
		<td>51 lines</td>
		<td>Merge e3.6 branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=98a39a7544a30d917735cf7598fd25a85315ee04">98a39a</a></td>
		<td>7 lines</td>
		<td>Remove extraneous &quot;mkdir &quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9973edf0a5505856465b09ffb23665edfc510daf">9973ed</a></td>
		<td>43 lines</td>
		<td>Fix <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=354267">Bug 354267</a>:  Bootstrapping fails with Java 7 pdebuild.xml:  During bootstrapping, change bundleJavacTarget=jsr14 to be 1.5 for those bundles that specify it as a target bytecode level. This will only affect the bootstrapped bytecode.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9b1ad84013a05f26ecf9dfbab4f8d193a7abd38e">9b1ad8</a></td>
		<td>6 lines</td>
		<td>2009-06-15  Andrew Overholt  &lt;overholt@redhat.com&gt; * buildSource.sh: Replace example build ID with probably 3.5 one.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9b7797336ce0fa0f245ebcbfec244cce2a1f2334">9b7797</a></td>
		<td>62 lines</td>
		<td>2009-06-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Initial checkin. * feature.xml: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9b8c9b0bb1d3d832733e42e115f6cf3212a83415">9b8c9b</a></td>
		<td>13 lines</td>
		<td>Add efj (fixes <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=342292">Bug 342292</a>)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9b95063b2a05586c224a4f967734259031ae18d6">9b9506</a></td>
		<td>7 lines</td>
		<td>2009-09-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * productFiles/sdk/sdk.product: Add /usr/share/eclipse/dropins to list of dropins locations.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9c39d3fa1ff2e70a907fd595c68885e135cc5225">9c39d3</a></td>
		<td>8 lines</td>
		<td>2009-06-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Include master-jetty feature to avoid building loops.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9ccd221f0b2a9b596d18eeb153f19ed268022d13">9ccd22</a></td>
		<td>8 lines</td>
		<td>2009-11-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Re-name variable for clarity.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9d79e04f7c5ccf78f5329aa3fe976863ff9d86fa">9d79e0</a></td>
		<td>7 lines</td>
		<td>2010-08-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Apply ant core and UI test patch to not be so strict with ant -version output.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9df68bb95b6c4205eb2f608dfff9d2e5b01c778e">9df68b</a></td>
		<td>75 lines</td>
		<td>2010-07-28  Andrew Overholt  &lt;overholt@redhat.com&gt; * patches/tests-nop2discoverytests.patch: New file.  Don't build the p2 discovery tests since that feature isn't part of the SDK. * patches/org.eclipse.pde.ui.tests-LocalTargetDefinitionTests.patch: Removed. * patches/tests-org.eclipse.pde.ui.tests-LocalTargetDefinitionTests.patch: Renamed to clarify that it's a patch for the tests. * build.xml: Correct typo with LocationTargetDefinitionTests patch name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9f20054708c0bc85e9055dbef9290b34c4856250">9f2005</a></td>
		<td>164 lines</td>
		<td>Create properties for bootstrap bundles pdebuild.xml:  To make it easier to have re-usable filesets of the bootstrap bundles, make properties and then create filelists from the properties so nothing else needs to be changed.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=a0c464b9580d235abbe77a200a0dc5f90c89e1ec">a0c464</a></td>
		<td>6 lines</td>
		<td>2010-07-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties.in: Remove svn:executable property. * customAssembly.xml: Likewise. * customTargets.xml: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=a27f9029bb033f02d1d5959315f3f9651835f590">a27f90</a></td>
		<td>88 lines</td>
		<td>Move retrieve_map.sh to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=a39d66f9fcc9d32e199dbe865faca842777fb710">a39d66</a></td>
		<td>188 lines</td>
		<td>2010-03-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Remove provision.tests task; do test provisioning in runtests.sh. * runtests.sh: Re-factor.  Clean test installation between runs of each test suite. (Roland Grunberg)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=a5bde14499fb6404239fa6dff8fa3b2429c2111d">a5bde1</a></td>
		<td>2 lines</td>
		<td>Update org.eclipse.test version number</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=a7c78dcc4cd04111585f57ce55fc2c866d87d3b1">a7c78d</a></td>
		<td>6 lines</td>
		<td>2009-09-23  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Make building of tests depend upon building of SDK.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=aa3e48049e2bf92c5bba354a6065a4d319050019">aa3e48</a></td>
		<td>43 lines</td>
		<td>Fix <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=354267">Bug 354267</a>:  Bootstrapping fails with Java 7 pdebuild.xml:  During bootstrapping, change bundleJavacTarget=jsr14 to be 1.5 for those bundles that specify it as a target bytecode level. This will only affect the bootstrapped bytecode.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=aaf1da8810105a61c1618f4b3114e0a72240ce21">aaf1da</a></td>
		<td>2 lines</td>
		<td>Typo in p2prep's dependency</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ab347b914fe2bd414f908b5f3fe9b33aafc3a276">ab347b</a></td>
		<td>36 lines</td>
		<td>Move TODO.mediawiki to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ab3a7c1edfd737a2485958c9df05ac4772ba5686">ab3a7c</a></td>
		<td>12 lines</td>
		<td>2008-11-19  Andrew Overholt  &lt;overholt@redhat.com&gt; * bootstrap/configuration/config.ini: Remove runtime.compatibility.registry.  Remove ignoreApp. * generatebuild.xml: Remove osgi from bundles list.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ace97d0238a53b72ca106fba9e18273beb7d457f">ace97d</a></td>
		<td>400 lines</td>
		<td>2009-09-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * genReport.xml: Initial checkin.  Generate HTML from the JUnit XML output. * runtests.sh: Initial checkin.  Run the SDK tests after a build (will be in build.xml in the near future). * build.properties: Add testsBuildID. * build.xml: Add multilib property to allow use of /usr/lib64.  Add getInstallationDir target to test for multilib and 64-bit architecture. Add provisioning of tests into test installation directory.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=afbe5f1065f08e966963e214ad6aacaa54ab7694">afbe5f</a></td>
		<td>3 lines</td>
		<td>* build.xml: Make default target build and provision.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=b04cbb75f4f3f5c39bb0cab913feddbd1baba2db">b04cbb</a></td>
		<td>17 lines</td>
		<td>Do not build Equinox region tests since this isn't in the SDK Add patches/tests-noequinoxregiontests.patch and apply it in applyTestPatches ant task in main build.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=b0daf773f56173f815c685ca56a5d6d44a90fe0c">b0daf7</a></td>
		<td>76 lines</td>
		<td>Use ${label} instead of &quot;3.5.2&quot; for SWT JAR symlinks.  Pass in profile to use when installing.  Further clean installation of build path references.  Apply patch from Benjamin Drung to clean up some of these references (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=322283">Bug 322283</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=b31d4fe5a5f0e757fabcab99f9611b4e11dc7669">b31d4f</a></td>
		<td>23 lines</td>
		<td>Add stuff to svn:ignore.  Actually check in patches.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=b516bfe395778ba5c0b835de76593a6d089718f7">b516bf</a></td>
		<td>26 lines</td>
		<td>Move ABOUT.mediawiki to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=b880d718e451d254f344d2290dcd58ff2b0f3f23">b880d7</a></td>
		<td>2 lines</td>
		<td>Set extraVMargs to empty string when not debugging For some reason, the &quot;performance&quot; variable is being set to true, forcing extraVMargs to contain classpath references that are not correct.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=b8d6f2ab4528fcda57a42aa8cb16843fb69c6cd7">b8d6f2</a></td>
		<td>13 lines</td>
		<td>Add stamp for provisioning SDK into dropins</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=bce5247ae7dcbb9d7741bccc43f75244815dd369">bce524</a></td>
		<td>53 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=363027">Bug 363027</a>: Please add license feature to eclipse-build Apply patch from Andrew Robinson to add the common license feature to the Eclipse SDK builds used by Linux Distributions.  Also make this feature usable by features built using pdebuild.sh.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=bd44df49534cb2953f88e9ced398acf86c807290">bd44df</a></td>
		<td>233 lines</td>
		<td>2009-10-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * patches/gtk2.18zorder.patch: Initial check-in of 3.5.1 back-port for (https://bugs.eclipse.org/287307). * build.xml: Apply GTK 2.18 z-order patch.  Organize patch section a bit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=be1e762fba03a74126b67f798a77ab63bddd6477">be1e76</a></td>
		<td>7 lines</td>
		<td>Make eclipse.ini symlink absolute for our Debian friends</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=beff29b1119606d4ea64df72d7be9b7bfdefb454">beff29</a></td>
		<td>2 lines</td>
		<td>Fix ordering of srcfile and targetfile for buildId stamp.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c024804297e45aac758ec06748efbb6a716740c4">c02480</a></td>
		<td>5 lines</td>
		<td>Update platform.product to have 2011 Eclipse SUA</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c07c9e0ee393ae221ef3d8e0f77757926dcdd93a">c07c9e</a></td>
		<td>10 lines</td>
		<td>2009-07-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Remove erroneous depends= between run.director and p2prep.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c145061ee7b76c8ed3b50d32c3629e81e46f693e">c14506</a></td>
		<td>10 lines</td>
		<td>Update source tarball generation for 3.7 final tags.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c1863a2d5406790b6cf41e178c9e5f8d59feba7b">c1863a</a></td>
		<td>434 lines</td>
		<td>Generate EMF source tarball while generating e4 source tarball.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c3b1cad0a5e2cb58eb4b1c3974fca64dabbf6aa9">c3b1ca</a></td>
		<td>71 lines</td>
		<td>2009-08-27  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=287752">Bug 287752</a> * build.xml: Add patch to not store build logs in separate files (from Benjamin Drung).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c42ad6166fcfcf766df63d7b8dc36cae8228d21d">c42ad6</a></td>
		<td>501 lines</td>
		<td>2009-11-03  Matthias Klose  &lt;doko@ubuntu.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=293948">Bug 293948</a> * patches/eclipse-add-archs-filesystem.patch: Add MIPs, PA_RISC, alpha, arm, ia64.  Alphabetize platforms. * patches/eclipse-add-archs-executable.patch: Likewise. * patches/eclipse-add-archs-swt.patch: Likewise. * patches/eclipse-add-ppc64-sparc64-s390-s390x.patch: Add MIPS and arm. * build.xml: Set strip=0 for eclipse-add-pp64-sparc64-s390-s390x.patch. Add application of patches/eclipse-addArchesAnd64bitSWT.patch. * patches/eclipse-64bitSWT.patch: New file.  Add arm, PA_RISC, sparcv9, MIPS to SWT build.sh.  Make SWT 64-bit on alpha, too.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c4f7ca15f7a82ff1e316828ac2d08884316e3d3f">c4f7ca</a></td>
		<td>18 lines</td>
		<td>2009-08-26  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=287719">Bug 287719</a> * build.xml: Add distclean target (from Benjamin Drung).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c5838267623ca6d5de4475227f3c70b977c6147e">c58382</a></td>
		<td>4 lines</td>
		<td>In copy-platform, don't glob symlinking dependencies from dropins Remove globbing (*&quot;name&quot;*) in copy-platform (used by pdebuild.sh).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c967cdc42465a4061559efc8faf525ecb6caeed2">c967cd</a></td>
		<td>197 lines</td>
		<td>2010-03-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * buildSDKSource.sh: Revert to fetching from CVS ourselves to get featureVersions.properties and pluginVersions.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c96ca72c9bc087b61935481d24a3d654bc6d61b1">c96ca7</a></td>
		<td>43 lines</td>
		<td>Fix <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=354267">Bug 354267</a>:  Bootstrapping fails with Java 7 pdebuild.xml:  During bootstrapping, change bundleJavacTarget=jsr14 to be 1.5 for those bundles that specify it as a target bytecode level. This will only affect the bootstrapped bytecode.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c99788e19d1e18509b17b26f298f3baae94abb7a">c99788</a></td>
		<td>15 lines</td>
		<td>2009-06-22  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=280681">Bug 280681</a> * build.xml: Explicitly set eclipse.p2.data.area as a JVM argument when running director.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=c9d20de965b883ab7bec4a55ea2e22949257be27">c9d20d</a></td>
		<td>7 lines</td>
		<td>2009-07-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Don't pass buildConfig to buildConfiguration.xml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ca2cfca232c3ca1411fac05d0180297112294f89">ca2cfc</a></td>
		<td>40 lines</td>
		<td>Move README.mediawiki to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=caf9a20d223d35bdce0c3f57e6f02d0492ba90c8">caf9a2</a></td>
		<td>11 lines</td>
		<td>2010-03-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Remove unnecessary copying of test result XML files.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=cc6cdf8c51f5bad5cc2a1cf403f016dbf8808da8">cc6cdf</a></td>
		<td>21 lines</td>
		<td>2009-10-08  Andrew Overholt  &lt;overholt@redhat.com&gt; Bud #291681 - Patch courtesy Benjamin Drung * build.xml: Add patch to build Equinox initializer application.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=cc946a0e71c1bb282bcdda1174fc8b3947f76b2e">cc946a</a></td>
		<td>13 lines</td>
		<td>2009-07-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * productFiles/rcpConfig/buildConfiguration.xml: Don't source buildConfig's build.properties.  Remove some debugging statements.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=cca40be0bc4c0d1669adb4c99869d9370ebe36b2">cca40b</a></td>
		<td>53 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=363027">Bug 363027</a>: Please add license feature to eclipse-build Apply patch from Andrew Robinson to add the common license feature to the Eclipse SDK builds used by Linux Distributions.  Also make this feature usable by features built using pdebuild.sh.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ccceada302ab3938d4c6ef4feb830c3ab2f4c112">cccead</a></td>
		<td>6 lines</td>
		<td>Update download links for SDK source drops</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ccd746a1dcc2cd8f63bf9a4b12bd32858f5513ed">ccd746</a></td>
		<td>7 lines</td>
		<td>Add config.ini changes missed in last commit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=cd3a91950fadfad1f46a71a2804836da87702fb6">cd3a91</a></td>
		<td>2 lines</td>
		<td>Remove -debug from launching of build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ce216f31996ab648b0413c491385df9b3d85a02c">ce216f</a></td>
		<td>2 lines</td>
		<td>Add missing ChangeLog entries.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=cfe1617c25df15bb8461499c223544a362ada6a9">cfe161</a></td>
		<td>285 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=294114">Bug 294114</a>:  Add ability to provision JDT and SDK into dropins ('provisionSDKinDropins')</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=d00f364f4c3243ccb9c730bf34a98c07090d1426">d00f36</a></td>
		<td>2 lines</td>
		<td>Typo.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=d40ea793468239c5d536dba8dfcbac5b6bcf0c9f">d40ea7</a></td>
		<td>21 lines</td>
		<td>2009-06-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Define productFiles globally.  Generate feature for root files.  To use this, ensure eclipse-build-config is up to date -- especially the generated tarball of it.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=d57c1f079e430c077c038ceb84608a43758f8ab3">d57c1f</a></td>
		<td>24 lines</td>
		<td>2009-06-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * buildSource.sh: Set workspace and user.home during fetching. Make 3.5 build ID the default. Add -noTests flag to not fetch the tests' source.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=d5a001f37884585a2e411cbe9065c3fcc6161fb0">d5a001</a></td>
		<td>17 lines</td>
		<td>2010-07-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=319110">Bug 319110</a> * build.xml: Apply patch from Benjamin Drung to rename some ant targets (distclean -&gt; clean, clean -&gt; clean-sdk).  &quot;distclean&quot; now removes *.log.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=d85e35f975d11468c0e3ed7e9b740fe4941cd44c">d85e35</a></td>
		<td>261 lines</td>
		<td>2009-06-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Make bootstrap stuff default but allow over-riding.  Add init target to do extraction of buildSource.sh-generated tarball.  Move insertBuildId and applyPatches targets here.  Add package target for debugging use.  Add full paths everywhere. * generatebuild.xml: Use a fetched feature instead of generating one. Pass buildDirectory property. * patches/cleanupMaster.patch: Initial checkin.  Don't include some SWT fragments. * build.properties: Don't hard-code plugin or feature ID.  Set other BREEs.  Update buildDirectory to reflect buildSource.sh output. * patches/eclipse-swt-buildagainstxulrunner.patch: Update to use unstable XULRunner headers (dom/ files). * assemble.xml: Call assemble and package files for feature we're building.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=d916a43df48e42b7aa9d0c3256cf4a526792ae4f">d916a4</a></td>
		<td>83 lines</td>
		<td>2009-07-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * pdebuild.xml: Work around duplicate org.eclipse.equinox.http.jetty. * pdebuild.properties: Copy some properties over from build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=d964b7c82ca088bf78b545095d6c1126a6d9c582">d964b7</a></td>
		<td>6 lines</td>
		<td>2009-06-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Don't set p2.{metadata,artifact}.repo.name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=d98dfc183ee61ec1c1eee6a3a211a6c92c6d3618">d98dfc</a></td>
		<td>7 lines</td>
		<td>2009-09-24  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Update URL for downloading (use mirrors).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=dabdace8638e11a79b160620253ea771883514ac">dabdac</a></td>
		<td>56 lines</td>
		<td>Build EMF features that e4 needs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=db4b95a4b769705debd7a991521c5e8ce67742db">db4b95</a></td>
		<td>11214 lines</td>
		<td>Merge 3.5.2 branch.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=dcd05153697702da37001c9e9d58f08f3fb5bdd4">dcd051</a></td>
		<td>9 lines</td>
		<td>2009-06-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Fix path for builtZip.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=de055cbfd8cc0ab5760df3d5e6debcfeee6c71f6">de055c</a></td>
		<td>128 lines</td>
		<td>Move build.properties to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=de4c68f4eae0bd38e3256c023ebdd8f76e4387e9">de4c68</a></td>
		<td>50 lines</td>
		<td>Move assemble.xml to eclipse-build folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=e1ecb0ab6388dc5160147dbc30cf25df5f21ab31">e1ecb0</a></td>
		<td>8 lines</td>
		<td>2009-09-21  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Add stamp for inserting the build ID.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=e30f2e5c5b9162bce469d070c1b7359cb6ad5384">e30f2e</a></td>
		<td>167 lines</td>
		<td>2010-08-11  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=293731">Bug 293731</a> * build.xml: Add ability to provision just the platform or just the platform and the CVS feature (default is still entire SDK).  Parametrize JUnit4 JAR location.  Replace @qualifier@ also in platform.product since we're using it now.  No longer copy content.{xml,jar} over for debugging during publishing.  Extract publishing of SDK into a common target that can be used by other publishing tasks.  Extract provisioning of SDK into common target.  Add installPlatform/installPlatformAndCVS targets for installing just the platform/platform+CVS. * publishProduct.xml: Parametrize the product file to use. * sdknonosgidependencies.properties: New file.  Non-OSGi dependencies present in the SDK but not the platform. * sdkdependencies.properties: New file.  OSGi dependencies present in the SDK but not the platform. * nonosgidependencies.properties: 
 Strip SDK-only dependencies. * dependencies.properties: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=e540797e66e00499ae1e9897c9f60eb53956145c">e54079</a></td>
		<td>48 lines</td>
		<td>2009-07-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Use new org.eclipse.equinox.p2.director app.  Split p2prep into multiple targets to ease debugging.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=e639d4841e1f4d039895f627d08d9d88c06fd355">e639d4</a></td>
		<td>25 lines</td>
		<td>Remove pre-generated build.xml files after bootstrap pdebuild.xml:  So that they will be cleanly re-generated by PDE Build during the build process, delete all pre-generated build.xml files following bootstrapping.  A few must remain around due to them either being custom build.xml files or being used for native fragment compilation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=e6e535b0edcc54989dc7c54af3d8f86b0d628d85">e6e535</a></td>
		<td>6 lines</td>
		<td>2009-11-03  Matthias Klose  &lt;doko@ubuntu.com&gt; * eclipse-build-additionalArchs.tar.bz2:  Add files for arm, mips, mipsel, PA_RISC, alpha, ia64.  Fix existing files for 64-bit platforms (ppc64 and sparc64).  Copy over fix for <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=293974">Bug 293974</a>.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=e729b15a0d941570aa2a222c003b907f1ecb7569">e729b1</a></td>
		<td>4 lines</td>
		<td>Rename 'javaHomeDoesNotExists' for clarity Call the variable 'javaHomeExists' instead.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=e7414077b9e831d54634d2858259fd635e43dd2d">e74140</a></td>
		<td>169 lines</td>
		<td>2009-07-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Use antrunner from bootstrap to run targets that need Eclipse extension points.  Add target to generate build.xml files for PDE Build boostrapping.  Extract pre-generated build.xml files before building. Don't fail if basebuilder (bootstrap)'s p2 folder doesn't exist and we try to move it.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=e817c79c309215c52368d8456e3b7ff933b21e3f">e817c7</a></td>
		<td>4 lines</td>
		<td>Add test build artifacts to gitignore.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ea77ffd7ddb8917dc22ee7cfddb5330fd50e15fe">ea77ff</a></td>
		<td>10 lines</td>
		<td>2009-11-02  Matthias Klose  &lt;doko@ubuntu.com&gt; * productFiles/rcpConfig/build.properties: Add arm support. * build.properties: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ea7e5dd21e6bfbf8685ba3e8a2fd1b5d51bd6fa4">ea7e5d</a></td>
		<td>3269 lines</td>
		<td>2009-06-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * productFiles/rcpConfig/build.properties: Initial checkin. Used to ensure IUs for root files are created and installed. * productFiles/rcpConfig/buildConfiguration.xml: Likewise. * productFiles/rcpConfig/config.product: Likewise. * productFiles/rcpConfig/feature.properties: Likewise. * productFiles/rcpConfig/feature.xml: Likewise. * productFiles/rcpConfig/p2.inf: Likewise</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=eab3453e49230528313cb6a8589a28689ad61f30">eab345</a></td>
		<td>5 lines</td>
		<td>2010-03-04  Andrew Overholt  &lt;overholt@redhat.com&gt; * buildSDKSource.sh: Drop .cvsignore files.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=eb714989be6612a96c64f6c609fce6857c1cbfc2">eb7149</a></td>
		<td>108 lines</td>
		<td>2009-09-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Copy the test installation into a sub-directory.  Copy genReport.xml and runtests.sh into test installation parent directory. Add runTests target. * runtests.sh: Add all test suites back (don't know if they all work, but ...).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ebcd006d142358e013420b3b4d2e748b498c7bbd">ebcd00</a></td>
		<td>6 lines</td>
		<td>2009-10-26  Matthias Klose  &lt;doko@ubuntu.com&gt; * additionalArchs/rename.sh: Remove bashism.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ec69acc8cb3806b6fa575c39940cf4448b6b9c46">ec69ac</a></td>
		<td>8 lines</td>
		<td>2010-08-03  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=321284">Bug 321284</a> * build.xml: Set installation directory after resolving libdir.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ecf09013aac2b5324804bbddb6d49130957870ef">ecf090</a></td>
		<td>20 lines</td>
		<td>2010-07-28  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Fix version of org.eclipse.test (3.2.0 -&gt; 3.3.0). * junitHelper.xml: Likewise. * runtests.sh: Likewise. * sdk-tests.properties: Add to svn:ignore. * tests_*: Add to svn:ignore.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ed704da5403949d0b1f3eac50472ff9e6e7f5826">ed704d</a></td>
		<td>55 lines</td>
		<td>2009-06-22  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=280684">Bug 280684</a> * ABOUT.mediawiki: Add some bug links and a bit more documentation. * build.xml: Default to 3.5 final build ID. * README.mediawiki: Update a bit with how to test.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ed7a72c696c98c5b8f27facd029cc96941a73ed2">ed7a72</a></td>
		<td>5 lines</td>
		<td>Create properties for bootstrap bundles pdebuild.xml:  To make it easier to have re-usable filesets of the bootstrap bundles, make properties and then create filelists from the properties so nothing else needs to be changed.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=eebaecbe2dc6708064f1b30918feea39554f2ea1">eebaec</a></td>
		<td>75 lines</td>
		<td>2009-12-01  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Add patch for transform clipping with GTK 2.18 (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=286687">Bug 286687</a>). * patches/transformclipping.patch: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ef794f34a2e17557b0803a61843abe1a51ac87b8">ef794f</a></td>
		<td>88 lines</td>
		<td>2009-09-23  Andrew Overholt  &lt;overholt@redhat.com&gt; * runtests.sh: Enable all test suites. * build.xml: Copy re-named junitHelper.xml instead of genReport.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=f0fe54eaa3b6269b555a6b5c3c6d453339ffd485">f0fe54</a></td>
		<td>5 lines</td>
		<td>Update platform.product to have 2011 Eclipse SUA</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=f12ba9e70e97745bedb68587515ce4bb727ba35d">f12ba9</a></td>
		<td>12 lines</td>
		<td>2009-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=293952">Bug 293952</a> * build.xml: Only build for target (idea courtesy Matthias Klose).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=f352b51668931e001c8cb33986726a2d676056df">f352b5</a></td>
		<td>3109 lines</td>
		<td>2009-07-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * productFiles/rcpConfig/p2.inf: Remove generated properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=f5000006b1bc40cf6349907ba1680addc1b53f70">f50000</a></td>
		<td>20 lines</td>
		<td>2009-09-21  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=289939">Bug 289939</a> * build.xml: Apply patch from Benjamin Drung to add stamp files for provisioning SDK and other targets.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=f508753bd01f55628d669cbbf902cf7cd62f714b">f50875</a></td>
		<td>48 lines</td>
		<td>2009-09-24  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Add message requesting posting of results. * runtests.sh: Add wiki page for posting results.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=f5e39c8d40fa9a6ff8ef1ee5ee77c75178d2caa3">f5e39c</a></td>
		<td>8 lines</td>
		<td>2009-09-29  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Update to 3.5.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=f840dae1a4ed8b4b27e403d4b737030562cab4d7">f840da</a></td>
		<td>14 lines</td>
		<td>2010-02-16  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=302256">Bug 302256</a> * build.xml: Add -Xmx to JVM arguments when forking separate java processes (Matt Whitlock).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=f8bb0ca33e6e47c3c65ee0379ad7b46064615673">f8bb0c</a></td>
		<td>6 lines</td>
		<td>2009-10-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * runtests.sh: Add missing line continuation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=f937229bae8f23cc6bce01358d8f7ccee5a6ca1a">f93722</a></td>
		<td>8 lines</td>
		<td>2009-09-21  Andrew Overholt  &lt;overholt@redhat.com&gt; * buildEclipseBuildSource.sh: Make default tag 0.3.1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=fb5967e7c41e2883cc7e6e7ddf59718da5ea0253">fb5967</a></td>
		<td>22 lines</td>
		<td>Compute PDE Build JAR path in its own task This way, the property pointing to the PDE Build JAR can be re-used.  Use this property when building EMF and the SDK tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=fbbbf7ed056c3126fb31d94f1b482399e0a6cb4f">fbbbf7</a></td>
		<td>16 lines</td>
		<td>Update p2 repos for 3.7 (Indigo)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=fbeca750a69c29505291c918a847c822d882e162">fbeca7</a></td>
		<td>15 lines</td>
		<td>2009-09-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * productFiles/sdk/sdk.product: Remote dropins from default eclipse.ini as it causes the tests to pick up system-installed stuff.  We'll add it to eclipse.ini later.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=fd51590fe85af12865bede343fa40cee33801611">fd5159</a></td>
		<td>4238 lines</td>
		<td>Add icu4j manifest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=fead46774009a1fb3dc17cf69bb80f7c26e929b0">fead46</a></td>
		<td>1 lines</td>
		<td>Explicitly set junit-stylesheet property as it's not resolving in library.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=fed8d064c19e7e5d4b18f11b25b3b660fd6f7f9c">fed8d0</a></td>
		<td>997 lines</td>
		<td>Merge e3.6 branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=feffc2f8ffe48c07c3b0273e8f59ef913898ad04">feffc2</a></td>
		<td>161 lines</td>
		<td>Create properties for bootstrap bundles pdebuild.xml:  To make it easier to have re-usable filesets of the bootstrap bundles, make properties and then create filelists from the properties so nothing else needs to be changed.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ff6f97d685fb23f818fe346afe7b19bf78f2e623">ff6f97</a></td>
		<td>2 lines</td>
		<td>Actually apply runtests patch to use rm -f and not just rm when removing properties file.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=008dc40850d93e58768fed7339f5b9903e3a454a">008dc4</a></td>
		<td>2 lines</td>
		<td>Use CDT Indigo site instead of Indigo staging repo.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=00c6b23ae6ee9080d7753ce712dc694cb2591042">00c6b2</a></td>
		<td>182 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=00d96171f04474c1e4318f2a8bf83d7b027c19cf">00d961</a></td>
		<td>2 lines</td>
		<td>Move from Eclipse-LazyStart to BundleActivationPolicy</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0119a99e7b241c7721328a0abf07b534484a018e">0119a9</a></td>
		<td>16 lines</td>
		<td>2008-11-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/cdt/autotools/tests/AllAutotoolsTests.java: New test suite. * src/org/eclipse/linuxtools/cdt/autotools/tests/autoconf/AutoconfTests.java: New test suite. * src/org/eclipse/linuxtools/cdt/autotools/tests/editors/EditorTests.java: New test suite. * test.xml: New file to drive tests on build.eclipse.org.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=01bc2ed6343446bd4f6e2e8b82f414d0a6c48a19">01bc2e</a></td>
		<td>97 lines</td>
		<td>2.5.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=01ce47aeed14282ed0f8f29bd35995ed24292b81">01ce47</a></td>
		<td>3 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=348271">Bug 348271</a> - OProfile help docs navigation icons missing Add images/ to bin.includes in build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=01d53e1c690ce6595240cc872ac5919359efa989">01d53e</a></td>
		<td>3 lines</td>
		<td>Update for re-named tests feature and add tests plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0241feea0081c5cc718441658dd0d334a5633f52">0241fe</a></td>
		<td>8 lines</td>
		<td>2009-07-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Add META-INF to build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0266b43c6c0dfd140ec6d4933405cffd9eac076d">0266b4</a></td>
		<td>22 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=034a9b9ff5bc61ae7ea296a74b76fed7c9b2a13f">034a9b</a></td>
		<td>6 lines</td>
		<td>2008-11-24  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix typo.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0363afb9a374159bc600bbef9a49e84861c6ee9c">0363af</a></td>
		<td>2 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0394ad5980ad4769f94b0f99136e277647198fe3">0394ad</a></td>
		<td>80 lines</td>
		<td>2009-02-24  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/cdt/libhover/LibHover.java: Comment out SharedASTJob references.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=03d69fea53ef837c7bb7f57b1f35ef0f11953566">03d69f</a></td>
		<td>8 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add &quot;qualifier&quot; for trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=041caf204df4973debce12f6b967171f4f98aac7">041caf</a></td>
		<td>8 lines</td>
		<td>2009-11-24  Andrew Overholt  &lt;overholt@redhat.com&gt; * testing.properties: Add temporary workaround for <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=295394">Bug 295394</a>.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=044543f141583714dccb982c030cf49632f8f59c">044543</a></td>
		<td>56 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Update.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0473730fc54331c974be22682200de74e0506d32">047373</a></td>
		<td>242 lines</td>
		<td>Tag 0.6 releng stuff.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=04bc42469f3fb80b848c829cf534f0d59f6b4984">04bc42</a></td>
		<td>41 lines</td>
		<td>2008-12-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Inital checkin. * feature.xml: Likewise. * feature.properties: Likewise. * epl-v10.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=04e88b415b652f9deecd1a7d6ea099f21fc7855f">04e88b</a></td>
		<td>7 lines</td>
		<td>Add org.eclipse.linuxtools.tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=05151316e4677fe4bc79c2085cb6d659a7edd8a8">051513</a></td>
		<td>59 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=057084b27891ca813113f92baedd4696a98791dd">057084</a></td>
		<td>10 lines</td>
		<td>2010-01-25  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/gcov.psf: New file. * psfs/linuxtools.psf: Add GCov contribution.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0595c94ddd152086f79f530e9f57a091e4ca0116">0595c9</a></td>
		<td>753 lines</td>
		<td>Branch for 0.3</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=05b4bb8cc56f554131157f57cb5475ecf50fe2ed">05b4bb</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=05b778eb950045ee0647458587e5d3561aedb5ad">05b778</a></td>
		<td>67 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=05c7c26e1d6789096dfc5d07f65a59de39da4891">05c7c2</a></td>
		<td>8 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Re-add update site information (sorry).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=05cba0c5920b0eb3d41721ae33590f72cb962531">05cba0</a></td>
		<td>12 lines</td>
		<td>2008-12-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add tests plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0613f9841045eeaa527f181df9a7695c3d486803">0613f9</a></td>
		<td>246 lines</td>
		<td>Add build artifacts to .gitignore files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=062461f88c017af41950cf6ec0c1398399ecce8d">062461</a></td>
		<td>17 lines</td>
		<td>Build p2 repository instead of update site</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=065f5dce3c434b6952c611071e927874ba4ff7eb">065f5d</a></td>
		<td>1 lines</td>
		<td>Add maven artifact to valgrind-feature/.gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=06ebcce01c41d16fe22db5c272f6cdfbe87e483c">06ebcc</a></td>
		<td>212 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html. * about.html: Remove. * feature.xml: Use licenseURL property instead of explicit URL.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0725dc61d7a443874c702b1a66de838bc2927cc3">0725dc</a></td>
		<td>16 lines</td>
		<td>2010-05-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Try out 3.6RC1 and RC2 dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=075089048ee340cd1b24dafdc723fad7849cb4f3">075089</a></td>
		<td>6 lines</td>
		<td>2010-03-15  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Bump version to 0.5.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=075caccaaea3eee0ad8cf3d41a0ff0e6ee6e9c67">075cac</a></td>
		<td>24 lines</td>
		<td>Run OProfile launch tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0773a74d6a3d097fe4d93581bac69c1d8710ade4">0773a7</a></td>
		<td>16 lines</td>
		<td>2010-07-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Update to final helios dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0773cb54d97f78bc83a9151ed70beb9e8355daa1">0773cb</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0784b0ff0db637abb4bb4ef1d2517a1278f821a3">0784b0</a></td>
		<td>83 lines</td>
		<td>Re-organize into updates-nightly and updates-released.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=07bd31ff968c24333c3498bddc994e401b83c0e6">07bd31</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=07db31f10ff50eb993e0cff5cf50bb0d223f87c6">07db31</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0802a240761826e74c0b4ec3f003d93cf9e58a67">0802a2</a></td>
		<td>2 lines</td>
		<td>Add missing version to man POMs Add version entities to man parent POM and man feature POM</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0806bb74fc2216234f40c4c3f4bbeae79601a2ad">0806bb</a></td>
		<td>537 lines</td>
		<td>Add .gitignore files for each feature/plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0872eb1ed57860a7ec3c466d0354dad754e1032f">0872eb</a></td>
		<td>18 lines</td>
		<td>NEW - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=314868">Bug 314868</a>: Create category for SystemTap views https://bugs.eclipse.org/bugs/show_bug.cgi?id=314868</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0890e59f8ac9bb5022d8b822abf91e328e98e104">0890e5</a></td>
		<td>1 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181249">Bug 181249</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0891c85d1be8e2152c922801cd0fb8f22553d297">0891c8</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0946321ae818a35c2e42b1013f68e2a2363bfd52">094632</a></td>
		<td>429 lines</td>
		<td>2008-12-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Inital checkin. * feature.xml: Likewise. * feature.properties: Likewise. * epl-v10.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=09a13b6c809ad7e98e70da3563be9f2620e9f523">09a13b</a></td>
		<td>49 lines</td>
		<td>2009-08-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285616">Bug 285616</a> * category.xml: Remove (can't figure out why it's not generating site.xml properly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=09a20858ae2694c025f211c45a233e8a81e61dd9">09a208</a></td>
		<td>2 lines</td>
		<td>Fix SDK URL.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=09eab97b7d40bfc7a6bb80c6d0c26af7a3fa5835">09eab9</a></td>
		<td>207 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=09f4d9ec5051924c6eea32c0737d1f12a38a7c60">09f4d9</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0a0df4904d78e3754de82e61e7ea830ef59f3fc0">0a0df4</a></td>
		<td>6 lines</td>
		<td>2009-07-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove trailing &quot;-feature&quot; on OProfile test feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0a41355a673bee2a700b5ee3def8b559c7a7f0d0">0a4135</a></td>
		<td>9 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * META-INF/MANIFEST.MF: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0a6c4f07363638e54f55c4f57c732ef6609cd122">0a6c4f</a></td>
		<td>12 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b018cefe68f9242721b80bc365a50cfb4ed9b9d">0b018c</a></td>
		<td>7 lines</td>
		<td>Include license.html in TMF feature JAR</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b0da251ad8b492f908756fef391e7aaa4e59290">0b0da2</a></td>
		<td>7 lines</td>
		<td>Remove erroneous tag from generated HTML docs 347868: Weird string on mediawiki-generated documentation https://bugs.eclipse.org/bugs/show_bug.cgi?id=347868</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b3daf7140ac99125a6797a1f99353d3fe8a2ba1">0b3daf</a></td>
		<td>24 lines</td>
		<td>2009-02-25  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Clean up variable names. * META-INF/MANIFEST.MF: Explicitly require JUnit 3. * build.properties: Add test.xml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b88fc46e6d1f1c4d39b0a2daeb60655b6dea667">0b88fc</a></td>
		<td>18 lines</td>
		<td>2010-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * OSGI-INF/l10n/bundle.properties: New file.  Externalized strings. * build.properties: Add bundle.properties to binary build. * META-INF/MANIFEST.MF: Externalize provider and bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b8e124bc4b3c069387711b48a5b2da7d65e81cf">0b8e12</a></td>
		<td>6 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Use featureURL property instead of explicit URL.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0ba96dad783de434338e1ee32386a205d6325a15">0ba96d</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0bb5497d13ae010fb4a711d6766921b6d2350a82">0bb549</a></td>
		<td>9 lines</td>
		<td>2008-12-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Typos.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0bddbc3dca66189a2d8ac436396c9462c9f55124">0bddbc</a></td>
		<td>32 lines</td>
		<td>2.5.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0be3a948d8391418fa2111a0c75ab5b276e9fdb2">0be3a9</a></td>
		<td>2 lines</td>
		<td>Remove CamelCasing in plugin name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0bfa1f7ad5b4f1d7dddada365d7bf581e2f1307f">0bfa1f</a></td>
		<td>170 lines</td>
		<td>2007-04-12  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181236">Bug 181236</a> * src/org/eclipse/linuxtools/rpm/ui/editor/tests/RpmPackageProposalsListTests.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/RpmMacroProposalsListTests.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/AllTests.java (suite): Add new tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0c1f44232c0b925bc2574f1172cc6ce26a9f0646">0c1f44</a></td>
		<td>21 lines</td>
		<td>Add plugins.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0c7c7336355fd48d37a1db4282459444f5bf6d3d">0c7c73</a></td>
		<td>1108 lines</td>
		<td>Add SDK feature to ease setting of API baseline This feature will not be built as part of our regular builds but can be used by committers to set up a full local build to use as an API baseline.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0c936b646600b7791c15ade3b5bfb888175e12f7">0c936b</a></td>
		<td>6 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Use newly-renamed libhover feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0d07f8b39c98ec523d2d37348f469278b22f8a40">0d07f8</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0d142cae0af4e091527e0dbf5133c2c818337a37">0d142c</a></td>
		<td>6 lines</td>
		<td>2008-11-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: gef-folder -&gt; specfile-folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0d9c1d67cbc70cd04f9f6a76a49cfd101802a837">0d9c1d</a></td>
		<td>2 lines</td>
		<td>Remove CamelCasing in plugin name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0d9fd24f1af73ebeb1f9e8cc8097ddd819ea00d1">0d9fd2</a></td>
		<td>2 lines</td>
		<td>Fix Bundle-Version -&gt; Bundle-Vendor typo.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0dff0ab9830f19a8905e8e5b5f290253d14bb22b">0dff0a</a></td>
		<td>89 lines</td>
		<td>Use releng build.xml instead of Athena run.sh</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0e12b0bad76f0ca4979d448645b479fcbf069439">0e12b0</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0eb9e6a4e2345719ea0bf3fdcfb6001d4450e277">0eb9e6</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0ef6ba30bb361eaccf9dd25d3f3a0983ccca95bb">0ef6ba</a></td>
		<td>5 lines</td>
		<td>Add test suites to run (testPluginsToRun) to testing.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0f2a6f07865505c61dc1a803a111bbf72451cc83">0f2a6f</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0f3e2cf77d7ce398940b23de42030e71a6265eec">0f3e2c</a></td>
		<td>8175 lines</td>
		<td>Branch for Helios.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0f8f9873eb4f7868c53d1650bf5558de87ad9d31">0f8f98</a></td>
		<td>7 lines</td>
		<td>2008-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add plugin.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0fc593985c4f9b9b1bebed43e96d434be3565483">0fc593</a></td>
		<td>6 lines</td>
		<td>2010-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * OSGI-INF/l10n/bundle.properties: Change provider to Eclipse Linux Tools.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0fc9c46f657512fdf2e0f0d8544ac78cfd21a7cb">0fc9c4</a></td>
		<td>51 lines</td>
		<td>2008-12-04  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add test.xml to bin.includes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0fe8721ff808c93a71172f02299ed6041f050e47">0fe872</a></td>
		<td>12 lines</td>
		<td>2009-04-23  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove 5.0.0.qualifier versions on CDT dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0ff6b6e475e39e330980689300d008d2ee4021ea">0ff6b6</a></td>
		<td>22 lines</td>
		<td>Put Galileo work on branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=10094d4c1733cc74c3d3b9e71d7f76e1d12dda80">10094d</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=10224a9d72711005f19d398d077dcf09e434558e">10224a</a></td>
		<td>10 lines</td>
		<td>2009-04-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * build-helper.xml: Get rid of Phoenix extension (to have common side navigation bar) in resulting HTML.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1052d0a318be965f94eb7c49c5b559c62af1a09e">1052d0</a></td>
		<td>25 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Initial import. * META-INF/MANIFEST.MF: Use plugin.properties.  Add &quot;(Incubation)&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=107e2831e0ff3e5ad9dddf756068c183cef75b65">107e28</a></td>
		<td>15 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: use feature.properties variables. * feature.properties: Provider:  Eclipse.org -&gt; Eclipse</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=109414e909035bd8ae2563f94eae05f0290eba1e">109414</a></td>
		<td>294 lines</td>
		<td>Make POM versions 0.8.1-SNAPSHOT In each pom.xml file, make the parent version 0.8.1-SNAPSHOT and make it 0.8.1-SNAPSHOT in the main (ex. autotools/pom.xml, lttng/pom.xml, etc.) POMs.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=11082c998cd513cb990d6d5c42b1c0a625af8e27">11082c</a></td>
		<td>10 lines</td>
		<td>Remove valgrind tests' unnecessary dependency on profiling tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1146e26b6bd222928302229f04cc2af3c6396ddb">1146e2</a></td>
		<td>2 lines</td>
		<td>Fix bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1162cbc31c404b2d860f31d64cc28515e7692468">1162cb</a></td>
		<td>532 lines</td>
		<td>Tycho-ify rpm</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1169b628afd8c89305d1b5d57c95ee8723efb76d">1169b6</a></td>
		<td>4 lines</td>
		<td>Use external JVM for local ant launch of releng build</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=11be2b54a85ba3e3ee2664d3bed2a2673778d30d">11be2b</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=11c4bd12bc26611b7a7caacac09ba1239951c814">11c4bd</a></td>
		<td>53 lines</td>
		<td>2009-04-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Add .qualifier.  Set bundle localization. * plugin.xml: Set id on toc extension.  Add generated toc. * toc.xml: Get rid of extraneous stuff.  We can re-add if we feel we need it.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=11cfa3ac116862fc3f6738a1725c62c190aa0fc0">11cfa3</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=11ed243cf9378a3fefffe882e6106374abbe9b76">11ed24</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=11fb84b2b057b6d23eaa95d5c367c2478ed826d3">11fb84</a></td>
		<td>270 lines</td>
		<td>Tycho-ify libhover</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=11fe741e49ee515a61ab54583eca3e7365277f32">11fe74</a></td>
		<td>5 lines</td>
		<td>2009-10-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * testing.properties: Add GProf tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1242675f0979ae26b44fb9f2ca9c5d4846c49cc6">124267</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=125e7de186ba21d179a52df758f8338df86f464e">125e7d</a></td>
		<td>22 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=12e6fd33406be368d6118a1cd13abd713feac10b">12e6fd</a></td>
		<td>1399 lines</td>
		<td>Ensure all bundles have proper about.html All about.html files are updated to be the exact same as http://www.eclipse.org/legal/epl/about.html <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=316849">Bug 316849</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1317c46725657d9e2145c16e94c309cf0b17312d">1317c4</a></td>
		<td>9 lines</td>
		<td>Externalize Bundle-Name and Bundle-Vendor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1329135d79a234e881d56b6f0b0699056845344f">132913</a></td>
		<td>626 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=346749">Bug 346749</a> - Re-name rpm.ui.editor *Tests.java to *Test.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=135e71a32c7b1f472a980356c3be1885496ea325">135e71</a></td>
		<td>36 lines</td>
		<td>Use valgrind branch towards 0.1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=136f10a34a9db7fcc67a0c7012aad8031cc2b162">136f10</a></td>
		<td>37 lines</td>
		<td>2008-12-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Inital checkin. * feature.xml: Likewise. * feature.properties: Likewise. * epl-v10.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=143f5c607fca57c3372f7af1b5a5bd0a9802de53">143f5c</a></td>
		<td>10 lines</td>
		<td>Remove valgrind tests' unnecessary dependency on profiling tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1462978b29cc60dd326c608443ba5c8cbb8b9c6c">146297</a></td>
		<td>1 lines</td>
		<td>Use localized strings for org.eclipse.callgraph.docs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1492cebef6342e2195aa30c5c07859cb2ee7eac2">1492ce</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=14dea999d91d32b792f1a8e977f72ca4f422bc74">14dea9</a></td>
		<td>10 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=272028">Bug 272028</a> * META-INF/MANIFEST.MF: Fix localization. * plugin.properties: Fix typo (missing 'S').</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=14e52e9853f0bf26ae0dfc67a93348b927edc5b5">14e52e</a></td>
		<td>7 lines</td>
		<td>2010-04-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Restrict to os=linux.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=151eca407573a8eb8c751a88d58ef6b14315f619">151eca</a></td>
		<td>7 lines</td>
		<td>Add zipPrefix and incubation variables to build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=15582059deb14b19c6fc8a38685601c164f31f4c">155820</a></td>
		<td>6 lines</td>
		<td>2009-11-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/callgraph.psf: Fix typos. * psfs/autotools.psf: Likewise. * psfs/linuxtools.psf: Change &quot;http&quot; to &quot;svn&quot;.  Add &quot;anonymous@&quot; for CVS modules.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=156136c5dd3a811ecf30c8ee1d1ef1c9fe0062f0">156136</a></td>
		<td>231 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright text. * license.html: Updated HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * about.html: Remove. * build.properties: Remove about.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1571e154e44d9bcece89cf60905af76e0e4140dc">1571e1</a></td>
		<td>20 lines</td>
		<td>Add maven directories to GCov .gitignore files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=159d8e530e0da8670b88f9f8e09aaccdff22ede2">159d8e</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=159ec5cf23f32bc101b947d6d84903cd606c22de">159ec5</a></td>
		<td>19 lines</td>
		<td>Remove pre-built opxml binary.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=15d1ef7f7385fe708b43c0046aa4f783c5abfb7d">15d1ef</a></td>
		<td>10 lines</td>
		<td>Add expansion of BIRT and EMF dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1608679224c12c9ea8112160d8be5db9cc704c68">160867</a></td>
		<td>95 lines</td>
		<td>Fix copyrights in maven files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=161f4e88f3baf725a396e57a6052b4337ce7b8ad">161f4e</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1632e68eefca9e39f4605a5de24da3eb4e892701">1632e6</a></td>
		<td>7 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * plugin.xml: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1650aae720b8c05f0eae1c24d3c63aaa4f8930fd">1650aa</a></td>
		<td>12 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Re-name to org.eclipse.linuxtools.cdt.autotools (-feature is the SVN directory name). * feature.properties: Update copyright.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=168930af6d74602fbd45c2ef528cf991e9eb0e62">168930</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=16b831647cbaf97b867aab3679915e07cfcb69e1">16b831</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=16be761a352dd5e9b22faec394a21b01de8520c0">16be76</a></td>
		<td>5 lines</td>
		<td>2008-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Add Bundle-ActivationPolicy.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=16da1026824f5206014086e421243548007c487b">16da10</a></td>
		<td>22 lines</td>
		<td>2007-04-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change Bundle-Vendor to Eclipse.org (#180822). * .settings: Add (#180822).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=16dade80e600faf7a343d3cddb62288862fd2d06">16dade</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1716aba781a68ef512c1f4373592489ccbf4380e">1716ab</a></td>
		<td>6 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=172ef10a2d9fa46ed92b140247313ba60e57d4f7">172ef1</a></td>
		<td>537 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=173639dab2e7b688665b95e45a0bcab727a9939f">173639</a></td>
		<td>10 lines</td>
		<td>Add maven artifacts to ChangeLog gitignore files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1789d714856e30ba3368e6d6b03902b378236be2">1789d7</a></td>
		<td>12 lines</td>
		<td>Add @since annotations to new method signatures</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1795e51bd90055f7fb7032fd02409c87384baf1b">1795e5</a></td>
		<td>45 lines</td>
		<td>2010-01-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * tools/linuxtoolsupdatesite-helios.sh: New file.  Helios update site updater. * tools/linuxtoolsupdatesite-galileo.sh: Update for new Hudson location. Rename from -trunk.sh.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=17a28109beac2417b0bed3670a0dac3dfc0beeae">17a281</a></td>
		<td>4 lines</td>
		<td>Add test gmon files to gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=17fb31b38083ea85ef35448eede47a2100294a17">17fb31</a></td>
		<td>4 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add test.xml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1819b7a281c3b4cd40016d68ab6c819abe63a3fc">1819b7</a></td>
		<td>8 lines</td>
		<td>2008-12-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Debugging statement.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1832a7875dd3ff648222135fd2821998ad5b4a4a">1832a7</a></td>
		<td>11 lines</td>
		<td>2010-01-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add gcov tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1888717ed16bd5fab924b95ad44fca86cb24538a">188871</a></td>
		<td>38 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * about.html: Initial checkin. * build.properties: Add test.xml, etc. to build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1937c1d62f4562faedb976fbdc476e3072d1fd5a">1937c1</a></td>
		<td>237 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=19943d4b522d2106a5a06384030b6cd0bcd96214">19943d</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=19d204dc27aa8b7a192e8a983cc599edebee632f">19d204</a></td>
		<td>6 lines</td>
		<td>2010-02-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Update featureName.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1a5fcfcf8be5f5bd5391d2348d05097e19515616">1a5fcf</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1a936270f2a8ee215bf3959a82656257b0641816">1a9362</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1b220dd6c876cfcab0c918408066786ba26b8c9a">1b220d</a></td>
		<td>56 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Move to valgrind.test-feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1bb8b1d81cc524774aaed749d4cae284be8a7108">1bb8b1</a></td>
		<td>2 lines</td>
		<td>NEW - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306239">Bug 306239</a>: Re-name 'Graphing' perspective https://bugs.eclipse.org/bugs/show_bug.cgi?id=306239</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1bf969a781fccf44d885007426bc0e578f1c34e4">1bf969</a></td>
		<td>2 lines</td>
		<td>Run cachegrind tests as a suite to pick up -DrunValgrind option</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1c1d75264150799e584590e5ae0a9e1062d2897e">1c1d75</a></td>
		<td>2 lines</td>
		<td>Fix Helgrind tests version in pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1cb91bf1bdf09a7fac6963dce033ef9662becf60">1cb91b</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1cd8cb9eb3a9d2e30a2c11da2bd363b6a7a546ff">1cd8cb</a></td>
		<td>6 lines</td>
		<td>2009-11-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Make featureName a bit more user-friendly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1d19a00e8f83b7bfbc6f83f138028d8b5db743d7">1d19a0</a></td>
		<td>1307 lines</td>
		<td>Initial import of code (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=268422">Bug 268422</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1d207cc8b00cdf0579bc78f05c220ad0b29e7523">1d207c</a></td>
		<td>2 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1d27ef97abf23ac3ede7a51f6ad4f94c217056fe">1d27ef</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1d3737b430bc3f553233c07df943ed24e4f413e0">1d3737</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1d3d4b7767502f52ef3a9a19d3a3b0a338a2cb65">1d3d4b</a></td>
		<td>4 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Fix plugin-name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1e6c3d65e536feae5c913f9718c669ec2230c61b">1e6c3d</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1e7bcc87867fcb7dcaf98c16139ae7325f0cb956">1e7bcc</a></td>
		<td>206 lines</td>
		<td>Import files missing from profiling.ui on stable-0.7</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1efeb1a3a00dc9667dabda54173b239bbf1dca00">1efeb1</a></td>
		<td>77 lines</td>
		<td>2008-12-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Inital checkin. * feature.xml: Likewise. * feature.properties: Likewise. * epl-v10.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1f0746284f7fc357876d36cd5534ff34443a1615">1f0746</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1f59efcd1743bc83ad1eb0902f2aaf187edd647a">1f59ef</a></td>
		<td>6 lines</td>
		<td>Add CDT repository to list of dependency repositories</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1fd4f15ea5f0c8115803745dda0df629a1f3cb71">1fd4f1</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=20233a9b5db9ea136ea0f4a43ca0f377f05f19e5">20233a</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2029d30dc5c0266ffe36e7d5fe7967746a35a052">2029d3</a></td>
		<td>2 lines</td>
		<td>Add Helgrind integration tests to build</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=203cb52e6ae97993532108ea92b55cc2d8980fec">203cb5</a></td>
		<td>2 lines</td>
		<td>Revert &quot;Change build order of profilling and OProfile in pom.xml&quot; This reverts commit 215f21426d08c251cffd77046b5b9a9990a4acaf.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=203e745c7dfa17a9dc037540c9c757ec38c5ba20">203e74</a></td>
		<td>8 lines</td>
		<td>2010-01-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/athena.psf: Remove extraneous tags.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=206cf8cbcc540aeb1d86650833ff05e91539a47f">206cf8</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=208ad486bc13032f5316bc1b736556a28770bd20">208ad4</a></td>
		<td>2027 lines</td>
		<td>Fix up profiling 0.5.0 merge</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2117acdac5be781a324a07801282689b84bebf05">2117ac</a></td>
		<td>2 lines</td>
		<td>Only .gitignore the releng site's target directory</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2131927efd40a0f28c02259ff8ca8809de7116c5">213192</a></td>
		<td>7 lines</td>
		<td>2010-01-19  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add missing DTP dep (of BIRT).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=21c96e5cf0ecd670e8336a693d1f87c833e3e1ed">21c96e</a></td>
		<td>1 lines</td>
		<td>Add oprofile-core.jar to o.e.l.oprofile.core/.gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=21ec258da1d47171ea05d4bb60eba99302c00a2c">21ec25</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=220c196e785b3b9f7db6ccdb1a265c82e69f10b2">220c19</a></td>
		<td>5 lines</td>
		<td>2009-11-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Attempt to get PSFs for each build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=224236cc60d6389ca1148a883f80d425183ab8d9">224236</a></td>
		<td>204 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html. * feature.xml: Use licenseURL property.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2268b45080840f3e7fa21fc9dfd0e8212d199788">2268b4</a></td>
		<td>3664 lines</td>
		<td>Remove old releng stuff</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=228ea66ecc29bb07300b90cf4ebce52e1ac7620c">228ea6</a></td>
		<td>1 lines</td>
		<td>Add target to valgrind test feature .gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=22b607e0ed29094fe60f3197195696280905420e">22b607</a></td>
		<td>82 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=22c4dd0da13ab9325d0f4745b51813ebf9e6157e">22c4dd</a></td>
		<td>56 lines</td>
		<td>Remove test.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=22f5e4648af6da0feb37df89ed0b7555ab06bc68">22f5e4</a></td>
		<td>2 lines</td>
		<td>typo</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=22f76aee2af131ab1a605ea84a092b76ef87ea05">22f76a</a></td>
		<td>7 lines</td>
		<td>2008-11-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Unpack test plugin JARs.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=22ff9757e99ffa9aaddc63cd7b706c9cb903406a">22ff97</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=235e87735561bd78462de47c1662602342fb9e04">235e87</a></td>
		<td>9 lines</td>
		<td>2009-07-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Attempt to fix renaming situation. * .project: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=236e611431e13403179e88d001ce3a9609736862">236e61</a></td>
		<td>2 lines</td>
		<td>Make libhover.newlib version match in MANIFEST and POM</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2375bebf29471fa1621b5447e3663281ca607206">2375be</a></td>
		<td>1693 lines</td>
		<td>Tag 0.6.0 of releng stuff.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=23957a0a30c0f8f1c6c60cc769ab5353c6a949a5">23957a</a></td>
		<td>7 lines</td>
		<td>2009-04-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * tools/linuxtools_build.eclipse.org_hudson.sh: Switch back to trunk for the releng project.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=23f4a27c809d1a7acae7f0673e7e4f85b7015b1a">23f4a2</a></td>
		<td>18 lines</td>
		<td>Fix category names.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=242fad34a65cb84b3c7626af31af5a8a9984c566">242fad</a></td>
		<td>32 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Initial import. * META-INF/MANIFEST.MF: Use plugin.properties.  Add &quot;(Incubation)&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=24448a0eb6dc5785262229e2df453367a9e3e0e0">24448a</a></td>
		<td>114 lines</td>
		<td>2009-11-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/systemtap.local.psf: Removed.  Renamed to callgraph.psf. * psfs/callgraph.psf: New file. * maps/linuxtools.map: Merged and renamed a few sections. * psfs/autotools.psf: Reflect re-written plugins. * psfs/libhover.psf: Add libstdc++. * psfs/linuxtools.psf: Merge changes in smaller .psf files.  Add dependencies. * psfs/rpm-editor.psf: Add new feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=247da4c4729845297c248c39a6a175c4e47f06e5">247da4</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=24dd8f6e069a419b76c91403fa173cec08b856c9">24dd8f</a></td>
		<td>10 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add update site information.  1.0.0 -&gt; 0.1.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=24ddd9403b9c8d0a5da4b482bd68957bcddba16b">24ddd9</a></td>
		<td>21 lines</td>
		<td>Remove pre-built opxml binary.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=254855793ceb3849826885f65cccf81c3479011d">254855</a></td>
		<td>9 lines</td>
		<td>2008-12-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Typos.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=259eadc3cb47b6332588612adbec5dbf8be9c433">259ead</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=25e2318f84d3bd95bf362cdff8439e203665926e">25e231</a></td>
		<td>967 lines</td>
		<td>2010-07-27  Andrew Overholt  &lt;overholt@redhat.com&gt; * natives/linux/opxml/imageheader.cc: Update license to be EDL. * natives/linux/opxml/imageheader.h: Likewise. * natives/linux/opxml/opinfo.cc: Likewise. * natives/linux/opxml/opinfo.h: Likewise. * natives/linux/opxml/oprofiledb.cc: Likewise. * natives/linux/opxml/oprofiledb.h: Likewise. * natives/linux/opxml/opxml.cc: Likewise. * natives/linux/opxml/oxmlstream.h: Likewise. * natives/linux/opxml/profileimage.cc: Likewise. * natives/linux/opxml/profileimage.h: Likewise. * natives/linux/opxml/sample.cc: Likewise. * natives/linux/opxml/sample.h: Likewise. * natives/linux/opxml/samplefile.cc: Likewise. * natives/linux/opxml/samplefile.h: Likewise. * natives/linux/opxml/session.cc: Likewise. * natives/linux/opxml/session.h: Likewise. * natives/linux/opxml/sevent.cc: Likewise. * natives/linux/opxml/sevent.h: Likewise. * natives/linux/opxml/stable.cc: Likewise. * natives/linux/opxml/stable.h: Likewise. * natives/linux/op
 xml/symbol.cc: Likewise. * natives/linux/opxml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=25e7e808a5a3bdbd34f14c02c53aef7541f4d16e">25e7e8</a></td>
		<td>9 lines</td>
		<td>2010-05-27  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=270326">Bug 270326</a> * src/org/eclipse/linuxtools/internal/cdt/autotools/core/AutotoolsNewMakeGenerator.java (initialize): Test fix for black-on-black configure console.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=265f529f0773420b88dcc6debbb301c898ba19f5">265f52</a></td>
		<td>2 lines</td>
		<td>Don't use UI thread for non-SWTBot Massif tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=26b03f51b3fd08215826cf108b81312e90883385">26b03f</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=27728c260bf747550cf44f799ce800614ad57834">27728c</a></td>
		<td>30 lines</td>
		<td>Add .gitignore files for some features/plugins missing them</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2776bd27040aabb989f5333917bc0ab3dbf79406">2776bd</a></td>
		<td>5 lines</td>
		<td>Add test.xml to binary builds.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=277f06677e2f969511e63204e36fceaa83098b84">277f06</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=27812c71cab8c8659cc95d783178421cab2ff775">27812c</a></td>
		<td>89 lines</td>
		<td>Use releng build.xml instead of Athena run.sh</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=27cf88289e54b099bf8e1a32dc272ea1827d3513">27cf88</a></td>
		<td>2 lines</td>
		<td>Revert &quot;Change build order of profilling and OProfile in pom.xml&quot; This reverts commit 215f21426d08c251cffd77046b5b9a9990a4acaf.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2860241939361b0cccb9a7768c6842d4f137eb7f">286024</a></td>
		<td>40965 lines</td>
		<td>2009-06-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * Fix up after erroneous SVN operation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=28a0bdd600223c83773d5915c8a3378791d4c7b8">28a0bd</a></td>
		<td>2582 lines</td>
		<td>Branch for Ganymede.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=290140d0fee6cabe28f06d08dabd75ae294390cf">290140</a></td>
		<td>6 lines</td>
		<td>Add CDT repository to list of dependency repositories</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2933151e3c2da6c15584446ade44b93bdd32974a">293315</a></td>
		<td>2 lines</td>
		<td>Add &quot;(Incubation)&quot; to bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2a04a88b43d05afcbaa3e2bf847922f8ff634ddd">2a04a8</a></td>
		<td>208 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2a204b9a2af5679a80e152a8407183988cc24ec8">2a204b</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2a210efce440dc46caf66483a6f7c11661a9da8e">2a210e</a></td>
		<td>6 lines</td>
		<td>Typo in class name</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2abc112d3e4c3f1101dd183a36170c0efe2d764d">2abc11</a></td>
		<td>4 lines</td>
		<td>JAVA50-&gt;JAVA60</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2acd26c3ab554c98d530470f3bea5b7fd9b08dcb">2acd26</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2b0db4427540f9d79c20b9845e0f335c445fa5ac">2b0db4</a></td>
		<td>6 lines</td>
		<td>Add gcov and gprof to main list of modules to build and re-order</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c4811c3de60b91892b036771f3879ada5c1e8db">2c4811</a></td>
		<td>2 lines</td>
		<td>Add icu util import-package and remove unnecessary birt.chart require-bundle.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c5afb8a1ee3638f957ed41163c9a8b5d4091048">2c5afb</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c6533118925867508779a8fa62cc30a5b51a151">2c6533</a></td>
		<td>2 lines</td>
		<td>Typo in Valgrind feature id variable.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c9b2d38b37d09912ad3f1d62bf7123a7b96ec7d">2c9b2d</a></td>
		<td>6 lines</td>
		<td>Pack</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2cca784244ea85274002ec9f4d501f1b1ca86bf8">2cca78</a></td>
		<td>4 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2ce4d5b08b24b08b51cbadba9e898aba4dd4b0bd">2ce4d5</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2cf465473bab41e15399de38fb86aff895f43388">2cf465</a></td>
		<td>56 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Move to valgrind.test-feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2cfabf8f2145ce979291096892908ffecf8fa816">2cfabf</a></td>
		<td>2 lines</td>
		<td>Change build order of profilling and OProfile in pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2d6ec0308a6ab5f6dec36f759347126129845299">2d6ec0</a></td>
		<td>8 lines</td>
		<td>NEW - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=252489">Bug 252489</a>: BREE needs to be JavaSE-1.6 https://bugs.eclipse.org/bugs/show_bug.cgi?id=252489 2008-10-28  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=252489">Bug 252489</a> * META-INF/MANIFEST.MF: Set BREE to 1.6 (STPMetadataSingleton.parse uses ResourceBundle.containsKey).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2d81dbb45618fa6340a8763a2e9ec606b79f621c">2d81db</a></td>
		<td>8 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add update site information.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2db5cb48a099e554f127821e31cc557d96e28b41">2db5cb</a></td>
		<td>3 lines</td>
		<td>Fix featureToBuildID properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2dd5243509c2357c0295797803ca816147f72fbe">2dd524</a></td>
		<td>6 lines</td>
		<td>Don't both specifying cachegrind suite; just let Tycho find all tests to run</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e1e8a5992e034dd4179ba3c7bc0a0e86a55eba0">2e1e8a</a></td>
		<td>45 lines</td>
		<td>Variable-ify site.xml's versions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e45b1459deaf2ceabed471edb2f99221d3a2626">2e45b1</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e4cbcef991ac309b62843095fd4d82ed469740b">2e4cbc</a></td>
		<td>821 lines</td>
		<td>Tycho-ify valgrind</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e50962ca30348d9e65be64aa1d6c0ac9bdaf779">2e5096</a></td>
		<td>8 lines</td>
		<td>2008-01-03  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=206964">Bug 206964</a> * src/org/eclipse/linuxtools/rpmstubby/StubbyPackageModel.java: Remove 1.5 API calls.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e7d14d5a4106cc389c9f734a5a2d72fcf3acd99">2e7d14</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e88a7280cd886d8e96a97c50d09f1c7d4c94683">2e88a7</a></td>
		<td>444 lines</td>
		<td>Tycho-ify ChangeLog</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e93f3637f64ab1ddac43301789cf2d232c839c3">2e93f3</a></td>
		<td>56 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Move to feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2ea5a317c9e3e0b9535f1ec4844c001872fe0879">2ea5a3</a></td>
		<td>29 lines</td>
		<td>2009-04-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * updates-nightly/site.xml: Parametrize feature versions. * updates-nightly/associateSites.xml: Remove as p2's content.{xml,jar} takes care of this for us.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2ebd65c56959b64e3508c74b6e197ed4ac8b3de9">2ebd65</a></td>
		<td>12 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * license.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2ee12850e07f5be80f970c8825e29ad6d89ee6d9">2ee128</a></td>
		<td>2 lines</td>
		<td>Fix missed call as per <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=206964">Bug 206964</a>.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2eef2f5c0973d5e22c5016be668d88a72704434b">2eef2f</a></td>
		<td>8 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Initial checkin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2f34bb7fb1e14abe80c1e2e8a953156f7bc8f056">2f34bb</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2f3f3d22c39d469ecc7d09a70592fa746c0bea10">2f3f3d</a></td>
		<td>288 lines</td>
		<td>Remove erroneously-included lttng files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2f4cf94213ead743904d3dbbce67f85b1d299cfb">2f4cf9</a></td>
		<td>14 lines</td>
		<td>2009-05-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * maps/linuxtools.map: Modify features for removed &quot;.feature&quot; suffix.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2fc9ca6b23c65337280e4a84d74e3ded693b7938">2fc9ca</a></td>
		<td>2 lines</td>
		<td>Fix bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2fdb2a61651acc63d54f2321f72c63b13646eaf4">2fdb2a</a></td>
		<td>4 lines</td>
		<td>Typos in valgrind feature URLs.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2fe43dcf1d4e0e91f84803863a011f7a76693040">2fe43d</a></td>
		<td>10 lines</td>
		<td>Temporarily comment out some failing SystemTap test suites</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=30256661084c751f90c6e7be7d18fdc09bdc9e85">302566</a></td>
		<td>10 lines</td>
		<td>Let Tycho figure out which specfile editor tests to run</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=306dc9a92bd56edf4cea8e3610180639d4733eab">306dc9</a></td>
		<td>28 lines</td>
		<td>2008-11-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Initial import. * META-INF/MANIFEST.MF: Add dependencies on other plugins to ensure they get built first.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=30926135f71857d34e1c57f886ab2ffa98b10b77">309261</a></td>
		<td>2 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=30a33270585e0d5f9d07810ce78be50f38fd06ae">30a332</a></td>
		<td>26 lines</td>
		<td>2007-08-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Remove unnecessary stuff from binary build. * feature.xml: Fill in provider and feature name. Don't include C and Java parsers as they are their own features now. Bump to 2.5.1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=30c90cf7afb7f6a0b0b81b051d743031482955ad">30c90c</a></td>
		<td>522 lines</td>
		<td>2008-10-28  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Update BREE to J2SE-1.5.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=30c9e4bbc06854d9fcd24aa64dd93448a0563163">30c9e4</a></td>
		<td>2 lines</td>
		<td>Add missing space before &quot;(Incubation)&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=30e26ccf3b62fe658a5a55340634de5ab1d4b434">30e26c</a></td>
		<td>3255 lines</td>
		<td>Branch for Helios.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3102c3d4806d3876cd0a4c6e95b343a255020662">3102c3</a></td>
		<td>214 lines</td>
		<td>Import files missing from profiling.tests on stable-0.7</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3123a0f4d71ff29206c63c1e6bca586484babe0d">3123a0</a></td>
		<td>46 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Re-add.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=31261fc1a11254277bb949355cd6c70e467bce67">31261f</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=314f9f8047f4589c22efc720ca74239c8709be0a">314f9f</a></td>
		<td>2 lines</td>
		<td>Remove unused imports</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=318b749bfc06f7b3ae21d0ea67ffc0ec98691397">318b74</a></td>
		<td>4 lines</td>
		<td>Temporarily comment out memcheck UI tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=32765dced7a104127da388d0a71565ffc20f30b1">32765d</a></td>
		<td>9 lines</td>
		<td>Fix up build.properties</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=32d8149d54d958e3e0213ee467983cc973d946a0">32d814</a></td>
		<td>7 lines</td>
		<td>2008-12-11  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Unpack memcheck.tests plugin after installation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=330b63fd9f61d71d408e194dc5eee2d33f3d4661">330b63</a></td>
		<td>18 lines</td>
		<td>2010-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Change provider to Eclipse Linux Tools.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3334780a22ad0984b04f49409bba40e2651d9aa8">333478</a></td>
		<td>11 lines</td>
		<td>Initial import of update site project.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3388cce8eccf9f695a97e3e9b5d7c8f2e5bf9145">3388cc</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=33900e443ee1adcf4fac77113643d90e80fb1470">33900e</a></td>
		<td>6 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3392863e32cacca1a3e51fcaff96d3159cabc1c2">339286</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=339a381f0b32fca074f25f9f381ea500220340d5">339a38</a></td>
		<td>4 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Fix plugin-name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=33a56706eb17dbf1b7c2241d955c82c25f86f45b">33a567</a></td>
		<td>178 lines</td>
		<td>2009-10-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * maps/linuxtools.map: Update to new map syntax.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=33c088d6b8e468e8655b9a1ac476178b106f0d2a">33c088</a></td>
		<td>5486 lines</td>
		<td>Move to rpm/trunk/org.eclipse.linuxtools.rpm.ui.editor</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=33c4c7f3ff92f79de427963dc5e9cfd46f6ec712">33c4c7</a></td>
		<td>4 lines</td>
		<td>Branch for Linux Tools 0.1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=343980d4e9e8d3bf1b9e63fe91c6fd48a9d57172">343980</a></td>
		<td>59 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3466cedada986d89b458dfef43559b88fd49d9c1">3466ce</a></td>
		<td>22 lines</td>
		<td>2009-08-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Remove trailing period. Add copyright. * feature.xml: Add copyright.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=34a798be653882c1bd0096c13ac671ca2655519a">34a798</a></td>
		<td>2 lines</td>
		<td>Typo in valgrind feature version variable.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=352d3ced8833364133f52fc9cdb9352a9a2ce565">352d3c</a></td>
		<td>1 lines</td>
		<td>Export valgrind.helgrind internal package for tests plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=354c536e8d50d670dbbad5b3eb702aa7ab598dee">354c53</a></td>
		<td>544 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3554202b9b07a8b5aeeb3ce7fb0845c9ca229a65">355420</a></td>
		<td>10 lines</td>
		<td>Remove OProfile tests' unnecessary dependency on profiling tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3587bfb81709d3e5f1f5de97bcfcc67baa3efe11">3587bf</a></td>
		<td>6 lines</td>
		<td>2009-03-04  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: s/autoconf-folder/memcheck-folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=359b0f8e5fde468fb728cd11bece0a93e77e3615">359b0f</a></td>
		<td>100 lines</td>
		<td>Fix copyrights in maven files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=364318482b653607e95f4a5b995c74e2d692c4d6">364318</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3654aa5a32c2effc160ed42b3aea4cf809a7570a">3654aa</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=366a39b4616840da184237cd8a834abea73f6f0f">366a39</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=367e78d03f7f7da12d40427bf464a6ec1a8a5b73">367e78</a></td>
		<td>377 lines</td>
		<td>Tycho-ify profiling</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3709a54c9b715336f51b4f51f8e008f25ed39b51">3709a5</a></td>
		<td>4 lines</td>
		<td>Temporarily comment out memcheck UI tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=372e9715db14dd02eb149c1bb51ed476bdb2fd4f">372e97</a></td>
		<td>1 lines</td>
		<td>Set BREE</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=37ded3518a3c035537d2747fb63a4f62b36e59f1">37ded3</a></td>
		<td>6 lines</td>
		<td>Re-name to org.eclipse.linuxtools.test</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3802bd34dee954fbed4286ddaa246058eb9d90b6">3802bd</a></td>
		<td>4042 lines</td>
		<td>Add missing gprof test data</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=387481af1645c6d153e826730fca6543b1c76625">387481</a></td>
		<td>54 lines</td>
		<td>2009-04-15  Andrew Overholt  &lt;overholt@redhat.com&gt; * build-helper.xml: Add comment about checking WikiText out into your workspace.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=38b5985960668811a94ea39c77342edd0f7a4d64">38b598</a></td>
		<td>45 lines</td>
		<td>Fix about.html in binutils and dataviewers.charts.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3913883b95ae5f319541538e6d357a8a403aeae2">391388</a></td>
		<td>13 lines</td>
		<td>Make memcheck tests run with only required bundles present</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=39371ce7a44ccceb0710265d1c0f3e641dec19f8">39371c</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=39b309ece70c3b2c95aab57e7637358868721cca">39b309</a></td>
		<td>2 lines</td>
		<td>Really fix typo.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=39cb10b91d3510d765d17f4a997eb8b14a4a30ed">39cb10</a></td>
		<td>124 lines</td>
		<td>Rename site.xml to be category.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a08332a11441e9fb064a13f5bfce17e6060b843">3a0833</a></td>
		<td>67988 lines</td>
		<td>Tag 0.5.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a33a04fc26a04c75be7a1e5f3ea0a4af479b08b">3a33a0</a></td>
		<td>229 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * epl-v10.html: New file. * feature.properties: New file.  Add more description feature. * feature.xml: Use feature.properties for strings.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a345cd1e5c2934c6b4c867d2df4fd77f11f6bf2">3a345c</a></td>
		<td>30 lines</td>
		<td>Remove old releng buildExtra.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a798d5a35dd56f8b1e126d392b1933a9da865f4">3a798d</a></td>
		<td>8 lines</td>
		<td>Let Tycho find the SystemTap IDE tests itself</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a8769002693f4238a171544d060b3e12584b3c2">3a8769</a></td>
		<td>8 lines</td>
		<td>2008-12-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: See if we can get the valgrind tests to find this plugin if it's jarred.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a9c2b688a702dccb677bd12d7273fbc26af3f13">3a9c2b</a></td>
		<td>2 lines</td>
		<td>Don't use UI thread for non-SWTBot Massif tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a9fa50cd375403684e69251b3ed5a01c0644519">3a9fa5</a></td>
		<td>8 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Re-add update site information.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b1a954a98dc565e9d22882c136b74207815604c">3b1a95</a></td>
		<td>5 lines</td>
		<td>Add profiling and valgrind to the master list of modules in pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b3c93a3b3eb6de67e62ba3ba73540b11380fd21">3b3c93</a></td>
		<td>9 lines</td>
		<td>2010-04-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add OS filter for Linux (won't work on other OSes).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b3d44ad479f7c31cc32351d2244d8fb80d3038a">3b3d44</a></td>
		<td>6 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Replace qualifier for 0.1 release.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b9189d43069e2170d958f2253ed3231cffbed35">3b9189</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Fix bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b9be55d617e8c74042dde130428e571344cc218">3b9be5</a></td>
		<td>2 lines</td>
		<td>Add Incubation and &quot;Integration&quot; to feature.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3c5c5f308383ee7fba21d7469849216134d48b71">3c5c5f</a></td>
		<td>9 lines</td>
		<td>Revert &quot;Use JavaHL Subversion client adapter and don't run SWTBot tests in UI&quot; This reverts commit 3aa1ba811f53dda9d8cd112e0048858387552d35.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3d1e5539a2e6e30c08a0048ec2c0ce236d589b7c">3d1e55</a></td>
		<td>12 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Remove GProf feature.  Add newlib feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3d4c039b272f51d913ee4a55c61a3a07d2b627fa">3d4c03</a></td>
		<td>5 lines</td>
		<td>Update with changes from Galileo script.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3d5872a9adec35b4376dce1d9d9e8507d64f1309">3d5872</a></td>
		<td>2 lines</td>
		<td>One final fix for gcov -&gt; gcov.core rename</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3d5ba74a8e87f37a11c65fbcb6df35d13857ac43">3d5ba7</a></td>
		<td>29 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3d707d68e3944b42786901d6530ff82650b269ec">3d707d</a></td>
		<td>3 lines</td>
		<td>Add valgrindFiles to .gitignore files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3d72ae71c9a0548b1b6bbea1c972b3e2dfed765b">3d72ae</a></td>
		<td>15 lines</td>
		<td>Add Subclipse deps. (ChangeLog tests) to have complete dep. chain</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3d7eecabc093319914e8fd4816477c94b381c4f9">3d7eec</a></td>
		<td>10 lines</td>
		<td>Add maven directories to GCov .gitignore files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3dc9219e283b915c8f6c22ef46be923aaad8efe5">3dc921</a></td>
		<td>2 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3e0454592563d190ee674f5657fd43b0bc2fc059">3e0454</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3e21e4b6c927e94c8f76e23e09cb3f904c93423a">3e21e4</a></td>
		<td>7 lines</td>
		<td>Calculate overall source directory based on releng plugin directory</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3e4100779bb850131d7d7720fff56b89963eec61">3e4100</a></td>
		<td>8 lines</td>
		<td>2009-02-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Move JUnit from Import-package to Require-bundle to see if this fixes the JUnit4 vs. JUnit 3.x issues.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3e426ee22dadbe1cac08e1e7c791f8f717396dea">3e426e</a></td>
		<td>2 lines</td>
		<td>Temporarily comment out ChangeLog SWTBot tests due to timeout issue</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3e596f51d7f89fab5a21c4c002fd212fa8caf9d8">3e596f</a></td>
		<td>28 lines</td>
		<td>Make all POMs use 0.8.0 as version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3e84f9cee54ab77aa455ebbc1440ef0fb6cb7a11">3e84f9</a></td>
		<td>7 lines</td>
		<td>2008-05-02  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=230024">Bug 230024</a> * META-INF/MANIFEST.MF: Bump BREE to J2SE-1.5</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3e9de178e69ef541d984a4a3dd45c448ebae0c76">3e9de1</a></td>
		<td>7 lines</td>
		<td>Externalize devhelp bundle information strings, add &quot; (Incubation)&quot;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3ea1d78b7ffef1a75ea3f70ed6175f5a854dc90b">3ea1d7</a></td>
		<td>100 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3f11e3fa18a93fc8de844bced68badbe44f60c9b">3f11e3</a></td>
		<td>6 lines</td>
		<td>Use BIRT report framework (not runtime) and move to DTP RC1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3f14fba42046ffb96e3f5fa03acba634a6507481">3f14fb</a></td>
		<td>6 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3f67fe42813abc694742d2dfb846c9b543083916">3f67fe</a></td>
		<td>12 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3fe6a0cf1f8bc7ddb8a3a6d7b36fd5db846cf368">3fe6a0</a></td>
		<td>214 lines</td>
		<td>Initial checkin of releng bootstrap.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=405c7318bb37b11a802591792758dfb1f5443546">405c73</a></td>
		<td>2 lines</td>
		<td>Test with /jre for pack200</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=409ff7bd6d374c4eb337eeb6dfecb37af2d6ad06">409ff7</a></td>
		<td>60 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=40b5c15ee0ba20ef902d0f31d412221eced5391b">40b5c1</a></td>
		<td>23 lines</td>
		<td>2009-09-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * tools/linuxtoolsupdatesite-trunk.sh: Don't worry about *.xml; use *.jar instead. * tools/index.php: Initial checkin of downloads index page.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=40cbfb3e01fca53a49aff8dd0b80c2a7f82f0fac">40cbfb</a></td>
		<td>5 lines</td>
		<td>2009-05-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/linuxtoolswebsite.psf: Initial checkin. * psfs/oprofiledocs.psf: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=40cce403ddf5a4b5552d4c5fc9b046c4685b1162">40cce4</a></td>
		<td>22 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=40f43774ec4faa4612f8325aca0e77ed671660fd">40f437</a></td>
		<td>617 lines</td>
		<td>2.5.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=41373b5258ae9fa2d71a1d82138338e9ecf5e468">41373b</a></td>
		<td>2 lines</td>
		<td>Re-add callgraph to p2 repository category</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=41ed56fe12f4a00fd32fb3685eb2da13476f51ae">41ed56</a></td>
		<td>6 lines</td>
		<td>2010-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * OSGI-INF/l10n/bundle.properties: Change provider to Eclipse Linux Tools.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4211da4e0c122e0e8dcb8ff3ba34a5d72983f759">4211da</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=42878f02570c0668228603cfbc9cf13372d3747d">42878f</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4299f1bbd9ee4fb17b038b9077440f36793ddc4d">4299f1</a></td>
		<td>6 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Replace qualifier for 0.1 release.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=42b6df723b842f238948e9976db8f3bf3f944d73">42b6df</a></td>
		<td>1 lines</td>
		<td>Don't build ChangeLog tests feature on stable-0.7</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=42dd02048596bf8227e26b45c423919b61350698">42dd02</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=435f29450faad6daabc30b70d692e2f42366987a">435f29</a></td>
		<td>2916 lines</td>
		<td>Change underscores to dots in autotools doc bundle name</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=43d28995533d7b7f62f403b04c0a266f39dbca40">43d289</a></td>
		<td>22 lines</td>
		<td>Remove man site</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=43f6c402554761c2d9e4108c59ecd94500b08ef4">43f6c4</a></td>
		<td>7 lines</td>
		<td>Calculate overall source directory based on releng plugin directory</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=43f77a1b18c42817cc76a76ff9bcc97a42b2530c">43f77a</a></td>
		<td>30 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=441b5025f9284c824befd026a87f38098cde52dc">441b50</a></td>
		<td>2 lines</td>
		<td>Revert &quot;Change build order of profilling and OProfile in pom.xml&quot; This reverts commit 215f21426d08c251cffd77046b5b9a9990a4acaf.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=442ac8f6b8e3ab38e4866977ea9361e6f268025c">442ac8</a></td>
		<td>6 lines</td>
		<td>Use getTestDependency and not getDependency.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=445ab98f788abd1fcf9bc91597c678bc754492dd">445ab9</a></td>
		<td>3 lines</td>
		<td>Add epl-v10.html to build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=448afeedccfb978dd67d0a683e26c8e2bd5672eb">448afe</a></td>
		<td>36 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Initial import. * META-INF/MANIFEST.MF: Use plugin.properties.  Add &quot;(Incubation)&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=449e149dfaf8898b027bd9fe2339baafa9f16a45">449e14</a></td>
		<td>23 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/linuxtoolsAndAthena.psf: Update for new libhover feature names. * maps/linuxtools.map: Likewise. * psfs/linuxtools.psf: Likewise. * psfs/libhover.psf: Likewise. * build.properties: Revert basebuilder version switch (it didn't help).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=44e16591aacc4d41ddf150880b1ed700276470cf">44e165</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=452b5a673176acc3149be7f2ea49144d05374472">452b5a</a></td>
		<td>1108 lines</td>
		<td>Add SDK feature to ease setting of API baseline This feature will not be built as part of our regular builds but can be used by committers to set up a full local build to use as an API baseline.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4556ccb4b52fb6ff83ab8314e5c82a8a1154d6b8">4556cc</a></td>
		<td>3 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=315605">Bug 315605</a>:  [LTTng] Document exact version of liblttvtraceread that works Add reference to wiki page in help contents.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=45b44eff2e305528b4212cf5924f1133abb772e2">45b44e</a></td>
		<td>6 lines</td>
		<td>2008-11-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Update BREE to 1.5.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=45bc0227e3e51bc417761b463d467bb86b20a543">45bc02</a></td>
		<td>9 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add newlib feature so it gets built (category.xml in our releng project determines where it is visible on the update site).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=45ccbf6f792ae410a48cd3947293ff6fd69e5c4e">45ccbf</a></td>
		<td>24 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=460cd661de2050af56942a668e65c122a0faf5f9">460cd6</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=461b903626800b8a9e7a24ebfde8da0e81d37969">461b90</a></td>
		<td>12 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=465ec3a0d48a3183ee3751626ab2f048a014669e">465ec3</a></td>
		<td>2 lines</td>
		<td>Add &quot;SystemTap&quot; before name to make it explicit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=469c4b31cde6a4a8ca8b20b3f76aaef79ae01313">469c4b</a></td>
		<td>6 lines</td>
		<td>Explicitly declare all ws and arch values in LTTng feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4708b99b8fef94603dfc2a6d6d51a4b1ff3d8d51">4708b9</a></td>
		<td>2 lines</td>
		<td>Fix project name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=470ab6e6d2c0f18441f014f4c8ac57cf241b0c58">470ab6</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=477024662a36ab7bbea1a5d7af5ff94198751117">477024</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=478b84cccb997055bca999a7a1e18e6ec0608a6f">478b84</a></td>
		<td>56 lines</td>
		<td>2009-08-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285616">Bug 285616</a> * category.xml: Remove.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=47caac1809ae6921ee4c9a95773211fb5aa5384c">47caac</a></td>
		<td>15 lines</td>
		<td>2007-07-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfilePackagesScanner.java: Fix copyright. * src/org/eclipse/linuxtools/rpm/ui/editor/PackageWordDetector.java: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=48025ad29d06eaca9b94b5ec838151873a0a8fff">48025a</a></td>
		<td>46 lines</td>
		<td>2008-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: New file. * build.properties: Include plugin.properties. * META-INF/MANIFEST.MF: Add Bundle-ActivationPolicy.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4870c74dce4fcb442244904e038d56cac81b294a">4870c7</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=490b61db83ea04ff34dcecf4de5e39584521c227">490b61</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=49528d837aab8966fe9a4c57c4a47d9e0cd11bf7">49528d</a></td>
		<td>6 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Add &quot;.qualifier&quot; to ensure it gets updated.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=49811208f18e81ad356112a1d8e7f378a20f3853">498112</a></td>
		<td>297 lines</td>
		<td>Tycho-ify GCov</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=499c5dd0e598d484fa9eda99bba0bd22cd65fb92">499c5d</a></td>
		<td>14 lines</td>
		<td>Update site.xml.  Add associateSites.xml for Ganymede and BIRT sites.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=49a4344145979b31487d433f7c816bb19ae4e005">49a434</a></td>
		<td>60 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=49a5500276f8f3da5752b6f4b6ee3e8d68603386">49a550</a></td>
		<td>8 lines</td>
		<td>2009-02-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Move JUnit from Import-package to Require-bundle to see if this fixes the JUnit4 vs. JUnit 3.x issues.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=49b21bac825b63c249d7622d01ac08ccdf2e9da3">49b21b</a></td>
		<td>4 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=49c139b5d9d0b9e63cbda6afd796b8ba13b80c3c">49c139</a></td>
		<td>46 lines</td>
		<td>Comment out failing massif test for now</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4a79306ccbb4a4803fdf53271b2e6fb8f3a22a0f">4a7930</a></td>
		<td>53 lines</td>
		<td>Update to new testing.properties structure and make ${incubation}=&quot;-incubation&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4b0ff9e94405298704150bd91cfd40d9671783ee">4b0ff9</a></td>
		<td>2 lines</td>
		<td>Add qualifier to RPM Specfile Editor Tests plugin manifest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4c3663fd13d3f0d6e227211ab13c8d4c21400fb0">4c3663</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4c84c70d94ac6d31673621dad0ef9314bceb292e">4c84c7</a></td>
		<td>5 lines</td>
		<td>Re-arrange JAVA_HOME variable order.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4cc05c7f28b777f8dac821e8d4ea6d3c0da0a8e7">4cc05c</a></td>
		<td>6 lines</td>
		<td>2009-03-04  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: s/autoconf-folder/memcheck-folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4cd7e9730acdeaddc5dcdd9ca2c94e5df810bd30">4cd7e9</a></td>
		<td>880 lines</td>
		<td>Renaming in SVN.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4d1fa1b17d134e8fbd8f3251ec5863e39e36cf6e">4d1fa1</a></td>
		<td>23 lines</td>
		<td>updates-released -&gt; updates</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4d64bd2362c2d988dfc7c3378df7490b86b76d7a">4d64bd</a></td>
		<td>10 lines</td>
		<td>2009-04-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add os and arch qualifiers to fragment stanzas.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4dc8070d57895d2f12df97a27a4ed64915c60a50">4dc807</a></td>
		<td>17 lines</td>
		<td>2009-11-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/eclipse-build.psf: Correct eclipse-build URLs. * psfs/linuxtools.psf: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4de6c8a29b52c3316122e7e19548fc1d2e4a3246">4de6c8</a></td>
		<td>1974 lines</td>
		<td>2007-04-04  Andrew Overholt  &lt;overholt@redhat.com&gt; This large functionality addition was done by Alphonse Van Assche.  The discussion surrounding it is available at https://bugs.eclipse.org/bugs/show_bug.cgi?id=177220. * .classpath: Add J2SE-1.4 preferred EE. * build.properties: Add icons and templates to binary build. * icons/changelog.gif: Remove apparently unused icon. * META-INF/MANIFEST.MF: Change changelog requirement to new namespace.  Add * plugin.xml: Update class namespace for editor extension.  Update changelog extension point locations.  Add templates and preferences extensions. preferences to package export list. * src/org/eclipse/linuxtools/rpm/ui/editor/Activator.java: Add template, contextType, and macro and package completion variables. (getTemplateStore): New method. (getRpmMacroList): Likewise. (getRpmPackageList): Likewise. (getContextTypeRegistry): Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/RpmMacroProposalsList.java: Likewise. * src
 /org/eclipse/linuxtools/rpm/ui/editor/RpmPacka</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4e2a2a3818243d0b2d19cea1cc3bbc30933e59c7">4e2a2a</a></td>
		<td>7 lines</td>
		<td>2008-12-11  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Unpack memcheck.tests plugin after installation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4e2dd50bdda6903a1eda09751591d1af8b96984e">4e2dd5</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4e2dd9f66c9ce8d89324e8bc3404356f90a4e1d1">4e2dd9</a></td>
		<td>673 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4e59e31a66a39f5082811033fb5265d4a2ae7227">4e59e3</a></td>
		<td>10 lines</td>
		<td>2008-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Remove plugin.xml, add plugin.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4e77ffa0f0f3c396de352e17b7da9aafeaede765">4e77ff</a></td>
		<td>7 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * plugin.xml: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4ea04302d46dabc355c5b5058f7a7a29265b3c39">4ea043</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4ea8505afb2ac4ac4b2361d92c2f7b83cd045a11">4ea850</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Make version 0.3.0.qualifier.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4f6a2f300ea800e7f6efe72050a040aa4501b961">4f6a2f</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4f6cfa2ee8508455cf12dc002d56da2f7d09927d">4f6cfa</a></td>
		<td>11 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Initial checkin. * META-INF/MANIFEST.MF: Use plugin.properties. Add &quot;(Incubation)&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4fbf7aa2ab7ff593ccd29db9bb2c682c1c53c2cf">4fbf7a</a></td>
		<td>1 lines</td>
		<td>Add rpm to overall list of modules in pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4fc300fe056d41eea5679cca51e53e34bd7ea1bc">4fc300</a></td>
		<td>62 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4ffec360d55472246513c97eb6e021a81a17b5fe">4ffec3</a></td>
		<td>7653 lines</td>
		<td>2007-03-28  Andrew Overholt  &lt;overholt@redhat.com&gt; Re-namespace to org.eclipse.linuxtools.rpm.ui.editor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=50734e6a52772f80f35083a043645502fb5269a4">50734e</a></td>
		<td>7 lines</td>
		<td>2010-02-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.xml: Add &quot;(Incubation)&quot; and Provider.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5086bacf51a009f0fe147dc1edc9c16934ef2af9">5086ba</a></td>
		<td>4 lines</td>
		<td>Remove BUILD_INFO from build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=50a4fef5a09c035fb7c446d8725a5a8ddf1cdda0">50a4fe</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=50a81609c016fb97eb7c5388ebf8711ffcd54286">50a816</a></td>
		<td>403 lines</td>
		<td>Tycho-ify ChangeLog</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=50b4f71e8e627b1143898810768e1f5d9def6c3c">50b4f7</a></td>
		<td>3 lines</td>
		<td>Temporarily disable GProf feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=50f9d2824b4571c9c1fc36a13cd84a4f9701ceef">50f9d2</a></td>
		<td>17 lines</td>
		<td>Build p2 repository instead of update site</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5122d40185a0ec8a4ae62d75d10f2490f67044d8">5122d4</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=514919bed9877fe6c8f38e34adb779a31376cbfc">514919</a></td>
		<td>5 lines</td>
		<td>Add test.xml to binary builds.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=517ff0640c3f44ff4e93fdb39c10a48c9eb11558">517ff0</a></td>
		<td>16 lines</td>
		<td>2009-06-25  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Update dependencies to Galileo releases.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=51917190ba37773da2ab30b5438978131cbf9190">519171</a></td>
		<td>6 lines</td>
		<td>Fix JUnit dependency version to work with Eclipse 3.6 test framework.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=51a92f5735a87616c1e33dbe3d9631e9437bda8f">51a92f</a></td>
		<td>6 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5223945bf74e9ee6de13e9bc29002156ddfddd50">522394</a></td>
		<td>33 lines</td>
		<td>2.5.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=524e509b9312da690dfe663a0eb3ca82979e1b83">524e50</a></td>
		<td>2 lines</td>
		<td>Run cachegrind tests as a suite to pick up -DrunValgrind option</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=52df2f72682a8836052393ef85d31991b5b8ae75">52df2f</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=53acb7d95ddee58e21951101cc8805823f6d2bb6">53acb7</a></td>
		<td>4 lines</td>
		<td>Add test gmon files to gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=53b6692cd2838952df3af78f31bc909abb3095dd">53b669</a></td>
		<td>1 lines</td>
		<td>Add oprofile-core.jar to o.e.l.oprofile.core/.gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=53c2a3cbf803f323cf1ceda734479c965b62736d">53c2a3</a></td>
		<td>7 lines</td>
		<td>2008-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add plugin.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5403a831dbb21e504dcccffd6b5ec4843f97e88f">5403a8</a></td>
		<td>2 lines</td>
		<td>Remove extraneous &quot;linuxtools-&quot; in archive name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=541a9d9b04388ecb4e9a8b6c4b609558edf4e174">541a9d</a></td>
		<td>111 lines</td>
		<td>2007-04-10  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/URLHyperlinkWithMacroDetector.java: New class to resolve macro in URL. (detectHyperlinks): New method. (URLHyperlinkWithMacroDetector): Likewise. (resolveDefinesInURL): Likewise. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileConfiguration.java: (getHyperlinkDetectors): Use URLHyperlinkWithMacroDetector.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=54248c3c5decb72ef6f6f98e7a5d83eef620a69e">54248c</a></td>
		<td>7 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add icons to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=545945e6e842eb1aec544ed1cb99e71d22910b50">545945</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5486313128a3b74d0bdd0e44b0fc119eebc0caf1">548631</a></td>
		<td>96 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5487a1c1a4c45f80371a71a9e1db67f9f2f04b20">5487a1</a></td>
		<td>4 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=54884fd31e1a291cb8dd7368c73757907ca7af82">54884f</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5581cee90b990c66a4e6052fd0d90fea468886f9">5581ce</a></td>
		<td>207 lines</td>
		<td>Add license, description, and copyright information to feature.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=55bc98dacebe0b558eaf00747dfcadcdd4c41236">55bc98</a></td>
		<td>27 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=562060c3c4abb1d1b83558b93595c792f22da6ef">562060</a></td>
		<td>3 lines</td>
		<td>Don't attempt to run valgrind on hudson.eclipse.org (default in Tycho everywhere for now)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=564ad4bd492825ac51185bc19de30c2fe748eed7">564ad4</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=56562e5655f36fba6e06f0e416e3a3c2f19c2bc0">56562e</a></td>
		<td>516 lines</td>
		<td>Tycho-ify rpm</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=566b98c4d16221e9c45d3843b6053b9a637e0071">566b98</a></td>
		<td>164 lines</td>
		<td>Re-name EPL HTML in rpm.core</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5682e6ec5562414a880c7815e472b03ffd95937f">5682e6</a></td>
		<td>51 lines</td>
		<td>2009-12-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/changelog/core/actions/ChangeLogRootContainer.java (setDerived): Stub out inherited methods. (isGroup): Likewise. (hasFilters): Likewise. (getFilters): Likewise. (createFilter): Likewise. (removeFilter): Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=56e78be92c6322496dd164e652667f69e7a3cb5e">56e78b</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=573788b246b5598272e88687742f076362109635">573788</a></td>
		<td>66 lines</td>
		<td>2010-06-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=576b46fe1d3c2c8b562aa7372a55d08877651873">576b46</a></td>
		<td>172 lines</td>
		<td>2007-07-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * Too many files to list: Add standard copyright and license header.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=580e7a9da0f373027b9b6a1c5117a0b1e399a41b">580e7a</a></td>
		<td>9 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * plugin.xml: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5851a55491735870f66d6d872beee0683d8acf26">5851a5</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5871ca9591d696bff4a8973d3ad4b2c355872750">5871ca</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=587d861564b41e7534ba884adc0dd5e98c65e581">587d86</a></td>
		<td>297 lines</td>
		<td>Tycho-ify GCov</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=58adc3cfffaf4ae239ad4e68db1c3a2194671168">58adc3</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=58d04eb7a8af66ce1b18a6c071fd85e4c12a111a">58d04e</a></td>
		<td>36 lines</td>
		<td>Fix typo:  LinuxTools -&gt; Linux Tools</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=58e6788a04ffc37b6810e785e07f5f8697682b81">58e678</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=58fd5c0cef0ca2bff5ffa001c76e8b891e5e548e">58fd5c</a></td>
		<td>13 lines</td>
		<td>Make cachegrind tests run with only required bundles present</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5985ef372db2a7c82ddeeede58326c6ff172deef">5985ef</a></td>
		<td>7 lines</td>
		<td>346455: Add helgrind to valgrind feature https://bugs.eclipse.org/bugs/show_bug.cgi?id=346455</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5987e1a0e4e2342daa825b70aa46f805902b070e">5987e1</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=59f4a5605616fe75866120b84aad7298c1e95111">59f4a5</a></td>
		<td>11 lines</td>
		<td>2009-10-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add GProf test plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a0c2e04334c688e3cb1009706b700a795ec8834">5a0c2e</a></td>
		<td>2 lines</td>
		<td>Temporarily disable GProf feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a0e71209760ba8765bec365678a41c3c7147913">5a0e71</a></td>
		<td>6 lines</td>
		<td>Add OProfile tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a1e03ff350e116050aa8bfdb00d75bd909af894">5a1e03</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a543fa3fbd0fc65ff97bd477d6206c0556aa4f7">5a543f</a></td>
		<td>6 lines</td>
		<td>Add gcov and gprof to main list of modules to build and re-order</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a7ca6d7e67fa5acbf66c20a7fa447f12b600703">5a7ca6</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5ae81d82e37c7fc77c18548735ebc33c88822b9d">5ae81d</a></td>
		<td>2 lines</td>
		<td>Fix some project name typos</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5b2a56f1f082a772c68168c980180735fc01e7e3">5b2a56</a></td>
		<td>1 lines</td>
		<td>Add bin to devhelp gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5b5a2e9e8a6eedd39b15a16c518f2f8daeef7729">5b5a2e</a></td>
		<td>17 lines</td>
		<td>[252196] - Documentation says &quot;Red Hat ChangeLog&quot;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5b5da14f0c46315228cf15d16a5c72aefd046a8a">5b5da1</a></td>
		<td>2 lines</td>
		<td>Make parent pom have 0.8.0 version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5b730ace3b903f37d335060e3c81ae95f053e83f">5b730a</a></td>
		<td>36 lines</td>
		<td>2009-08-06  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285778">Bug 285778</a> * category.xml: Add &quot;Additional Library API Hoverhelp&quot; category.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5bc1554e5140b94db89e5f785aedd4158854f08c">5bc155</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5bc1a6be7592e30f2438b2044ad400eb7d0d1f4f">5bc1a6</a></td>
		<td>1 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181249">Bug 181249</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c155dac8f0c385b27e45e3dd3f60c1b1d3f1648">5c155d</a></td>
		<td>12 lines</td>
		<td>Update LTTng versions in POMs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c3f2d3419362e9b76523dfab2269e2a845ba4f1">5c3f2d</a></td>
		<td>1 lines</td>
		<td>Add maven artifact to rpm.ui.editor.tests gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c4425249815a005ff8456073b7e15e9a79979f8">5c4425</a></td>
		<td>541 lines</td>
		<td>Initial import of OProfile documentation plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c666859fe157921f9a4e406cfde8cbe8a8d5db2">5c6668</a></td>
		<td>5 lines</td>
		<td>2008-11-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Don't require org.eclipse.test.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c6a466b9a508450e9721c3fae6307cec6e1ffc3">5c6a46</a></td>
		<td>6 lines</td>
		<td>2008-12-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Typo in feature ID.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5cb8aee8d7c74095fbab8e94f407fcb2e512c838">5cb8ae</a></td>
		<td>1527 lines</td>
		<td>2.5.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5cb9057084951ea9b4df284e63be54bcea81a456">5cb905</a></td>
		<td>6 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Try reverting to 3.6M4 to see if tests &quot;install&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5ce9eb84f425da32ef4d77973d771ce34bd9f6b5">5ce9eb</a></td>
		<td>2 lines</td>
		<td>Put Galileo work on branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5cf1b44a45fb72efe28ab033e1c2aac0edad0d2a">5cf1b4</a></td>
		<td>8 lines</td>
		<td>Update BIRT requirements to 2.5.1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5cf9e68b02c0b1909fc2df03d1250e4f4c8f2f59">5cf9e6</a></td>
		<td>231 lines</td>
		<td>Import files missing from profiling.ui.capability on stable-0.7</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5d983bf6fc9571e82342d3f82aabd26daf73b93d">5d983b</a></td>
		<td>8 lines</td>
		<td>2009-04-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * userguide/OProfile Reference.html: Newly-generated to include image. * userguide/images/LinuxTools-0.2.0-OProfile-Screenshot.png: Initial checkin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5da9e062f2b85eefc215975197eed9a02d5ba414">5da9e0</a></td>
		<td>2 lines</td>
		<td>Move back to using CDT milestone repo for dependencies This reverts commit 8196f568f7263540b52a576f7be1d79a2fd8f747.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5e5733602dcfa22a57cff2d66896656c447fe46f">5e5733</a></td>
		<td>12 lines</td>
		<td>Update LTTng versions in POMs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5e739687ece89440fec97bcf91013fce91842f8c">5e7396</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5e7b5b80bfe55115e3731d815188bcebf611c02a">5e7b5b</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5ec2513bb6f05b415798449cf1ac063f870004be">5ec251</a></td>
		<td>23 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Update copyright years.  Add update site information.  Remove discovery tag.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5ec9363783fa2b1fe39e097a65c84ba8b1ae5f9a">5ec936</a></td>
		<td>2 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5eda49c71933ceae77b09835abcea2e6ff794c98">5eda49</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5f292b79b4a6b44d869cf569d79ce5adb579f178">5f292b</a></td>
		<td>1 lines</td>
		<td>Add rpm to overall list of modules in pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5fc5917d2ab6397cdb0cb22d5c1be5ee745641a3">5fc591</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6010310b3af4a239695ed96146c1f1db66d1119b">601031</a></td>
		<td>10 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: 1.0.0 -&gt; 0.1.0.  Add update site information.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=60237c050ad361abc8aa7fbd6ffbbfe11fa426a9">60237c</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=605652b5a9774ae8f04faa3acc8b003fba65c46c">605652</a></td>
		<td>2 lines</td>
		<td>Temporarily comment out ChangeLog SWTBot tests due to timeout issue</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6062636cd5163c526d7c8ae9afacb473f9f959be">606263</a></td>
		<td>3339 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=60696cf523b8739c32be9b6b7fcf93e91c491cb8">60696c</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=608f1070a556a78ed27ff682d0589f77c2afa590">608f10</a></td>
		<td>16 lines</td>
		<td>2009-04-27  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Build against Ganymede SR2 dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=610e87239568676ff5e93d97b9b79e06fa6ab380">610e87</a></td>
		<td>8 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Hard-code qualifier for 0.1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=611dbea09b68c23df67c036d1469ce4112d2d40c">611dbe</a></td>
		<td>6 lines</td>
		<td>Add valgrind.helgrind.tests/.gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=617f56f38692a8c1dbdaeb4f372dc813dee68cfb">617f56</a></td>
		<td>57 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Update.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=61af565bee24733b84df6466ad49681d7749dc89">61af56</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=61d788e732223db49bf028d0ee24e8e1ddbf7806">61d788</a></td>
		<td>2 lines</td>
		<td>Add &quot;Incubation&quot; to feature name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=61d91adf05871f617f2ef23fe2a1260c72f55331">61d91a</a></td>
		<td>80 lines</td>
		<td>2009-02-24  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/cdt/libhover/LibHover.java: Comment out SharedASTJob references.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=621d75c9036daef96e298b8088d5da4c1253fccf">621d75</a></td>
		<td>2 lines</td>
		<td>Use UI thread for ChangeLog SWTBot tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=626b5655065d7f029d077b467910d063a70fb3e8">626b56</a></td>
		<td>5 lines</td>
		<td>Revert map2psf change in build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=63005aff188b3afc02b3a30fdd4d7479938a9bcc">63005a</a></td>
		<td>15 lines</td>
		<td>2009-11-04  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Update dependency versions (SDK 3.5.1, CDT 6.0.1, GEF 3.5.1, BIRT 2.5.1).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6324a1adc4a44ae89bb16286d659034c813eef99">6324a1</a></td>
		<td>2 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=637f175bbe27d44dbe2c72e52423da073ed1e7c7">637f17</a></td>
		<td>11 lines</td>
		<td>2009-02-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Use Require-Bundle instead of Import-Package to ensure we get JUnit 3 and not JUnit4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=63b8ff046086e524e1cb355a4c428169ac4787de">63b8ff</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=63d185c58e8465731986b54ee3ec0f5dd124b0e4">63d185</a></td>
		<td>3182 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=63fb261b3ec840ce163e18781b379e1295712240">63fb26</a></td>
		<td>43 lines</td>
		<td>2010-05-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * lots: Merge Helios branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=640c77b5a8b52a9d5a4c22dc5645256ee9313431">640c77</a></td>
		<td>6 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6422a50f08847d22949d19e35481eef14765998f">6422a5</a></td>
		<td>26 lines</td>
		<td>2010-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * OSGI-INF/l10n/bundle.properties: New file.  Externalized strings. * build.properties: Add bundle.properties to binary build. * META-INF/MANIFEST.MF: Externalize provider and bundle name. * plugin.xml: Externalize strings.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=648025c8efcb9762a2dd9948fe8d248cc978d777">648025</a></td>
		<td>2 lines</td>
		<td>Add qualifier to RPM Specfile Editor Tests plugin manifest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=64bf22136228422959e258ee3949c9eece9cbe92">64bf22</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=64c16b3e8a118894a8a8370fddef5d1424d857e6">64c16b</a></td>
		<td>32 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Use plugin.properties for %bundleName and %provider. Add &quot;(Incubation)&quot;. * plugin.properties: Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6505a2d6af1f4a15df736aa22622520cbbf09c46">6505a2</a></td>
		<td>8 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Rename to org.eclipse.linuxtools.cdt.libhover.newlib.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=65080a63b7c6df21bbc5104647f56d4b03a8afc1">65080a</a></td>
		<td>8 lines</td>
		<td>2009-04-15  Andrew Overholt  &lt;overholt@redhat.com&gt; * doc/notices.html: Use copyright symbol.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6523977a40dbfe1ff917dae1e5e02f2e17c55843">652397</a></td>
		<td>42 lines</td>
		<td>Remove man site</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=658e2e99bb0f8f4a0579450d661dd829e2519ff4">658e2e</a></td>
		<td>11 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add cachegrind plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=66076b2aa4e1d37e49c75656242c90f29b81afeb">66076b</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=660f181cbb3cc9042d778d7e80c5d7d84ee966b2">660f18</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=661c31b5b63c6e10b0f03334b2e2b6943cfc8500">661c31</a></td>
		<td>10 lines</td>
		<td>2009-05-20  Andre Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove unnecessary &quot;.feature&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=663443c505b179cb46f05c590dbca90fb5ef13dd">663443</a></td>
		<td>4 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=348267">Bug 348267</a> - Documentation navigation arrows missing</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=664cf465e21e1bd487d0b3d402b3154fd884a3f9">664cf4</a></td>
		<td>1 lines</td>
		<td>Add target directory to SystemTap UI test feature .gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=66572c1df0077bcb3261460dbb0f6669910cd135">66572c</a></td>
		<td>7 lines</td>
		<td>2009-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Add GProf feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=66a177fa1f7043a91a3094d73c57dbb243aa9a02">66a177</a></td>
		<td>2 lines</td>
		<td>Don't bother specifying Helgrind test suite/class</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=66a5e1a76cb5a4f7bc7384ff28f3b601ad648a73">66a5e1</a></td>
		<td>62 lines</td>
		<td>Rename site.xml to be category.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=66c7bc3156a79c79236ba66017d061ad46a6ffa1">66c7bc</a></td>
		<td>8 lines</td>
		<td>2009-04-21  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Change from Linux Distros/Linux Tools to Linux Tools.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=67497acad086b7dd51b13d2582f8fa1e1ae30726">67497a</a></td>
		<td>59 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=67d75f5c7c873fb66317296c251d22652d70eb58">67d75f</a></td>
		<td>8 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=682375b94332dcf860ee31aea2782d2f101d20dc">682375</a></td>
		<td>120 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Use %featureName, %provider, %copyright, and %description from feature.properties.  Add &quot;(Incubation)&quot;. * feature.properties: Initial import. * epl-v10.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=684f482fb7cdacb352e9494ab03fa845ef72c0fc">684f48</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=68538320a42cc5e17f31dbf014e5c533b093b821">685383</a></td>
		<td>2996 lines</td>
		<td>Put Galileo work on branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6897031a837cf243ba7d5824ba37e1fedddb7550">689703</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=68a73e3910336f3adb0c815c3cd503ca721a7b52">68a73e</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=68ea7aaf046e7589ef928323ee34d5a84a1f73c3">68ea7a</a></td>
		<td>8 lines</td>
		<td>2009-10-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/eclipse-build.psf: Add -config and -feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=68f2c89927d09e729f98e5b3d99a76eb76a4385c">68f2c8</a></td>
		<td>132 lines</td>
		<td>Add build artifacts to .gitignore files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=690606cc98354bdd8d384241cce92952a9b3c8d3">690606</a></td>
		<td>2 lines</td>
		<td>Remove extraneous space in dependencies repo list.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6930a0309cfdba44f83a42d574706809ea3a61d3">6930a0</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6938af3fc72abaf4b87bf3ea4b86d4c36d08c473">6938af</a></td>
		<td>24 lines</td>
		<td>Run OProfile launch tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=695f7d73c66745c3fe420c85fef183d79621792e">695f7d</a></td>
		<td>2 lines</td>
		<td>Make version 0.7.1 on stable-0.7</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=699428a37ef7d191739aca6b84104d3d24a941b1">699428</a></td>
		<td>4 lines</td>
		<td>Fix some project name typos</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=69ccf02098081b0b36d951910e0ec0fc861c36db">69ccf0</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6a259bfe0c8aca77ee29416e525b04ddc74e33f5">6a259b</a></td>
		<td>70 lines</td>
		<td>Re-remove test.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6a49b384bd7c063ebb91e5aecb21dfb8b0746f97">6a49b3</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6a6fe134dcf5f1a19cfb92b284230563893a2666">6a6fe1</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6a8190d3e6a0c74c0cf2e96db9008b4084d5c707">6a8190</a></td>
		<td>30 lines</td>
		<td>Clean some whitespace in build.properties.  Update map file to include valgrind, oprofile, and profiling framework.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6bc6ee39beb12724152ba18ef95651af79013692">6bc6ee</a></td>
		<td>7 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * META-INF/MANIFEST.MF: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6c0ed003337ed7b717f8b7c85c798889d47293e6">6c0ed0</a></td>
		<td>2 lines</td>
		<td>Tycho-ify ChangeLog</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6c4f98da931166dc1e92be7cac8a056e6bdea296">6c4f98</a></td>
		<td>2 lines</td>
		<td>provider -&gt; featureProvider</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6ca23d05188d57e8383b699975e4c7c2072f491e">6ca23d</a></td>
		<td>4 lines</td>
		<td>Exclude building valgrind remote plugins for now</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6cb6b97f790f81ad94c305232c961c0bd3ffca55">6cb6b9</a></td>
		<td>2 lines</td>
		<td>Fix GProf project name in its pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6cc7ae06820c5861c7b7271c6baca292f19396d8">6cc7ae</a></td>
		<td>10 lines</td>
		<td>Add gitignore files for new launch plugins</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6d1a74a6389eec3f26ddf2ffb37286ec797034cd">6d1a74</a></td>
		<td>9 lines</td>
		<td>Avoid conflict with SystemTap editor bundle symbolic names</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6d4cfa97b86d78a4318c8bf0d3d1cfe121fbdaa3">6d4cfa</a></td>
		<td>3273 lines</td>
		<td>Initial import of code (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=268422">Bug 268422</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6d59fb887e08941f12397dded58886bb706b01a0">6d59fb</a></td>
		<td>58 lines</td>
		<td>2.5.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6d9c1a06cb5ea80448bf5df63694e9b60b4d0227">6d9c1a</a></td>
		<td>92 lines</td>
		<td>2007-04-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/RpmMacroProposalsList.java (getProposals): Escape &quot;{&quot; character in regex.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6dd2f36dc14d7e66938b2c181649ecae905db172">6dd2f3</a></td>
		<td>5868 lines</td>
		<td>Put Galileo work on branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6e130f0b3a76ca6745653d6e7e7ea8d94ea4c7e6">6e130f</a></td>
		<td>4 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add test.xml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6e28a161987dd8977ab855458f3238a0b4e82b03">6e28a1</a></td>
		<td>82 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6e2f7c10c0613c3d87ebb6a439396fd8a1ac3c51">6e2f7c</a></td>
		<td>46 lines</td>
		<td>2009-04-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * site.xml: Temporarily remove.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6e6c6ed84e4e367989844cfe2ea68ea1d36da213">6e6c6e</a></td>
		<td>29172 lines</td>
		<td>Tag initial import of SystemTapGUI contribution.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6ea7211e43bb58cbd7be910b230448cce56d7991">6ea721</a></td>
		<td>56 lines</td>
		<td>2009-04-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Increment version to 0.3.0 now that 0.2.0 is finished. * tools/linuxtools_build.eclipse.org_hudson.sh: Likewise. * tools/linuxtoolsupdatesite-trunk.sh: Update drops location.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6eafd6cd3fb52ef85cdbac920542a5d954b46344">6eafd6</a></td>
		<td>2 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6ee0eabfd7d6295ed6f810b4b52cf3a1f86dbe47">6ee0ea</a></td>
		<td>7 lines</td>
		<td>2009-05-21  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove unnecessary &quot;.feature&quot; qualifier in requirement of profilingframework.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f07480f8941adc4631b57745589304489f92848">6f0748</a></td>
		<td>373 lines</td>
		<td>Tycho-ify profiling</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f07cb6893252ab24bb21570003da6ddfeba9072">6f07cb</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f15ed696e8389a8bc8bf17d68c0c80076f428ca">6f15ed</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f507f0eddc0354854c7c92fee9f3d3eb36dcd8e">6f507f</a></td>
		<td>68 lines</td>
		<td>2007-04-10  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileReconcilingStrategy.java: Update the editor without saving the file. (updateFolding): Don't create a specfile instance. (reconcile): Use the same method to reconcile. (SpecfileReconcilingStrategy): Remove unneeded code. (updateEditor): Update the specfile instance of the editor. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileParser.java (parseSimpleDefinition): Cleanup. (parseComplexDefinition): Remove all existing error handler markers before parsing the file. (parse): Remove workarounds which are no longer needed. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileCompletionProcessor.java (getContextType): Fix array out of bounds bug with incomplete specfiles. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileFoldingStructureProvider.java (updateFoldingRegions): Use the Specfile instance in the editor one.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f5dbaa63a6d7df36919796f23d68ae29cfb979b">6f5dba</a></td>
		<td>22007 lines</td>
		<td>Put Galileo work on branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6fea9733d4cf863a7698a9e2112d3ec830423a53">6fea97</a></td>
		<td>12 lines</td>
		<td>2008-12-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Clean up some typos.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6ff5fa9258a5146277060e8265f79c0fb549eb11">6ff5fa</a></td>
		<td>13916 lines</td>
		<td>Merge systemtap 0.5.0</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=701904aab9455235d6d077e2698871f2cfd39845">701904</a></td>
		<td>446 lines</td>
		<td>2009-07-31  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=282028">Bug 282028</a> * feature.properties: Initial commit. * feature.xml: Likewise. * build.properties: Likewise. * epl-v10.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7057deb827f0ad8f48483578a3bdac5a55fa413a">7057de</a></td>
		<td>278 lines</td>
		<td>Revert changes made which cause test failures.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=705e479e9c70903f435876744d71883297f48ccc">705e47</a></td>
		<td>5 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.propertis: Add feature.properties and epl-v10.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7079601ce2fed2314232422a21e3ca7a1ed14dc6">707960</a></td>
		<td>4 lines</td>
		<td>Update to new snapshot of signing plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7092e342821e7502015f4b2142ee77ef2e4824f4">7092e3</a></td>
		<td>34 lines</td>
		<td>Fix typo:  LinuxTools -&gt; Linux Tools</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=70dd64d0b19460cf9a07742dd633b2260ed7bfa4">70dd64</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7102873f87c5836f6507f7a02952c7db92f7486d">710287</a></td>
		<td>207 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=71234bf249580cabd6a8a807938608950e508f2c">71234b</a></td>
		<td>55 lines</td>
		<td>2007-04-12  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181236">Bug 181236</a> * src/org/eclipse/linuxtools/rpm/ui/editor/tests/RpmPackageProposalsListTests.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/RpmMacroProposalsListTests.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/AllTests.java (suite): Add new tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=718250b05868449d025fb0b4cae83be5acbd2352">718250</a></td>
		<td>298 lines</td>
		<td>Initial import of code (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=268422">Bug 268422</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=719e03a62ca5771650cc838553a4f4b205642371">719e03</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=71aac09b47419ffa3f43caea24e989f906c5ce6f">71aac0</a></td>
		<td>98 lines</td>
		<td>2009-11-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/linuxtoolsAndAthena.psf: Removed. * psfs/athena.psf: New file.  PSF for Athena for local builds. * psfs/linuxtools.psf: Update cdt.test dependency version.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=71ccb9b2149308d71db47f9937eb5b504004416d">71ccb9</a></td>
		<td>6 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=722bb8f5a3a27b607b328f2352d115bac5265357">722bb8</a></td>
		<td>2 lines</td>
		<td>Re-add os directory to build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=725f8b48ea1588a7bf519f06635ff3ab61282ff9">725f8b</a></td>
		<td>52 lines</td>
		<td>2008-12-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Inital checkin. * feature.xml: Likewise. * feature.properties: Likewise. * epl-v10.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=727ab2e1fec82e5cccc9940524d77211837682e9">727ab2</a></td>
		<td>12 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=72adcdd7874cf04fda203c99822c5cd5aec290ce">72adcd</a></td>
		<td>5 lines</td>
		<td>Remove threadprofiler class files and add to gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=72b5dda5644687a9b0a0791765ebe3ad7a2f1229">72b5dd</a></td>
		<td>2 lines</td>
		<td>Add &quot;(Incubation)&quot; to bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=72f83a14530f6f3d4fdf5a60ead25e3be1028191">72f83a</a></td>
		<td>18 lines</td>
		<td>2008-07-04  Andrew Overholt  &lt;overholt@redhat.com&gt; * .settings/org.eclipse.jdt.core.prefs: Set to 1.5.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=72fc17dc45a3961d2c77f32df0360e15e9ea290a">72fc17</a></td>
		<td>6 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7377e564f2e03904f2d393adce8b057d5fa9e13c">7377e5</a></td>
		<td>8 lines</td>
		<td>2009-12-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=297007">Bug 297007</a> * natives/linux/opxml/move_opxml.sh: Fix release number.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=73c5cf4dec4c275f8ac35d3207f6cbd6237ee1ff">73c5cf</a></td>
		<td>6 lines</td>
		<td>2009-09-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Fix typo  in systemtap.local version variable.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=743bc8159b50eb2a83fcc24c9474863e4572d332">743bc8</a></td>
		<td>1242 lines</td>
		<td>Change underscores to dots in libhover doc bundle name</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=74a08b0fc14234b9f8a910745adaab31c2ce6ee4">74a08b</a></td>
		<td>591 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=74e00e5f6cfa1a3a38f6fff303ed0f1471dc5423">74e00e</a></td>
		<td>12 lines</td>
		<td>2009-05-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove &quot;.feature&quot; from feature IDs that changed.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=764f6e0b25d8dec2325d20505b51567c06d868d9">764f6e</a></td>
		<td>294 lines</td>
		<td>Make POM versions 0.9.0-SNAPSHOT In each pom.xml file, make the parent version 0.9.0-SNAPSHOT and make it 0.9.0-SNAPSHOT in the main (ex. autotools/pom.xml, lttng/pom.xml, etc.) POMs.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=767990e5e960973f60789f62817333f6c65970a0">767990</a></td>
		<td>7 lines</td>
		<td>2009-04-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/cdt/autotools/internal/ui/HTMLTextPresenter.java (updatePresentation): Fix compiler warnings.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=76811edef0077d87c2f1c1600a351c69f2221b33">76811e</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=76ba81a1568a0b80aa51df27c2fb4fc46fe36643">76ba81</a></td>
		<td>14 lines</td>
		<td>2009-06-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Update to newer Galileo dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=76fd4b3ca5097409d09d4e7d695adb981447dc3c">76fd4b</a></td>
		<td>4 lines</td>
		<td>Exclude building valgrind remote plugins for now</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=77158df42a60f63b9cf1ceef1759195406fab496">77158d</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=773cffa05e4d798565f976c7f22f66d6d9663d2c">773cff</a></td>
		<td>70 lines</td>
		<td>2008-01-04  Alexander Kurtakov  &lt;akurtakov@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=214217">Bug 214217</a> * src/org/eclipse/linuxtools/rpm/ui/editor/wizards/SpecfileCompletionProcessor.java: Enable auto-complete for the defined sources in the spec.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=776b1de57239063490673bbdf1512d28a2c0c63e">776b1d</a></td>
		<td>22 lines</td>
		<td>Add some environments to target platform list</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7797f7908e16e2f2908c4ba70474351eb7fc8611">7797f7</a></td>
		<td>100 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=299995">Bug 299995</a> Comment out GcovViewTest suite until failures are resolved.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=787f4c436fbd1d6caef16147c6c1587db2a9deef">787f4c</a></td>
		<td>302 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=789a5dec537b6e9f7f44690868ce4fd0187264a9">789a5d</a></td>
		<td>288 lines</td>
		<td>308881: [consumability] Enable PDE API tooling Enable PDE API tools on all projects. https://bugs.eclipse.org/bugs/show_bug.cgi?id=308881</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=78d9799de2a74d215be8384e26fda40b895143dd">78d979</a></td>
		<td>6 lines</td>
		<td>Add valgrind.helgrind.tests/.gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=78de326fdc118603029a30dd8109976848ed2b82">78de32</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7915aa6659f4ea17b9858323c5704c9c2c95da9f">7915aa</a></td>
		<td>3 lines</td>
		<td>Add cdt.core to dependencies (JDT UI was giving a &quot;&lt;class from cdt.core&gt; is indirectly referenced in STAnnotatedCSourceEditor but cannot be found&quot; error).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=79160a1284602d187a2302531af9f117472f90c5">79160a</a></td>
		<td>12 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=79239cf825bc2a6b0e8ece93f15ededde9516837">79239c</a></td>
		<td>584 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=79948bf36f7942226da83deb34ef7923f6db8f98">79948b</a></td>
		<td>73 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: New file.  Run test suites.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=79a6abe814b4ad5760b0b745140dc09180970479">79a6ab</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a0001e20e6c5c64e900db35b324ab6e52b8f5fd">7a0001</a></td>
		<td>166 lines</td>
		<td>ASSIGNED - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=282039">Bug 282039</a>: Externalize bundleName and bundleProvider in plugin/feature.properties https://bugs.eclipse.org/bugs/show_bug.cgi?id=282039</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a1be2a7b38d7ec2ecfc05b080725e231b8ec480">7a1be2</a></td>
		<td>33 lines</td>
		<td>NEW - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=314868">Bug 314868</a>: Create category for SystemTap views https://bugs.eclipse.org/bugs/show_bug.cgi?id=314868</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a23086a23d70abfb746a7b6a2b253370daec644">7a2308</a></td>
		<td>6 lines</td>
		<td>2008-12-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Typo in feature ID.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a523c7918f0060c59fe56895be80108eaf6d7ea">7a523c</a></td>
		<td>60 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a69c4afbe34289958f0439aa869a3512d44c6ec">7a69c4</a></td>
		<td>5 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add feature.properties and epl-v10.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a85a3b9bed664c66a3a29d4d5814381289f3aae">7a85a3</a></td>
		<td>28 lines</td>
		<td>Make all POMs use 0.8.0 as version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7aa9f1012b65c56b15304833493c30e81007f49b">7aa9f1</a></td>
		<td>6 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7abdda24d257a8dc10af4aba535e472ba212e71f">7abdda</a></td>
		<td>5 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Add Bundle-Localization.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7ba663ce205528957032c0ceb9fe06fc980d7487">7ba663</a></td>
		<td>8 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * META-INF/MANIFEST.MF: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7ba75cbc3bb26a1d9458630cd1c99d205a5a6cc4">7ba75c</a></td>
		<td>8 lines</td>
		<td>Let Tycho find the SystemTap IDE tests itself</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7bd6c766677de0fc97d6b77bd8133bea9e16a0cc">7bd6c7</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7bee14bed88486e73327a14cb599e82d35c7018e">7bee14</a></td>
		<td>2 lines</td>
		<td>Revert &quot;Re-enable changelog UI tests.&quot; This reverts commit 169aa1d9d3172bb5c2d010632b4c7534bb80f638.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7c03a8f7b51326d6792c53f6040c5a35d874cc00">7c03a8</a></td>
		<td>19 lines</td>
		<td>Remove unnecessary lib folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7ceb730ad641d369fa3d62746b79b36964e49148">7ceb73</a></td>
		<td>2 lines</td>
		<td>Change build order of profilling and OProfile in pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7d6a7b35b87c5056acc645efd38770e471797e94">7d6a7b</a></td>
		<td>2 lines</td>
		<td>Typo in oprofile feature URL</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7d758a50f62f59cac2dfde9b51e42ded9b35b71a">7d758a</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7d8bd87731686f43f91b2ec64225887ce5123a8c">7d8bd8</a></td>
		<td>2 lines</td>
		<td>Add &quot;(Incubation)&quot; to bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e2e6b3a4d6a8532fafe56803effcb635e1caf3e">7e2e6b</a></td>
		<td>604 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e62a7ba2fbabbe61401f61d3493c2aabfbb9e93">7e62a7</a></td>
		<td>8 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Update autotools and systemtap feature IDs.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e67aca38585bc39312eef6fe8ec37fb6fcfe7e4">7e67ac</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e7942cda013affa968d31dc87e75a280e8f5a21">7e7942</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e883a2f18b54ae088eb583c01c969b58d470b6c">7e883a</a></td>
		<td>13576 lines</td>
		<td>Put Galileo work on branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7ed06c91e868237d4042a0a13a12effb79ac731e">7ed06c</a></td>
		<td>7 lines</td>
		<td>2008-12-04  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add test.xml to bin.includes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7ee8b185820f101a97f5dc4161a8a24f24089ea4">7ee8b1</a></td>
		<td>50 lines</td>
		<td>2009-12-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Set bundle version constraint on o.e.c.resources. * src/org/eclipse/linuxtools/changelog/core/actions/ChangeLogRootContainer.java: Revert 3.6-only changes on trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7f87660c56806001789ab5ef9911f75e050dcfc4">7f8766</a></td>
		<td>2 lines</td>
		<td>Add timeout to ChangeLog SWTBot tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7f8f304c0c908282289b811b542d21d1b2c935b2">7f8f30</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7fc2ba5ad7f2730c7bfe41878d44243d1f0c7061">7fc2ba</a></td>
		<td>214 lines</td>
		<td>Initial checkin of releng bootstrap.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8014912ec4d21ccc39162bba935487d07bfe1ebe">801491</a></td>
		<td>1104 lines</td>
		<td>Tycho-ify systemtap</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8027218f78e6e86c9c5efef205430a1b4cd19cb9">802721</a></td>
		<td>207 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8049941512f0349827a36ff84aad17e67b234fe5">804994</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8080a8a97349a03e15b03aa921ad42d95309023a">8080a8</a></td>
		<td>5 lines</td>
		<td>2009-07-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove trailing &quot;-feature&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=809886fceeb4f4944a3028c00d85488e848895e8">809886</a></td>
		<td>9 lines</td>
		<td>2009-07-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add GProf feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=80db869a66e8f9445ecc8bcb3f1cf11b6c937927">80db86</a></td>
		<td>89 lines</td>
		<td>Tag 0.6 releng stuff.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=81323a339843e493230194fc2fd547916803031a">81323a</a></td>
		<td>4 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=813539c7ebb36a8fea829fde23e934c0301bbfdc">813539</a></td>
		<td>29 lines</td>
		<td>Clean up.  Add new valgrind plugins.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=813f7148bac91955884d6f36f611dffe5a835755">813f71</a></td>
		<td>211 lines</td>
		<td>Tag for 0.3.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8155f54f41f3f3ad56ac14b1bef4ed95725190a2">8155f5</a></td>
		<td>20 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8196f568f7263540b52a576f7be1d79a2fd8f747">8196f5</a></td>
		<td>2 lines</td>
		<td>Use nightly CDT site so we catch problems early</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=81bde7ec698b76e08c57114454f904fb717acd22">81bde7</a></td>
		<td>8 lines</td>
		<td>org.eclipse.linuxtools.annotatedsourceeditor -&gt; org.eclipse.linuxtools.dataviewers.annotatedsourceditor</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=82625239bad43edd8347bac24a2d123b3667c605">826252</a></td>
		<td>2 lines</td>
		<td>Fix bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8297f8b1900cf1dc65334ec505cf62d856341b89">8297f8</a></td>
		<td>1399 lines</td>
		<td>Ensure all bundles have proper about.html All about.html files are updated to be the exact same as http://www.eclipse.org/legal/epl/about.html <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=316849">Bug 316849</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8313809c38d928bca0c677a0c11b35ebc6bc0e26">831380</a></td>
		<td>2 lines</td>
		<td>See if we can get categories again with IBM JDK 5.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=836270c48462c75bbe4abee7312a86eb3ff0a837">836270</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=84684337e18ecc410e90a1038bd7f09dc4f0add8">846843</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=84d04c2112cc771d7176fa66bcb1142722b8f940">84d04c</a></td>
		<td>16 lines</td>
		<td>RESOLVED - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=253016">Bug 253016</a>: Hang when creating initial ChangeLog https://bugs.eclipse.org/bugs/show_bug.cgi?id=253016</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=84e682afbe43771161f6340187fdabd052836ab2">84e682</a></td>
		<td>14 lines</td>
		<td>NEW - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=315143">Bug 315143</a>: Put GraphingAPI preference in SystemTap category https://bugs.eclipse.org/bugs/show_bug.cgi?id=315143</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8536c537b59e78130c1e2cf6de96dc2da3f54388">8536c5</a></td>
		<td>39 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8555e41986f5c97481f7f9cc6964858f074c7c9d">8555e4</a></td>
		<td>2 lines</td>
		<td>NEW - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306239">Bug 306239</a>: Re-name 'Graphing' perspective https://bugs.eclipse.org/bugs/show_bug.cgi?id=306239</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=855c12b415fe557337d264f3d84d0de0b716c1ad">855c12</a></td>
		<td>4 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Fix provider.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8581cee21faf7beb542124d2a12c842c6f4c6463">8581ce</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=85b08970682e23d3afe75af198acdb37b6740082">85b089</a></td>
		<td>2 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=86157adc5186185bf2333dfd53bd481db3d680bb">86157a</a></td>
		<td>7 lines</td>
		<td>2009-04-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * updates-nightly/site.xml: Remove associateSites.xml now that we're using p2.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=861df05e0fdd6ddabcc2a0182046334423afac20">861df0</a></td>
		<td>2 lines</td>
		<td>typo</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=862e296e2d8b95eeefb358535f8dbb9e66eeb99d">862e29</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8656f6586c13fd418b22563eb32c1665308436f0">8656f6</a></td>
		<td>17 lines</td>
		<td>2009-12-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java (getMemberSummary): Revert Helios-only change on trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=86711c49dcb0ca104aa8523b0578bc6038386298">86711c</a></td>
		<td>314 lines</td>
		<td>2009-06-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * Fix up after erroneous SVN operation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=86905a08680b46ef4d5609dddd27af2534187329">86905a</a></td>
		<td>259 lines</td>
		<td>Add missing epl-v10.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8699e9b309eb758959c31aa3ea58d086d575e966">8699e9</a></td>
		<td>2273 lines</td>
		<td>Move to rpm/trunk/org.eclipse.linuxtools.rpm.ui.editor.tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=86b69bcea2bf80003bceb41c3fc45761ad51880a">86b69b</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8732dce63910dae10c4947d5d47d00a173f8a645">8732dc</a></td>
		<td>15 lines</td>
		<td>Ensure externalized feature provider names are used</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=88ab428118ed7004bed6d88fa86254bbb7c880e1">88ab42</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=890714afc39770f70bc487bb089232975df9fdef">890714</a></td>
		<td>4 lines</td>
		<td>Temporarily remove callgraph from the build (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=341552">Bug 341552</a>)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8926cf75b9fa73f94cb682cbdafdf4ab860e742d">8926cf</a></td>
		<td>3510 lines</td>
		<td>2009-06-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * Fix up after erroneous SVN operation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=896256e3e64be6a3ee511e4b3cd11eddf69c51ff">896256</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8980ebd45bbd7bc8dac681a9cad7e11a7ce21dbe">8980eb</a></td>
		<td>4 lines</td>
		<td>Remove test commit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=89c3cd1b0be6bfd4b91b18e2b44735642245e07d">89c3cd</a></td>
		<td>8 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Re-add update site information (sorry).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=89e30af9c0391b28cb50a758b8cb65a7dd6b96d6">89e30a</a></td>
		<td>83 lines</td>
		<td>2007-04-04  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/tests/HeaderRecognitionTest.java (newFile): Un-comment creation of specfile object. * .settings/org.eclipse.jdt.core.prefs: New file. * .classpath: New file.  Set J2SE-1.4 as EE.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8a1b4a47de06d6213b2b576a0caa3bc5d4c94858">8a1b4a</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8a3c6aa191a4c2e3d416d98a5453d9cecb48c5d4">8a3c6a</a></td>
		<td>4874 lines</td>
		<td>Initial import of code (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=268422">Bug 268422</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8a7232a7365dc9350eb62251aeb67ec149d56e94">8a7232</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8a7dbf6ef503b4b9d00119f8ed66c4027eb3ed38">8a7dbf</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8a8a9fa445a9bfbe05d64e44dbb61b6bdef86356">8a8a9f</a></td>
		<td>40 lines</td>
		<td>Copy existing .cvsignore files to .gitigore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8a93acf4434b37c40d2dd008efd16fce5521e618">8a93ac</a></td>
		<td>5 lines</td>
		<td>2009-07-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * maps/linuxtools.map: Remove valgrind.history.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8ac01a34d89e994e3e753acfd090720060ec19bd">8ac01a</a></td>
		<td>138 lines</td>
		<td>Remove ChangeLog UI tests on stable-0.7 (can be re-added later)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8b0062ba192c8b1a4632a5449d49b2466cfd4613">8b0062</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8bc389640a77f908775470214f81d17f16fb6a29">8bc389</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8bcb0d2e35af80ea3515292bcf52ce9a3941d0b0">8bcb0d</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8beeb8e453aff25eb6c377338f16439a08db3d01">8beeb8</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8c089c86c64029a58044af7ca4f5dd8faa896aac">8c089c</a></td>
		<td>10 lines</td>
		<td>Add BIRT and EMF to testing requirements.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8c210494d48d5f4c26cab82622b798acd4970f75">8c2104</a></td>
		<td>7 lines</td>
		<td>Include more files Valgrind Helgrind build.properties</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8c38a080a7bf5649eb3f19e9a5a72b6c54c76212">8c38a0</a></td>
		<td>2 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8d418c2f9af2d691c6e0ae0677e7189baea568f6">8d418c</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8e13b2f143552957a5037df7ebea2202c778e740">8e13b2</a></td>
		<td>2 lines</td>
		<td>Add OProfile to the Tycho party</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8e17a3b686715fc55b5248b829fd1517f6066483">8e17a3</a></td>
		<td>7 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Unpack cachegrind tests plugin so test.xml is present.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8e33308c3c829c1c6e795c3466e32f4dbfc635cb">8e3330</a></td>
		<td>9 lines</td>
		<td>2010-05-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/oprofile/core/oprofile.properties: Clean up build/install instructions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8e5af6f9d0c36081f2d8c30f7fd8e07af9ff1c90">8e5af6</a></td>
		<td>2314 lines</td>
		<td>Create 0.3 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8e6e284055b961b090b801317411c80b7589fb03">8e6e28</a></td>
		<td>4 lines</td>
		<td>Use external JVM for local ant launch of releng build</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8e7e0abca6f0461f2291dcc937927e0cb0587bba">8e7e0a</a></td>
		<td>2 lines</td>
		<td>Remove custom OSGi environments in pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8e871dd17d481b9cfa0e190f35a14a320069ff4e">8e871d</a></td>
		<td>3 lines</td>
		<td>Add RPM Stubby</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8ea22d6c0c260a2a23dbfbe754e902b091c1d223">8ea22d</a></td>
		<td>40 lines</td>
		<td>Clean up site.xml a bit.  Add CDT to associateSites.xml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8eae3684d4e6c499dfa6ccbebc7df18cd20a2240">8eae36</a></td>
		<td>13 lines</td>
		<td>Sync with CVS</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8eb65b4ad180d5490ac1c376d88c2d2697d7d746">8eb65b</a></td>
		<td>6 lines</td>
		<td>Don't both specifying cachegrind suite; just let Tycho find all tests to run</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8eb9da235e516ec5f72bf315b67f266584244045">8eb9da</a></td>
		<td>1 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181249">Bug 181249</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8eedddd2d04f3cb71230964bd82b246abdd1e336">8eeddd</a></td>
		<td>11 lines</td>
		<td>Make massif tests run with only required bundles present</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8efee42eeb6ad604b64b20da2332e1c1440d27a4">8efee4</a></td>
		<td>3 lines</td>
		<td>Update</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8f03995eb686b1a9a8d96b363ed82f32932fa2ed">8f0399</a></td>
		<td>3705 lines</td>
		<td>Remove erroneously-placed libhover files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8f0c3b2a00a81f223971bd769fcc510770450d85">8f0c3b</a></td>
		<td>429 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8f330511c75adc638910b1ae1699aadd4bc8d13a">8f3305</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8f38e2b961ddba4caa156ba39bd77714076ffe1a">8f38e2</a></td>
		<td>6 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Add qualifier back to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8f5b965a3dfb9ff502dcb61eee2790e29196b182">8f5b96</a></td>
		<td>4 lines</td>
		<td>Make actual feature.properties fixes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8fa88878c67e6aef259a5558214b1f67011994b7">8fa888</a></td>
		<td>13 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Try reverting to 3.6M4 and other deps to see if tests &quot;install&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=900ba5d6857a880801b85822a88ead8cca80f317">900ba5</a></td>
		<td>2994 lines</td>
		<td>Put Galileo work on branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9021dc16ac46b773b3ce331f45923f74b8b1f692">9021dc</a></td>
		<td>4 lines</td>
		<td>Temporarily remove lttng from build</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=90370cb4b9866c40ceb192277f02e6f4ced256fd">90370c</a></td>
		<td>119 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Use feature.properties.  Add &quot;(Incubation)&quot;. * feature.properties: Initial checkin. * epl-v10.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=913c3f31e2fd74a4993b28eda0984c0947aa76d4">913c3f</a></td>
		<td>69 lines</td>
		<td>Add suite and test.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=915325fa2e2626ae445551745a677dd7e9bc50da">915325</a></td>
		<td>10 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Add &quot;(Incubation)&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9165dfaae434753d1da79207907ff572b8da9ce5">9165df</a></td>
		<td>2 lines</td>
		<td>Don't use UI thread for non-SWTBot Massif tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9172cb96a12716c26536045098d52d0a3e356c78">9172cb</a></td>
		<td>29 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Use bundleName and provider from plugin.properties. Add &quot;(Incubation)&quot;. * plugin.properties: Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=917b8560d8db4f70ea72f58b174494e0d5a7fc5b">917b85</a></td>
		<td>207 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=918dc9dd3a25ae733cb2a48579fb09e7364c8f84">918dc9</a></td>
		<td>8 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Re-added update site information (sorry).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=919ac727d4d9fc214472b4aedea201ee20bedca4">919ac7</a></td>
		<td>1 lines</td>
		<td>Activate Helios profile by default on stable-0.7 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=91cb118157e9622f4bf73e0fe4a92635d99121ee">91cb11</a></td>
		<td>56 lines</td>
		<td>Re-add test.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=91e2e81f2efce5c7722ca3018714ec7c1c4c4556">91e2e8</a></td>
		<td>3 lines</td>
		<td>Re-enable GProf</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=926b6c6740dc686937635c3c32cafbd64b194c31">926b6c</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=937ee3a53a8f11710f4cce0408952e10e4e39325">937ee3</a></td>
		<td>3413 lines</td>
		<td>2011-01-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/: Re-naming directories to account for refactoring.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=948badb9bac758884685bf8196795f0890bc1738">948bad</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=951ed5f758bf8b56a4d98ef20fd68a4d4566fefd">951ed5</a></td>
		<td>19 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Externalize a few strings and update. * feature.properties: Update a few properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=957db04ebee2f488ce1338e65849fa8152328a02">957db0</a></td>
		<td>8 lines</td>
		<td>2008-12-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Clean up some typos.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=959216a7141ac337fb5f7881dd3d46e5c830678b">959216</a></td>
		<td>8 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Rename to org.eclipse.linuxtools.cdt.libhover.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=95aa79952208161c1fbbcd2e6f9f2db66d8be464">95aa79</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=967249b2e5ec4f549e8bb67e17010a3fa5d1238f">967249</a></td>
		<td>14 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Use feature.properties.  Add &quot;(Incubation)&quot;. * feature.properties: Initial checkin. * epl-v10.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=96f67239f8a2075cd036395aeebf9ef3eea726d2">96f672</a></td>
		<td>1 lines</td>
		<td>Remove CDT's copy of org.eclipse.test.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=973ec081e5f8e1ebd929149df9bc43b0884e993c">973ec0</a></td>
		<td>20798 lines</td>
		<td>Tag Linux Tools 0.2.0 release.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9740aa7b9c1018e669d0956c076524e96f6bdbbd">9740aa</a></td>
		<td>19 lines</td>
		<td>Remove pre-built opxml binary.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9772279cf952e6a1603e197af518deb031ca7b22">977227</a></td>
		<td>4 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9791d44bf9922bc50779b06cc98719b49f0d070c">9791d4</a></td>
		<td>56 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Move to valgrind.test-feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=97d7660ae46b581bcb6497fe9e9d5c4e9e817e2f">97d766</a></td>
		<td>2 lines</td>
		<td>Fix bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9803dd5a6cecd8d10e0fe8bc5fd544d9b50b72dd">9803dd</a></td>
		<td>4 lines</td>
		<td>dashTools -&gt; ${relengCommonBuilderDir}/tools/scripts</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=985429f1c4d99f6c7354c85334044fa27308d4d6">985429</a></td>
		<td>2 lines</td>
		<td>Try unpacking CDT into dropins/cdt for test run.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=985da3bcde4ac6394a17515a245fb112b862be22">985da3</a></td>
		<td>10 lines</td>
		<td>Remove OProfile tests' unnecessary dependency on profiling tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=987d6e30db12fb12083838d44d7abd0441d537fd">987d6e</a></td>
		<td>204 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html. * feature.xml: Use licenseURL property.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9899d277c776e26749bbeb25c3607eb35ec4900b">9899d2</a></td>
		<td>1200 lines</td>
		<td>Tycho-ify systemtap</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=98f2ecc3320c5d71299391de8578304501db58c7">98f2ec</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=996484530e8002a9461667e389c1e50fd72ddfff">996484</a></td>
		<td>7 lines</td>
		<td>2008-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add plugin.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=998362017bec3a03550492d0aca34e4319db56da">998362</a></td>
		<td>59 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9984eaf0f12eb3a036fda2baf742b4c97a3bfed5">9984ea</a></td>
		<td>6 lines</td>
		<td>Explicitly declare all ws and arch values in LTTng feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9a3151c28b7874adcb744afd0d5293ae60f3b23e">9a3151</a></td>
		<td>3 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9ab4a357d2124aca1570f4042e877a3bc07b75f4">9ab4a3</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9acaa4c320488ef5b50a7628784fcdea0f6b9005">9acaa4</a></td>
		<td>17 lines</td>
		<td>Build p2 repository instead of update site</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9ae86ea18e5a1dc669d9d92cf99f23fcb4db0be8">9ae86e</a></td>
		<td>1 lines</td>
		<td>Add Helgrind gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9afac610618ff4bc0d1cafa0aee24adb45ca3a63">9afac6</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9afe7df979b8bcdf6e1b6866d6ab1fe8b9a7a8f5">9afe7d</a></td>
		<td>12 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9b2f0d89005e299bb95251db7d23cdc27258ffc3">9b2f0d</a></td>
		<td>7 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Unpack cachegrind tests plugin so test.xml is present.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9b453a2b0059ced0c1f7681bd8bccbbf375f2de8">9b453a</a></td>
		<td>297 lines</td>
		<td>Tycho-ify GProf</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9b5dbbcd9e20bd45c1fd9d68a960a1b30ce29d29">9b5dbb</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9b9f65cb4d7753c9ecaa748a5297ebaa932ecb00">9b9f65</a></td>
		<td>6 lines</td>
		<td>Add suite and test.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9bd52b4bc1da5295c6bff2ed1a6ac46adb9b57d9">9bd52b</a></td>
		<td>8 lines</td>
		<td>2008-12-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: See if we can get the valgrind tests to find this plugin if it's jarred.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9c1fcebe0f6bc54e560887506f16e8496712358e">9c1fce</a></td>
		<td>4 lines</td>
		<td>[252196] - Documentation says &quot;Red Hat ChangeLog&quot;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9c4cd5c6a7daf5124bb257d444f41cc891f643f0">9c4cd5</a></td>
		<td>7 lines</td>
		<td>2010-04-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Restrict to os=linux.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9c7d17b5966767d67082881da63a8792cc9f6c94">9c7d17</a></td>
		<td>669 lines</td>
		<td>Tag 0.6 releng stuff</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9ce657539bf2bc8f7af1c4b4b6d20843b01db9d8">9ce657</a></td>
		<td>1 lines</td>
		<td>Add oprofile-core.jar to o.e.l.oprofile.core/.gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9cee5c1eb2cb40e61788af8807ac44984b7cbb71">9cee5c</a></td>
		<td>7 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove Linux requirement to see if it then gets included in all feature. Added update site information.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9d253b2bbfb117c802f740da93a6d6658f64d39c">9d253b</a></td>
		<td>2 lines</td>
		<td>Bundle-vendor:  Red Hat -&gt; Eclipse.org</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9d416a0b1bbe09e830abc361a95cf6caa4eb9f5c">9d416a</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9d959c28ebe3a9b04640bdec476c18b5f8b0e2bb">9d959c</a></td>
		<td>2 lines</td>
		<td>Add OProfile to the Tycho party</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e12c677f981773641a62aa71ab75ae7e41ef959">9e12c6</a></td>
		<td>2 lines</td>
		<td>Remove &quot;.qualifier&quot; from TMF feature import in LTTng feature.xml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e62c3d73acb193455e09b2a1d3ef52eb3313db9">9e62c3</a></td>
		<td>4 lines</td>
		<td>Temporarily remove callgraph from the build (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=341552">Bug 341552</a>)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e87e13254b766d4e634c039392ffff26babd7e5">9e87e1</a></td>
		<td>6 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Update description.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9ead2efd94ddf454cede1101d957149b566ba0d5">9ead2e</a></td>
		<td>22 lines</td>
		<td>Add maven artifacts to ChangeLog gitignore files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f06b186847055901ad3e3887acca1aab44c7e41">9f06b1</a></td>
		<td>11 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add cachegrind tests plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f08009d6530a0913fde18d899562d4ffe122987">9f0800</a></td>
		<td>3 lines</td>
		<td>Don't attempt to run valgrind on hudson.eclipse.org (default in Tycho everywhere for now)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f3b78cf6d05f3d84d89fcdb362bd750ee0cccc8">9f3b78</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f671e6980198c831d2322b06bbf2a06ef3315ea">9f671e</a></td>
		<td>2 lines</td>
		<td>Match SystemTap version in POM and feature.xml Make version in o.e.l.systemtap-feature/pom.xml match that in feature.xml.  0.3.0 -&gt; 1.2.0.  Related to <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=352099">Bug 352099</a>: Fix SystemTap feature version to match previous home https://bugs.eclipse.org/bugs/show_bug.cgi?id=352099 * systemtap/org.eclipse.linuxtools.systemtap-feature/pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f8ea252963e769bf49e22586f0ed2e45f1cc14e">9f8ea2</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9fd7054528cc85736fbdc58987b0d6a4c83c1f16">9fd705</a></td>
		<td>22656 lines</td>
		<td>Branch for Ganymede.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9ff649a26be2a14c1fb70288a59a93b7afbcf7b4">9ff649</a></td>
		<td>66 lines</td>
		<td>2010-06-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a00ac69a3776cb101840141c96ecd3f8875060af">a00ac6</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a02b3866a1baf32c4e841743eba70225edfeb0d9">a02b38</a></td>
		<td>12 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * license.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a09266c0a23d7e74e925786ca2025175588d0bbb">a09266</a></td>
		<td>10 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add update site information.  Add qualifier back to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a0aed7b855b0d560f17618470515232f9347882b">a0aed7</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a101c3de05970d9742417b5a2704d6f88f161e6e">a101c3</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a1464d0cb2df666734082b895060f572914b7dcd">a1464d</a></td>
		<td>8 lines</td>
		<td>2009-08-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285616">Bug 285616</a> * category.xml: Add pack200=true.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a181a530684e6b81d5242e71422e0108b36228de">a181a5</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a1a0d7d30638454f896ccc025ee90007895c6f23">a1a0d7</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a1de90790a9d6b6161b3a6f975ca6c2b4e2742ae">a1de90</a></td>
		<td>2 lines</td>
		<td>Add timeout to ChangeLog SWTBot tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a1e55691cf6402c8340c76fb3d4fde1063960846">a1e556</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a23aeacc459dccd2d010c8eb5ac193c83781cd5f">a23aea</a></td>
		<td>2 lines</td>
		<td>Add missing space in how-to-build-opxml instructions dialogue.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a244254763efde370d5ca7588a988261d7aafa64">a24425</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a2719dcd415da514e6144577c26553daa69cfc72">a2719d</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a28790d7c755db2069a9f93d2c4d44f68090c1fd">a28790</a></td>
		<td>2 lines</td>
		<td>Add missing version to man POMs Add version entities to man parent POM and man feature POM</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a29397dee633397cd9443bb7adbc0476c48bdd42">a29397</a></td>
		<td>8 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove .feature from name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a298a40870544044f198c700b796fd2633f8a2e4">a298a4</a></td>
		<td>3 lines</td>
		<td>2007-04-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * .classpath: Add (#180822).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a2a93f5266f1494bd4ff9e519e5afbb12692e801">a2a93f</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a2fdbb57e7d0d5dcf5f8e95a48a1cac50d479192">a2fdbb</a></td>
		<td>10 lines</td>
		<td>2009-08-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Remove references to nightly update site.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a3c32a533639f8d1228c9f9116733101e13937f8">a3c32a</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a43f7a3c5406d10110f5d741f5488bfdb4ebd2c8">a43f7a</a></td>
		<td>73 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: New file.  Run test suites.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4495da3ea4d3bf0b8b607fed95a682cf36277f0">a4495d</a></td>
		<td>194 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright text. * license.html: Update HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4ab7b47352a9db70bfade02c42b9a08624205b0">a4ab7b</a></td>
		<td>645 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4be5407dbdbc6fcd73dc76a2d3b11cba0340188">a4be54</a></td>
		<td>837 lines</td>
		<td>Tycho-ify valgrind</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4c0c2bac61d5912c747ff35bf2016b86721e6ec">a4c0c2</a></td>
		<td>2318 lines</td>
		<td>Create 0.3 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4dde7c696a2c68402ca02f0bd253fc3e41824a0">a4dde7</a></td>
		<td>12 lines</td>
		<td>Don't have output if unnecessary; never overwrite local files; ensure file exists before trying to unzip it; remove pack.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a50a26a6ef0d9c2f7750997a369da66bf1e4ef5a">a50a26</a></td>
		<td>15 lines</td>
		<td>Sync with CVS</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a51f91c67be102daf4865dc3e3e65265d3422cc7">a51f91</a></td>
		<td>288 lines</td>
		<td>Remove erroneously-included lttng files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a52ff252a544085250350d939e36c51b3d661f88">a52ff2</a></td>
		<td>12 lines</td>
		<td>2008-10-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Update version to 2.6.3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a53c6872418ad6e43b53afd413c4b27a1e460004">a53c68</a></td>
		<td>2 lines</td>
		<td>Remove custom OSGi environments in pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a5c3b7ba1f2bb149e18b26524e53b7fd5dd75b22">a5c3b7</a></td>
		<td>4 lines</td>
		<td>Add autotools feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a66cdd09dc3ffef3b474503aa12d74533e0ff661">a66cdd</a></td>
		<td>13 lines</td>
		<td>Add org.eclipse.test and org.eclipse.ant.optional.junit</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a6a5e2598ad8ae57178480399bc0480d8619ba16">a6a5e2</a></td>
		<td>37910 lines</td>
		<td>Merge valgrind 0.5.0</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a7162de8e61cb7f0eaaf84a3c7b066169e9ca4e7">a7162d</a></td>
		<td>45636 lines</td>
		<td>Branch for 0.3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a7224f9837e19cd6e3d689d3bdbc5afea5252d61">a7224f</a></td>
		<td>32 lines</td>
		<td>2009-08-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Linux Tools Features -&gt; Linux Tools; alphabetize.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a7373a07b0e7b86018e72a5a045add739d652644">a7373a</a></td>
		<td>6 lines</td>
		<td>Remove BUILD_INFO from build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a7df15d6b62e252be3a06f70b095c9db27584668">a7df15</a></td>
		<td>20 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a7e17e7b540881e769205a1746b3de66235aeec3">a7e17e</a></td>
		<td>21 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * maps/linuxtools.map: Use trunk for test plugins that were previously using Helios branches.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a7efd47b62aa97cb3263f16dcc2034060a0a2621">a7efd4</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a82a48ab5473063fbd2e2ab29a5d8b6a3ff4329c">a82a48</a></td>
		<td>2 lines</td>
		<td>Add timeout for memcheck tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a8dd5e00b6b816e9cacb08cecb9f9e18239fa251">a8dd5e</a></td>
		<td>2 lines</td>
		<td>Make valgrind version 0.0.0 in category list</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a96e256e27892e8a4cb2c237d0c1a1985c8999ee">a96e25</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a99cfbe187a7e5e7ee74be76c9c5947e6309b97b">a99cfb</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a9d4200753ef1c92186cc42784ad9950ee7fbc02">a9d420</a></td>
		<td>8 lines</td>
		<td>2009-10-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add GProf feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aa4432d8d5fa30371f066d0f3b845ef826f7c3a1">aa4432</a></td>
		<td>66 lines</td>
		<td>2007-04-14  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=182302">Bug 182302</a> * src/org/eclipse/linuxtools/rpm/ui/editor/PackageWordDetector.java (isWordPart): Detect packages contain '_' char. (isWordStart): Add support for packages begining with ' ' | ',' | '\t' | ':' char. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileParser.java (parseLine): Fix tags parsing. (parseSimpleDefinition): Don't show warning about acronym error. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileScanner.java (sections): Add %clean and %check section. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfilePackagesScanner.java (PACKAGES_TAGS): Add Requires(hint) (SpecfilePackagesScanner): Detect packages that begin with ' ' | ',' | '\t' | ':' char. Add comment support.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aa5e9c0be22b5271d752319ece4671948dc62d97">aa5e9c</a></td>
		<td>3 lines</td>
		<td>Update testPluginsToRun</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aab71b2269085c7a6365a4f403ccc078db2edae3">aab71b</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aac88f10d3ce7a6bfd7c44ce1ecf74b80d666aed">aac88f</a></td>
		<td>9 lines</td>
		<td>2010-05-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/oprofile/core/oprofile.properties: Clean up build/install instructions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aad7edfe11e9ca6cc286b9fdb5b3c9252cdcae08">aad7ed</a></td>
		<td>245 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html. * about.html: Remove. * feature.xml: Use licenseURL property instead of explicit URL.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aaef8c800b4bd8c2a95cbcea943337d1c10d3858">aaef8c</a></td>
		<td>125 lines</td>
		<td>Update from dash CVS.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ab0856da1f50f5faea588adef0546e6c80158c87">ab0856</a></td>
		<td>6 lines</td>
		<td>2008-10-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Update version to 2.6.3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ab161f4e3e1813ef646aeebcaadab126c1fe822c">ab161f</a></td>
		<td>7 lines</td>
		<td>Fix up signing based on comments on <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=347041">Bug 347041</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ab3526161f279e586d7ca414751b85cbf58cf1a3">ab3526</a></td>
		<td>2 lines</td>
		<td>Remove extraneous space in dependencies repo list.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ab3f04e7ddcbdc4fc3ddea92ef0f2de54761073e">ab3f04</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ab8db170f21258e1f038a86999f29ead4e7ee0b3">ab8db1</a></td>
		<td>62 lines</td>
		<td>Rename site.xml to be category.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=abb8be6f8c07a926de0c8f2de469dbebf3566ab1">abb8be</a></td>
		<td>7 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * plugin.xml: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=abf0260953dcd42bf2fa2afae0f293b27afa1ec8">abf026</a></td>
		<td>16 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add valgrind, profiling framework, and oprofile features.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ac08f52afae93829ca82a96883f3e5a7486f2e02">ac08f5</a></td>
		<td>4481 lines</td>
		<td>Initial import from sourceware.org.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ac2bf3c8eb0a5183b9898cb159c9e1bd849bf6ab">ac2bf3</a></td>
		<td>2 lines</td>
		<td>Add &quot;qualifier&quot; to trunk</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ac66676738d863b6c1225014a31298a30e60bee0">ac6667</a></td>
		<td>4 lines</td>
		<td>Remove BUILD_INFO from build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=acd5355c5704f6903f5b09da844f2646b88b829f">acd535</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ad79a78ad4edd446998e254f2680c6c359f84c4c">ad79a7</a></td>
		<td>245 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html. * about.html: Remove. * feature.xml: Use licenseURL property instead of explicit URL.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=add08cf9323d20104ddca293826e48eefe231816">add08c</a></td>
		<td>2 lines</td>
		<td>Don't bother specifying Helgrind test suite/class</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=add8d0ed5fc03e27b9e208ce0dd17fad6a248041">add8d0</a></td>
		<td>27 lines</td>
		<td>Add script to be used in Hudson on build.eclipse.org.  Remove unnecessary stuff in build.properties and clean up a bit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ae0ad841ed6331538759da349ac268da15cd4f1d">ae0ad8</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ae2849fe7bd7a49250975f31fed32c3f61884570">ae2849</a></td>
		<td>9 lines</td>
		<td>Fix map for renamed feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ae44b8d74eb5ccd4d245a93277bef84a7fbe4ffc">ae44b8</a></td>
		<td>45 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ae506039efe1043a2c659c8d0772f7a28229e2dc">ae5060</a></td>
		<td>2 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ae82c7febdfa0f6479a5848d041045b6a24fe06c">ae82c7</a></td>
		<td>6 lines</td>
		<td>A few more fixes for .gcov -&gt; .gcov.core rename</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ae9d7e90c55daa101f47f349e36a9d8e3b52d482">ae9d7e</a></td>
		<td>2 lines</td>
		<td>Use tag for releng project.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aee6bba4644ef070b7a80612b2c6c661594365bb">aee6bb</a></td>
		<td>25 lines</td>
		<td>2009-10-29  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=292172">Bug 292172</a> * natives/linux/opxml/move_opxml.sh: Update release number.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aefd962b300e0919724d8b3556b9f9e51743c086">aefd96</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=af2f137e7fa1a72517120190bb15e7b2223ce20e">af2f13</a></td>
		<td>5 lines</td>
		<td>Fix typo in copyright year</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=af5a427bdec49362934589648b508f6137091763">af5a42</a></td>
		<td>16 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=af60e28ace48f8d89dddd2ff02cdd1f97da331f4">af60e2</a></td>
		<td>30 lines</td>
		<td>Remove old releng buildExtra.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=af956215c565d1840aaf4c4901b2a26f83f4a941">af9562</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=afacfd9d2c4c984c214839ec12519a2a11e0f527">afacfd</a></td>
		<td>1 lines</td>
		<td>Remove CDT's site.xml during tests to avoid issue with dropins.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b095bf9763a03c9d462b7ce45bfe1360f17c7ea7">b095bf</a></td>
		<td>204 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b121ebe5ad9b9261545138c10c5af2fb1eb7be37">b121eb</a></td>
		<td>12 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b12cf435211f378f8363682a7404c8de4d41affc">b12cf4</a></td>
		<td>2 lines</td>
		<td>Put Galileo work on branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b13c82a1d0578190f8fb8753fe8451a3b9a32e7f">b13c82</a></td>
		<td>12 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Use translated BundleName and provider. Add &quot;(Incubation)&quot;. * plugin.properties: Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b14e4d08cf9ea9a5927dcfb23abf224d92d25803">b14e4d</a></td>
		<td>13 lines</td>
		<td>2010-05-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Update to latest Helios drops of dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b16b029deb8def406a2947f954fcadea7ff917f7">b16b02</a></td>
		<td>241 lines</td>
		<td>Branch for 0.6.x.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b17ac0316c10692075f2aa2765f9baff202c4817">b17ac0</a></td>
		<td>7 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove Linux requirement to see if it then gets included in all feature. Added update site information.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b188a4860e7893691eee8ef499319fe9574820e8">b188a4</a></td>
		<td>19 lines</td>
		<td>2008-11-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: New file to drive tests on build.eclipse.org.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b19196f2b51380a59fa56c4c5a95b43feedc0549">b19196</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b1f9bd9bb9e70656f0bf7ce165c240e1b6a29ef7">b1f9bd</a></td>
		<td>6 lines</td>
		<td>Re-add os directory to build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b1fb86305b00bc14cc67503b522b8b69c75710ea">b1fb86</a></td>
		<td>527 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b2d0dfa7a6daf1f9da954b2e37965614fd4ae87f">b2d0df</a></td>
		<td>106 lines</td>
		<td>Switch to 0.2.0 branches as we prepare 0.2.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b360785354bee88d4ce01789fcdfe82db5ea9058">b36078</a></td>
		<td>243 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b3bbe4c8600a46b62b2432cdf46f274321a2b58d">b3bbe4</a></td>
		<td>1 lines</td>
		<td>Set version to 0.2.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b3feec28ce7678392393af565ffb1075db0b0e3c">b3feec</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b40e6a47f908e7ff2ee99ab90e762181f3e1fe49">b40e6a</a></td>
		<td>287 lines</td>
		<td>2007-04-08  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileScanner.java: Remove unneeded RPM tags, these tags are now taken into account by SpecfilePartitionScanner. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfilePackagesScanner.java: New file. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfilePartitionScanner.java: Add __spec_packages partition type. Use SpecfilePackagesScanner.PACKAGES_TAGS. (SpecfilePartitionScanner): Add new scan rules for the__spec_packages partition. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileHover.java: Add hover support for RPM packages. (findPackages): New method. (getHoverRegion): Add support for findPackages() method. (getHoverInfo): Get RPM package hover information. Rename macroName to currentSelection to reflect the current code. (getHoverControlCreator): Use HTMLTextPresenter as information control presenter. * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileConfiguration.j
 ava: Add support for the RPM packages content </td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b4326cd1dab306a95977d0f08df9b6be77777564">b4326c</a></td>
		<td>2 lines</td>
		<td>Match SystemTap version in POM and feature.xml Make version in o.e.l.systemtap-feature/pom.xml match that in feature.xml.  0.3.0 -&gt; 1.2.0.  Related to <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=352099">Bug 352099</a>: Fix SystemTap feature version to match previous home https://bugs.eclipse.org/bugs/show_bug.cgi?id=352099 * systemtap/org.eclipse.linuxtools.systemtap-feature/pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b456038aeaf3ba69e1f7da5d494080ffaad3f211">b45603</a></td>
		<td>184 lines</td>
		<td>Tag for 0.3.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b4d231f7d4c43951fb4ee28679741876eff97f53">b4d231</a></td>
		<td>2 lines</td>
		<td>Remove CamelCasing in plugin name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b5511d8a4ac613982272f53d8e63bf6f3231e5e8">b5511d</a></td>
		<td>22 lines</td>
		<td>Reflect _docs to .docs change in remaining references.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b5dab03479a9d38f70fffc936e8276c9e51f858a">b5dab0</a></td>
		<td>40 lines</td>
		<td>Don't run OProfile core tests on Hudson. The OProfile core tests require the OProfile kernel module to be loaded.  Since we can't guarantee this will be the case on the Eclipse build infrastructure, we don't run these tests by default. The mechanism for excluding them is the same as the OProfile launch test suite.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b6355d9d1721ade8448ada805965edaa2b4bc024">b6355d</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b68b5264e1babf402cac78645693dbfce65865a7">b68b52</a></td>
		<td>3845 lines</td>
		<td>Tag initial contribution.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b6da28f06da5a64ff9a65ed75143e5910326c3de">b6da28</a></td>
		<td>2 lines</td>
		<td>Only .gitignore the releng site's target directory</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b6f1e62a07a5f604be10e91eccb9da695693a183">b6f1e6</a></td>
		<td>9 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Update.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b73797b1119a0622dd0956586271498363c74cf0">b73797</a></td>
		<td>9 lines</td>
		<td>2009-04-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * tools/linuxtoolsupdatesite-trunk.sh: chmod and chown to fix <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=272328">Bug 272328</a>.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b796fbfff54cc69eabe6abbde9376e10650a9439">b796fb</a></td>
		<td>2 lines</td>
		<td>Make parent pom have 0.8.0 version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b7dbc1a1e271307f9afba1a6f0b1045930c7bfd1">b7dbc1</a></td>
		<td>6 lines</td>
		<td>Add org.eclipse.test and org.eclipse.ant.optional.junit</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b7e20b2cb8122f5c27e9f8ab47a131c56e8d5297">b7e20b</a></td>
		<td>7 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add icons to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b868986ac1024b6a711f0ce7fd64ab129a3fdb38">b86898</a></td>
		<td>280 lines</td>
		<td>x68_64 -&gt; x86_64</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b89b1d53157968568f9788800f98dff69bdb910b">b89b1d</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b93a28cb870d3c167629d5b7615268ae95f7fb99">b93a28</a></td>
		<td>6 lines</td>
		<td>2007-04-05  Remy Suen  &lt;remy.suen@gmail.com&gt; * META-INF/MANIEST.MF: Set the Bundle-RequiredExecutionEnvironment attribute to J2SE-1.4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b9505bda5a40b0c7cf9a361c4fe89dc8f54c31e6">b9505b</a></td>
		<td>7 lines</td>
		<td>2009-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Set noclean=false (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=292911">Bug 292911</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b95db512ce7664af4714394db229f74a85b7ae11">b95db5</a></td>
		<td>204 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b96a5a2c9f2c37d2a63ae3de3d0c3c8b4dcdb08f">b96a5a</a></td>
		<td>6 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b9cc2f47839a1e12ce2f021590cda89a305f51fe">b9cc2f</a></td>
		<td>2 lines</td>
		<td>Fix GProf project name in its pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b9fcd5bbf743b696cb141d89b828d7df75e354bb">b9fcd5</a></td>
		<td>2 lines</td>
		<td>Don't copy over non-existent images.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ba1f236d8cf51a2c654ffb3a7fa65c279b0ab1d0">ba1f23</a></td>
		<td>278 lines</td>
		<td>Tycho-ify libhover</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ba5b85004c8b87008084f39fbf95b5db084a84ca">ba5b85</a></td>
		<td>4 lines</td>
		<td>Add test gmon files to gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bafd6b642f1a54425b21d09c3d94baf68cfc5d82">bafd6b</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bb3e4b54de70236c05f1dee53b06069bca27eb58">bb3e4b</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bb7bf647fb650b2e8b388e23edf6aab54c60b53c">bb7bf6</a></td>
		<td>11 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add update site information.  Remove Linux requirement.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bb7de51a65fdb1409e178f2c6d0a7e24f21e69d9">bb7de5</a></td>
		<td>2 lines</td>
		<td>Use UI thread for ChangeLog SWTBot tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bbddbdb527d7d6850a330986545a013f1a0f633a">bbddbd</a></td>
		<td>4 lines</td>
		<td>Remove CamelCasing in plugin name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bc0e479848c1e43c6fbd2ea233ea61f3755598b0">bc0e47</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bc4c6637e7154af672f245a1db23328fee1a8e9c">bc4c66</a></td>
		<td>11 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add cachegrind tests plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bc88cb164f0a4887d17f54927dc6e1c4d3d73333">bc88cb</a></td>
		<td>9 lines</td>
		<td>2009-07-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Temporarily revert change to included plugin. * .project: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bcbb8ddaaa0158dd592325bbf606733df3a1fddb">bcbb8d</a></td>
		<td>6 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: classname -&gt; memcheck_classname.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bcc635763c69ec1722c2db50089daed17fe2c6c7">bcc635</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bcc7b9eb51014623221e7a405700e2a7237d6048">bcc7b9</a></td>
		<td>6 lines</td>
		<td>2009-11-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Make featureName a bit more user-friendly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bcfbf7a6940b73d14484f2f2b1382d33f7246a06">bcfbf7</a></td>
		<td>452 lines</td>
		<td>Rename</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bd8bd57b3aa9a8d547ad7fb63eb5ea7724f2d1b7">bd8bd5</a></td>
		<td>3 lines</td>
		<td>Use Indigo staging repository instead of CDT nightly repository</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bdf0b195f1f12d54fae16b051f8476515e746adf">bdf0b1</a></td>
		<td>7 lines</td>
		<td>Fix up SWTBot and CDT update sites for Indigo</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=be165809597b941fdb7143fd14cfa424f37ed5ba">be1658</a></td>
		<td>2 lines</td>
		<td>NEW - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=314861">Bug 314861</a>: %action.import.desc hover for import button https://bugs.eclipse.org/bugs/show_bug.cgi?id=314861</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=be3cc321daffd67d39c3c3cca695f1cd4b30ee9d">be3cc3</a></td>
		<td>211 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bec74ce1a41e31055fe7425437ecc3cc0c16f9f7">bec74c</a></td>
		<td>6 lines</td>
		<td>Add comment and second crontab entry to clean up old builds.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bedb04a32758051f1291bd415537944c7ad02b90">bedb04</a></td>
		<td>2 lines</td>
		<td>Add project set files.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bf0e4e83f6f2f0973e1a2c7f13a709ac4d7fa434">bf0e4e</a></td>
		<td>12 lines</td>
		<td>2007-11-21  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=207207">Bug 207207</a> * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecfileParser.java (parseSimpleDefinition): Allow macros in simple definitions (Alexander Kurtakov).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bf1769260e7d48c996e7e8428f0142c1e9fb7c38">bf1769</a></td>
		<td>7 lines</td>
		<td>2008-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Remove libhoverdocs/.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bf2f337fa5eb403d3a0b377bcc91ab2c6ad3b096">bf2f33</a></td>
		<td>8 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bf8c53fd7db6dc44dc7e84fe7ee552a924b1edb3">bf8c53</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from IBM to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bfe13072cd88a8b6f43ee566365f761441c095b9">bfe130</a></td>
		<td>237 lines</td>
		<td>2010-06-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Update SDK dependency URL. * maps/linuxtools.map: Use 0.6.0 branches.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c05d843e0518bf785ff884e3271753acc4ce5de4">c05d84</a></td>
		<td>14 lines</td>
		<td>2009-01-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.xml: Back to version 2.6.3.  Include META-INF in binary build. * plugin.properties: Update provider to be Eclipse.org.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c0973f3c0aa431ff1f8a36140a6e795e5ce90a3b">c0973f</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c09c79edadfe1562b2290e9cbaac3518403ae200">c09c79</a></td>
		<td>774 lines</td>
		<td>Tag releng stuff for 0.6.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c0ad5754bd65b202b7e19591c41c3949a89b4d9e">c0ad57</a></td>
		<td>2 lines</td>
		<td>Don't build Helgrind tests until they pass</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c0b0397b59cc4165fd1db61311167fccee852c8d">c0b039</a></td>
		<td>2 lines</td>
		<td>Fix test failures in massif tests by using UI thread</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c0ebdd457d084ad17325e76d14353d83a594a40d">c0ebdd</a></td>
		<td>12 lines</td>
		<td>2010-01-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * maps/linuxtools.map: Fix TMF and LTTng feature IDs.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c0f36183c6186b341048e62fa4feae776dc912b8">c0f361</a></td>
		<td>10 lines</td>
		<td>Let Tycho figure out which specfile editor tests to run</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c14a73bc23f9d280e8546b9d213acfb5accbe06e">c14a73</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c1698253fab0f8cfeca612bf6a123d199274399e">c16982</a></td>
		<td>67 lines</td>
		<td>2010-06-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c1a03daf1f06249af148ec0771cf9dffbff34eb5">c1a03d</a></td>
		<td>278 lines</td>
		<td>2010-05-26  Jeff Johnston  &lt;jjohnstn@redhat.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/SpecfileEditor.java (setDocumentProvider): New override to set the document provider to the SpecfileDocumentProvider. (getSpecfileDocumentProvider): New static method. * src/org/eclipse/linuxtools/rpm/ui/editor/UiUtils.java (resolveDefines): Prevent NPE from occurring instead of letting try/catch handle it. * src/org/eclipse/linuxtools/rpm/ui/editor/parser/SpecFileParser.java: (parseMacro): Add check for lastSection being null before accessing. * src/org/eclipse/linuxtools/rpm/ui/editor/markers/SpecfileErrorHandler.java: Rewritten to support external files in addition to project files. (SpecfileErrorHandler): Changed to accept an IEditorInput instead of IFile. (SpecfileMarker): New private class. (handleError): Rewritten. (removeAllExistingMarkers): Moved here from base class. (removeExistingMarkers): Ditto. (getAnnotationModel): New method.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c1a4bf7da49d99e2000d5400821e1c957a93cbbb">c1a4bf</a></td>
		<td>11 lines</td>
		<td>2009-02-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Use Require-Bundle instead of Import-Package to ensure we get JUnit 3 and not JUnit4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c1ece6b9621448801110fd47d3565e215814f8e9">c1ece6</a></td>
		<td>4 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c1f178738544ff8f1ee4cb84355ab6a681112bf2">c1f178</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c20458d6cf828b5958ec8ecd3e98bb73399bffe1">c20458</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c2117520838e47154dd11b7600b7990f2f788623">c21175</a></td>
		<td>234 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c211e7ec42cca5d0efcb986af28874eef4badd22">c211e7</a></td>
		<td>7 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Try entire build with 1.5 JDK instead of 1.6 (IBM 1.6 seems to have issues generating metadata with categories).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c24d7ca9e03ed6b9607e46eada44786c7cf91a8a">c24d7c</a></td>
		<td>8 lines</td>
		<td>2008-12-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add test.xml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c2b663300212785c0cc065fdb262b594d2da45fb">c2b663</a></td>
		<td>15548 lines</td>
		<td>Branch for RCP app. modifications.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c2c3710d9cebb2e31960ce65df44b832e7846694">c2c371</a></td>
		<td>12 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c2efa15375866c17ed55b147cbc7a9efafd88aa9">c2efa1</a></td>
		<td>6 lines</td>
		<td>2009-11-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Make featureName a bit more user-friendly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c321546974dacfb94b218431a6fee244378a28a2">c32154</a></td>
		<td>6 lines</td>
		<td>2007-04-05  Remy Suen  &lt;remy.suen@gmail.com&gt; * META-INF/MANIEST.MF: Set the Bundle-RequiredExecutionEnvironment attribute to J2SE-1.4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c36408901f8a6586b6c6ab9fe0624b6c1ae31431">c36408</a></td>
		<td>104 lines</td>
		<td>2009-04-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * maps/linuxtools.map: Switch back to trunk for everything.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c3ea3845f31f81ad49272f1ff2bee47d1bf6a6c0">c3ea38</a></td>
		<td>54 lines</td>
		<td>2009-07-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Add GProf feature. * maps/linuxtools.map: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c3f9b635897dbe91ee9cc03aebeead447871dd8c">c3f9b6</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c468a19d24ee1bee29f4fe0bf48e02fa20658056">c468a1</a></td>
		<td>8 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Use newly-renamed autotools and systemtap features.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c4742b8947e09a9c8c3eedd57607cff33e8d8802">c4742b</a></td>
		<td>56 lines</td>
		<td>Change versions to 0.7.1 in stable-0.7 POMs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c48f5bc39c923d7810cf4e1289c794545a838b8c">c48f5b</a></td>
		<td>8 lines</td>
		<td>2008-12-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add test.xml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c4e41f033691f844dbce68a9911fc3700bc42d1d">c4e41f</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c4ff298bc869f63041865d864f2ba0b4f6c20a0b">c4ff29</a></td>
		<td>235 lines</td>
		<td>2010-03-15  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Update version. * maps/linuxtools.map: Fix syntax.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c51c902715cadb6a1f577d29f3ffeb1a29cdd548">c51c90</a></td>
		<td>1 lines</td>
		<td>Remove lib folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c52408b33c68541c7a2f74e30e56083c972c38fd">c52408</a></td>
		<td>23 lines</td>
		<td>Fix packaging type for OProfile core tests plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c545d7c740d3744fb2196b2b36a1ce304d9db87b">c545d7</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c5d3d3b6566eca036e607c137df4e6d0c92151d1">c5d3d3</a></td>
		<td>5 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Add feature.properties and epl-v10.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c5ea1d8f5db8857d4a90d59581f282cb82b5f75f">c5ea1d</a></td>
		<td>105 lines</td>
		<td>2009-06-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Rename from site.xml (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=272991">Bug 272991</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c6618ff061f31fd81125df0e9dd7e3fc313d5365">c6618f</a></td>
		<td>4 lines</td>
		<td>Make actual feature.properties fixes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c67db198a7fd699ebaaf3f70788ada690ce18ec1">c67db1</a></td>
		<td>36 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c6aba50c44d9583839e5fedfa257a680e058cfcf">c6aba5</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c721494b56801576d97e7dda749368866a47c0c0">c72149</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c7284dbaedca6d62d0648f8804be0438fca251b8">c7284d</a></td>
		<td>57 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Initial checkin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c774976aa93993bf0ef4e62177961f24679f857d">c77497</a></td>
		<td>5 lines</td>
		<td>Temporarily work around <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=296352">Bug 296352</a> by explicitly setting build.steps.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c7a8f61f3718ad8c770f0a178b8181cdb6a5dad8">c7a8f6</a></td>
		<td>2 lines</td>
		<td>Add &quot;(Incubation)&quot; after Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c7c29ccba1deb1d56e4779c270dadfef057298ff">c7c29c</a></td>
		<td>2 lines</td>
		<td>Fix test failures in massif tests by using UI thread</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c87e944ad4c200ee77efcc6adb995397ea76a3bc">c87e94</a></td>
		<td>5 lines</td>
		<td>2007-04-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Remove erroneous dependency on CDT.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c889377b469c7c8233169419807b0901e4032d8f">c88937</a></td>
		<td>2 lines</td>
		<td>Revert &quot;Match SystemTap version in POM and feature.xml&quot; This reverts commit b4326cd1dab306a95977d0f08df9b6be77777564.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c8ade5bbc7191bd4f7b675c7042471514144924c">c8ade5</a></td>
		<td>6 lines</td>
		<td>Don't include systemtap.ui.graphingapi.nonui.tests due to compilation errors</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c91ee9b68489e9480411511afa037dbcb8e6dc0f">c91ee9</a></td>
		<td>6 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add dependencies.  Add update site information.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c93dee83fac64d3ba4138ec0b16cb8dc38db1fe4">c93dee</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c98b1b92d1c1a97e29f750e67b7a08a23d5db75b">c98b1b</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix o.e.c.resources bundle version range.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c9a3eee98171195c36a2c0701d2621dfb43492e8">c9a3ee</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c9a4920108eb015dea132783a0c653456b70b476">c9a492</a></td>
		<td>8 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285616">Bug 285616</a> * build.properties: Try to see if using an earlier basebuilder fixes things.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c9c794dd337bf9efdf0dd6c31e26c8faeba04314">c9c794</a></td>
		<td>7 lines</td>
		<td>2009-08-04  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove category.xml until 0.4 builds start.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ca197005563480706d00e031e51b959fc43fe651">ca1970</a></td>
		<td>4 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Re-added update site information (sorry).  Re-add &quot;qualifier&quot; for trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ca286104c25bc3ee71bda0f4769315c60f45b367">ca2861</a></td>
		<td>6 lines</td>
		<td>2010-02-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Capitalize &quot;library&quot; in featureName.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ca36df1b3f3f02f9f962a805ba386ed2ed166e6b">ca36df</a></td>
		<td>958 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ca39ad4c93aec22ddb0d6d85ec51f276b4d0ae5d">ca39ad</a></td>
		<td>2 lines</td>
		<td>Add &quot;(Incubation)&quot; to bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ca3c134336b6ada491dd230090ba278bbc8d4888">ca3c13</a></td>
		<td>29 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Use bundleName and provider from plugin.properties. Add &quot;(Incubation)&quot;. * plugin.properties: Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=caaa1d09b065e505dc06dedce9b954fcb2d48b8c">caaa1d</a></td>
		<td>78 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Make version 0.3.0.qualifier.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cabbbb2771c9810cd78c566dad70bacd3fcc44ca">cabbbb</a></td>
		<td>11 lines</td>
		<td>NEW - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=314868">Bug 314868</a>: Create category for SystemTap views https://bugs.eclipse.org/bugs/show_bug.cgi?id=314868</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cae863377ae6101abcc4824eb9f2a2f1ccf0fd67">cae863</a></td>
		<td>40 lines</td>
		<td>2008-12-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Inital checkin. * test.xml: Likewise. * plugin.properties: Likewise. * about.html: Likewise. * META-INF/MANIFEST.MF: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=caf9313d14a761448a8e649fb13683c37ff3d016">caf931</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cb38c4995f8b1b67e128ef136faf3c4ed66ce370">cb38c4</a></td>
		<td>6 lines</td>
		<td>Rename to -feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cb5d7563febd682698c2f5a68d8d3153c803d6aa">cb5d75</a></td>
		<td>9 lines</td>
		<td>Externalize Bundle-Name and Bundle-Vendor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cb966b159b009284c0aafe8ea1bca5d733c3343b">cb966b</a></td>
		<td>3683 lines</td>
		<td>Remove old releng stuff</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cba677d8632642d50347d2de9d938da1787bdab2">cba677</a></td>
		<td>38 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * about.html: Initial checkin. * build.properties: Add test.xml, etc. to build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cba9f3854572dfc28bc9ecb0e14c6a6aecd76c21">cba9f3</a></td>
		<td>15 lines</td>
		<td>2008-11-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Add Bundle-ActivationPolicy.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cbc1da7879f080aa6bc4f3773352556a48753d11">cbc1da</a></td>
		<td>136 lines</td>
		<td>2008-12-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Inital checkin. * test.xml: Likewise. * plugin.properties: Likewise. * about.html: Likewise. * META-INF/MANIFEST.MF: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cbeeda913f1453b6adc317a171046fbc3547a578">cbeeda</a></td>
		<td>112 lines</td>
		<td>Tycho-ify Valgrind Helgrind tests plugin Remove old-style test.xml and suite class.  Add pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cbf89504d908d9e5ed9cf956159b584fda455f7b">cbf895</a></td>
		<td>5 lines</td>
		<td>Set PACK200_JAVA_HOME to work around <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=294678">Bug 294678</a>.  Move back to 1.6 JDK for rest of build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cc7e135678026a2fbb4d04d0d08e9348af5db72d">cc7e13</a></td>
		<td>52 lines</td>
		<td>Remove man site</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ccbe7f2b280d14458b2d66a413d6784613bf985f">ccbe7f</a></td>
		<td>9 lines</td>
		<td>Add profiling framework, OProfile, and Valgrind tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ccc19d7b8ee4568b3dada73e5ef084e55cfcf016">ccc19d</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ccea8afe69abc4e21c6b57ae58d3b22c0ae724fd">ccea8a</a></td>
		<td>30 lines</td>
		<td>Move remaining .cvsignore to .gitignore on stable-0.7</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cd0769c8be7103213e2da2b7e312482aa8bd0463">cd0769</a></td>
		<td>6 lines</td>
		<td>2010-02-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Capitalize feature name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cd32dd83b42b22a4f5feeb8fcea9731e2e9f4267">cd32dd</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cd790096bd1458e13338f1f7167e770c3acdb47d">cd7900</a></td>
		<td>2 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cdcaac1c8a806f936959ee62c218a45e8942da4d">cdcaac</a></td>
		<td>2 lines</td>
		<td>Revert &quot;Change feature version to 1.2.0&quot; This reverts commit eb4a39b82fba9d6458fae7d2a31a3eb445deacce.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cde5e8cca3eb4a211a469e0193029049d2364373">cde5e8</a></td>
		<td>6 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Add &quot;qualifier&quot; to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ce1cc3deaf4c5bc145d99ebdce66a31497cf34d6">ce1cc3</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ce5c051cf9772d4f0406299452208d5c733f236a">ce5c05</a></td>
		<td>32 lines</td>
		<td>2010-07-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * about.html: Add missing file. * build.properties: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ce63333ade7c021366a5095905304006a22eeca5">ce6333</a></td>
		<td>2 lines</td>
		<td>Switch to Orbit release repo In the top-level pom.xml, change the URL of the Orbit repository from the old &quot;S-build&quot; URL to the &quot;R-build&quot; (release) one: R20110523182458.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ce647410e74b3737d49c6f743c73521896206ac0">ce6474</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ce6a2fb297fbac1cf9a8fe2fd25912f93bdd85f4">ce6a2f</a></td>
		<td>3288 lines</td>
		<td>Tag for Linux Tools 0.2.0 release.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cecc02566ebdcc36812641fc6761a87675406fb6">cecc02</a></td>
		<td>313 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cef7970f8e05aef1ef9798f4ff91f76e157af83e">cef797</a></td>
		<td>56 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Move to valgrind.test-feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cf6d455fd0886f7daef96ed04ce228a954e5cd20">cf6d45</a></td>
		<td>2 lines</td>
		<td>Fix up bundle name</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cf91efb4045bd196449b21d4e481b85245f5216e">cf91ef</a></td>
		<td>108 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html. * feature.xml: Use licenseURL property.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cfad5dd6a5462120f5791fdec4d5da3431cb2bdc">cfad5d</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cfbcbac8d9276f82dbae66999a6d2cad5f943b2c">cfbcba</a></td>
		<td>18 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Use plugin.properties for provider. * plugin.properties: Add &quot;(Incubation)&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cfc4c10bfbd1189c97a0bd9dcab09f8619d03a86">cfc4c1</a></td>
		<td>6 lines</td>
		<td>2010-05-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Make release 0.5.1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cfc9fdc430d43f844b29faf66cb22d2d62258de2">cfc9fd</a></td>
		<td>45 lines</td>
		<td>Fix about.html in binutils and dataviewers.charts.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d00f20477a09a47e9472cc1da83f2c52d17160b3">d00f20</a></td>
		<td>10 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d05bb5fcef21fb1d9956bc89a66af8cbedddff46">d05bb5</a></td>
		<td>3 lines</td>
		<td>Add Bundle-Localization: plugin to MANIFEST.MF.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d072a7aa7a7bed06eeb034273342b8480b5259a9">d072a7</a></td>
		<td>30 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * maps/linuxtools.map: Update for renamed features (removing &quot;.feature&quot;). * psfs/autotools.psf: Likewise. * psfs/linuxtools.psf: Likewise. * psfs/linuxtoolsAndAthena.psf:  Likewise. * psfs/systemtap.psf:  Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d07921a78f795e1ad3c4ce731d89c29af36a4f80">d07921</a></td>
		<td>8 lines</td>
		<td>Add OProfile UI tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d0ee285516f483e045b938c6894de1867c7a924e">d0ee28</a></td>
		<td>22 lines</td>
		<td>Fix typo:  Oprofile -&gt; OProfile</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d133e817ddd2cf1d1b164748f7d3079052ce5b0f">d133e8</a></td>
		<td>7 lines</td>
		<td>2010-04-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Restrict to os=linux.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d136b73082c2575c9ed0a46bb01eabfa0d7566b4">d136b7</a></td>
		<td>2 lines</td>
		<td>Fix test failures in massif tests by using UI thread</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1a50abd19b640ac31f8660112609bf6341873e1">d1a50a</a></td>
		<td>7 lines</td>
		<td>2010-05-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/oprofile/core/oprofile.properties: Fix typo with \find instead of \nfind.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1b2358d9dbadae28b545198d91a7b43837b23a2">d1b235</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1d24e27aa079b60740db58c0cec222c80be7e1e">d1d24e</a></td>
		<td>194 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright text. * license.html: Update HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1d5de0c3fa4ec33f5e6066dceb672e6359e597c">d1d5de</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1ee0fa60934e7f1df44a7dce9aff174faeee2ac">d1ee0f</a></td>
		<td>6 lines</td>
		<td>Don't include systemtap.ui.graphingapi.nonui.tests due to compilation errors</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d26c8473dd71a6fc3d9175fbbca2db92a901442e">d26c84</a></td>
		<td>2 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d270c98057a415f8e7a992543168cb64a74694ba">d270c9</a></td>
		<td>53 lines</td>
		<td>Add testing.properties and testManifest.xml.  No real idea what testManifest.xml does.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d2744aad7f7823997fec7fb0eed5567e7aae06b3">d2744a</a></td>
		<td>5296 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=336846">Bug 336846</a> - Update to 2011 SUA</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d29d1e71445913733c09c17b3efe17388c70edc8">d29d1e</a></td>
		<td>7 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add valgrind, profiling framework, and oprofile features. 0.7 -&gt; 0.1.0 (as it should be).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d3146c9c7e247826928a48456d9bb145e84524e3">d3146c</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d330576a06c26fe6c53bce83b64aeda1958ab360">d33057</a></td>
		<td>5 lines</td>
		<td>Add profiling and valgrind to the master list of modules in pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d3d6639ba2a3cc108a42d5b937bc51889dad3dbd">d3d663</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d3f08b291538774509730afe28782bff0d16964b">d3f08b</a></td>
		<td>2 lines</td>
		<td>Try a different location for unzipping the CDT while running the tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d41a9e6f3e91685398a10a64f41db2f476c0d373">d41a9e</a></td>
		<td>3181 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d4d160af5581a7c98981171a0334c38b838aefb7">d4d160</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d5350410e0ed299ba668b66deae7918c643207b0">d53504</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d545ba26c461b93660419ab1b088c4c7c9249f75">d545ba</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d55895efee4b0c1f1891312c068bfaa8c4d8eae2">d55895</a></td>
		<td>9 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * plugin.xml: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d5e879dbec743f80224e22027a3e704b45bba4a6">d5e879</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d5ee1df36396ec1d7b639b66395d12cb8affc291">d5ee1d</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d605cd8683f84edd092989c72b93e69b2b82c2e3">d605cd</a></td>
		<td>23 lines</td>
		<td>NEW - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=314737">Bug 314737</a>: oprofile.core class files should be jarred https://bugs.eclipse.org/bugs/show_bug.cgi?id=314737</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d6632b40b1a3b98bf962afdbee0ab59b6ca8914f">d6632b</a></td>
		<td>42 lines</td>
		<td>2007-01-29  Remy Suen  &lt;remy.suen@gmail.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181249">Bug 181249</a> * META-INF/MANIFEST.MF: Initial import. * .classpath: Set a J2SE-1.4 JRE. * plugin.xml: Migrate dependency information to an OSGi manifest.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d6e2fab64b329b0bd00597c63a7abdebad16170a">d6e2fa</a></td>
		<td>121 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d729c8e51deb944354d75549caad5435671aeb8b">d729c8</a></td>
		<td>17 lines</td>
		<td>Remove libhover devhelp bin directory from git</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d76002d0314dc21b27409103a9a99d4fc10fda76">d76002</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d764058afa1147f454c007589dc652c7210905a8">d76405</a></td>
		<td>5 lines</td>
		<td>Add OProfile UI tests and don't try to run valgrind.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d764657568f961c496cc289694cdca441e4e4a1e">d76465</a></td>
		<td>7 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove Linux requirement to see if it then gets included in all feature. Added update site information.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d799b3ca88e6525350a02e47c5c51ce966d28673">d799b3</a></td>
		<td>4 lines</td>
		<td>Add maven test artifacts to valgrind .gitignore files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d7d2e87f17d53011ba08147aecd171af59fa241d">d7d2e8</a></td>
		<td>6 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: classname -&gt; memcheck_classname.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d7dcd34b9346d28b160849ebd6205872983f1c7b">d7dcd3</a></td>
		<td>2 lines</td>
		<td>Revert &quot;Re-enable changelog UI tests.&quot; This reverts commit 169aa1d9d3172bb5c2d010632b4c7534bb80f638.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d7ff177e92e641590c38bfb48579158b8a52a5ae">d7ff17</a></td>
		<td>37113 lines</td>
		<td>Branch for 0.3</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d80977513528356c170d4ab32fce776e2248055d">d80977</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d817adcea6c5f690fcb0719d7938620088b53de8">d817ad</a></td>
		<td>421 lines</td>
		<td>2008-12-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Inital checkin. * feature.xml: Likewise. * feature.properties: Likewise. * epl-v10.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d85c2618e06dca326d88fdf8f47d8a32c6cb7956">d85c26</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d889af312a2bbf52f20981e7d6d3fc8e8546eb57">d889af</a></td>
		<td>18 lines</td>
		<td>2007-08-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Change to be jarred plugin and not contain changelog.jar. * META-INF/MANIFEST.MF: Change from changelog.jar to .. Set required EE. Bump to 2.5.1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d8af4a69f32b42c139fd4bdbc4737666cfbeb3c3">d8af4a</a></td>
		<td>7 lines</td>
		<td>2008-12-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.xml: Remove erroneous metadata element under &lt;plugin&gt;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d8b07db9afdc6a5c7a02cc1096340e4f094662c6">d8b07d</a></td>
		<td>4 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d915b4f1426430e512636cf3d4d63d58f9b594d2">d915b4</a></td>
		<td>2 lines</td>
		<td>314869: Re-name &quot;Dashboard&quot; perspective https://bugs.eclipse.org/bugs/show_bug.cgi?id=314869</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d925a61196c240d531093f168bcc38c1ba204981">d925a6</a></td>
		<td>6 lines</td>
		<td>2010-02-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Capitalize words in featureName.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d936aa59877cfebbe0a2f4ab438165923e831c52">d936aa</a></td>
		<td>6 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add &quot;.qualifier&quot; to version.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d94f58d73f3304a5d399a613093ad9613c012378">d94f58</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d9591dcf8126c7d67c3e198c105d931641dc30bd">d9591d</a></td>
		<td>7 lines</td>
		<td>2007-04-06  Alphonse Van Assche  &lt;alcapcom@gmail.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/RpmMacroProposalsList.java (getValue): Escape &quot;?&quot; character in regex.  <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181395">Bug 181395</a>.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d960a2a7e89b5adaf58e1d635e85ea04ea651da0">d960a2</a></td>
		<td>692 lines</td>
		<td>2009-06-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * Fix up after erroneous SVN operation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d9abff57986da43f32d1ecfea156698104f7f464">d9abff</a></td>
		<td>11 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add cachegrind plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d9afbba076c9ac55e32b7e7a9428e30f44403103">d9afbb</a></td>
		<td>148 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d9ecead90dd900c9b0d7ac0104158b55bb6a42ce">d9ecea</a></td>
		<td>52 lines</td>
		<td>2009-08-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285616">Bug 285616</a> * category.xml: Add pack200=true.  Remove category for non-user-visible stuff.  Remove profiling feature (it will still be present on the update site).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=da2e13370bba511014cf8ddcecdd48283c51e069">da2e13</a></td>
		<td>3 lines</td>
		<td>Re-add runpackager=true to see if it fixes the missing o.e.test</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=da6b3f17c7f665b6098a7d938aafbdf763095c87">da6b3f</a></td>
		<td>6 lines</td>
		<td>2008-10-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Update version to 2.6.3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=da7f03fe5bec9dcb9289a319d1ab65ec731b09a0">da7f03</a></td>
		<td>2 lines</td>
		<td>Add (Incubation) after Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=daae3271a0e07f0c0c54cce7ba0ec91fb735a12b">daae32</a></td>
		<td>751 lines</td>
		<td>2010-03-15  Andrew Overholt  &lt;overholt@redhat.com&gt; * maps/linuxtools.map: Use 0.5.0 branch. * psfs/autotools.psf: Likewise. * psfs/callgraph.psf: Likewise. * psfs/changelog.psf: Likewise. * psfs/eclipse-build.psf: Likewise. * psfs/gcov.psf: Likewise. * psfs/gprof.psf: Likewise. * psfs/libhover.psf: Likewise. * psfs/linuxtools.psf: Likewise. * psfs/lttng.psf: Likewise. * psfs/manviewer.psf: Likewise. * psfs/oprofile.psf: Likewise. * psfs/oprofiledocs.psf: Likewise. * psfs/rpm-editor.psf: Likewise. * psfs/rpmstubby.psf: Likewise. * psfs/systemtap.psf: Likewise. * psfs/valgrind-tests.psf: Likewise. * psfs/valgrind.psf: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dab2a54771d4271c2f990383b4c344b3d97e2f2c">dab2a5</a></td>
		<td>8 lines</td>
		<td>2009-02-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: plugin-name -&gt; massif-plugin-name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dab665704cf426566d2c0bac8245fa8ca8b2dbf1">dab665</a></td>
		<td>70 lines</td>
		<td>Re-remove test.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dad566202bf9e71df9b6e384aa9e433208d2cd2a">dad566</a></td>
		<td>614 lines</td>
		<td>2.5.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=db3fc99ef0e18736625d1d6ab19af146e777e65f">db3fc9</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dbcb8c868e54a33c77cb0bcd30856442221c2858">dbcb8c</a></td>
		<td>4 lines</td>
		<td>Try putting CDT into its own dropins folder.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dd1965a0e819f75a4e2aec2c9fe3aad60157993c">dd1965</a></td>
		<td>7 lines</td>
		<td>2010-05-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/oprofile/core/oprofile.properties: Fix typo with \find instead of \nfind.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dd3a8b8286575cba53fa95fff290fb708f843edd">dd3a8b</a></td>
		<td>17 lines</td>
		<td>Temporarily update to signing plugin 1.0.1.2-SNAPSHOT This version of the eclipse signing plugin has bugfixes needed to enable the Indigo aggregation build to properly consume the Linux Tools p2 repository.  Also see [1].  Shamelessly taken from EGit commit 7bacd2cb4b21a94c521b3ad72e64d7a03925d366. [1] http://dev.eclipse.org/mhonarc/lists/cross-project-issues-dev/msg06044.html <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=347591">Bug 347591</a> <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=347594">Bug 347594</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dd5d447612ad7aa6dcecabc95468ab30e1053574">dd5d44</a></td>
		<td>828 lines</td>
		<td>Add missing profiling.launch files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dd993df7102535c88afe7601090672973836ab82">dd993d</a></td>
		<td>10 lines</td>
		<td>2009-10-29  Andrew Overholt  &lt;overholt@redhat.com&gt; * maps/linuxtools.map: Change map for GProf test plugin to be a fragment.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ddcfd2922701f14a914c064a65e0b97c8710507c">ddcfd2</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ddd5a5ed1ec7fca30958723204f6e4d207306cde">ddd5a5</a></td>
		<td>1 lines</td>
		<td>Add bin to devhelp gitignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=de3af4f3505c5615124ca304394580f2df662258">de3af4</a></td>
		<td>15 lines</td>
		<td>2010-01-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=300003">Bug 300003</a> * maps/linuxtools.map: Add gcov. * category.xml: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=de517de20652383c17948ee2b1c16b289471f741">de517d</a></td>
		<td>6 lines</td>
		<td>Fix name of devhelp feature description variable (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=346444">Bug 346444</a>). 2011-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix name of feature description.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=de86cf06486fa80ffe18575f4e117cf22aa35767">de86cf</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=de8f8394f5d78ec43295ebccc07ad5ebeb6b7ff0">de8f83</a></td>
		<td>47 lines</td>
		<td>Put Galileo work on branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=deabdb8a72998e547e65ecac337a853190701fe2">deabdb</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=debc762cb7ecde8a8d1c307e102697d1af8d330b">debc76</a></td>
		<td>16133 lines</td>
		<td>Put Galileo work on branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=decab3fce526553867d35ea8a6ec6b248137e7f0">decab3</a></td>
		<td>256 lines</td>
		<td>Add copy of EPL.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ded24699a0be9a1e021a6c7f9ca0e97c8b77a531">ded246</a></td>
		<td>9 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Use plugin.properties. * plugin.properties: Initial checkin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=df8da3219951931bcd376f697ea169aca7836f22">df8da3</a></td>
		<td>7 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * META-INF/MANIFEST.MF: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=df9794ca99c1bf5d0e4174944383a4d8fa722d40">df9794</a></td>
		<td>236 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Use .properties file and include new systemtap feature. * feature.properties: Initial import. * epl-v10.html: Likewise. * build.properties: Add feature.properties and epl-v10.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=df9afaa0d8754a4e4b2794ee77b5c419dad996c5">df9afa</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=df9b137e06c1452dcfd84412f7837c6d5223b4a5">df9b13</a></td>
		<td>10 lines</td>
		<td>2009-07-21  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add OProfile launch tests (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=283623">Bug 283623</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dfc85990a59a3492274667c8b7bccafa91aa2bd2">dfc859</a></td>
		<td>30 lines</td>
		<td>Add some API filters to excuse API changes without major bundle version changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dfcbac0a1b7eeea5408f7a107fef43445a6251d5">dfcbac</a></td>
		<td>7 lines</td>
		<td>2010-04-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Restrict to os=linux.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dfda65590ce67515db0fc204dd349fc92a7c1866">dfda65</a></td>
		<td>564 lines</td>
		<td>2007-07-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * Too many files to list: Add standard copyright and license header.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dfdb71c22a31295d0ff85cf80a98ba670d676783">dfdb71</a></td>
		<td>7 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * fragment.xml: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dfffec73c8e0056bea988a45602004c104bb961c">dfffec</a></td>
		<td>6 lines</td>
		<td>2009-09-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Move to GEF-ALL since new SystemTap stuff needs Zest.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e037310581dacd7aff738f75feed73ad4779611e">e03731</a></td>
		<td>2 lines</td>
		<td>Use UI thread for ChangeLog SWTBot tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e037e0260f244305c93f2384a47e20238f8133b4">e037e0</a></td>
		<td>112 lines</td>
		<td>Tycho-ify Valgrind Helgrind tests plugin Remove old-style test.xml and suite class.  Add pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e04d45c42425687099a2e194879b098985c9c5f8">e04d45</a></td>
		<td>1 lines</td>
		<td>Add ChangeLog to top-level pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e0870c44b5e8e60c365cba25c18c44ba262f1c6e">e0870c</a></td>
		<td>18 lines</td>
		<td>Use tag for systemtap.  Fix entries for rpm and stubby.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e08a674af2e81d7f13cc4c8335ba2718a58cfc0c">e08a67</a></td>
		<td>2 lines</td>
		<td>Fix SDK URL.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e0bd0ab86edbb0910d115a831b32d336f0a1806c">e0bd0a</a></td>
		<td>2 lines</td>
		<td>Remove extraneous space in dependencies repo list</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e0ce4bb2e5316bce4bd0673421b85c0dee571034">e0ce4b</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e135260a5349a302312bd93d0e79c2a5077394c5">e13526</a></td>
		<td>381 lines</td>
		<td>Branch for Ganymede.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e166c4f4eca0ac84e29a4ee506bf1ab2ab17d52f">e166c4</a></td>
		<td>187 lines</td>
		<td>2008-01-03  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=206964">Bug 206964</a> * src/org/eclipse/linuxtools/rpm/ui/editor/wizards/SpecfileNewWizardPage.java: Remove 1.5 API call.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e1846acba8c437f924df50b94320fdeae21ac9f6">e1846a</a></td>
		<td>27 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e1a355549cb1cfefb7d5551dc7d20f78f14a73b8">e1a355</a></td>
		<td>45 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e1afc00ab2eeb767c5f4e0e303e8d5011f1e09f0">e1afc0</a></td>
		<td>6 lines</td>
		<td>2010-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * OSGI-INF/l10n/bundle.properties: Change provider to Eclipse Linux Tools.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e1e4e349f18a49cda15afb7b13abe4cf6910e110">e1e4e3</a></td>
		<td>1 lines</td>
		<td>2008-12-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Clean up some typos.  Add debugging statement.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e1f1e2a78cc9f072dfadf6ef6889b827b21f908b">e1f1e2</a></td>
		<td>42 lines</td>
		<td>2007-04-05  Remy Suen  &lt;remy.suen@gmail.com&gt; * .classpath: Set required EE. * META-INF/MANIFEST.MF: Initial commit. * build.properties: Include MANIFEST.MF. * plugin.xml: Declare dependency and runtime information in an OSGi manifest.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e213503b731d2af507a193415f268beff833ce4d">e21350</a></td>
		<td>12 lines</td>
		<td>2008-10-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Update version to 2.6.3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e21f79723510aeb7b73d558f1cd5f19a87ebe5f2">e21f79</a></td>
		<td>7 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * META-INF/MANIFEST.MF: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e228caf13034a7e566237c978e355c60320f4e82">e228ca</a></td>
		<td>19 lines</td>
		<td>2009-04-22  Andrew Overholt  &lt;overholt@redhat.com&gt; * tools/linuxtoolsupdatesite-trunk.sh: Use Update zips instead of Master zips.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e230182e87f0a7008ff38f9933df14c685257963">e23018</a></td>
		<td>2 lines</td>
		<td>Change build order of profilling and OProfile in pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e29689e2f8eaf9711e5f154736e08a0eb7280048">e29689</a></td>
		<td>4 lines</td>
		<td>Add MANIFEST.MF.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e2b0585334482325d96736957f24b08f6dbceb7a">e2b058</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e2e2e399a07a3532670d93fa36bfe823d5e395e4">e2e2e3</a></td>
		<td>2 lines</td>
		<td>Remove extraneous space in dependencies repo list</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e32cac3afdb391a242068aefa2e1ca24541796b8">e32cac</a></td>
		<td>12 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * about.html: Initial checkin. * build.properties: Add test.xml, etc. to build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e3835ac01a75cf9ebc7503ce08e13420dddd40e1">e3835a</a></td>
		<td>6 lines</td>
		<td>Fetch dummy org.eclipse.linuxtools.all feature from trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e3ea1e9cc32a55b79c2735f36a07c90975bec67d">e3ea1e</a></td>
		<td>2929 lines</td>
		<td>Tag for Linux Tools 0.2.0 release.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e49c814f9f3b41e60e5a023808df96b9323d037a">e49c81</a></td>
		<td>201 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Variable-ize some strings. * feature.xml: 	Use variables.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5216fa95fa3bba586f26069daa056ee88a7fd10">e5216f</a></td>
		<td>9 lines</td>
		<td>2008-10-31  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Initial import. * META-INF/MANIFEST.MF: Use plugin.propeties.  Add &quot;(Incubation)&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e587987bb6ca404a08f3b5b34772ec4b7a56d3e2">e58798</a></td>
		<td>9 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * plugin.xml: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5993214b962a90214524a2b0e2575d6d689cd1b">e59932</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5c1e12b0e4a9e1b2c5a10d1ab7a27d4b824c2b5">e5c1e1</a></td>
		<td>209 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5c3f455cfbf5239b138c70932e71451838c0d1c">e5c3f4</a></td>
		<td>30 lines</td>
		<td>Add suite class to run all GProf tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5d3344dfdc4fcaac062a7fb86869765eeb6f7b6">e5d334</a></td>
		<td>56 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Update.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5d43d9a979dd7280a1b6255d9124d3b9fa72b51">e5d43d</a></td>
		<td>13 lines</td>
		<td>Make memcheck tests run with only required bundles present</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5f534bba2efb5d3458a33adbd28dd3a7c05b44e">e5f534</a></td>
		<td>297 lines</td>
		<td>Tycho-ify GProf</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e6213d693665dfdbbecb0b262200ca4b055526de">e6213d</a></td>
		<td>58 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Initial checkin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e64d5d90e5c0e25ce9598ec64e6ab25a2a84d262">e64d5d</a></td>
		<td>22 lines</td>
		<td>Add some environments to target platform list</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e669126980c4034a8183f585cfe085037c82d773">e66912</a></td>
		<td>6 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; * plugin.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e68dcf6595e99c674c724ee2fab5ce731399a008">e68dcf</a></td>
		<td>58 lines</td>
		<td>2009-03-13  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Initial checkin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e69021c13116b08d9e88ffad17365c0dc4e6332b">e69021</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e6925ef0e18afc91e3bc6559c51ffd61cecd5b83">e6925e</a></td>
		<td>12 lines</td>
		<td>2008-12-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add tests plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e6e9b5e0c7d872e2359f0ce39f659545482e766f">e6e9b5</a></td>
		<td>60 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e764a7828923afd15256ddec44017fbb9dbec36b">e764a7</a></td>
		<td>4 lines</td>
		<td>Re-order</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e7ca088ec2f55e6d9f8706b11dcb760a659f8969">e7ca08</a></td>
		<td>10 lines</td>
		<td>Temporarily comment out some failing SystemTap test suites</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e7cfea67cdc798f43679d918b85535d3082ad288">e7cfea</a></td>
		<td>8 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Re-add update site information (sorry).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e8083aefe54db9edb4eb1c1782531475d486f2fb">e8083a</a></td>
		<td>62 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e870e76d23a067cc4cc3c56757010af253fec286">e870e7</a></td>
		<td>8 lines</td>
		<td>Add some debugging statements.  Require org.junit 3.8.2 explicitly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e8af8c72a549642474d3ae6e8d370878b6797b6a">e8af8c</a></td>
		<td>17 lines</td>
		<td>2009-12-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java (getMemberSummary): Remove unnecessary catch block.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e8d265a71021f4a4239af6a5d1747df0a795a127">e8d265</a></td>
		<td>449 lines</td>
		<td>2008-12-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Inital checkin. * feature.xml: Likewise. * feature.properties: Likewise. * epl-v10.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e950a7957690e710e0bc07be88699d58334c9e5a">e950a7</a></td>
		<td>4 lines</td>
		<td>Make Indigo builds write to updates-nightly-indigo</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e98c681a2a40ccca8416676ace703204b3935189">e98c68</a></td>
		<td>1 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181249">Bug 181249</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e9a57b1287bfc2583ab50ffa3eb13aa26a6d7b17">e9a57b</a></td>
		<td>11 lines</td>
		<td>Remove pre-built opxml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e9e676d35373709369d04a9c5b55ab80c73cfb1b">e9e676</a></td>
		<td>8 lines</td>
		<td>2009-01-14  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Re-add update site information (sorry).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ea20d7c487f9774817e7f4a003f1d928b54317da">ea20d7</a></td>
		<td>56 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Move from test plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ea2a108bf0110340043070d78f66dac15e99f645">ea2a10</a></td>
		<td>95 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * license.html: Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ea58058659198af905671a86b1adbe55382940d5">ea5805</a></td>
		<td>38952 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ea705787fe1c89296903fdaccc211d3e8095bcd4">ea7057</a></td>
		<td>6 lines</td>
		<td>2008-10-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Update version to 2.6.3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ea73168b8298e3036cda2bcd17f8841f3ad9c982">ea7316</a></td>
		<td>154 lines</td>
		<td>Use git checkouts instead of map files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eaa113ee57d343cc21371fc8c572af122383b67e">eaa113</a></td>
		<td>631 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eac22ce2b40af3bdb7a5acde0961dd194ac9ae5d">eac22c</a></td>
		<td>503 lines</td>
		<td>Add perf feature license files; include these and properties in build</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eb1e26f0f8a9908d3b06af707f8230aaef9d241f">eb1e26</a></td>
		<td>47693 lines</td>
		<td>Tag initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eb5b429b008685cdc2eb3fd772673a8ac96ea552">eb5b42</a></td>
		<td>2 lines</td>
		<td>Add timeout for memcheck tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ebe0d72d00585d374cbd8c5b40985ea4191b8af3">ebe0d7</a></td>
		<td>6 lines</td>
		<td>2009-11-10  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Make featureName a bit more user-friendly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ec1b541a59f9105e85a3b1cafd351816bc24858a">ec1b54</a></td>
		<td>4 lines</td>
		<td>More path fixes for signing plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ec8cbb4e67e71ea4a06674862ca5d08ae5e58269">ec8cbb</a></td>
		<td>9 lines</td>
		<td>Avoid conflict with SystemTap editor bundle symbolic names</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ecacac534f3bce39169582ab385045eda31e2bcf">ecacac</a></td>
		<td>10 lines</td>
		<td>2009-06-08  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Fix some feature names (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=272991">Bug 272991</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ecda4885df405e16dc3c2fbcea193ff34f0b984c">ecda48</a></td>
		<td>8 lines</td>
		<td>2010-01-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * maps/linuxtools.map: Fix TMF SVN location.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ed70705abc83491753904e401f7ee3d6bcc50e94">ed7070</a></td>
		<td>2261 lines</td>
		<td>Put Galileo work on branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ed863c2a5c40063beea8f4ec12b763d3cdce3e60">ed863c</a></td>
		<td>8 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ed9a53399db25ed3da5f06e6eb456962af1f0e1c">ed9a53</a></td>
		<td>14 lines</td>
		<td>Use tag for specfile editor and rpmstubby.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ed9c48ba64e8881f0a29e3e28523c0c115b32d3e">ed9c48</a></td>
		<td>4 lines</td>
		<td>Update to new eclipse-signing-maven-plugin This update fixes the fact that many of the pack.gz files are not actually packed with pack200.  This is the relevant bug: <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=356931">Bug 356931</a> - many pack.gz files for indigo are not packed Also update eclipse-parent POM (version 2 -&gt; version 3).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ee255a3ceb6ae1fa12f46ed2e523c97e486b96d3">ee255a</a></td>
		<td>5 lines</td>
		<td>2007-04-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * .classpath: Remove spurious junit.jar entry (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181238">Bug 181238</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ee5d4d3798c033b9614d487d55fe143d854b8b76">ee5d4d</a></td>
		<td>11 lines</td>
		<td>Remove pre-built opxml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ee702af86410e37f9d23b66704f06735888815f0">ee702a</a></td>
		<td>6 lines</td>
		<td>2009-05-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove unnecessary .feature qualifier.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ee86146df28ed100e3a08bf63a90e97ef949248c">ee8614</a></td>
		<td>2 lines</td>
		<td>Change bundle provider to &quot;Eclipse Linux Tools&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef7a049027f7f5d2b4a4ae316e6160272bec1bd3">ef7a04</a></td>
		<td>107 lines</td>
		<td>Branching towards 0.1 release.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef8348a39bea67ddcc80c583ce0270fee899cdce">ef8348</a></td>
		<td>22 lines</td>
		<td>Fix typo:  Oprofile -&gt; OProfile</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef91906683a7d6a406fe45c65b33769cbf8b1482">ef9190</a></td>
		<td>16 lines</td>
		<td>2009-06-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Use Galileo dependencies. * tools/linuxtoolsupdatesite-trunk.sh: Pull from Galileo builds.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef9646664c8415c15bc10e43014b148b09de8930">ef9646</a></td>
		<td>4 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=efbe96f7578c8d7db08ff471322f027efc3f4fd5">efbe96</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eff3b7376aa5b8f3ee9ca38843166abd58b9266e">eff3b7</a></td>
		<td>13 lines</td>
		<td>Make cachegrind tests run with only required bundles present</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f011266cbb0960b11c7466d52d09569416147c30">f01126</a></td>
		<td>7 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * META-INF/MANIFEST.MF: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f02037d93a3ffa1aceb29ab4952fce1f4feed7d6">f02037</a></td>
		<td>38 lines</td>
		<td>2007-04-05  Remy Suen  &lt;remy.suen@gmail.com&gt; * META-INF/MANIFEST.MF: Initial commit. * build.properties: Include MANIFEST.MF. * plugin.xml: Declare dependency and runtime information in an OSGi manifest.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f093169ed606aa6963abe241bb6274fe271e138c">f09316</a></td>
		<td>6 lines</td>
		<td>2009-05-19  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=273931">Bug 273931</a> * feature.properties: Change provider from Eclipse.org to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f0a171374a16fa2aef7af4771174391be115253b">f0a171</a></td>
		<td>10 lines</td>
		<td>2009-04-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * site.xml: Initial check-in.  Will be used by Athena to generate p2 categories.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f0f623bb7d12093dcbcef59c6ea45a56bf0967ea">f0f623</a></td>
		<td>91 lines</td>
		<td>2007-04-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/tests/AllTests.java (suite): Add (commented-out) HyperlinkWithMacroTests. * src/org/eclipse/linuxtools/rpm/ui/editor/tests/HyperlinkWithMacroTests.java: New file.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f110c3970c79832de508642585f0b6ebd6847601">f110c3</a></td>
		<td>11 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add update site information.  Remove Linux requirement.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f12cbd117e0712afc8fe1262d406e9fd5b9ba9d5">f12cbd</a></td>
		<td>7 lines</td>
		<td>2009-04-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: 	Add ws qualifiers.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f145e71b12dfe77a76ae756de419dbcf3d0b4a89">f145e7</a></td>
		<td>11 lines</td>
		<td>Make massif tests run with only required bundles present</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f17fd10fb72e12c0300a70e571f7052ce76683fd">f17fd1</a></td>
		<td>7 lines</td>
		<td>2009-07-20  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Add RPM feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f188acfc83d1002d71692f6b99c4b4f6e38a0c41">f188ac</a></td>
		<td>9 lines</td>
		<td>ASSIGNED - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=252423">Bug 252423</a>: getDependency &amp; getTestDependency should handle case where input is an Update zip https://bugs.eclipse.org/bugs/show_bug.cgi?id=252423 Unpack test plugins.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f18b9d2c0ccd47ac59cc77b7b34a72edcc0ab63d">f18b9d</a></td>
		<td>6 lines</td>
		<td>2009-12-22  Roland Grunberg  &lt;rgrunber@redhat.com&gt; * META-INF/MANIFEST.MF: Make necessary changes to switch from JUnit 3 to JUnit 4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f1d9be5fd4cbb20d6c3ee546ec37d84ee67b213d">f1d9be</a></td>
		<td>1 lines</td>
		<td>Revert &quot;Add bin to devhelp gitignore&quot; This reverts commit 5b2a56f1f082a772c68168c980180735fc01e7e3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f1ecd3767890babba91f505796bb0bf5f3fb426e">f1ecd3</a></td>
		<td>2 lines</td>
		<td>Make valgrind version 0.0.0 in category list</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f204b103c91fa0822070ef64ff965beda9e092f9">f204b1</a></td>
		<td>16 lines</td>
		<td>2010-07-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * build.properties: Update URLs for final Helios builds of dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f20b9d5b73bab79ecbc832a1a7b81d0e45095a0e">f20b9d</a></td>
		<td>9065 lines</td>
		<td>Tag 0.5.1</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f212aa0787d3247679634867e8aba2891a904a76">f212aa</a></td>
		<td>39 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f213949c6453424844e8d3cc0629dc250705f8a4">f21394</a></td>
		<td>2 lines</td>
		<td>Bundle-vendor:  Red Hat -&gt; Eclipse.org</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f22ac114d886d72cda1edf7fefceb67a03831b76">f22ac1</a></td>
		<td>3 lines</td>
		<td>Add valgrindFiles to .gitignore files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f237b51fcbc028520a88e66e342471faa32c59a8">f237b5</a></td>
		<td>26 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f2435805eac076d486949aa305617d2b0162c987">f24358</a></td>
		<td>5 lines</td>
		<td>2010-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * fragment.properties: Change provider to Eclipse Linux Tools.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f27fa8a6718541bd96e8fcd09d3bd3e3f1fe5b7a">f27fa8</a></td>
		<td>5 lines</td>
		<td>2009-04-17  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/linuxtools.psf: Add releng project.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f28eca0a17b5d73f44fb083ce07e420070adbd22">f28eca</a></td>
		<td>6 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f33834bab63a2d50af753aa2d828534601bc538d">f33834</a></td>
		<td>18 lines</td>
		<td>2010-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * OSGI-INF/l10n/bundle.properties: New file.  Externalized strings. * build.properties: Add bundle.properties to binary build. * META-INF/MANIFEST.MF: Externalize provider and bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f351b5a05acdea27c2afb2f883c9a4af7e7a92e2">f351b5</a></td>
		<td>140 lines</td>
		<td>Merge Galileo branch to trunk.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f39dd733fffbd0f595f60ceb9786924b8c6f253b">f39dd7</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f43380d2a82608bb56eed4f17d68f66830e7f33f">f43380</a></td>
		<td>4 lines</td>
		<td>Re-add os directory to build.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f44cc0fc9ddc992ab5c33c06493d3172db305cfc">f44cc0</a></td>
		<td>7 lines</td>
		<td>Fix up SWTBot and CDT update sites for Indigo</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f4755bdc2c8b5b6b7a53c6bbc89902c698ce8a76">f4755b</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f4a06847363ca68f658099dff9c7c9d84a14c121">f4a068</a></td>
		<td>84 lines</td>
		<td>2010-04-12  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f54f62609b9ba939797726f13e9a9490828ea5ce">f54f62</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f5534b581786b9214e121e74cc90579f014a7fdb">f5534b</a></td>
		<td>8 lines</td>
		<td>Revert &quot;Fix assertion in external project creation.&quot; This reverts commit afcf63129652483040738c52229109fda98ab422.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f553ae82b9f9294bf953b04199c7939694510313">f553ae</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f64f5b706b79088131d3036e267fc8c8b8df6ce5">f64f5b</a></td>
		<td>12 lines</td>
		<td>2009-04-23  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove 5.0.0.qualifier versions on CDT dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f67e05f7ca379fb23665f8ec9f71a823e4f76aea">f67e05</a></td>
		<td>1 lines</td>
		<td>Export valgrind.helgrind internal package for tests plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f6c7c2243e6c77a5495623655ae72df9fd7038b4">f6c7c2</a></td>
		<td>8 lines</td>
		<td>2009-08-07  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=285861">Bug 285861</a> * plugin.properties: Change Provider to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f709a06112e3d5757c645d167e5611d9cecdb9ae">f709a0</a></td>
		<td>65 lines</td>
		<td>2009-06-29  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/linuxtools.psf: Add GProf and SystemTapGUI contributions. * maps/linuxtools.map: Likewise. * psfs/linuxtoolsAndAthena.psf: Likewise.  Update basebuilder to 3.5 tag. * build.properties: Use basebuilder 3.5.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f795177449a7d82d3165c866bfe4da56f8ab6406">f79517</a></td>
		<td>207 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f7e502d007fe133237c9c9fcc6a86d9ac09c0608">f7e502</a></td>
		<td>207 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f80e6b1492ff9f034c43de4223639d7324e8aac4">f80e6b</a></td>
		<td>6 lines</td>
		<td>test, please ignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f8226d52259173ff92ac37d2e68ce5145d855702">f8226d</a></td>
		<td>235 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright text. * license.html: Updated HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f88ae77eb343feb22896f0665ed84c4c50483f06">f88ae7</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f8c35517e84ddd3f8f3d7d767ae034000e97f154">f8c355</a></td>
		<td>1 lines</td>
		<td>Add ChangeLog to top-level pom.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f8c4c564d317408a33faabf49d0420d4a33ad60f">f8c4c5</a></td>
		<td>74 lines</td>
		<td>2009-11-09  Andrew Overholt  &lt;overholt@redhat.com&gt; * psfs/callgraph.psf: Fix typos. * psfs/autotools.psf: Likewise. * psfs/linuxtools.psf: Change &quot;http&quot; to &quot;svn&quot;.  Add &quot;anonymous@&quot; for CVS modules.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f8f145df1bbfc1ba108d6fcdf0f21bbe2b84ea12">f8f145</a></td>
		<td>246 lines</td>
		<td>Tag for 0.2.0 release.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f9055e0ad58b72ddb619c53c51b1a1c5fc7903eb">f9055e</a></td>
		<td>234 lines</td>
		<td>2010-07-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * maps/linuxtools.map: Update for 0.6.0 final.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f91c49c6d9f9c96e9d38221d4f5d29e046d8bdef">f91c49</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f96fce5e8881fc1a0c54be09147b42d43f91d976">f96fce</a></td>
		<td>8 lines</td>
		<td>Add valgrind and profiling framework test features.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fa003b35e6d40bdab6cf2d66af0d4652c05584f9">fa003b</a></td>
		<td>10 lines</td>
		<td>2010-01-18  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=300003">Bug 300003</a> * feature.xml: Add gcov feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fa05a8628602367a040364f4e4eba9202237e922">fa05a8</a></td>
		<td>45 lines</td>
		<td>NEW - <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=314868">Bug 314868</a>: Create category for SystemTap views https://bugs.eclipse.org/bugs/show_bug.cgi?id=314868</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fa8af6a395d333d292e6236fbdb66315f88d7805">fa8af6</a></td>
		<td>57 lines</td>
		<td>2009-02-02  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: Update.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fa998a8c4f9ef8311dabd9c5b6b51814b47f6eee">fa998a</a></td>
		<td>20 lines</td>
		<td>Build from valgrind trunk for now.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=faa93d6937cc0ea95235040fe3951e57494c9335">faa93d</a></td>
		<td>109 lines</td>
		<td>Add Subclipse deps. (ChangeLog tests) to have complete dep. chain</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fad91cfce05e48f8000ec785c544e1d8f4b4cfec">fad91c</a></td>
		<td>7 lines</td>
		<td>2007-05-04  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=185598">Bug 185598</a> * META-INF/MANIFEST.MF: Add &quot;Incubation&quot; to Bundle-Name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=faf991e55392d29466ba1e38a260ecf8ac4209eb">faf991</a></td>
		<td>30 lines</td>
		<td>2008-11-21  Andrew Overholt  &lt;overholt@redhat.com&gt; <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=253016">Bug 253016</a> * src/org/eclipse/linuxtools/changelog/core/actions/ChangeLogAction.java (createChangeLog): Don't refresh entire workspace when creating initial ChangeLog.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fb4211da96c51f2a695c9649c1010d2da63f8af8">fb4211</a></td>
		<td>159 lines</td>
		<td>Use git checkouts instead of map files</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fb4e6c5ab5df038170d8985ed5fc008c46e4c44a">fb4e6c</a></td>
		<td>8 lines</td>
		<td>2009-02-03  Andrew Overholt  &lt;overholt@redhat.com&gt; * test.xml: plugin-name -&gt; massif-plugin-name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fb8cdbd52c4d1fabf77fd70b0a21ccf634647756">fb8cdb</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fc2fc159d6816442b5148068151bd0d783ed6b37">fc2fc1</a></td>
		<td>16 lines</td>
		<td>2007-04-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * src/org/eclipse/linuxtools/rpm/ui/editor/tests/HeaderRecognitionTest.java (newFile): Remove unnecessary specfile instantiation. (setUp): Instantiate specfile object. (testGetComplexSectionName3): Update test to use getPackageName() instead of getName(). (testGetComplexSectionName4): Likewise. (testGetComplexSectionName5): Likewise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fcf501264aadeadfbe0f52e81c06f5f56de15f24">fcf501</a></td>
		<td>6 lines</td>
		<td>2010-05-18  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Fix provider name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fcf6687ad03c09d83b237c2ebf626b10152597b1">fcf668</a></td>
		<td>52 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fcfd9230d42f8227c087e9b55860935d34e1c1a9">fcfd92</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fd4f5f2c4a42d44a2e34b9ef24549ab6de727fa3">fd4f5f</a></td>
		<td>7 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Remove Linux requirement to see if it then gets included in all feature. Added update site information.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fd6fa822174980282efb3984c69cb12963e206cf">fd6fa8</a></td>
		<td>1 lines</td>
		<td>build.properties: Add about.html to binary build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fd8a864a12a1cdd7a887429ddceec684dd474c4e">fd8a86</a></td>
		<td>11 lines</td>
		<td>Remove pre-built opxml binary.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fd95b0fec2dddc1b9b64854daf6201c66b317362">fd95b0</a></td>
		<td>6 lines</td>
		<td>2009-11-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Fix bundle name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fda4ff3dca13a938190c534b64e8daa1337bf1b8">fda4ff</a></td>
		<td>26 lines</td>
		<td>Add missing about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fdd834118cec0f95e1a26a242ab5d7bc8c0b09bc">fdd834</a></td>
		<td>4510 lines</td>
		<td>Re-name directory to match refactored bundle ID.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fdf497dd27c64d555957396b52201d86d2d4714e">fdf497</a></td>
		<td>2 lines</td>
		<td>2009-06-16  Andrew Overholt  &lt;overholt@redhat.com&gt; * META-INF/MANIFEST.MF: Change provider from Ericsson to Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fe20b86523373f7ee8a9e35917e2d73ceb3bcb36">fe20b8</a></td>
		<td>8 lines</td>
		<td>2009-08-05  Andrew Overholt  &lt;overholt@redhat.com&gt; * category.xml: Fix a few more typos in libhover variable names.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=feca0ce2c64bc9a2b9ad6758b7eb1e635ff08755">feca0c</a></td>
		<td>110 lines</td>
		<td>Revert &quot;Add Subclipse deps. (ChangeLog tests) to have complete dep. chain&quot; This reverts commit faa93d6937cc0ea95235040fe3951e57494c9335.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=feecdfbf5bccf20f412eaa050ecc8275ffd8f9b7">feecdf</a></td>
		<td>8 lines</td>
		<td>2009-01-06  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.xml: Add update site information.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ff1fe3ed729d99a71c636262e9436f0307618912">ff1fe3</a></td>
		<td>222 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ff7e33d683913880a87ea898acb1b4c09e6c4072">ff7e33</a></td>
		<td>207 lines</td>
		<td>2010-04-26  Andrew Overholt  &lt;overholt@redhat.com&gt; * feature.properties: Match consistent license text (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>).  Update copyright year. * license.html: New file.  HTML version of SUA (<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627">Bug 306627</a>). * build.properties: Include license.html.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ffde2f7438e987a67fa8719b1c66a4cf31326f43">ffde2f</a></td>
		<td>37 lines</td>
		<td>Use proper about.html</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Andrew&nbsp;Robinson (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=353214">353214</a></td>
		<td>21555 bytes</td>
		<td>Modification of command running methods to allow process access.<br/>Updated patch.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=363027">363027</a></td>
		<td>5261 bytes</td>
		<td>Please add license feature to eclipse-build<br/>License feature patch.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=369578">369578</a></td>
		<td>2677 bytes</td>
		<td>Make eclipse-copy-platform use relative path.<br/>The updated fix.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Ben&nbsp;Konrath (bagu.org)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=74a22ba3f70460127d712be118b3cb4b18b6024f">74a22b</a></td>
		<td>4281 lines</td>
		<td>- Initial commit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7da1054a40486bb299d1e0aaaded9e4ab12bcec7">7da105</a></td>
		<td>112 lines</td>
		<td>2007-04-11  Ben Konrath  &lt;bkonrath@redhat.com&gt; * patches/eclipse-javadoc-linkoffine.patch: remove. * eclipse-build.sh: fix system-installed javadoc links.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=324e87181b236c5e23c9e3b34bfb8fa5646ffa30">324e87</a></td>
		<td>156 lines</td>
		<td>- Create svn repo structure.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=38557bf5fdc130fb5e864f95547a65274c83b098">38557b</a></td>
		<td>442 lines</td>
		<td>- Create svn repo structure.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=46b107ddafdd05ee8eed9bf3196b9140bb30be77">46b107</a></td>
		<td>5 lines</td>
		<td>2007-03-27  Ben Konrath  &lt;bkonrath@redhat.com&gt; * .svnignore: Rename from .cvsignore.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4a47b4930158c726141f778664c4ddef89a06d68">4a47b4</a></td>
		<td>635 lines</td>
		<td>- Initial import of ChangeLog plugin 2.3.4.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=525297224be85eb69cdde2903002672cb865e59b">525297</a></td>
		<td>16 lines</td>
		<td>2007-03-27  Ben Konrath  &lt;bkonrath@redhat.com&gt; * src/org/eclipse/linuxtools/changelog/core/editors/GNUHyperlinkDetector.java: Don't use internal classes. * .svnignore: Rename from .cvsignore.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7bf4054c9649f38573c6932298d6513cc051503a">7bf405</a></td>
		<td>18212 lines</td>
		<td>- Create svn repo structure.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a52069958c10156461d548ccf0dbfc5d698ec2ba">a52069</a></td>
		<td>5952 lines</td>
		<td>- Initial import of ChangeLog plugin 2.3.4.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Benjamin&nbsp;Drung (ubuntu.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=358246">358246</a></td>
		<td>1145 bytes</td>
		<td>[eclipse-build] Support finding libjasper-java 5.5.33-1 or newer on Debian.<br/>find-newer-system-jasper.patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Benjamin&nbsp;Drung (debian.org)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ee1a5cafa0964ea151daddf8ef0e43869cff28c5">ee1a5c</a></td>
		<td>2 lines</td>
		<td>Support finding libjasper-java 5.5.33-1 or newer on Debian.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Bernd&nbsp;Hufmann (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=316467">316467</a></td>
		<td>18412 bytes</td>
		<td>[LTTng] Histogram View short requests not coalesced with Control Flow View and Resources View<br/>Improved Request Coalescing and other performance / usability improvements (indigo)</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=327711">327711</a></td>
		<td>18412 bytes</td>
		<td>[LTTng] SWTException (widget is disposed) problem<br/>patch for asyncExec problems</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=329473">329473</a></td>
		<td>1127 bytes</td>
		<td>[LTTng] Experiment instability<br/>update vertical scrollbar in CFV asynchronously to get correct display</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=329579">329579</a></td>
		<td>911 bytes</td>
		<td>[LTTng] NullPointerException when opening HistogramView<br/>Fix for NullPointerException</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=329764">329764</a></td>
		<td>727 bytes</td>
		<td>[LTTng] NullPointerException when loading an Experiment<br/>Fix for NullPointerException in LttngExperiment</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=331156">331156</a></td>
		<td>1954 bytes</td>
		<td>[LTTng] Memory leak when selecting an experiment<br/>Fix for memory leak</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Camilo&nbsp;Bernal (voip-10-15-18-77.yyz.redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=36c6dc340a8fccfbd0e18e83abc9e468938256b7">36c6dc</a></td>
		<td>6 lines</td>
		<td>Implemented compare method for NameSorter class in PerfProfileView.java. Adding sorting functionality in PerfViewContentProvider.java does not have any effect on sorting. Implementing the compare method for NameSorter correctly sorts the tree elements by percentage.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Charley&nbsp;Wang (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=000d4b6344da5c5fe78d515dec74ba80a19a3609">000d4b</a></td>
		<td>21 lines</td>
		<td>Created abstract function postProcessing() in SystemTapParser for specifying actions after parsing is done.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=00698d6a0611e30feb528f3b8b662b7c2b4408e5">00698d</a></td>
		<td>12 lines</td>
		<td>2009-11-16  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Reflect change to static methods in SystemTapCommandGenerator</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=00bbf1d81910273fbed7bb00c4787d0881a9fb78">00bbf1</a></td>
		<td>22 lines</td>
		<td>2009-11-12  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchShortcut.java: Add method validFile(ICElement e): this function will return true if the given element is a .c, .cpp or .h file.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0127454f33d28ad34d08523d251e1892f02eb7cd">012745</a></td>
		<td>24 lines</td>
		<td>2009-11-26  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Make use of the generateCommand abstract function in ProfileLaunchDelegate</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0179f77b50831b2ef4c93c2f5677c20a0dca62b2">0179f7</a></td>
		<td>224 lines</td>
		<td>Added testMode variable to SystemTapLaunchShortcut. Added uncalled.c to force the selection dialog to trigger. Added calls to LaunchShortcutsTest to test dialog creation/function fetching</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=01d18757a336e61f157998d6f44e0c59c7b7c09e">01d187</a></td>
		<td>17 lines</td>
		<td>Changed LaunchStapGraph and errorhandler so that the probe call and return is all on one line</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0221d881860d575233916492d250bc0ed644b210">0221d8</a></td>
		<td>6 lines</td>
		<td>Changed error output path to a static String, rather than declaring on the fly</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=023cce103de1f34120f8a516dc1ddf6308f683b2">023cce</a></td>
		<td>84 lines</td>
		<td>Stopped exit calls from causing negative times to be displayed. Added capability to remember the last function that was called. Added goto_last Action in SystemTapView for going to said last function, as well as an appropriate keyListener (L).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=02ca0ada0c2a4c5daad480ff095ac169ff076c13">02ca0a</a></td>
		<td>11 lines</td>
		<td>Fix for 311780: Allows the CreateModuleAction dialog to close when the dialog is closed. Also changes the hotkeys for Export Script and Create Module Action from &quot;ctrl-X&quot; and &quot;ctrl-Y&quot; to &quot;ctrl-1&quot; and &quot;ctrl-2&quot; respectively. The latter two actions do not appear to conflict with any major editing shortcut keys.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=02fd2144b1e4dcd0cdb458ed38cabf9b18a701b6">02fd21</a></td>
		<td>321 lines</td>
		<td>Completely retooled Stap Parser and scripts so that all data aggregation/manipulation is done in Java.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=038e434aa46c4de0a045aa0b818b002f4bd7a89c">038e43</a></td>
		<td>10 lines</td>
		<td>2010-01-18  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Properly attach nodes with id &lt; 0</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=039fe7ab257a42dcde47cb73a9b20cb420008892">039fe7</a></td>
		<td>166 lines</td>
		<td>Removed eag.cpp, added eag.c with some modifications to work under c rather than c++</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0448e1bba7035f180b10f43556fc0e3501d884a4">0448e1</a></td>
		<td>9 lines</td>
		<td>2010-01-28  Charley Wang  &lt;chwang@redhat.com&gt; * psfs/callgraph.psf: Add profiling framework to callgraph.psf</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0479b8b978f5d1a0099a0d1471846632a1660c00">0479b8</a></td>
		<td>66 lines</td>
		<td>Replaced CheckedTreeSelectionDialog with RuledTreeSelectionDialog which subclasses the former -- everything is identical except the createDialogArea method adds a line after the buttons. Also fixed dialog so that child-items' checked status will change with parent-items' checked status, and other minor dialog appearance things.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0497d5b945c88cd7befc31f950b9ba5938713d94">0497d5</a></td>
		<td>26 lines</td>
		<td>2009-11-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Mild code cleanup, commenting</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=04cf8f4d08ae0e19724a18f77c829487916b208b">04cf8f</a></td>
		<td>2 lines</td>
		<td>Removed unused imports for MouseListeners</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=051c780e02eb7156e439fd1aaa2fb1c0f1438e20">051c78</a></td>
		<td>79 lines</td>
		<td>Removed graphUIJob. Added extension of the callgraphview extension point</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=052993c7eaa19c57185927a8754b284137ff2305">052993</a></td>
		<td>217 lines</td>
		<td>Fixed problem with bad timing, added cleanName function for preventing the printing of functions that contain a strange symbol, fixed statistics for aggregate view, adjusted script to work even if the program exits unexpectedly (exit call), fixed File--&gt;Save, added flag to StapGraphParser so parse Errors don't trip multiple times, changed end time calculation to avoid some round-off errors</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=053616056eea00916efff6a65d766850e5257d7e">053616</a></td>
		<td>13 lines</td>
		<td>Moved declaration of viewID to Delegate. Delegate now calls setViewID(config.getAttribute(VIEW_CLASS) after creating a parser class. Added declaration of viewID in LaunchStapGraph</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=058e5a809bf21332db87c2faf2eecea09ab6dec9">058e5a</a></td>
		<td>4 lines</td>
		<td>2009-11-26  Charley Wang  &lt;chwang@redhat.com&gt; * META-INF/MANIFEST.MF: Add org.eclipse.cdt.core, which seems needed with some versions and not with others.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=05c2902fd1a1b50ee77d5abf17c6efecf632e618">05c290</a></td>
		<td>39 lines</td>
		<td>Replaced getJob().cancel() in the Delegate with cancelJob() function, defined in SystemTapParser</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=05ca4576383002db92399fb67f6aebbd586e8a88">05ca45</a></td>
		<td>0 lines</td>
		<td>Removed useless file -- hopefully it will no longer appear.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=05d557cf7af8f08fbfd7cf8c4aba232312e09829">05d557</a></td>
		<td>2 lines</td>
		<td>Removed unused imports in LaunchStapGraph</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0638dca6aeabef97f479045b1fc8822a25882a3d">0638dc</a></td>
		<td>225 lines</td>
		<td>Switched potential print statements in StapGraphParser to MP, Changed some variables to conform to naming conventions and console now gets activated when the process launches, fixed some timing issues that were causing bugs, changed launch wizard naming convention for new configurations</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=082ee4161c7160f021eda762bed117d7b9783bba">082ee4</a></td>
		<td>637 lines</td>
		<td>Changed most fields in SystemTapView to non-static, so we can have multiple instances of SystemTapView-type things. Modified other classes/tests as need be.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=09107caeb7fe665cb4ad21d8a64f2705fa679e84">09107c</a></td>
		<td>8 lines</td>
		<td>2009-12-01  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java: While collapsing nodes, first check for existing collapsed nodes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0976ae02eb79bd1914a2004a111516ae6eb3c6ea">0976ae</a></td>
		<td>1 lines</td>
		<td>Removed unused import of PluginConstants</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0a318456aaacf8ce1bea51738eb7e2566e8ff449">0a3184</a></td>
		<td>25 lines</td>
		<td>Added pause.gif and perform.png, both images from Eclipse 3.4 (Source: http://xantorohara.110mb.com/core-icons/Eclipse.html). Made the Play button tooltip and icon toggle between 'Play' and 'Pause'</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0adcd9930742eae344ac1b6fba1e0fd212ad8a9d">0adcd9</a></td>
		<td>2 lines</td>
		<td>2010-08-19  Charley Wang  &lt;chwang@redhat.com&gt; * linuxtools.map: Added Callgraph docs plugin * callgraph.psf: Added Callgraph docs plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b0217568085d26d2487d3f6c599594e930a935c">0b0217</a></td>
		<td>4 lines</td>
		<td>The markers weren't commented out before? Commented them out.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b280916694b704ab0b40c13f67601b248a4ccdd">0b2809</a></td>
		<td>108 lines</td>
		<td>2009-11-04  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Make nonRealTimeParser work again * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Fix problem with marked messages not displaying until the methods have closed. * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Remove unused comments. Minor formatting. Make nonRealTimeParser work again.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b8e9452f7caf9443cf1d2110c81107b2f00d41f">0b8e94</a></td>
		<td>34 lines</td>
		<td>Updated more references to systemtap.local that were causing problems with extensions/extension points</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0ba97161dd081506eb212f4ff914b67b5a312349">0ba971</a></td>
		<td>70 lines</td>
		<td>Modified SystemTapParser to have realtime toggle switch. If realtime is set to true while viewID is set or if viewID is set while realtime is true the parser will attempt to open a view via a call to GraphUIJob. GraphUIJob has a SystemTapView variable that can be obtained via job.getViewer().</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0cc4c2916bfacbe801e89a12dda96a0ed4efb4fb">0cc4c2</a></td>
		<td>35 lines</td>
		<td>2009-11-06  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/XMLParser.java: Add javadocs, modify functions for ease of use.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0d46751585aeeb25a2a8061ebe1ca5114f352532">0d4675</a></td>
		<td>45 lines</td>
		<td>Removed function_count.stp and makefile</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0d636f83680a61e928e9611687c8b7eab4782eca">0d636f</a></td>
		<td>1518 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.local.launch.tests =&gt; org.eclipse.linuxtools.callgraph.launch.tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0dfca787d84bb7b5748c90d91da93d65126b1ccb">0dfca7</a></td>
		<td>28 lines</td>
		<td>Added asserts to check for the presence of function probes in the generated script.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0e0fa16b807449dd1ee4e2f9e64480acc2c21404">0e0fa1</a></td>
		<td>6 lines</td>
		<td>2010-02-02  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapCommandGenerator.java: Fix binary argument handling.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0e48426099b5f9c8fd0274b6aa3d911a9777e871">0e4842</a></td>
		<td>1 lines</td>
		<td>Removed org.eclipse.linuxtools.rpm.doc, which no longer exists in the SVN</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0f02a8dbc643dbf9839c14e42d3bc816e36b650a">0f02a8</a></td>
		<td>5 lines</td>
		<td>Added test for maximizing view</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0f99ea6a82bc641b7d7ce910272f48cacd1b8c9f">0f99ea</a></td>
		<td>253 lines</td>
		<td>Committing hooks for relaunch -- Roland please insert your code for quickly replacing chunks of the text :)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0fd9945d91dabd05a85a9d8dbdca086ddaa55146">0fd994</a></td>
		<td>17 lines</td>
		<td>2009-11-16  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/tests/SystemTapCommandGeneratorTest.java: Reflect change to static in SystemTapCommandGenerator</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0fdba5f4f6f6aee55e675c8447a22487d4e10a39">0fdba5</a></td>
		<td>62 lines</td>
		<td>Committed stap script for producing xml-esque output.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=104953aad246f38867e5cbb7ad00c7596e070fda">104953</a></td>
		<td>8 lines</td>
		<td>2009-11-05  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Externalize strings.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=10afca4d4858363efc2d6ce9c72cccb353416370">10afca</a></td>
		<td>1 lines</td>
		<td>Add final call to realTimeParsing after the while loop in RunTimeJob to help with a timing problem</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=112aec9d0e95530e73f38e4bcb3ac54472b7ed57">112aec</a></td>
		<td>118 lines</td>
		<td>2009-11-06  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/ConfigurationOptionsSetter.java: Remove unused Options setting function</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=11c138305dd92a4002cfd370098105d6d7d47a3e">11c138</a></td>
		<td>104 lines</td>
		<td>2009-11-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Use the new ProfileLaunchConfiguration.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=12510ee735700986093576c12a322cc48aaad7d5">12510e</a></td>
		<td>5 lines</td>
		<td>2009-11-30  Charley Wang  &lt;chwang@redhat.com&gt; * plugin.xml: Add icon to SystemTapTextView, from Eclipse Icons (http://xantorohara.110mb.com/core-icons/Eclipse-16x16.html)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=12b569ff334bad02c6db96ed17d3002676206dee">12b569</a></td>
		<td>58 lines</td>
		<td>Added limits action in SystemTapView (for user setting maximum nodes to draw)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=12b8fe1ab4065d5dd7cac2a609593ff77abab230">12b8fe</a></td>
		<td>5 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Do not label edges in uncollapsed .dot files. Change order of collapsed/uncollapsed .dot's</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=139f907d2ad762c548c396b4da744daf0f9a9099">139f90</a></td>
		<td>8 lines</td>
		<td>2009-12-08  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/tests/ConfigurationTest.java: Call generateCommand directly</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=13c7768611a81ccc4a57e3c221ae5eff7b871367">13c776</a></td>
		<td>543 lines</td>
		<td>Should not be part of 0.4 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=14056e8d315e91572c632aa55801212959eaf0f6">14056e</a></td>
		<td>2415 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.localgui.tests =&gt;org.eclipse.linuxtools.systemtap.local.tests THis test suite now contains only tests that depend solely on core and launch. Tests that refer to .callgraph have been moved to another test suite, and tests that contained a mixture of both graphing and non-graphing tests have been split into graphing and non-graphing components to be placed in their respective locations. Error in SystemTapDisplayTest and SystemTapGraphTest and StapGraphParserTest is intentional - SVN is refusing the changes otherwise. Will delete in next commit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=140cf40c47a2c0ca32b3ac54bbd9abaaa52472f9">140cf4</a></td>
		<td>20 lines</td>
		<td>Removed unused check functions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=14d2bb0f4e463f5af3562102f712d0ff0fe14a01">14d2bb</a></td>
		<td>13 lines</td>
		<td>Synchronize with trunk</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=14d74fcccc58cf3357503cbdaf0b539c0d8fe628">14d74f</a></td>
		<td>105 lines</td>
		<td>Added finishLaunchHelper to SystemTapLaunchShortcut, standardizing some of the prelaunch setup.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1533860aed85aea89f8a4533ad09f497b3057642">153386</a></td>
		<td>2 lines</td>
		<td>Set defaultEnablement to turn capabilities on by deafult</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=15e017cfa9f7a1491a65890143f3ee214580b859">15e017</a></td>
		<td>19 lines</td>
		<td>Stupid hack to get the Viewer button working in the Profile Configurations. Added iterator to the list of extensions of org.eclipse.view to see which had a namespace containing org.eclipse.linuxtools and an executable class of type SystemTapView. This throws CoreExceptions, which we ignore.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=165073cadb46a9e94326c89f5935bd66fd569301">165073</a></td>
		<td>1 lines</td>
		<td>Added error for when workspace contains ( symbols</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=16a2d020799407729617559792580a175bca2139">16a2d0</a></td>
		<td>6 lines</td>
		<td>2009-11-05  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/messages.properties: Updated UnknownMarkers error message.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1724bde5f08d7339d66c9b9451e019ea105e79a9">1724bd</a></td>
		<td>37 lines</td>
		<td>Add comments to functions, make thumbnail appear properly in realtime mode</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1838c0ceaeb0e1ec3e3cdc5f107d48faec6710d1">1838c0</a></td>
		<td>1588 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.local.tests =&gt;org.eclipse.linuxtools.systemtap.local.launch.tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1872c9734a1630ab3412838962d65dc447ad0c07">1872c9</a></td>
		<td>22 lines</td>
		<td>Replaced the CallgraphView object with a SystemTapTextView object.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=190ccdb237e28854798ace6869c9b19a1dc21730">190ccd</a></td>
		<td>2 lines</td>
		<td>Uncommented test</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=194ead73d837ff96f49d34814b71b291ec8f7dd8">194ead</a></td>
		<td>20 lines</td>
		<td>Cleaned up unused imports in LaunchShortCutsTest, removed unused variable in SystemTapGraphTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1ad228b3a58ffbb83408cab5aa5666ebcde76d81">1ad228</a></td>
		<td>81 lines</td>
		<td>Removed eag.c and factorial</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1bad6a31350a9476ec82450586e007642e322b27">1bad6a</a></td>
		<td>57 lines</td>
		<td>Changed error message in StapGraphParser to say &quot;Encountered return without matching call for function &quot; + name. Enlarged error log box. Fixed ConfigurationTest (after making a small change to getCommand SystemTapLaunchConfigurationDelegate), added ConfigurationTest back to AllTests suite.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1c57e588824c9aef26483c4933b122a5ff1fd553">1c57e5</a></td>
		<td>24 lines</td>
		<td>Modified SystemTapView to throw an error and print the viewID if it cannot cast the viewPart to SystemTapView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1c6da6dda14cdc55f03456d7d24712ebc2615314">1c6da6</a></td>
		<td>48 lines</td>
		<td>Moved callgraph icons from core to callgraph Added CallGraphConstants file to hold the location of the .callgraph project (will add more constants later) Added function in Activator to get the location of the project and store it in CallGraphConstants</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1d285d7e0910a6eab25fd7b126aa1439f2753712">1d285d</a></td>
		<td>7 lines</td>
		<td>2010-01-26  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Fix miscounting caused by lack of proper escape clause.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1d5ed72fc18116bbdd616e8c941cad99da9caebc">1d5ed7</a></td>
		<td>2 lines</td>
		<td>PluginConstants: Changed DEFAULT_VIEW_ID to poitn to SystemTapTextView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1da20772e5e330b705d64ec93ad56fc2bde555d5">1da207</a></td>
		<td>43 lines</td>
		<td>Fixed a number of things related to cancelling monitor: - Cancelling monitor during process execution will now properly terminate both the stap script and the RunTimeJob - Cancelling monitor during post-execution phase will now properly terminate the RunTimeJob held by SystemTapParser - Prevented multiple RunTimeJobs from being scheduled simultaneously</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1dd7c5d429865e0431fd96248627e012a8e25cf7">1dd7c5</a></td>
		<td>4 lines</td>
		<td>Updated timeCheck to trigger if total running time is &lt; 50ms, instead of 10ms</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1e016a2ae2f47a06554b83b2babdfb55766919d9">1e016a</a></td>
		<td>34 lines</td>
		<td>Removed unnecessary call to draw() from goto actions. Added clause to skip functions if all three of the following are true: 1. No function named 'main' has been encountered. 2. The function name contains an illegal symbol -- at present this means &quot; or ) 3. The function name contains a double underscore (&quot;__&quot;) These functions are disabled because they are likely to be C directives</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1e4672f7e7aee3184263386bafe8d0a5a34726c4">1e4672</a></td>
		<td>6 lines</td>
		<td>Changed the maximum number of errors to deal with to 500 Moved this number into PluginConstants, for easier manipulation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1f235fca6c14476efa2e698c8dba50b60cbc61fb">1f235f</a></td>
		<td>26 lines</td>
		<td>Changed some function names (setFile --&gt; setFilePath)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1f2d1a80046665c502fcccdf2a6fd8bae65d3435">1f2d1a</a></td>
		<td>10 lines</td>
		<td>Fix problem with nonRealTime graphing drawing 3 times</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=215402e167fcbbee8cc68ef5859afd2ca6b8491e">215402</a></td>
		<td>43 lines</td>
		<td>Changed DocWriter to append to end instead of writing to the beginning... Comments?</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=221b33bd7c1dc51b3be15613eee8f31f53c80fd5">221b33</a></td>
		<td>55 lines</td>
		<td>Fixed some missing globals and functions in parse_function_mark_partial.stp</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=241b52a001a0821e20f90679a087d2fed812be0c">241b52</a></td>
		<td>14 lines</td>
		<td>Renamed the launchFileDialogError method to launchFileErrorDialog -- the latter is more indicative of what the method actually does. Added basic implementation of realTimeParsing() to StapGraphParser</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=242c37bf26c202f63e3594c25f40f99e9089d356">242c37</a></td>
		<td>8 lines</td>
		<td>2009-11-20  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java (finishLoad): Set project in the regular load, not just in finishLoad</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=247dbca9c25a8dda777b4ab7c5cc26d0a2c13277">247dbc</a></td>
		<td>23 lines</td>
		<td>Proper sh.open() call</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=25222664f96f8cc4350248c5a9372f00a6240ecd">252226</a></td>
		<td>2 lines</td>
		<td>Changed message for total time &lt; 50ms marker.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=25605d0bfa7bb69aa54eb280c6d57af3739b1022">25605d</a></td>
		<td>3 lines</td>
		<td>Added oel.rpm.core, oel.rpm.core.tests and oel.rpm.ui to the psf</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=25d8d871751e56fa89775b06b20f6f6d587088de">25d8d8</a></td>
		<td>20 lines</td>
		<td>Cleaned up unused imports in LaunchShortCutsTest, removed unused variable in SystemTapGraphTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=268644e8fea8e63d80cc904bd96dfaa021464b3a">268644</a></td>
		<td>41 lines</td>
		<td>2009-11-12  Charley Wang  &lt;chwang@redhat.com&gt; * ChangeLog: Remove the ShellOpener class.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=277b5260d03b2822b4a59fbc6ce8f1078ef209f0">277b52</a></td>
		<td>14 lines</td>
		<td>Change svn+ssh to svn, in order to match everybody else :)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=282f24309ef6f80deeb617750b782d727e8163d9">282f24</a></td>
		<td>59 lines</td>
		<td>Make time collection work fairly well for real-time graphs. If the total time has not been set, the graph uses start time and end time to estimate the total time. The graph also assumes that any function which has not exited at the time of the pause is still running, and uses the current end time to estimate the total time taken by that function. Any time a new event is parsed (function call or return) the end time is changed to the time of this event. This means the granularity of the timing is restricted to the granularity of the function call/returns.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=298a0ce140c3a9963d9d51643869c2d780d572ae">298a0c</a></td>
		<td>432 lines</td>
		<td>Commented unnecessary function calculateAggregateStats in StapGraphParser, commented other methods in StapGraphParser previously used to tgenerate data maps, added copyright headers, removed some unused xml from plugin.xml in the .launch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=29d221b915b78ed74c634d76e36abed17d7c9541">29d221</a></td>
		<td>2167 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=29fbf2b2cceec548e0c3a53b9b4f57b9221628bb">29fbf2</a></td>
		<td>2 lines</td>
		<td>Warning cleanup: Suppressing warnings on the instanceof List check in ListTreeContentProvider, unused imports in SystemTapLaunchShortcut</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2a01a36b76bda62cb22093705ddd407c88e78cda">2a01a3</a></td>
		<td>6 lines</td>
		<td>2010-02-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapParser.java: Add a Thread.sleep() to stop abusing CPU cycles so much</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2acf8979464ec7491a386b21e8e603008b15725f">2acf89</a></td>
		<td>132 lines</td>
		<td>Revamped SystemTapParser's realtime parsing capability: If realtime mode is active, the run() method will create and schedule a RealTimeJob. The run method of the RealTimeJob consists of repeated calls to the abstract realTimeParsing() function. All an implementing class needs to do is create an implementation for realTimeParsing() and ensure that the isDone flag is set to true when the process terminates. &lt;CUrrently working on removing the latter restriction&gt; Roland: I removed the function you wrote for now, it's in my gedit -- when I get access to my sleepingthreads test plugin I'll try putting this into the SleepingThreadsParser class.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2b47b0c67cfe2fdfd1fc3ddc49eb27490132125d">2b47b0</a></td>
		<td>248 lines</td>
		<td>Modified CallgraphView so that it extends SystemTapView in core, moved most non-callgraph-related functiosn to SystemTapView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2ba5e617d861ec199b27a18d4abe367fdd7c923b">2ba5e6</a></td>
		<td>202 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Fix misgraph error in the writeToDot function.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2bf1f2b14642b09d7c003c43bb01b44299527c37">2bf1f2</a></td>
		<td>108 lines</td>
		<td>Added error check for debuginfo to errors.prop. Added comments to error for stapdev to include instructions for debuginfo and make uprobes. (This should be the first error that a user sees, so we may as well give them all the solutions at once. TODO: Get rid of the popup. It's really annoying. Just append the information to the console instead. Modified SystemTapGraphTest to test save and open as well. Added abstract saveData function to SystemTapParser, implemented in StapGraphParser (this is for testing purposes, and also because it sort of makes sense to have it there). Added checks for negative indices in SystemTalErrorHandler.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c044a1f2b976a3bb7c36fe2143106c4582586cc">2c044a</a></td>
		<td>48 lines</td>
		<td>2009-11-12  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/CallgraphCorePlugin.java (getPluginLocation): Add javadoc. Remove commented functions at the bottom.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c40b8b7c3cf3288aa35dc1e9a404bea9c6fa0ac">2c40b8</a></td>
		<td>2 lines</td>
		<td>2010-08-19  Charley Wang  &lt;chwang@redhat.com&gt; * linuxtools.map: Correct Callgraph docs entry</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2cb0eb4f0624ebdfd9843f8938378b1e22a6229e">2cb0eb</a></td>
		<td>22 lines</td>
		<td>These are the actual functions to go along with the previous commit - implements jumping directly to the line that a function was defined on.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2cc918806c8a102bf94939e6f707706620063832">2cc918</a></td>
		<td>16 lines</td>
		<td>Removed unused allsyscall.stp file</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2cd52cc8d377ebdb0ec9f9be1617f049835418a1">2cd52c</a></td>
		<td>2 lines</td>
		<td>Changed plugin id to org.eclipse.linuxtools.systemtap.local.core (was ...localgui.core)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2ce3ece4dd55ee432232fddf2c02741ae5b42543">2ce3ec</a></td>
		<td>1 lines</td>
		<td>Added call to &quot;kill stap&quot; to prevent occasional problems with the CommandLineTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2d245c1031dc8f9a613d970e71d8429800cde8d9">2d245c</a></td>
		<td>465 lines</td>
		<td>Added class SystemTapTextView containing all the printing functions from SystemTapView. STTV is an extension of SystemTapView. Added extensions to the SystemTapView extension point and the eclipse.ui.view extension point. Removed duplicate comments from Helper.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2d8105a14f048fbcf8eaab6dc30b44a542f0f3e5">2d8105</a></td>
		<td>2 lines</td>
		<td>Slight change to error message, deleted old package local</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2d82a866435c9726dfb705bb6471f759246b6924">2d82a8</a></td>
		<td>97 lines</td>
		<td>2010-01-13  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Add function parseDotFile() -- this function only works in nonrealtime. * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Add capacity for parsing .dot files generated by the program The toggle for parsing .dot or regular .out files is automatically detected if the file is properly formatted. Else error!</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2db387feeb3c2fdff7900511f330661638af6d91">2db387</a></td>
		<td>34 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.local.* =&gt; org.eclipse.linuxtools.callgraph.*</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e1dad8ddf72c788660c4c7f76244aa95c1f08b4">2e1dad</a></td>
		<td>3009 lines</td>
		<td>Rename plugin in SVN to match changes to the plugin itself</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2edf7b6e5fe7f2eaf23c04de4c20937fb170ecd5">2edf7b</a></td>
		<td>8 lines</td>
		<td>2009-11-10  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Up/Down.gif now refer to the correct icons.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2fad5bf82c6ab2be4b5f9e26bc586efd5bbef1ea">2fad5b</a></td>
		<td>6 lines</td>
		<td>Changed get and set methods for open_callgraph action to static</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=30c3f705b02feacc4f4da9cefc7c24082ad304f8">30c3f7</a></td>
		<td>63 lines</td>
		<td>2009-11-28  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/ViewFactory.java:Add createView function that uses secondaryID. * src/org/eclipse/linuxtools/callgraph/core/SystemTapParser.java: Add secondaryID * src/org/eclipse/linuxtools/callgraph/core/StapUIJob.java: Add toggle for creating views with and without multiples * src/org/eclipse/linuxtools/callgraph/core/LaunchConfigurationConstants.java: Add SECONDARY_VIEW_ID and DEFAULT_SECONDARY_VIEW_ID</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=31d2640cf2a6b59fbf15a46d24bf9545a0fde25f">31d264</a></td>
		<td>1191 lines</td>
		<td>Adding files for tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=31ea0a409f23030d940ca20b0e102356f3cfbdbc">31ea0a</a></td>
		<td>31 lines</td>
		<td>Added length map for determining length, offset of nodes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=326ff16e99a2489b88751dbe288a4928f7b66cd3">326ff1</a></td>
		<td>2 lines</td>
		<td>Note the source for 12446.monitorOn.gif</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=329e1fdfe336c837792d5a01c31d55006d8c03bb">329e1f</a></td>
		<td>5925 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.local.callgraph  =&gt; org.eclipse.linuxtools.callgraph (SVN name)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=337db5ccd0835cefb2f0297363d3b7147d8fd574">337db5</a></td>
		<td>18 lines</td>
		<td>2010-05-20  Charley Wang  &lt;chwang@redhat.com&gt; * build.properties: Revert back to 3.6M4 so the build doesn't keep failing</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=33b3abe0c5ee974cf3a49eed970d018990a16d9c">33b3ab</a></td>
		<td>2 lines</td>
		<td>Changed comments to more accurately reflect the launch function needed (public void launch vs just saying 'launch')</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=34488646d5a9c3b28960c8d208ffc17dbf6197fc">344886</a></td>
		<td>6 lines</td>
		<td>2010-01-26  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapParser.java: Fix settings for nonrealtimeparsing.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3596a50aa5e39d1d0c526077f8cc72c75f6aeac8">3596a5</a></td>
		<td>6 lines</td>
		<td>Added returns to CmdLineTest if canRUnstap in testConstants is false. Set canRunStap to be non-final</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=35ff9c655e8ca287fa0cb54e776d3e005c54b6d1">35ff9c</a></td>
		<td>9 lines</td>
		<td>2009-12-08  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Externalize strings and cleanup of the finishLaunch function Rename 'command' to 'stap' -- variable name was confusing</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=36d07db25093f8160f925b8148da0d4395b2d548">36d07d</a></td>
		<td>117 lines</td>
		<td>Delegate contains streamlistener class for the process' error stream, allowing us to parse all errors and not just the 80000 characters stored in the console.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=36de3e433aa07bb8d2480c5adeda6d7aca4ad56e">36de3e</a></td>
		<td>6 lines</td>
		<td>Box view draws 3x faster theoretically, practically more like 2x because of the way animations are handled in Zest.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=37524901ef4a2d074a410e58e498c6b3dfb7cb36">375249</a></td>
		<td>16 lines</td>
		<td>Refresh of the way LaunchShortcut works. Added setParserID, setViewID and setScriptPath variables -- these are called by finishHelper before the launch (though the user is more than welcome to call them him/herself in advance if they need to be set earlier for whatever reason.) Merged finishLaunchWith and ...WithoutBinary functions in SystemTapLaunchShortcut. Made StapLaunchShortcut Abstract, changing the tests that initialize it to initialize an instance of LaunchStapGraph instead.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=37c572a71d7798ddbba3665aed4c39674d562cf5">37c572</a></td>
		<td>19 lines</td>
		<td>Changed some display messages in SystemTapGraphTest, rearranged tasks to run a little faster</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=37cfea24bdecdbe8b5e56c058a3cb64f15129c33">37cfea</a></td>
		<td>4 lines</td>
		<td>Fixed problem with graph not loading -- removed unnecessary condition on the if statement inside the process loop.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=397aaaf5a1657bd6cab004593e3e05a13b14ffee">397aaa</a></td>
		<td>4 lines</td>
		<td>Renamed extension for callgraph to match new name of StapGraphParser class</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a136b8da12b6cad19a9f2403b73701c7fea9fab">3a136b</a></td>
		<td>6 lines</td>
		<td>Renamed the executeParsing() method in SystemTapParser to nonRealTimeParsing()</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a6983f58b2a92ef8a5e673a00d26ee3c5073f57">3a6983</a></td>
		<td>19 lines</td>
		<td>2009-11-12  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/LaunchWizard.java (.widgetSelected): Remove dependency on ShellOpener, use Display.asyncExec() instead.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b23d2007b34198beefff26393a3617200a803c9">3b23d2</a></td>
		<td>543 lines</td>
		<td>Adding files. SleepingThreadsParser parses basic information in XML-esque. XMLData is a simple data structure for node storage. XMLGraphingView turns arrays of XMLData into a Zest graph. LaunchSleepingThreads contains launch parameters.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3bf654776c56b71cdea6b7e87553fc6321716928">3bf654</a></td>
		<td>2625 lines</td>
		<td>Initial commit</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3ca32abbafe81d4f6d3cd119548ba9ed72494bec">3ca32a</a></td>
		<td>171 lines</td>
		<td>Added SystemTapDisplayTest back to the test suite, removed use of system time in SystemTapLaunchShortcut, added null checks and a convenience method to SystemTapLaunchShortcut to generate a new ILaunchConfiguration</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3d6f06c6071207aac4c2049b1ec48b42d133c5bd">3d6f06</a></td>
		<td>38 lines</td>
		<td>Make loadData in CallgraphView no longer overwrite/skip nodes unnecessarily.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3df42746c020dea14a26d88f5bd3fc9795e109f6">3df427</a></td>
		<td>30 lines</td>
		<td>Added function makeCreate() to SystemTapView, allowing the view to initialize without becoming visible.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3e4070c8f2a128a852cbf3184cf73e0ee6cdfbdd">3e4070</a></td>
		<td>17 lines</td>
		<td>Externalized strings in FileFinderOpener</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4028439f875ab98612e3070e0aaf47b0447ef4e4">402843</a></td>
		<td>64 lines</td>
		<td>Disregard previous commit, removing StapButton now.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=40850be4b4159b5620ecd57b6d4dc0711b580ef8">40850b</a></td>
		<td>21 lines</td>
		<td>Removed unused variable testMode from CommandParser, removed unused folder</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=40bd5e7acd4a30a45d53f6f990f72f43d07976cb">40bd5e</a></td>
		<td>54 lines</td>
		<td>Added tasklist to SystemTapGraphTest. Still some kinks to iron out, need to smooth the interface a little more, but it is usable.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4186ce9d15b1e9361d87578e92a2afd9a61ee30f">4186ce</a></td>
		<td>96 lines</td>
		<td>2009-11-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapErrorHandler.java: Create cleanScript(): function as a possible first step to abstraction of Error Handling</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=41d6b616adab6fad61f74b93d437a630cdd9e74b">41d6b6</a></td>
		<td>4 lines</td>
		<td>Added tooltip text to the up and down buttons in the thumnail</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4208ebbcd9a866c76194985925ea9c2cac2b79e1">4208eb</a></td>
		<td>3 lines</td>
		<td>Fixed warnings related to marked nodes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=43a112821a03ca43dbfceff68d56bd0726a48062">43a112</a></td>
		<td>4 lines</td>
		<td>2009-11-10  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Up/Down.gif now refer to the correct icons. Remove import of CallgraphCorePlugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4407d1f69d83e8a095babe7609fc85d5afb97a3e">4407d1</a></td>
		<td>459 lines</td>
		<td>Added comments, changed order of a few lines for efficiency, general cleaning up.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=440ae9a5a41ed60a025fb5a78420e46ed33e44bc">440ae9</a></td>
		<td>119 lines</td>
		<td>Removed animation menu from the menu manager for now, renamed &quot;Goto&quot; to &quot;Go to&quot; and externalized strings in CallgraphView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=443d0ed3f9c4c146de62752b2f9fb91c1f2586db">443d0e</a></td>
		<td>1 lines</td>
		<td>Fix classpath</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4473c7bc7d1dae89944df09961207536992db909">4473c7</a></td>
		<td>12 lines</td>
		<td>Commenting out tests in preparation for rename: will uncomment later</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=44f771e9a7744589274a0ed4342fb1384b3d4b90">44f771</a></td>
		<td>36 lines</td>
		<td>2010-02-12  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapView.java: Create default implementations of getParser and setParser using a private SystemTapParser variable. * src/org/eclipse/linuxtools/callgraph/core/SystemTapTextView.java: Get rid of getParser and setParser functions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=44faaa07aa31b537b22ae2813b904a8242760add">44faaa</a></td>
		<td>3 lines</td>
		<td>2010-02-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Change cancellation language/checks</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=450bd283368446056522bbdf8ec28ff07079374d">450bd2</a></td>
		<td>4 lines</td>
		<td>Removed unused comments from LaunchStapGraph</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4581f75794ce4ca8bad5df09a2eb60a198a878ab">4581f7</a></td>
		<td>7 lines</td>
		<td>Tree view will now colour the last level of nodes displayed if they possess children that have not yet been drawn (changes to StapGraph)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=458ab59cde77d7eea9b941476635a05b83970309">458ab5</a></td>
		<td>21 lines</td>
		<td>Made setViewID nonabstract, defaults to text view.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=467409a4034dccdbd0352cb59b0a1496a9417ed9">467409</a></td>
		<td>11 lines</td>
		<td>Add docs plugin to feature.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=46a869ad0d4353d2ac647116531c8237ea4f9c0f">46a869</a></td>
		<td>4 lines</td>
		<td>2009-11-10  Charley Wang  &lt;chwang@redhat.com&gt; * plugin.xml: Add icons folder</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=47052695a5eb7ccb8ea60610ef43d57d5b5f140e">470526</a></td>
		<td>172 lines</td>
		<td>Modified createOpenAction and createOpenDefaultAction functions -- these abstract functions return a boolean which determines whether or not they should be added to the File menu.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=47274def7e754f9a9fd954f9d5aa6d8573166f02">47274d</a></td>
		<td>5 lines</td>
		<td>2009-12-09  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java (loadData): Fix faulty marking of threaded nodes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4750e755494ba2225672c776ff551586441fa188">4750e7</a></td>
		<td>39 lines</td>
		<td>Added capacity for viewID settings in OptionsTab and LaunchShortcut</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=476ceac03d40850264dce89ac7b21f237586ecbc">476cea</a></td>
		<td>27 lines</td>
		<td>Make aggregate view display and sort properly. Removed one of the whiel loops, replaced it with a temporary hashmap (we don't want to modify the aggregateTime hashmap, because that would mess things up later on down the line). This is more computationally efficient, but at the cost of requiring more memory in the brief instance that aggregateView is generating data.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4785847dc3827a7c5846d66847b66094b3edf533">478584</a></td>
		<td>75 lines</td>
		<td>Modified plugin.xml in callgraph to match new extension definition for point org.eclipse.linuxtools.systemtap.local.core.parser. Modified SystemTapLaunchShortcut to include parserID variable, identifying the extension of the parser object to use. This variable is eventually set to the configuration via config.setAttribute(LaunchConfigurationConstants.PARSER_CLASS, parserID). Made the LaunchConfigurationDelegate take and launch based on an extension of point org.eclipse.linuxtools.systemtap.local.core.parser.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=481385e9d8c81415a744fe31e20e417c3dcb0e76">481385</a></td>
		<td>3 lines</td>
		<td>2009-12-08  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Make generateCommand public</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=48cea20cbf30daceb2191557b2c77d569826aec7">48cea2</a></td>
		<td>206 lines</td>
		<td>Added extension point for systemtap views (currently called callgraph.view, to match existing nomenclature) Added necessary constants for VIEW_ID and VIEW_RESOURCE to PluginConstants and LaunchConfigurationConstants Added setViewID() abstract function to SystemTapParser</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=493d087727f159196c94f3fdd08e36e88bcfc315">493d08</a></td>
		<td>99 lines</td>
		<td>Started adding a tasklist to SystemTapGraphTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4a100e8c81152fbebcc926a4b4ec1f57e2e18c5f">4a100e</a></td>
		<td>41 lines</td>
		<td>2009-11-18  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchShortcut.java: Make setParserID non-abstract. Default implementation returns the id of the SystemTap Text View. Create error message.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4a6800d1f848987efe8f35eb72182ba441bfcdac">4a6800</a></td>
		<td>70 lines</td>
		<td>Removed unused functions from SystemTapTextView. Added JavaDoc comments to println and prettyPrintln</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4a853be920460397ae48aeafa2035aabbd157c99">4a853b</a></td>
		<td>6 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java:	Remove unused import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4a87c1b95c9e92e0d86fd9448817f8b59bdf69b0">4a87c1</a></td>
		<td>20 lines</td>
		<td>Update to latest RC1 versions of Eclipse &amp; dependencies</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4ad0dda371c1d7e5756ff546a9ae7b5b0926d576">4ad0dd</a></td>
		<td>176 lines</td>
		<td>Added some mouse focus redirection when zooming in/out, fixed MouseListener so nodes can be dragged without causing panning, truncated long names (user can still mouse over nodes to see the full name), fixed aggregate view refresh error, fixed treeViewer being drawn on top of the horizontal scrollbar, removed unnecessary code graveyard from keyListener, changed Refresh and Collapse in KeyListener to use the actions in SystemTapView instead of their home-brew functions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4af66cf1a716ae7f30dff8444c30fba2cbfd3a82">4af66c</a></td>
		<td>12 lines</td>
		<td>2010-03-02  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java (launch): Toss out a message dialog if output path is broken.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4bc80bf01865b563033190b1a6a3063472f01ab6">4bc80b</a></td>
		<td>5 lines</td>
		<td>2009-12-21  Charley Wang  &lt;chwang@redhat.com&gt; * errors.prop: Get rid of error for uprobes -- the stap output is pretty descriptive. The popup box is just annoying.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4bce474abefcd1b84fb64af7e9db104a064a6189">4bce47</a></td>
		<td>5 lines</td>
		<td>Made ViewFactory only create, not bring into view.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4bfb3595b5fedba7d87d9acd0de9be50d43b9464">4bfb35</a></td>
		<td>196 lines</td>
		<td>Added capability to select files to profile from a list of available files when right-clicking a selection in project explorer, Fixed problem with TreeViewer not rendering after closing stap view, force refresh of SystemTapView when switching from radial to any other view (to remvoe TreeViewer composite)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4caa69a6a0cd8fdeb25ee79fb6b5142d15d863fe">4caa69</a></td>
		<td>3 lines</td>
		<td>Disabled UIErrorMessages in AllTests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4cb5ed190af40447cea098fa2acfd7345935c525">4cb5ed</a></td>
		<td>4 lines</td>
		<td>Updated name and id in the Manifest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4cd8fe8291ae00d37550bc0baa02b776341b13f7">4cd8fe</a></td>
		<td>16 lines</td>
		<td>Created createHelpMenu() action in SystemTapView, insetad of  leaving it merged with createErrorMenu().</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4d4386e170a0a2bcf581d02deff6f63919676047">4d4386</a></td>
		<td>40 lines</td>
		<td>Added SystemTapView.join method for joining with the UIUpdater job. Changed setData to take an Object argument</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4d6ff60ad61070509a29edf35d6ae8468bf3cb6d">4d6ff6</a></td>
		<td>22 lines</td>
		<td>Added functions to parse_function_partial so that we can create stap markers again</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4d7274f6fe3a73466555a9cee048fdb001404703">4d7274</a></td>
		<td>12 lines</td>
		<td>Moved docwriter to be the final thing we schedule</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4e22dc986a6719681d9750cb0c574c1728c05afe">4e22dc</a></td>
		<td>1018 lines</td>
		<td>Removed unnecessary files in tests/resources</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4e5cd501a3f746aaa9dd5ae624d99f296ed69c0c">4e5cd5</a></td>
		<td>12 lines</td>
		<td>Modified launchShortcutsTest to use the launch(IBinary, String)  method isntead of calling submethods directly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4e9c61dc8e4d7918baacfd40a3faf7e81536b2a5">4e9c61</a></td>
		<td>11 lines</td>
		<td>XML for use of SystemTapTextParser</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4eba4f326c403a218211274bcff84d960330d2b2">4eba4f</a></td>
		<td>20 lines</td>
		<td>2009-12-08  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Change delegate to launch by creating a temporary shell script, rather than launch directly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4f0a4d431c98e1061ca9ceb5cb84c151bd376a73">4f0a4d</a></td>
		<td>4 lines</td>
		<td>2010-01-18  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Cleanup of TODO's</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4f40cd68722459d234a3703e0e872649bbb32945">4f40cd</a></td>
		<td>29 lines</td>
		<td>Fixed a few minor things in SystemTap and CallgraphView with regards to the Display object being passed in. Added a few extra exceptions to the StapGraphViewTest, hopefully will show us what the problem is.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5002bcfabfcbf6c3bdc69752a5ca3a2730491443">5002bc</a></td>
		<td>6 lines</td>
		<td>2010-02-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/LaunchStapGraph.java: Add tid to marker functions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=500c8191b2c67157c919e6e2509280d9ee84aef2">500c81</a></td>
		<td>11344 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.localgui.graphing =&gt; org.eclipse.linuxtools.systemtap.local.graphing</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=507fd50fc54f21d5807bafe4ab198e8e0331c600">507fd5</a></td>
		<td>11 lines</td>
		<td>2009-11-27  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/tests/SystemTapCommandGeneratorTest.java: Add functions to use the new command option in the CommandGenerator class.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=50baf546bc6c4e252f9aab738815acbc66c44beb">50baf5</a></td>
		<td>24 lines</td>
		<td>Removed callgraphtest and catlan.c</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=50f37f7964435e470fcbc6793696e5e266474e0a">50f37f</a></td>
		<td>17 lines</td>
		<td>Computed dependencies for feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5110cd3ddb3f377e7f285544dd61712274ce3fcd">5110cd</a></td>
		<td>72 lines</td>
		<td>Moved getter for help actions into SystemTapView. Renamed Box View to Level View, including internal function names and constants.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=51432509fe11ffe689de0604585555043942eeb2">514325</a></td>
		<td>45 lines</td>
		<td>Added boolean return value to finishLaunch so we can check whether or not to attempt a relaunch. CHanged some strings in messages.properties.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=51492e82353679abfe025dc3fa824b1813e8407b">51492e</a></td>
		<td>14 lines</td>
		<td>Added quick checks in MouseListenerTest for mouseUp and mouseDown events -- since there is no way to verify that anything 'really worked,' we're essentially just testing for a lack of failure. Modified Manifest to include cdt.core.model, because we need it.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=51e4ee77b822400497d706e5f33026e62886144d">51e4ee</a></td>
		<td>47 lines</td>
		<td>Removed parse_function_nomark.stp and simple.stp -- This completes the process of removing unused files from .launch.tests (Since we can't launch stap from Hudson, none of them will be very useful. Currently pursuing ways to test without them.)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=524d92f7eeac220d5310915d244cc257a1b5a853">524d92</a></td>
		<td>7 lines</td>
		<td>2009-11-26  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchShortcut.java: Fix naming of basic configurations. Add call to PluginConstants.DEFAULT_PARSER_ID instead of hard-coding.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=537b9690aa713fa43081a0dec83f2ef5d7b683b9">537b96</a></td>
		<td>2 lines</td>
		<td>Patch for 306241 -- do not set visibility for Create/Export script actionsets to True</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=53e98a402e445146ede3f3b0d9a1aba4ff2f391e">53e98a</a></td>
		<td>208 lines</td>
		<td>MouseListener: Created helper function 'getNonNullNodeFromSelection', added action for ctrl + double click to attempt to open the selected file. Added class FileFinderOpener that provides methods to find and open files based on the specified project and function name. Got rid of some printlns that had remained after previous commits.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=53f09c15019dda48d71bc2e6cfa64e0297a4d8c4">53f09c</a></td>
		<td>4 lines</td>
		<td>Synchronized draw radial and treeviewer - when user double-clicks on a node, treeviewer now also highights the node that was double clicked (Radial view only)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=54204d0c15e6f06238b1b6d623f9da5357d3bf77">54204d</a></td>
		<td>0 lines</td>
		<td>Removed useless file -- hopefully it will no longer appear.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=54b317bed91a76cd4402db225d2cdac6ba1c3746">54b317</a></td>
		<td>16 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.local.graphing =&gt; org.eclipse.linuxtools.systemtap.local.callgraph</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=54bf446bff15c24ad40a63211394dbdf69406cf9">54bf44</a></td>
		<td>122 lines</td>
		<td>In StapData: Renamed callees --&gt; children Renamed collapsedCallees --&gt; collapsedChildren Renamed called --&gt; timesCalled</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5538456ee472cb38f21cabc0908da05a969a359d">553845</a></td>
		<td>14 lines</td>
		<td>Added some space to the label at the top, to match the space on the bottom</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=555b6a0bcca5301f77c23d76ca98b8c255987438">555b6a</a></td>
		<td>21 lines</td>
		<td>Made the file dialog in SystemTapLaunchShortcut list default to 'all', added a method in ListTreeContentProvider that returns all valid ICElements.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5584405b44abd8d093d70687503bce17e879fa06">558440</a></td>
		<td>58019 lines</td>
		<td>2009-12-09  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/tests/StapGraphParserTest.java: Fix to correlate with the new threading output. There are a lot of changes to the .graph files, all to add ',,1;' to the end of each call/return line to indicate that these are single-threaded. Tests for multi-threaded runs will come soon.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=55e2009a7dbb8b0f8a1b9e93d322b8d085bc8032">55e200</a></td>
		<td>38 lines</td>
		<td>2009-12-08  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Externalize strings and cleanup of the finishLaunch function</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=567354f309a25343e6f104b39271ab8a7a7fc7b0">567354</a></td>
		<td>5 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: (FIX: uncollapse should attach to d.parent, not d.collapsedParent)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=58803ff9686495a3f26576a6905f1759b7e96467">58803f</a></td>
		<td>6 lines</td>
		<td>2009-12-15  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/FileFinderOpener.java: Make findAndOpen safety-valve return null if project is null.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=58e00c459a8616a717218948c7e973824fa25a0d">58e00c</a></td>
		<td>16 lines</td>
		<td>2009-11-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationTab.java: Add (Currently empty) ProfileLaunchConfigurationTab * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchShortcut.java: Improve documentation on abstract functions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=597fc3b02a0f36dce77223feb2b39855c62d348d">597fc3</a></td>
		<td>1018 lines</td>
		<td>Removed unnecessary files in tests/resources</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a64dc9f323ba6963396144595ba738202a2b8e2">5a64dc</a></td>
		<td>1 lines</td>
		<td>2009-11-03  chwang  &lt;chwang@toto&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Delete unused temporary variable</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a828a4715d447b723c3279365e4c2fc7514b499">5a828a</a></td>
		<td>18 lines</td>
		<td>Added AllTests suite for testing purposes. Still need to double check which non-java files from .tests need to be migrated over to make all tests run properly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5b74c2a1dd3fdabde982680df18c6989438c14ff">5b74c2</a></td>
		<td>4 lines</td>
		<td>2009-11-03  chwang  &lt;chwang@toto&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Delete unused temporary variable</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5baaaed8d011b098381be0fbaaae1a357972fb9f">5baaae</a></td>
		<td>305 lines</td>
		<td>Enabled searching for functions in the currently selected file - right clicking in the editor will now simply attempt to profile all functions in the currently opened file</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5d397b3e41e6301067e7f7b8b7a87b95c6d954b5">5d397b</a></td>
		<td>151 lines</td>
		<td>Removed more unused xml from plugins.xml in localgui.launch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5e15d4fe220e038d494de570a9927959d4c1382a">5e15d4</a></td>
		<td>45 lines</td>
		<td>Added method to SystemTapErrorHandler for fetching the list of functions that could not be probed.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5ea8f67bf8e3e58358c950e7d82fa4e92139a6ad">5ea8f6</a></td>
		<td>6 lines</td>
		<td>Removed unnecessary imports from FileFinderOpener, the STLCDelegate and STLShortcut</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5eadabe4ec54faa2ea8131044d711ead3b8ece0f">5eadab</a></td>
		<td>42 lines</td>
		<td>2009-11-04  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Fix problem with marked messages not displaying until the methods have closed. * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Remove unused comments. Minor formatting.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5f0fa52a3b4a197b393997e14cc17e8216ddb86d">5f0fa5</a></td>
		<td>151 lines</td>
		<td>Added new test to callgraph: MouseListenerTest. Added get methods to StapGraph for fetching the relevant listeners. Modified FileFinderOpener so the relevant functions return a String -- the name of the file that was opened. Started implementing the MouseListener, but this is not yet complete (test will run without errors or failures, but has not 'succeeded')</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5f3ea266ce02ed630e5964b2eec502db58e418b4">5f3ea2</a></td>
		<td>336 lines</td>
		<td>2009-11-16  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/tests/SystemTapGraphViewTest.java: Change call to TestHelper to a call to ViewFactory * src/org/eclipse/linuxtools/callgraph/tests/SystemTapGraphTest.java: Change call to TestHelper to a call to ViewFactory. Remove unnecessary checklist, add assert in the call to parse.testRun * src/org/eclipse/linuxtools/callgraph/tests/MouseListenerTest.java: Change call to TestHelper to a call to ViewFactory</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5f57eb70884581abab7cdeafdf0e76cd461ad4fc">5f57eb</a></td>
		<td>1 lines</td>
		<td>Remove println hook in closing tag portion of the parse method.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=60193d85f59518ce3dea8b96429944292331acb4">60193d</a></td>
		<td>90 lines</td>
		<td>Reformatting, minor changes to javadocs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=60bef0a8a45fa5d5ad23dbc696b327cc1e8e471c">60bef0</a></td>
		<td>167 lines</td>
		<td>Moved options setting to class OptionsSetter, added null check in SystemTapLaunchShortcut, removed CommandList option for now (integration with other buttons would take too long), added parseError to errors.prop</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=60c60e72101952e9c3d2a9eedcf27247f5797aa3">60c60e</a></td>
		<td>18 lines</td>
		<td>Removed the help button from the dialog, removed the extra blank space between the buttons, made the size of the dialog's selection field depend on the number of elements in the list.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=60e0a989bb2e17f60ebc6c746ab8d9d59fbd43e4">60e0a9</a></td>
		<td>220 lines</td>
		<td>Moved FileFinderOpener to core -- this is essentially a helper function, and has no dependency on the graph itself. Also, it maybe useful for other scripts as well.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=611287aaac28f998bb4a0a4c3aefcb39f07e35e8">611287</a></td>
		<td>16 lines</td>
		<td>2009-11-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationTab.java: Add (Currently empty) ProfileLaunchConfigurationTab * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchShortcut.java: Improve documentation on abstract functions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6241aae72f39f29e6afaaeab3d7a562a2b2f66e6">6241aa</a></td>
		<td>36 lines</td>
		<td>Removed some more rounding errors that crept in when fixing exit calls earlier. When C directives are detected, automatically set the total time to the first user-defined node and attach a marked message to this node so the user knows that this has been done.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=625febd0f14a9b8ab5453dc839f11e67e015a631">625feb</a></td>
		<td>8 lines</td>
		<td>Removed unnecessary plugin.xml, updating build.properties</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=62a3ca5ed6d73ff56bedbb9796decfd28dc2bc35">62a3ca</a></td>
		<td>159 lines</td>
		<td>Converted errors to regex, moved error handling completely to SystemTapErrorHandler, added errors.prop file with regexes and an appropriate user-friendly response</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=62b4d6117c5228bbcb7e8411592e3e05dcfd53c2">62b4d6</a></td>
		<td>199 lines</td>
		<td>2009-11-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Add ProfileLaunchConfigurationDelegate. This class contains functions that Roland and I had difficulty with when we were creating the SystemTap plugin, namely the creation and reading of a process.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=632815d94abc7e7571f0a0a5d7c02ff1e5afd8a2">632815</a></td>
		<td>20 lines</td>
		<td>Prevent additional graphs from loading in a separate composite. Unfortunately, graphs now redraw twice instead of just once...</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=647432cafb55930153e5f48d3f7354e243846bb9">647432</a></td>
		<td>212 lines</td>
		<td>Added progress_stop.gif for the stop button on the kill script action button. This action button has been moved into SystemTapView as addKillButton(). A corresponding method exists for setting the enablement state of this button -- setKilLButtonEnabled in SystemTapView. A helper function setKillButtonEnabled has also been added to the parser so that the delegate can easily call setKillButtonEnabled(false) when the process has finished execution. The stop button now appears only when a process is running, and disappears when the process has been killed.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=647ea6c17ceb5387c43c58f628b82c7833bf6c28">647ea6</a></td>
		<td>60 lines</td>
		<td>Fix for 307195. Creates command oprofileStatus() that calls the defunctional &quot;--&quot; empty string as an argument. It should allow the cancel operation on the password prompt to work properly in most situations. Unfortunately there are still ways around this...</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=64cb9cf77ea3e29f9f2395acd77aa769342469fc">64cb9c</a></td>
		<td>151 lines</td>
		<td>2009-12-09  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraphParser.java (parse): Add basic threading capability into parse. Create maps sorted by thread ID for neighbours. * src/org/eclipse/linuxtools/callgraph/CallgraphView.java (loadData): Add basic threading capability into loadData</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=64f53a4382c7bf472384d887b1fd0fcfb9e1dc38">64f53a</a></td>
		<td>17 lines</td>
		<td>2009-11-17  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchShortcut.java: Have parser default to text parser if not selected</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=65214d32616db1afb8dd6ffa543fde7d43ec8880">65214d</a></td>
		<td>19 lines</td>
		<td>2009-11-28  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchShortcut.java (finishLaunch): Set LaunchConfigurationConstants.SECONDARY_VIEW_ID using an overrideable function (defaults to returning &quot;&quot;) * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Set the parser's secondary view id.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6562643117139ba3e2a6a90b4e12ec2c537c169f">656264</a></td>
		<td>33 lines</td>
		<td>Added testMode workaround to launchShortcut that will select all files named 'main' if testMode is active (from chooseUnit function)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=659ffc191ce830b6786a2ade7b6c169d61276e17">659ffc</a></td>
		<td>26 lines</td>
		<td>Moved polling loop inside SystemTapParser, all user needs to implement is the 'meat' of the polling.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=65a15a3e7e0899fc38c0fdb2812bee6636894863">65a15a</a></td>
		<td>2 lines</td>
		<td>Fixed reference</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=666d640df58184acb43b1dfaac51de1b7e92acfc">666d64</a></td>
		<td>1 lines</td>
		<td>Fix classpath</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=669806f520301a6a0c53f01589d94bb99cf718b1">669806</a></td>
		<td>16 lines</td>
		<td>2009-12-15  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapParser.java: Set monitor * parse_function_partial.stp: Remove semicolon from partial script</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=66cc245fdddff586b961293bbcc0091eb26fc87b">66cc24</a></td>
		<td>4 lines</td>
		<td>Missed a commit with the previous submission? Made SystemTapViewTest aware of the fact that makeView returns null.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=66e074b645d586c1d6fe46e446e0facc276c3884">66e074</a></td>
		<td>193 lines</td>
		<td>Added createSaveAction() method to SystemTapView, which creates a default Save action (protected Action save_file) referencing a public saveData(String targetFile) method in SystemTapView. Modified some comments. Created sourcePath variable in SystemTapView so the view knows which file is being used to generate the view (in addition the the parser object) Updated test methods accordingly to accoutn for the change.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=672199e3315b870c05154bf5201bd9c9fb2c1b14">672199</a></td>
		<td>24 lines</td>
		<td>Add comments to various functions in StapGraph. Fix CallgraphView so that startTime and endTime are set properly each time updateMethod (and hence loadData) is called.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=689ed17ca9e9275ec834e3914872d6d41c62cad0">689ed1</a></td>
		<td>175 lines</td>
		<td>Removed unnecessary extension point for SystemTapViews. Can just extend org.eclipse.ui.views instead. Made the necessary changes to PluginConstants.VIEW* constants as well as to the CallgraphView extension in .callgraph plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=68a04713c99b139ce75fef6fc1f929ab8c82f219">68a047</a></td>
		<td>2 lines</td>
		<td>Format change log</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=691257bad55fa9ec712f0d4ef20a93425efe9cf2">691257</a></td>
		<td>82 lines</td>
		<td>2009-12-21  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Fix setLimits logic Add save as ASCII option -- TODO: Implement a table view in Eclipse.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6a4d020fd3b79f07c70a0cc8e9e72cb538f7d52f">6a4d02</a></td>
		<td>211 lines</td>
		<td>Initial import. This project will blanket-disable all UI contributions from: Gprof Gcov Lttng Tmf Callgraph Valgrind OProfile This project should NEVER be included in a build!</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6a84acb12b8f584377010f3c33adbb39359bab79">6a84ac</a></td>
		<td>2415 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.localgui.tests =&gt;org.eclipse.linuxtools.systemtap.local.tests THis test suite now contains only tests that depend solely on core and launch. Tests that refer to .callgraph have been moved to another test suite, and tests that contained a mixture of both graphing and non-graphing tests have been split into graphing and non-graphing components to be placed in their respective locations. Error in SystemTapDisplayTest and SystemTapGraphTest and StapGraphParserTest is intentional - SVN is refusing the changes otherwise. Will delete in next commit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6b14dedab52e432e254a2093ddc8c5829d795b22">6b14de</a></td>
		<td>38 lines</td>
		<td>2009-11-17  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Fix draw() to redraw from the root visible node number rather than the first available node.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6b93c7ef63cdad30863a177f62de46959f80a5a9">6b93c7</a></td>
		<td>138 lines</td>
		<td>Added buttons to thumbnail for scrolling up/down -- works more intuitively in box view than in tree view. Added some 'scrolling up' in tree view - just deletes nodes from the bottom. Added AutoScrollHelper class and an AutoScrollSelectionListener class with toggles for different types of actions (i.e. up button, down button and scroll bar) Have not yet added any listeners for the scroll bar, not sure if I should...</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6bc373abd0fb137cb110ae1596942c8ef9b277a3">6bc373</a></td>
		<td>128 lines</td>
		<td>Fixed relaunching even for really large numbers of functions (although this is quite slow). For large numbers of errors, the plugin will warn the user that the relaunch will be slow and suggest relaunching with a different selection.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6bc4f1ce7f9c1275c671c98726ebf240ae542374">6bc4f1</a></td>
		<td>6 lines</td>
		<td>2009-12-21  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Fix setLimits logic</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6c19becce9d1da1082e585c074166bc72fdf3bb4">6c19be</a></td>
		<td>80 lines</td>
		<td>2010-01-18  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Proper error catching for number parsing failures.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6c479bd861cb92371d87686e308f3adf551cd985">6c479b</a></td>
		<td>90 lines</td>
		<td>Moved GraphUIJob to callgraph.core</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6c4b2a379e7dbf3fb82657ad865534b35facf45b">6c4b2a</a></td>
		<td>1 lines</td>
		<td>Removed extra print message</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6cb5c141a93c4a5c20e98aece989ecb40a47a60b">6cb5c1</a></td>
		<td>79 lines</td>
		<td>Created function generateScripts() in SystemTapLaunchShortcut, which can be overridden by other classes. Added private IBinary field to SystemTapLaunchShortcut, available for other classes to set.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6ccd02ab45b247456bb486c141b5a17a3f193508">6ccd02</a></td>
		<td>166 lines</td>
		<td>Removed eag.cpp, added eag.c with some modifications to work under c rather than c++</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6d22de57de24bd7a3ee842ebe1b2fd88c63e7673">6d22de</a></td>
		<td>17 lines</td>
		<td>Changed error message in StapGraphParser to say &quot;Encountered return without matching call for function &quot; + name. Enlarged error log box. Fixed ConfigurationTest (after making a small change to getCommand SystemTapLaunchConfigurationDelegate), added ConfigurationTest back to AllTests suite.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6d279fbe736ba947fb657bc7b6434cb45e5fc392">6d279f</a></td>
		<td>51 lines</td>
		<td>Added toggle switch 'active' for SystemTapUIErrorMessages -- set to false if you don't want error messages to pop up. Removed useless files in tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6d6717ea685f50c7ce02e11df744d809e1f67bb1">6d6717</a></td>
		<td>124 lines</td>
		<td>fixed copyright for shellopener, removed useColour argument and commented unused functions from SystemTapcommandGenerator</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6da6fb798e4da692f365ce9a61932662d12aaf09">6da6fb</a></td>
		<td>38 lines</td>
		<td>2009-11-09  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapData.java: Cleanup * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Delete unused functions, simplify logic in StapGraph setCollapsedMode.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6e0a0fab55bc6e5d0e0be0fc9c5ff93ac800dd10">6e0a0f</a></td>
		<td>18 lines</td>
		<td>2009-12-15  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Make the project variable non-mandatory. Read and reset buffer to avoid eating an extra line while looking for project name.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6e5709a84effdb0ed2f4777f9531f7891026cb60">6e5709</a></td>
		<td>81 lines</td>
		<td>Removed eag.c and factorial</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6e978c2cab7ffe069c7dd215400310fb7c8e6a1c">6e978c</a></td>
		<td>3 lines</td>
		<td>2009-12-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Remove System.out.println hooks.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f49043f83fd2ba4c706db3d5c467a150c63c352">6f4904</a></td>
		<td>11 lines</td>
		<td>2009-11-27  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/tests/SystemTapCommandGeneratorTest.java: Add functions to use the new command option in the CommandGenerator class.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f82cec7fe5515b2f091012ea94b9468289fdfda">6f82ce</a></td>
		<td>51 lines</td>
		<td>Changed some error message contents, added error message popup when relaunching</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f9544e52736e712c6dbcb04ff51fdcbeba879c7">6f9544</a></td>
		<td>2 lines</td>
		<td>Added call to setFilePath in Delegate</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=70e942000b60a3896274e7bd53ae14f93347549e">70e942</a></td>
		<td>137 lines</td>
		<td>Achieved basic functionality for real-time view updates. Made RunTimeJob a job, so that realTimeParsing() can contain polling loops. Made the SystemTapView.update() function schedule a ViewUIUpdater UIJob, which calls the user-defined updateMethod() method. Other minor cosmetic changes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=71281fd73a4dc91fb875e9765cb93eec98a2cbc9">71281f</a></td>
		<td>12 lines</td>
		<td>Add systemtap.local.psf</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7138a198c229896239043f846eece7831eac011e">7138a1</a></td>
		<td>269 lines</td>
		<td>Externalized strings, added tooltips to SystemTapOptionsTab, added Save option to SystemTapView, reorganized functiosn in SystemTapView, added ReadFile helper function to Helper, added mute() and unmute() functions to MP, removed parse_function and parse_function_nomark</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=71cec842b25f51004811e9fb0d70369361cd2b70">71cec8</a></td>
		<td>18 lines</td>
		<td>Update to tests to match rename of localgui.launch to local.launch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=72090706dce25515d6ee3de716c83e47d84bc4ae">720907</a></td>
		<td>3 lines</td>
		<td>Add cdt testplugin to make OProfile tests work</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=720abb64cc218e47f310de695fe5a1eaaf43115f">720abb</a></td>
		<td>5 lines</td>
		<td>2009-12-22  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Only display error popup if there is something to say -- use isErrorRecognized instead of message length.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=723233b43680d3b51167f4a043c44d3827436488">723233</a></td>
		<td>113 lines</td>
		<td>Removed unused warnings in launch. Renamed the schema for parser extension points.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=72a5f369ce17db582b59d5fb05b7af635fb7b400">72a5f3</a></td>
		<td>31 lines</td>
		<td>Finished implementing backend for markers by adding functionality for parsing marked messages.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=72cecbd13e2bc90a7c0232c4db8d0b5a23bd63c0">72cecb</a></td>
		<td>59 lines</td>
		<td>Removed prints from StapGraphParser, added actions for ErrorLog to SystemTapView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=73d54f1faadb3c11f722cf54231bd867e0f6c4d4">73d54f</a></td>
		<td>5 lines</td>
		<td>Removed reference to icons, removed allsyscall.stp, added systemtapbanner.png to build list</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=74b2d6f91f928f03bc86aafb86adb79fdc443567">74b2d6</a></td>
		<td>54 lines</td>
		<td>Added tasklist to SystemTapGraphTest. Still some kinks to iron out, need to smooth the interface a little more, but it is usable.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=74b4ff7e481075eebeb30b8a2ed16dfa2c141138">74b4ff</a></td>
		<td>33 lines</td>
		<td>Modified LaunchStapGraph to allow markers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=74cd133ce86e23381a5a17efa73a2c6b59149b42">74cd13</a></td>
		<td>65 lines</td>
		<td>Fix bug with drawBox not displaying collapsed nodes properly. Revamp the isPartOfCollapsedNodes logic. Add a check for !isOnlyChildWithThisName when skipping nodes (nodes which are the only child with that name should never be skipped)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=75712fa37be5c8a847053f07e7eb57590e1a4c69">75712f</a></td>
		<td>1650 lines</td>
		<td>2009-11-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapView.java: Use deleteLog function * src/org/eclipse/linuxtools/callgraph/core/SystemTapErrorHandler.java: Add deleteLog function</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=758aceb397233dc0e443d179c52cab3901418a45">758ace</a></td>
		<td>4 lines</td>
		<td>Removed unnecessary cast CallgraphView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=75b4f57384502bb9f8345d638b4fd87a3076a0f6">75b4f5</a></td>
		<td>2 lines</td>
		<td>Changelog edit</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7676ec7903208bbfe2b962221c504ccceb35e423">7676ec</a></td>
		<td>30 lines</td>
		<td>2010-02-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Fix markers to work with threads</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=767711d660997002661a0d18f393b2910ccacc3b">767711</a></td>
		<td>3019 lines</td>
		<td>Initial commit</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=77817667fa612bc1d298a84be1b700a595992d97">778176</a></td>
		<td>73 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Add &quot;Save current view as .dot&quot; which will save only the currently visible nodes, in whatever collapse mode they are in. Fix problem where nodes will display parent's timeCalled instead of their own.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=77ab02462a2db18ac0c14f0991a22b848e2ffbd6">77ab02</a></td>
		<td>9 lines</td>
		<td>Made jump-to-functions jump to the parent of the selected function, moves directly to the line containing the definition of the parent function, as well :)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=77ae8a54ea14ff3025550cedff7b49b7891d9514">77ae8a</a></td>
		<td>99 lines</td>
		<td>Started adding a tasklist to SystemTapGraphTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=787e2161f3146123192332c92fa80552861fd741">787e21</a></td>
		<td>5 lines</td>
		<td>Removed unused imports in SystemTapLaunchConfiguration, all warnings should now be gone.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=78bf255f0c53596ba8485ada3cc44052dc7b8809">78bf25</a></td>
		<td>183 lines</td>
		<td>Externalized most strings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=795bbe92f0998a32fcd8005820952534c9b97771">795bbe</a></td>
		<td>6 lines</td>
		<td>Comment out local source directory and Java_home lines, as standard</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=79fde48f4a6a771121bd27e4f8722837427cb6e2">79fde4</a></td>
		<td>2 lines</td>
		<td>Updated one reference to localgui.graphing.stapview to local.graphing.callgraphview</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7c81318cedd11d04bbc90f2faf1428ad1dce0994">7c8131</a></td>
		<td>23 lines</td>
		<td>Proper sh.open() call</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7d4562f4b9ed2c7a24d641c75c9e0b8a4d69a144">7d4562</a></td>
		<td>18 lines</td>
		<td>Eliminate N^2 portion of the layout algorithm.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7d99d9510bb9ac926d65f6a43e947e101174064b">7d99d9</a></td>
		<td>9 lines</td>
		<td>Eliminated useless call to create new file in LaunchStapGraph</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7da57fdfc78db1c067414f43157ac2b55bab91d4">7da57f</a></td>
		<td>164 lines</td>
		<td>Added parser tab to the options tab. Clicking on the Find parsers button will prompt the user with a list of available parsers. Delegate will use this parser to process data.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7dd1220fd59debd3c481347f7cb3a5a6692111d1">7dd122</a></td>
		<td>173 lines</td>
		<td>Rearranged functions in SystemTapParser so it makes some sort of sense, instead of leaving the functions lying around in no apparent order.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e0dfcd6aeb9da1808e1e013e59fc6c447bf12ae">7e0dfc</a></td>
		<td>20 lines</td>
		<td>Cleanup of SYstemTapGraphTest -- In case it wasn't clear, the previous commit was the first addition of those files to SVN.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e1995ac4f5705f0bb404dae4842688dd2f76852">7e1995</a></td>
		<td>1518 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.local.launch.tests =&gt; org.eclipse.linuxtools.callgraph.launch.tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e37b3359dae85d030b8fd39885ed53e047da248">7e37b3</a></td>
		<td>70 lines</td>
		<td>Fixed error in LaunchStapGraph that was causing subsequent launches to use the exact same list of files/functions to probe. Fixed script-generation capability -- launchstapgraph now does not write anything to file, nothing is written until the delegate, which takes the generated script and places it in the targetted file.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7ec90da0a0d20280fbb0ade10b47705ea26ee797">7ec90d</a></td>
		<td>51 lines</td>
		<td>Moved draw to be the last action we perform in GraphUIJob, added borders to graph/thumbnail, removed references to SystemTapView.maximizeOrRefresh() in StapGraph, moved reference to the end of draw(int,int,int), added a call to layout() between each added/removed GridData, made sure to remove the composite before adding a new one (also in StapGraph). Thumbnail now displays properly, overlaid on the existing graphs. There is still a bug with the size of the thumbnail: it looks like the thumbnail is either obeying the width hint too strictly or something else, but the border is definitely too big.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7eef9f939425841347dd6d17d2f432e525563a65">7eef9f</a></td>
		<td>3 lines</td>
		<td>Added resources to binary build</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7f912ff035a7547d4eb0a028f0bf2575ce1bdc40">7f912f</a></td>
		<td>2 lines</td>
		<td>Fixed problem with subsequent relaunches not displaying properly -- added a dispose call to createPartControl in CallgraphView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7fd6db9c990ae996dcb2b1e8290bb1f4a847a816">7fd6db</a></td>
		<td>6 lines</td>
		<td>2009-12-15  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Add extra catch to prevent missing data in the graph.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7fdaad17ab972f1f95bdf6c323dd46c875e31131">7fdaad</a></td>
		<td>125 lines</td>
		<td>Remove the now deprecated/useless parse_function_mark_partial.stp</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8010ed4e5e995ec824395340e9583560fe466d6e">8010ed</a></td>
		<td>24 lines</td>
		<td>Removed callgraphtest and catlan.c</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=805487c7939fcb6793b6336facf26419bf9178cd">805487</a></td>
		<td>13 lines</td>
		<td>Fix some no job termination problems when stap throws an error</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=80635e906fa4affb485025ab569e2bde6a5372f0">80635e</a></td>
		<td>128 lines</td>
		<td>Committing temporary fix to allow error log to read and attempt to fix all probe errors.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=808546afd8980de1291d9daf17efdeab550cff0e">808546</a></td>
		<td>230 lines</td>
		<td>2009-11-09  Charley Wang  &lt;chwang@redhat.com&gt; * META-INF/MANIFEST.MF: Change reference to Activator to reflect name change * src/org/eclipse/linuxtools/callgraph/treeviewer/StapTreeLabelProvider.java: Change references to PLUGIN_LOCATION to use getter. * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Change references to PLUGIN_LOCATION to use getter. * src/org/eclipse/linuxtools/callgraph/CallGraphConstants.java: Change PLUGIN_LOCATION to private, create getter. * src/org/eclipse/linuxtools/callgraph/CallgraphPlugin.java: RENAME: Activator --&gt; CallgraphPlugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=810689a9e38784dfc5dfd69b87100e36ce872772">810689</a></td>
		<td>43 lines</td>
		<td>2009-12-18  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Reorganize menus and externalize.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=81931ab18c17db4ac3ac83d8401cdf0b6e036b39">81931a</a></td>
		<td>7 lines</td>
		<td>2009-11-12  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java (StreamListener.streamAppended): Add a return if text is less than 1 character</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=81b4c242400380e22e7b33c5918a7fd894d195c4">81b4c2</a></td>
		<td>99 lines</td>
		<td>Added tree icon, added Aggregate View icon, commented out launchAbout, removed warnings, added icon for collapseMode, changed fileSelector to OnePanel instead of TwoPanels. Added icons: ....core/icons/mode_collapsednodes, radial-view, showchild_mode, tree_explorer. Externalized some strings. All icons are either from Eclipse itself or made in house.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=831d27da9bc8ce5f66f655ebaeb327f7df5b3380">831d27</a></td>
		<td>3 lines</td>
		<td>Added resources to binary build</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=84316c441d33513be55098e27566a5b76ba3f50e">84316c</a></td>
		<td>565 lines</td>
		<td>Change SystemTapParser so that real-time graphing will work. Implement updateMethod in CallgraphView Implement realTimeParsing in StapGraphParser Some changes to SystemTapParser and StapGraph organization so it will work To test real-time parsing, add a new line after every line printed in parse_function_partial.stp and set realtime=&quot;true&quot; in the plugin.xml for org.eclipse.linuxtools.callgraph</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8436083d4490d6ba41ac24dce512e4833d91cdd7">843608</a></td>
		<td>308 lines</td>
		<td>2009-11-06  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/CallgraphCorePlugin.java: Rename Activator --&gt; CallgraphCorePlugin. (start): Clean out the start method to contain only the bare essentials instead of always finding the location, etc. on startup.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=84571264f7fdd328d568e66164c2088081ae0934">845712</a></td>
		<td>28 lines</td>
		<td>Externalized last few strings in core and launch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8459b1c66524c434a1df8d8b724a41d19dc81cbc">8459b1</a></td>
		<td>217 lines</td>
		<td>2009-11-09  Charley Wang  &lt;chwang@redhat.com&gt; * META-INF/MANIFEST.MF: Change to reflect rename of Activator * src/org/eclipse/linuxtools/callgraph/launch/CallgraphLaunchPlugin.java: RENAME: Activator --&gt; CallgraphLaunchPlugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=84827dd4719618e7768e143738eed10740ee5c18">84827d</a></td>
		<td>2 lines</td>
		<td>Removed _feature in the feature id</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=84845eb01cd8f98dd5987e16fce0b6ff22d96fc2">84845e</a></td>
		<td>33 lines</td>
		<td>Changed the way views are created, proof of concept only. Added a static array of views to ViewFactory, had SystemTapTextView add itself to that array as the last action of createPartControl.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8500b6fe16fe49b15301404db5268cb09d989741">8500b6</a></td>
		<td>6671 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=85c98cd9ffdfda76d5be25d32810fed5d328ce60">85c98c</a></td>
		<td>275 lines</td>
		<td>Added SystemTapView abstract class to callgraph.core</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=85e0672f75b7a78eaffe66e757c50fe114928dde">85e067</a></td>
		<td>94 lines</td>
		<td>Removed unnecessary print statement from SystemTapLaunchShortcut. Minor changes in SystemTapView, added a clause to change max node size for screen resolutions with horizontal &lt; 1000, added a scrollable thumbnail to the graph (mainly in GraphUIJob, some changes in StapGraph to make the thumbnail appear/disappear as needed)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=85e6f846022208930346359aa27d4be422f93c33">85e6f8</a></td>
		<td>22 lines</td>
		<td>2009-11-16  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapParser.java: (testRun): Change testRun so it will actually work and actually mimicks the properties of run.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=864c1e3fe49ae450bebb6cd1fc4b24667287deb1">864c1e</a></td>
		<td>26 lines</td>
		<td>Removed allsyscall.stp and basic.c</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=86ee4f140a4550d21aba2218f34d5c85b70e31ab">86ee4f</a></td>
		<td>2 lines</td>
		<td>Replaced function call with call to helper function</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=873fd41b62ce2f43353c6a288e00c2cc7add7b2d">873fd4</a></td>
		<td>8 lines</td>
		<td>2010-03-05  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Stop passsing a useless argument to finishLaunch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8748e4de5448b109957fd548ce3af141ffb12670">8748e4</a></td>
		<td>2 lines</td>
		<td>Removed warnings from LaunchShortcutsTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=87e260b8eb06a355a07ebc19606c5c143cf8a678">87e260</a></td>
		<td>68 lines</td>
		<td>Transferred ownership of Projectionist to StapGraph, made necessary changes in tapGraphKeyListener and CallgraphView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=882d506f3b642d96893366b173db3913d5378ecf">882d50</a></td>
		<td>25 lines</td>
		<td>2010-01-18  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Add addCalled method, which increments the timesCalled variable on stapData corresponding to the input id. * src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Add multiple identical entries to neighbourMap for collapsed nodes (dot-file) * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Properly attach dot-file nodes with id &lt; 0 Properly account for collapsed nodes (dot-file)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=884d1ea037e138391d80312d1d0578a6df15f97f">884d1e</a></td>
		<td>110 lines</td>
		<td>Moved the graphdata adding/removing code to a spearate method in StapGraph. Removed unnecessary import from SystemTapView.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=88dca75f1620ea78da5e4ebdf3de9c3554d54085">88dca7</a></td>
		<td>14 lines</td>
		<td>When a node only has one child, scroll down in tree view will now change the root visible node to that child node.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8af94462cd3902c7b4ed84d6e59f57e8c47dbbf1">8af944</a></td>
		<td>1 lines</td>
		<td>2009-11-10  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/RuledTreeSelectionDialog.java: Delete unnecessary TODO</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8b00494296307ff008819d257392d6036990119e">8b0049</a></td>
		<td>2 lines</td>
		<td>Removed warnings from LaunchShortcutsTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8b42032c58b441cff2bf8c21cc3beffc3e5bd015">8b4203</a></td>
		<td>6 lines</td>
		<td>Temporarily remove ExportScript and CreateModuleAction shortcut keys</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8b7f483ec47cf1b0350a67dbcdab4fc3d674eda5">8b7f48</a></td>
		<td>25 lines</td>
		<td>2009-11-12  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/ListTreeContentProvider.java (getElements): Use validElement in SystemTapLaunchShortcut * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchShortcut.java: Rename validFile --&gt; validElement</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8b9614c267032b72253cd3bc680bcb232eba0397">8b9614</a></td>
		<td>48 lines</td>
		<td>Renamed SystemTapView to CallgraphView (it's a more fitting description). Haven't updated the plugin.xml files yet</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8be6278d669f477a26b027858d0b0706fadb77a0">8be627</a></td>
		<td>4 lines</td>
		<td>StapUIJob: Fix NPE when attempting to launch graphs -- moved setParser above initialize call</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8c767f1cce804feb973405ab7b53155a39636cbf">8c767f</a></td>
		<td>3 lines</td>
		<td>2009-11-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Correct binaryArguments being passed into the final error message</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8d19a41e967b1f963cdf307e7f46637008e80a7d">8d19a4</a></td>
		<td>51 lines</td>
		<td>Added SystemTapTextParser, a default parser to use with SystemTapTextView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8d87233b3e3217ac53df410f23889bdc5394015b">8d8723</a></td>
		<td>63 lines</td>
		<td>2009-11-04  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapParser.java: Fix nonRealTimeParsing.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8e07b7a25fd80ca388b23610248ef5fcad0cb6cd">8e07b7</a></td>
		<td>8 lines</td>
		<td>Fix array index out of bounds error.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8fdbe80c48bd33a42c8e4c2a80d69e51009c4102">8fdbe8</a></td>
		<td>3 lines</td>
		<td>Added oel.rpm.core, oel.rpm.core.tests and oel.rpm.ui to the psf</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=90a5e0900c87f9cb12e334d6d8876103ca75a883">90a5e0</a></td>
		<td>107 lines</td>
		<td>RENAME: RuledTreeDialogSelectionDIalog =&gt; RuledTreeSelectionDialog Removed more margin space from RuledTreeSleectionDialog.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=910bf8fa1c68093f734458788d60bb858ba9fdea">910bf8</a></td>
		<td>2 lines</td>
		<td>Changed view ID</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=910ee9df04aeed2dd88b527ed0fa56d78d0b3a96">910ee9</a></td>
		<td>3 lines</td>
		<td>2009-12-08  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Make generateCommand public</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9140eb0421925aba75e7366bc8583968246b71c5">9140eb</a></td>
		<td>121 lines</td>
		<td>Associated checkboxes with actions to save the tester some time.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=925667a552cdcfac0bd1b71720e6f11046c6c728">925667</a></td>
		<td>19 lines</td>
		<td>Changed some display messages in SystemTapGraphTest, rearranged tasks to run a little faster</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9293fef012e5480528c4718cc180b6b5fba2fc48">9293fe</a></td>
		<td>7 lines</td>
		<td>Very rough hack to eliminate double error messages</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=92c7201fac25b6eba2a8a6526e374d13411c7310">92c720</a></td>
		<td>1 lines</td>
		<td>Added callgraph.tests (graphical tests for eclipse-callgraph)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=92e05f8be7577c1383188c88102320f0673db0d7">92e05f</a></td>
		<td>38 lines</td>
		<td>Relocated attribute names to PluginConstants, modified some error messages.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=944e7e0bc82f0489526f95362a928d172321a6f0">944e7e</a></td>
		<td>6 lines</td>
		<td>Changed messages.properties messages.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=945998a28e0020d154aa3fe5e76fd2162ec4f585">945998</a></td>
		<td>15 lines</td>
		<td>2009-11-10  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapView.java: Change reference to kill button to use imageDescriptor function in AbstractUIPlugin * src/org/eclipse/linuxtools/callgraph/core/CallgraphCorePlugin.java: Add PLUGIN_ID string</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9674c441d89f3884e59895d969fe9b57a0318f95">9674c4</a></td>
		<td>22 lines</td>
		<td>2009-11-03  chwang  &lt;chwang@toto&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Fix capability to mark nodes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=973dd686e4c67422fbde0234d2d503d9800950d8">973dd6</a></td>
		<td>38 lines</td>
		<td>2009-11-10  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Convert everything to use AbstractUIPlugin.getImageDescriptor(String path)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=97d267dc8fa18a5d2b3950a9b8b9aebcdc5ec74c">97d267</a></td>
		<td>17 lines</td>
		<td>2009-11-26  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/PluginConstants.java: Rearrange constants. Add DEFAULT_PARSER_ID. Remove final modifier on STAP_PATH, so it can be changed to accommodate other commands, if need be. * src/org/eclipse/linuxtools/callgraph/core/SystemTapTextParser.java: Get rid of println statement</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9838509b7a5efd8f6e6176724517b44e2a7874bf">983850</a></td>
		<td>91 lines</td>
		<td>Automated SystemTapGraphTest -- everything except Open and Save, which require user input (still need more work to automate these)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9855a7773f007a386bec65a1dc0d0d01f1a27649">9855a7</a></td>
		<td>2 lines</td>
		<td>Add command.import.name and command.import.desc to plugin.properties, using their values as found in org.eclipse.linuxtools.systemtap.ui.graphing</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=988c5553c0eface1c46ca4b7acf7fb738d9fcd1a">988c55</a></td>
		<td>25 lines</td>
		<td>Replaced name.isDeclaration with name.isDefinition -- this will avoid false negatives for functions that are declared but never defined.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=98acca8bb07e54fba77adb521bbc098ab2505663">98acca</a></td>
		<td>46 lines</td>
		<td>2010-01-22  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java: removed extra loadData function that is never used. * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Fix miscounting in non-dot-file-node</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=98c462a0ae58074c7d8c9300f9e7ad09a7accc94">98c462</a></td>
		<td>42 lines</td>
		<td>Passed progress monitors into all error handling operations that contain a loop - provides more convenient exit locations.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=98eafab3fa474fee8c9dcbf51c8185570a054331">98eafa</a></td>
		<td>4 lines</td>
		<td>Added shortcut key messages for the two things with shortcut keys -- Collapse mode is now '(C)ollapse mode', Reset is now '(R)eset'</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=99125d3bab139d9fe36c11b69612a4e62d1d848a">99125d</a></td>
		<td>26 lines</td>
		<td>Made the makeView function in testHelper return a SystemTapView instead of a CallgraphView object -- castable to the view you were expecting</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=992a31fb8057c37a78f31b76c373354b90775b8e">992a31</a></td>
		<td>15 lines</td>
		<td>Moved the join call inside the update call in SystemTapView, update() now throws IOException and does not return until the UIUpdater is done.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9944749e1289db1e22f03161e2daaafe6bc9d8ae">994474</a></td>
		<td>9 lines</td>
		<td>Add javaDoc to the now abstract getParser() method.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=99b79e345a97868e20519fce92a07d8926cb1f9c">99b79e</a></td>
		<td>190 lines</td>
		<td>RENAME : RunSystemTapActionTest =&gt; SystemTapCommandGeneratorTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=99b7f3d160310c6164b4519abf9ff4bab53b17af">99b7f3</a></td>
		<td>16 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Rename save_dot, save_col_dot. Add these to the list of actions enabled/disabled by opening a graph.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=99ca4615497a52e8b9071a2df8efac09cc838de2">99ca46</a></td>
		<td>11 lines</td>
		<td>2009-12-22  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Only display error popup if there is something to say</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9a292df34b5ffaac88cdabe774068e7b0d357239">9a292d</a></td>
		<td>15 lines</td>
		<td>2009-12-22  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapErrorHandler.java: Remove extraneous logic * errors.prop: Re-add uprobes error after slight modification to popup error</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9a3bf0b9467a28754386ec9e81513180cded341c">9a3bf0</a></td>
		<td>250 lines</td>
		<td>Moved Error log actions and menu into the addErrorMenu method of SystemTapView. THis gives all extending views access to the same error logging capabilities. TODO: Make the error log better than 'save and parse a random text file in a textbox'</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9a6126b601644910861b19938f94fc9df9829b81">9a6126</a></td>
		<td>3 lines</td>
		<td>Removed unnecessary import of .launch -- we can add this back later if we need it, just removing it for now.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9a7460f4c0a1dbe096be1208bf2aae45d5681cc7">9a7460</a></td>
		<td>10 lines</td>
		<td>Changed the format to 'Collapse (C)', etc. instead of '(C)ollapse'</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9aa2f7def957225a79c0ee6b43df711fa6d118eb">9aa2f7</a></td>
		<td>20 lines</td>
		<td>2009-12-08  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Change delegate to launch by creating a temporary shell script, rather than launch directly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9abb03ee23c2bd506e4cd96da44112bae23a09bf">9abb03</a></td>
		<td>101 lines</td>
		<td>Added copyright headers, fixed problems in GraphUIJob, StapGraphParser and SystemTapView where the wrong draw() function was being called, fixed problem with 'main' function not showing up when graph is refreshed</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9bbff6eb904aa3b1ff362254665e82cce95e1ba8">9bbff6</a></td>
		<td>74 lines</td>
		<td>Added message to Console informing user of 1: the name of the configuration that was run and 2: the binary arguments currently supplied. Also indicates where the Binary Arguments tab can be found, if the user wants to supply binary arguments.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9bcfb76cd3f75c1ebca041598ba80507cd66c4f9">9bcfb7</a></td>
		<td>38 lines</td>
		<td>Renamed stapact variable in GeneratorTest to stapgen Added toggle for activating/deactivating CommandLineTest in AllTests -- stored in TestConstants.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9bd316e638f37f2ac66393cbfbaced9569fc065c">9bd316</a></td>
		<td>1 lines</td>
		<td>Added call to systemtapview.layout() in SystemTapTextView's initialize method -- fixes problem with display not reinitializing properly</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9cb4e11fd11d4ea85f55825bd7a60fd0661b3a8f">9cb4e1</a></td>
		<td>66 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapNode.java: Make numberFormat public. * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Create the 'Save as .dot' option. Create 'save uncollapsed as .dot' and 'save collapsed as .dot' options in the File menu.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9ce0db452a54248695463ffac4fb8e4cadc8e4e4">9ce0db</a></td>
		<td>14 lines</td>
		<td>2009-12-09  Charley Wang  &lt;chwang@redhat.com&gt; * parse_function_partial.stp: Add threading capability</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e202efe060c23133abe740d8fddf1f42901e026">9e202e</a></td>
		<td>52 lines</td>
		<td>2009-11-16  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapCommandGenerator.java: Remove unused functions, variables. Make commandGenerator methods static.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e27348a44270425d72c65e910ef2bdbef46a8b6">9e2734</a></td>
		<td>46 lines</td>
		<td>2009-11-06  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/DocWriter.java: Update DocWriter's methods.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e73564fcb35189deb3c60a57040e7a632f7b9a5">9e7356</a></td>
		<td>10 lines</td>
		<td>Moved docWriter to hopefully get rid of timing issue with user input.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e87439979462bc813311ed13dceb0c5b593d4b7">9e8743</a></td>
		<td>21 lines</td>
		<td>Changed message in SystemTapLaunchShortcut file selection dialog to provide more information. Changed Error Handler message when more than 300 errors are found.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9eb29818a1fc895599751cbae37b89c714a6f3b8">9eb298</a></td>
		<td>18 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Add check for nullity when attaching parent nodes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f25a582731a5a014ead7d6d09b017a0745b5efa">9f25a5</a></td>
		<td>6 lines</td>
		<td>2010-01-18  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Change bounds on radius in radial view.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f55159a390287d21467f3229e77ac448e273c99">9f5515</a></td>
		<td>17 lines</td>
		<td>2009-11-26  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Add generateCommand abstract function for command generation. This is called by createProcess()</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f8dcae91810a4b9836dbafe0266987a60d65e32">9f8dca</a></td>
		<td>381 lines</td>
		<td>Reorganized the way the graph composite is set up (makes it possible to add/remove the treeViewer composite), reorganized the SystemTapView actions and buttons.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a09a6593c02ea65f9d3beaf4fa44466f46259a0a">a09a65</a></td>
		<td>211 lines</td>
		<td>Initial import. This project will blanket-disable all UI contributions from: Gprof Gcov Lttng Tmf Callgraph Valgrind OProfile This project should NEVER be included in a build!</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a0dee57978b6a1fd544cad3195123746fda6bba3">a0dee5</a></td>
		<td>10 lines</td>
		<td>Disabled play/pause in aggregate mode</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a19b68efa6c135127545998a56cbf74021d5b69e">a19b68</a></td>
		<td>41 lines</td>
		<td>2009-11-06  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Delete unused functions, add javadoc comments to other functions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a25a9508efa892c9b941ef1dc79dc099a5d459b1">a25a95</a></td>
		<td>6 lines</td>
		<td>2010-01-19  Charley Wang  &lt;chwang@redhat.com&gt; * build.properties: Remove trailing ,\ from dependencyURLs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a28a7d00994615f8d13c2d3c04833ee20ff9ad5f">a28a7d</a></td>
		<td>4 lines</td>
		<td>Expand commented region in plugin.xml of org.eclipse.linuxtools.callgraph to get rid of warnings due to the currently removed marker actions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a2f911ccabf4bcbe60d5974d2c54c4f26e75c551">a2f911</a></td>
		<td>11160 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.local.graphing =&gt; org.eclipse.linuxtools.systemtap.local.callgraph</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a31e0c98d37ccb5c442de63e1596850ef336fdee">a31e0c</a></td>
		<td>5 lines</td>
		<td>2009-11-03  chwang  &lt;chwang@toto&gt;	* feature.properties: Change featureName</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a3214e65ef87cfc3dacb0fcf8a88aaf72f6e1a30">a3214e</a></td>
		<td>3 lines</td>
		<td>Added oprofile.doc, oprofile.launch.tests, oprofile.test-feature plugins to the linuxtools.psf</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a359ba5131cd7b37a4e2aada3e42b8cdac2d9d31">a359ba</a></td>
		<td>47 lines</td>
		<td>Removed parse_function_nomark.stp and simple.stp -- This completes the process of removing unused files from .launch.tests (Since we can't launch stap from Hudson, none of them will be very useful. Currently pursuing ways to test without them.)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a47d8162ec968acd13b14226a581f398fcf093ed">a47d81</a></td>
		<td>5 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=308376">Bug 308376</a> -- avoid passing null listeners into StreamGobbler</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4a09694aa44c54252c08db9e132ce71997b9bb1">a4a096</a></td>
		<td>6 lines</td>
		<td>2009-12-16  Charley Wang  &lt;chwang@redhat.com&gt; * build.properties: Update reference to GEF-ALL to point to the correct location</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4bec4083c80573bb3f7f6b458b20e83b6f1fc9a">a4bec4</a></td>
		<td>234 lines</td>
		<td>Integrated test cases with AbstractTest in Profiling.Launch, using intermediate class AbstractStapTest to provide access to some of AbstractTest's methods. Made test case LaunchShortcutsTest to demonstrate auto build/launch of a project. Added project basicTest which will allow us to test some basic functionality.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a61b4f199444e3d7ea80c05f7e8d10c51af5d91b">a61b4f</a></td>
		<td>54 lines</td>
		<td>Transferred how-to documentation from StapGraph to SystemTapLaunchShortcut</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a67a0782413848c221df5c829f3a9d88c2fd4731">a67a07</a></td>
		<td>69 lines</td>
		<td>Applied html formatting to the javadoc for SystemTapLaunchShortcut</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a67a6b4e168c9b13602b7576f37e1fd1908990de">a67a6b</a></td>
		<td>7 lines</td>
		<td>2009-11-06  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/changelog/core/editors/GNUElementScanner.java: (GNUElementScanner): Change the rule for colouring of ( ) elements so that the colour ends on the next ), rather than terminating on ):</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a733b75651bd9cb279b4458d4f277bfab2d2f14e">a733b7</a></td>
		<td>2202 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a742f4cc46991c2e3401bd249be0663c07536d04">a742f4</a></td>
		<td>11 lines</td>
		<td>Fix recursivelyCollapseAllChildrenOfNode() function so that it works properly in real-time mode. This also conveniently fixes the treeViewer in realTime mode as well (so that the tree actually displays properly in the middle of a program execution)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a7a64e537f4503f4aa20ab2d9c91acfe5d373ad1">a7a64e</a></td>
		<td>37 lines</td>
		<td>Add imports and add date/time logging to SystemTapLaunchCOnfigurationDelegate's error handling methods.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a7b0f08d6aee47cdc6c85192477d1c8e3c6f6707">a7b0f0</a></td>
		<td>10 lines</td>
		<td>Added print hooks for LaunchShortcutsTest, reorganized MANIFEST -- see if this works on rgrunbers' version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a7ecd20567108f58d6c26f702e8cec387cc2fc4c">a7ecd2</a></td>
		<td>58 lines</td>
		<td>Fix for 307195. Hack using opcontrol --help to get the user's password, and checkign the output of this command to determine whether or not opcontrol was cancelled.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a81ba527edbabd33967df71face318ae23670d03">a81ba5</a></td>
		<td>12 lines</td>
		<td>Add JavaDoc to initalize method of SystemTapView. Change the order in which initialize is called in StapUIJob</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a8d5ec30dd3e83bd263180eb4a407509c2a6b6b2">a8d5ec</a></td>
		<td>4 lines</td>
		<td>Fixed null pointer error in SystemTapGraphTest by renaming the id in CallGraphConstants and relocating the call to forceDisplay()</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a9041725bae88f4dde60dfc00d400909ba8aa77b">a90417</a></td>
		<td>1 lines</td>
		<td>Removed TODO, off-by-one does not appear to be an issue</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a918829b9af0777c02b7e66eef5b8564d2c3c020">a91882</a></td>
		<td>2 lines</td>
		<td>Fixed reference</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a93390ff248388c2676b8af67ff312cc24c1fa1e">a93390</a></td>
		<td>76 lines</td>
		<td>Complete makeover of marked messages. Instead of printing all marked messages at the end, marked messages are printed during runtime and appended to their corresponding node. Got rid of a few useless memory structures -- nonRealParsing will now *not* work, unless parse_function_partial is changed. However I think we should jsut use realTime only...</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aa78e2f5ba1169b1c6b56674e1e5d9e17688183d">aa78e2</a></td>
		<td>2398 lines</td>
		<td>Integrated test cases with AbstractTest in Profiling.Launch, using intermediate class AbstractStapTest to provide access to some of AbstractTest's methods. Made test case LaunchShortcutsTest to demonstrate auto build/launch of a project. Added project basicTest which will allow us to test some basic functionality.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ac6404034bcca2ec2fa71f04b5002279f47dcecf">ac6404</a></td>
		<td>79 lines</td>
		<td>Updated the messages.properties -- moved the externalized strings from CallgraphView into the correct messages.properties, renamed SystemTapView externalized strings to CallgraphView, to avoid missing strings.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ac96c81ea87131078dd0859df2fd4064f432d424">ac96c8</a></td>
		<td>7 lines</td>
		<td>Renamed stapview to Call graph, renamed the id to .callgraphview</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=acc270015d4de05f3bae40bca47dee1a0ed3e5fa">acc270</a></td>
		<td>52 lines</td>
		<td>Added function to launchShortcut for finding all files that define a function funcName.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ad511a1f0ff9a02e2aec3a322ecad7ac8a838db1">ad511a</a></td>
		<td>42 lines</td>
		<td>2009-11-26  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchShortcut.java: Provide default implementation of launch in SystemTapLaunchShortcut.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=add49f4ccfc402c4605ccd6d9838e4410418e599">add49f</a></td>
		<td>427 lines</td>
		<td>Removed StapGraphParserTest, SystemTapDisplayTest, SYstemTapGraphTest and the localgui folder</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=adeadea880d2e1e33d8a5818a2ef3ff1a5ba3451">adeade</a></td>
		<td>8 lines</td>
		<td>Fixed unused imports in Activator/GraphUIJob, replaced one insatce of PluginConstants with CallgraphConstants</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ae260d2ead63e3e556c6db4b0ebc24d63c591fde">ae260d</a></td>
		<td>814 lines</td>
		<td>Refresh of the way LaunchShortcut works. Added setParserID, setViewID and setScriptPath variables -- these are called by finishHelper before the launch (though the user is more than welcome to call them him/herself in advance if they need to be set earlier for whatever reason.) Merged finishLaunchWith and ...WithoutBinary functions in SystemTapLaunchShortcut. Made StapLaunchShortcut Abstract, changing the tests that initialize it to initialize an instance of LaunchStapGraph instead.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aec5f0c21dbab574e10f50f986f99c94f2df49ab">aec5f0</a></td>
		<td>152 lines</td>
		<td>Reorganize CallgraphView, removed several functions that were never called</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aee9ae1641b8411a038d25b29228c30e61a88d2c">aee9ae</a></td>
		<td>5031 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=af97b474a63ec937a31bebb4c7a79cceb7e4b06d">af97b4</a></td>
		<td>147 lines</td>
		<td>Moved DocWriter class to core, removed externalized strings in launch related to DocWriter.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=afb305fb8fa73980cdd10eba5bdaf25e7551f382">afb305</a></td>
		<td>14 lines</td>
		<td>2009-12-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Properly align nodes in radial mode. No more annoying 'just-off-center'ness!!</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b019c6675cfd2bf9e93f2fbc28afbda521e91c7e">b019c6</a></td>
		<td>18 lines</td>
		<td>Change StapData to correctly identify marked nodes -- this was causing some nodes to not be properly coloured</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b03189914c19d1b8c7acfd203b10ad52656beb6d">b03189</a></td>
		<td>6 lines</td>
		<td>2009-12-08  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Return endTime - time if time &gt; 38 years</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b1475ee3e0a64043710caf2de70ab38eaa682252">b1475e</a></td>
		<td>167 lines</td>
		<td>Added mouseDownEvent(int x, int y) and mouseUpEvent() functions to StapGraphMouseListener for handling those respective events. These functions are more modular and easier to test than the actual mouseUp/mouseDown functions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b20566c48ee212abec75ed0f9ba5648a91265a19">b20566</a></td>
		<td>1617 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b326547c23a0274def888743c822cc7d79acafab">b32654</a></td>
		<td>20 lines</td>
		<td>Relaxed restriction on user setting isDone flag, now done in LaunchCOnfigurationDelegate. Modifed the JavaDoc for the realTimeParsing() function accordingly. In SystemTapParser.RunTimeJob, added one last call to realTimeParsing() after the while loop, to catch stragglers.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b4ba7c0c511e496b6dbcd0b41a16df3969276d73">b4ba7c</a></td>
		<td>20 lines</td>
		<td>2009-12-21  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Gentle code cleaning</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b5d8387a4d2b24a3c1972286a06a2a8b363e6878">b5d838</a></td>
		<td>8 lines</td>
		<td>2009-12-08  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/tests/ConfigurationTest.java: Call generateCommand directly</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b5e0fafb4513b0ff9184d8900c9fde4724325bec">b5e0fa</a></td>
		<td>4 lines</td>
		<td>Added check for length of input string in SystemTapTextView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b61f3c47c4ef837143e0ad3e95a123ffde5cb54f">b61f3c</a></td>
		<td>32 lines</td>
		<td>2009-11-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/changelog/core/actions/ChangeLogRootContainer.java: Resolve warnings about generic type inferral. All methods return null, in any case. * src/org/eclipse/linuxtools/changelog/core/actions/ChangeLogAction.java: Add check in getDocumentLocation to fetch the relevant page of a multipage editor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b83129f802c513dead72939527ce0e5c79e945f6">b83129</a></td>
		<td>7 lines</td>
		<td>2010-05-20  Charley Wang  &lt;chwang@redhat.com&gt; * build.properties: Switch versions of swtbot to a non-broken link for swtbot 3.6</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b85fb4faf80de1b870b000887c6dd1299b213759">b85fb4</a></td>
		<td>61 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Create the 'Save as .dot' option * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Make the DataMap publically accessible</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b884c08a890be956c435b09c1c0dc177023fbe4a">b884c0</a></td>
		<td>143 lines</td>
		<td>Added catch in StapGraphParser for empty files, fixed error log not scrolling to bottom by using setTopIndex, fixed small rounding error in the script by removing integer truncation (store full number instead of number/100), parsingError now takes a message argument, customized parse errors for different types of parse errors, re-enabled keyListener with only reset and collapse keys (Shift+R, shift+C)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b8cef113afc3841065dbcf8eabf0ffe9dd52d372">b8cef1</a></td>
		<td>2 lines</td>
		<td>2009-12-08  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Do not setExecutable on the script.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b96b8e1cd97959241fe65e3edb26938f3a0bf497">b96b8e</a></td>
		<td>18 lines</td>
		<td>Update to tests to match rename of localgui.launch to local.launch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b9eaf955583ef85b82873f688d8de8383ab19a90">b9eaf9</a></td>
		<td>17 lines</td>
		<td>2009-11-16  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/tests/SystemTapCommandGeneratorTest.java: Reflect change to static in SystemTapCommandGenerator</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b9ff765c751530ee64108d937b08558ed294cd69">b9ff76</a></td>
		<td>67 lines</td>
		<td>Reorganized variables in LaunchStapGraph, updated instructions for creating new launches. Moved generateScript to finishLaunch method.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bc5913bea8001463dfac750b2d976fb6eb581538">bc5913</a></td>
		<td>75 lines</td>
		<td>Revamped TestHelper to use ViewFactory</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bc60cab870dd27d099565700bd2aa3855d3fdaf6">bc60ca</a></td>
		<td>6 lines</td>
		<td>2009-11-06  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/AggregateLayoutAlgorithm.java: Improve javadocs * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Add better progress monitor use to updateMethod. Remove many unused methods. Remove reference to SystemTapView because we can just use 'this' instead.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bc98a58de4b2e14f7b20e6b021b92aa20a189697">bc98a5</a></td>
		<td>1 lines</td>
		<td>Remove reference to the nonexistent parse_function_mark_partial.stp</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bde9df3150fd5e29cf01ac68688b0000c869792a">bde9df</a></td>
		<td>31 lines</td>
		<td>2009-11-12  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapCommandGenerator.java (buildScript): CommandGenerator no longer extends action or IWindow...Delegate. None of those functions were being used.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=be176b9e8e3e1e361633e99cc096619022c9a987">be176b</a></td>
		<td>6 lines</td>
		<td>Added returns to CmdLineTest if canRUnstap in testConstants is false. Set canRunStap to be non-final</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=be6a82b1e57d3b9455e2a91292c9d031a0dc5ff9">be6a82</a></td>
		<td>9 lines</td>
		<td>Added testMode workaround to launchShortcut that will select all files named 'main' if testMode is active (from chooseUnit function)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bf2a6a293f6e42875102d8bf78eeb1759fe1b25a">bf2a6a</a></td>
		<td>125 lines</td>
		<td>Add Projectionist class for creating a movie -- currently the Projectionist is owend by the keyListener, but it should be moved into StapGraph instead. Hitting Shift+D will now cause Stap to play through the list of functions in the order that they were called. Change the way the TreeViewer and StapGraph's radial draw mode are integrated. Instead of having the double-click listener highlight the treeview, the radial draw method itself now deals with the Tree View. This prevents us from having to implement treeview integration multiple times. Change the way StapData handles collapsed nodes. The partOfCollapsedNode variable is now an integer which will contain the value of the collapsed node that the node is a part of, if any, and defaults to the constant NOT_PART_OF_COLLAPSED_NODE defined in StapData. Other minor organizational changes. TODO: Move ownership of Projectionist job into StapGraph.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bf34eff0446b0ed994b8fe007a4b7d7148e75f99">bf34ef</a></td>
		<td>148 lines</td>
		<td>Removed unused folder, removed unused functions from SystemTapCommandParser for calling the colourful printer, removed SystemTapUIJob for writing to the colourful view.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bf679a6d24e8457208681307ff3decde738197da">bf679a</a></td>
		<td>352 lines</td>
		<td>CallgraphView initialization moved to CallgraphView itself, in preparation for the creation of an abstract class. GraphUIJob now independent of .callgraph, can be moved to .core</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bf8d09dc0be9e5a6512d7d30f8704e87bca912ca">bf8d09</a></td>
		<td>4 lines</td>
		<td>Temporarily remove keybindings for ExportScript and CreateModuleAction</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c04ac0b7801c7def1abbdedda710037f9ba18695">c04ac0</a></td>
		<td>2 lines</td>
		<td>2009-12-08  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Do not setExecutable on the script.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c09f874da49a9f935423fc1d12811784299377e9">c09f87</a></td>
		<td>2 lines</td>
		<td>Fix reuse of disposed treeComp widget.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c0bfbf1b4be272981c8c672ae160f3b34ff05936">c0bfbf</a></td>
		<td>4 lines</td>
		<td>Script appears to have been broken for a little while. Changed the awk delimiter to , instead of /, which obtains the correct project names (as opposed to e.g. &quot;rpm,,org.eclipse.linuxtools.rpm&quot;)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c231970dbc716b5d96eb98ee27fea8190d2cceb1">c23197</a></td>
		<td>17 lines</td>
		<td>Update to the way the array is maintained. No more adding to the array in the VIewFactory itself, the getter now cycles through and searches for SystemTapView instead of returning the first object it can find.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c231b840f6fdd66cda124b4bbc74a1ded904627c">c231b8</a></td>
		<td>134 lines</td>
		<td>2009-11-06  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/ViewFactory.java: Change the way viewFactory creates views. Have ViewFactory set the view id. * src/org/eclipse/linuxtools/callgraph/core/StapUIJob.java: Simplify StapUIJob by using ViewFactory to instantiate views. * src/org/eclipse/linuxtools/callgraph/core/DocWriter.java: Update DocWriter's methods. * src/org/eclipse/linuxtools/callgraph/core/XMLParser.java: Add javadocs, modify functions for ease of use.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c2867329f143594d7c8394778aeacc4d91c02720">c28673</a></td>
		<td>11458 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.local.callgraph =&gt; org.eclipse.linuxtools.callgraph</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c36e865c7f8a68103339d1d310003ee2038eef5f">c36e86</a></td>
		<td>38 lines</td>
		<td>Added toggle switch 'active' for SystemTapUIErrorMessages -- set to false if you don't want error messages to pop up. Removed useless files in tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c37a51ab17e9d018db0ff2f70edd0f34db413549">c37a51</a></td>
		<td>20 lines</td>
		<td>Updated error messages. Forced error handler to not attempt relaunch if there are more than 300 probes missing.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c3a1485a0f491fc18bb5d89380f4f9ffc3e48d29">c3a148</a></td>
		<td>299 lines</td>
		<td>Fixed resolution problem, added refresh action, changed draw() method used in collapse mode so it doesn't change the draw_mode and animation_mode, Fixed grayed profile button in profile configurations, removed null pointer issue in treeDoubleClickListener, got rid of need to call a double maximize action to refresh</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c3fa56ffb7b86365eab1c5ff5cf21168c21676fa">c3fa56</a></td>
		<td>37 lines</td>
		<td>Added isJobCancelled() call to SystemTapParser, so the Delegate can terminate early if the user has cancelled the RunTimeJob</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c55fccd4445b4331566f331a04d37787d920ca1a">c55fcc</a></td>
		<td>8 lines</td>
		<td>Changed id of launch.callgraph to launch.callgraph (was still launch.graphing)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c65f8b10360ce81990254805f766ab63efd57c2c">c65f8b</a></td>
		<td>199 lines</td>
		<td>2009-11-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Add ProfileLaunchConfigurationDelegate. This class contains functions that Roland and I had difficulty with when we were creating the SystemTap plugin, namely the creation and reading of a process.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c671e2984c94160c83ad90bb24f8950c731bceec">c671e2</a></td>
		<td>225 lines</td>
		<td>Added OptionsSetter java file (forgotten in previous commit)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c738bb2995d8517de753dc87d5c2083fc3374df9">c738bb</a></td>
		<td>40 lines</td>
		<td>2009-11-06  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/AggregateLayoutAlgorithm.java: Improve javadocs * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Add better progress monitor use to updateMethod.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c82d77da74c3b649965f8d087cd6f74bc09ef84e">c82d77</a></td>
		<td>2 lines</td>
		<td>Parser class now loads from the correct text field when running from a configuration tab.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c844e90f7d45f8813792875c424383d4cd1e8e8d">c844e9</a></td>
		<td>93 lines</td>
		<td>Added extension point org.eclipse.linuxtools.systemtap.local.core.parser. Modified SystemTapParser class to take advantage of this extension point. Will next add scaffolding for launching a given parser in the delegate. Modified CallgraphView, and tests because the constructor for StapGraphParser has now changed.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c84f2bf40af59eed38b1ced5af63474719d327a3">c84f2b</a></td>
		<td>20 lines</td>
		<td>Removed unused check functions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c86052911ead3251d66a65deeb8cda4b3b920d1f">c86052</a></td>
		<td>8 lines</td>
		<td>Removed message about panning being disabled in tree mode - it is really annoying.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c86a190f339dcf8df21696f7de61496dc56f0869">c86a19</a></td>
		<td>144 lines</td>
		<td>Eliminated text widget in graphing, treeViewer only active in Radial, moved actions into the menu, silenced marker functionality, removed numbers in radial mode, disabled wizard and about, added MAXMAPENTRIES check to errors.prop, renamed SystemTap view to SystemTap View.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c86c0871d61dc01f2936308d2bd29ef36b34799e">c86c08</a></td>
		<td>5 lines</td>
		<td>Removed ToDo from SystemTapLaunchShortcut. Modified messages.properties to make the tree selection dialog more sensible.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c8b46c123a24ab3d48738f197f25534909e2cf7e">c8b46c</a></td>
		<td>14 lines</td>
		<td>2009-11-20  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/LaunchStapGraph.java (launch): Remove redundant check for projectName == null</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c9c89dba98c04e4025ca8285d17e98a4b0623608">c9c89d</a></td>
		<td>53 lines</td>
		<td>Fix StapGraph's aggregate layout algorithm in a way that is neither time nor space efficient.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ca067ac5cc7d724699b86635f2e624cf259c46ce">ca067a</a></td>
		<td>15 lines</td>
		<td>Added a check for programs with less than 10ms execution times. Still a bit of hack and it may be better to just include syscall exits.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ca8126b371fbfb1b92531ef166e26139499cbd6f">ca8126</a></td>
		<td>112 lines</td>
		<td>Changed the way collapse and uncollapse are handled to get rid of weirdness in collapsing/uncollapsing nodes. Added int uncollapsedPiece to StapData, which contains the id of a child node incorporated into each collapsed node (value is -1 if not valid) Renamed the 'caller' parameter in StapData to 'parent,' which makes more sense</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cb501e31c5b920710d6677cd22e8219f96abbab1">cb501e</a></td>
		<td>11 lines</td>
		<td>Changed javadoc comments on functions in abstract class SystemTapParser</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cb94aaeb8890eef8714ef99a6e172e358af0bd20">cb94aa</a></td>
		<td>7 lines</td>
		<td>Added profiling.tests to feature.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cba9d9b6558c21b3156e81f71790f777f77ecb65">cba9d9</a></td>
		<td>4 lines</td>
		<td>Updated to reflect name change in org.eclipse.linuxtools.callgraph</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cc5362210f7e63e78e435e59e5bfc8af57501c55">cc5362</a></td>
		<td>41 lines</td>
		<td>Removed extra space in the chooseUnits dialog box in SYstemTapLaunchShortcut via addition to RuledTreeDialogSelectionDialog. Fixed problem that was causing errors when user selected Cancel.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cc7adfff53071b75a6cdf098efb2ed8e207feaff">cc7adf</a></td>
		<td>170 lines</td>
		<td>Temporarily forced totalTime to use the time for function 'main', added some files for dynamic help integration (currently unused), fixed double-clicking box view nodes causing overlap, added binary arguments to launch configuration, added tab folder for binary arguments, changed script delimiter to ',,' instead of :, reorganized stapview</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cd31057575ada41ce182da4902464359204c3fe7">cd3105</a></td>
		<td>9 lines</td>
		<td>2009-12-10  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/FileFinderOpener.java: Properly quit if findAndOpen encounters a user-sent 'Cancel'</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cd4e2e564aac73e6e520a5f566131af7d6411550">cd4e2e</a></td>
		<td>11644 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cd6289da92687cbb4c9d8dcc9d82022cce15a85f">cd6289</a></td>
		<td>6 lines</td>
		<td>Fixed erroneous references to core/icons</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cebda64956f5540a75d3f79d08578be5414ad971">cebda6</a></td>
		<td>101 lines</td>
		<td>Added xml parser based on the proposed tapset for xml scripts -- returns HashMap&lt;Integer, HashMap&lt;String,String&gt;&gt; containing ids and data values for the given xml.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cf362b3f7ed5845fc0c3f1bebb5ad539ac52e760">cf362b</a></td>
		<td>25 lines</td>
		<td>Shuffled javadocs and comments to make creating a shortcut easier.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cf7d948c052a45cd441a11e4436756276addd07e">cf7d94</a></td>
		<td>10 lines</td>
		<td>2009-12-09  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java (generateCommand): Tweaks for threading. Force command generation every time (otherwise may skip for bad reasons) * src/org/eclipse/linuxtools/callgraph/launch/LaunchStapGraph.java (launch): Enable threading, make process probes accept tid() argument</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cf92e24e88228aaea7ec1b912958c260d2d98680">cf92e2</a></td>
		<td>111 lines</td>
		<td>Previously, the behaviour of markedMessages was time-dependent: if a marked message was inserted after a node is created, that message will never be attached. Add insertMessage functions to StapData and StapGraph to fix this issue. Now the CallgraphView will automatically loop through markedMap if there are any marked messages left over after the initial node addition. Note this means that markedMap should be empty each time the realTimeParsing method runs (because view.update waits for the RunTimeJob to terminate), which suggests a few other memory optimizations we can make. Made a few other timing changes, fixed off-by-one errors and some general maintenance as well. Added a marking clause to mark the top-level user function with the total runtime. Currently this node is not coloured properly. To do: Make marking work in real time</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d0b6835c3b5a10d4d3ecf2fa41d79b0fcf31cb32">d0b683</a></td>
		<td>76 lines</td>
		<td>Added getters and setters for the actions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d0c8d15738aab0cf07e66efc311b02cb7c96ee27">d0c8d1</a></td>
		<td>158 lines</td>
		<td>Initial commit</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d148fe29d12775f8f68801df58307bfe2d47f8d7">d148fe</a></td>
		<td>10 lines</td>
		<td>CHanged play and pause externalized strings in CallgraphView to the same reference, added the return ccal to Projectionist's busy checkk so it actually avoids rapid frames :)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1d9dc30cf568e715f34ab151efe94d76cb49c59">d1d9dc</a></td>
		<td>138 lines</td>
		<td>Cleanup and renaming of variables/functions in StapGrapharser</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d238b8b8563ada3ce27c2a5092a20c258733c739">d238b8</a></td>
		<td>572 lines</td>
		<td>Added small changes to partial_script to fix rounding errors, completely revamped file selction to use CheckedTreeSelectionDialog, added dialog to prompt user when attempting to profile too many files, fixed errors thrown when user attempts to cancel file dialog, fixed incorrect count of .c/.cpp files in the file searcher and validator, removed unnecessary printlns and cleaned up some minor TODO's, changed function search to output a string directly instead of converting from string to list to string, added autoselection of file if only one .c/.cpp file is found.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d25454ad51655df434ac04275b3f22a31de2bd88">d25454</a></td>
		<td>6 lines</td>
		<td>2009-11-18  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/PluginConstants.java: Correct default viewID.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d4050e17b6ad23bd48d7ecb9aa51420f2c811181">d4050e</a></td>
		<td>265 lines</td>
		<td>Added getNextMarkedCollapsedNode to StapGraphKeyListener and the appropriate function to StapGraph, Deleted unnecessary comments in StapGraphParser, added setters and getters to SystemTapView, cleaned up new lines and comments in SystemTapLaunchConfigurationDelegate</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d4428e655fdfc17f755f78c13ebfa8b9da4fbdf6">d4428e</a></td>
		<td>12 lines</td>
		<td>RENAME =&gt; org.eclipse.linuxtools.ystemtap.local.core =&gt; ...callgraph.core</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d4663b2bb58a38dc6d19cb4ffb0b653110b91cac">d4663b</a></td>
		<td>3 lines</td>
		<td>Get rid of unused currentDepth global in partial script</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d4d7e336f3fc2d6946c4523a1f2af8137dfbd28c">d4d7e3</a></td>
		<td>8 lines</td>
		<td>Added clause to pause Projectionist if the mouse is clicked.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d505acccc852a92596a9dbbc907bbc9231dc6773">d505ac</a></td>
		<td>208 lines</td>
		<td>Added TranslationUnitVisitor (needed for file searching, was missing from previous commit), Fixed missing icons in radial view, added icons for TreeViewer (gray and green dots), Fixed graph not-reloading problem</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d67a13dafad897f14e6974ade3c1ff7606b8b1e6">d67a13</a></td>
		<td>4 lines</td>
		<td>Replaced exceptions with return null.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d707cf6855f4fad646cae71ea1cb823929f8b40c">d707cf</a></td>
		<td>4 lines</td>
		<td>Changelog addition to go with previous commit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d73fd4348eb0df9fa8aaaf319c7a4695193f6519">d73fd4</a></td>
		<td>190 lines</td>
		<td>Fixed File --&gt; Save (was skipping lines) and added more graceful error messages to SystemTapGraphParser for parsing errors, made File --&gt; Open open a normal sized selection shell instead of a really small one, added outneighbours to call in StapGraphParser, fixed off-by-one error in data aggregation, implemented maxNodes in StapGraph as a limit on the number of nodes to draw (supercedes levelBuffer), changed SetLevelLimit dialog box to include option to set maxNodes, used composite.layout() to implement refresh (bypasses maximize actions), elimited pointless printlns, renamed 'Refresh' action to 'Reset', fixed problem with small programs not switching to tree view caused by levelBuffer, attempted to force boxView animation to take constant time by capping the amount of time spent animating.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d74717c2cc39a58d9d1c8f1005bceb91011999b9">d74717</a></td>
		<td>22 lines</td>
		<td>Added connections hashmap that stores a list of connections to every node.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d864e69ba95a249aabec0dbbe4f5cb61484bfa3a">d864e6</a></td>
		<td>46 lines</td>
		<td>Implemented scrolling down for tree view. Caveat: Scrolling down will not change the root node. This is because for any node with N children I have no idea which node the user wants to focus on, and arbitrarily assigning a root node is dangerous behaviour. On a more serious 'please fix' note, scrolling down also just adds to the bottom without removing from the top.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d9f35df4dd4123f871d96957c2fda901e487d032">d9f35d</a></td>
		<td>2 lines</td>
		<td>Fixed problem with graph not loading -- removed unnecessary condition on the if statement inside the process loop.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=da83a818fdb7a23026a10625145c4669918b1262">da83a8</a></td>
		<td>147 lines</td>
		<td>Modified DocWriter and SystemTapErrorHandler and SystemTapLaunchConfigurationDelegate so that errors now appear in the console view (no intrusive UI-message popup).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=da9f5c7c333f14c60bfc1a746efb9f34b27ce085">da9f5c</a></td>
		<td>339 lines</td>
		<td>2009-12-15  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Terminate properly if an unknown symbol is encountered. Do not split on the semicolon</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=db27f67663ec9ee12901554375d0092a49ef6a56">db27f6</a></td>
		<td>3 lines</td>
		<td>Slight changes to the caps on the dialog</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=db35eb714ee61e97f44485c9dfc6197411c3f612">db35eb</a></td>
		<td>4 lines</td>
		<td>2009-11-26  Charley Wang  &lt;chwang@redhat.com&gt; * META-INF/MANIFEST.MF: Add org.eclipse.cdt.core, which seems needed with some versions and not with others.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dbaeb72e0ea7e5aeeb9b6812afe2f81a0a239247">dbaeb7</a></td>
		<td>5 lines</td>
		<td>2009-11-12  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchShortcut.java:	(validFile): Fix remaining manual check for file ending.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dbc1352a547a7aedea72a95df405ddf8ba4a6444">dbc135</a></td>
		<td>24 lines</td>
		<td>2009-11-27  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapCommandGenerator.java: Add capacity to change the command used. The command attribute should be derived from Config.getLaunchAttribute(LaunchConfigurationConstants.COMMAND) * src/org/eclipse/linuxtools/callgraph/core/LaunchConfigurationConstants.java: Adding Command to LaunchConfigurationConstants. The default value is PluginConstants.STAP_PATH.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dca4293a22942319893475b3f335729c724ad4f2">dca429</a></td>
		<td>2 lines</td>
		<td>Update to CDT_6_0_2</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ddd46a217c2e062e133ae4b9c1385d8259bf4708">ddd46a</a></td>
		<td>18 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Write to .dot in a slightly modified way that will make it easier for users to just delete chunks of data and still graph accurately.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=de0307bee953465adff7a0e25a47f827b767535d">de0307</a></td>
		<td>108 lines</td>
		<td>2010-02-23  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapParser.java: Add a Thread.sleep() to stop abusing CPU cycles so much Get rid of extraneous parsing job as a further optimization</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=de1497f42b4285d3125e4dedf4f497c89a10e22c">de1497</a></td>
		<td>21 lines</td>
		<td>2009-11-12  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapParser.java: Remove unused functions. Add docs to setDone.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=de4b58a14245c96f49ad705bddc75bf88adc3e3e">de4b58</a></td>
		<td>12 lines</td>
		<td>Commenting out tests in preparation for rename: will uncomment later</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=deb6e15f46fb820909bb3c8323e7f6687e113409">deb6e1</a></td>
		<td>147 lines</td>
		<td>Remove functions getButtons and hasButtons from StapNode -- these are never called. Remove search function in StapData -- makes more sense to sort by call order, and in any case search was not fully working and phenomenally slow. General cleanup in CallgraphView/StapGraph. Change initalizeTree in StapGraph to only refresh and return if the tree has already been initialized.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dec6555efef307b0dbc05d1c29222a2ea271dd2e">dec655</a></td>
		<td>27 lines</td>
		<td>Finished making the relaunching work. Modified the error handler to skip 6 more lines when it encounters an unused function. Removed unused variables in SystemTapLaunchConfigurationDelegate</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dee4fc866bec52131ec38fc30034095b0ae278b1">dee4fc</a></td>
		<td>45 lines</td>
		<td>Removed function_count.stp and makefile</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dfa308b0a220ae55276960d45ff45c35b03d2806">dfa308</a></td>
		<td>427 lines</td>
		<td>Removed StapGraphParserTest, SystemTapDisplayTest, SYstemTapGraphTest and the localgui folder</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e05a994f5df397d66fdd30096bcc3b55ce4e7d9c">e05a99</a></td>
		<td>73 lines</td>
		<td>Reorganized StapGraph's setLevelLimits -- setLevelLimits(id) now calls setTopLevelTo(level). Added some stuff to MouseWheelListener to add/remove nodes in real-time when the user uses the mouse-wheel in Box view the graph will automatically add nodes to the top and bottom. For Tree view, if the user scrolls up we will automatically start following the parent of the RootNode, but nothing happens when we scroll down. I'd like to make it so that if you scroll down in Tree view it follows all children of the current root node... This will require some serious modifications to Tree view, so it'll have to wait for another commit.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e181cc0010dbe34570ec802e70714c2bdaa748a7">e181cc</a></td>
		<td>7 lines</td>
		<td>Moved check for unitList== null to avoid null pointer exception in SYstemTapLaunchShortcut</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e195a1246e813775962d249d6f898dd55880d6cd">e195a1</a></td>
		<td>6 lines</td>
		<td>2010-02-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapParser.java: Call makeView earlier so SystemTapTextView will stop breaking.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e1f8f8ad61220ff1db81a80fabdfa967139ebc5f">e1f8f8</a></td>
		<td>1 lines</td>
		<td>Removed unused suppression</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e21adf24fe8be60e3f1e07dc8782483105931612">e21adf</a></td>
		<td>5 lines</td>
		<td>2010-02-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapTextParser.java: Properly grab new lines in text parser.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e2300b4afd193a454c7194ed09922e44cda67898">e2300b</a></td>
		<td>263 lines</td>
		<td>Improved marked node navigation in StapGraphKeyListener, added listener for MouseExit, made MouseListener add/remove a focusListener during press/release events, simplified MouseMoveListener</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e24c207f1b66195dd09d0c1c71a28f0b42779ad8">e24c20</a></td>
		<td>60 lines</td>
		<td>2009-11-12  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapData.java (StapData): Eliminate useless variables, rearrange functions, add javadoc.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e297cd8e56d71015397732aa3f1b6c2e10692c0f">e297cd</a></td>
		<td>126 lines</td>
		<td>Fixed SystemTapLaunchShortcuts 'user selected all files' detection, cleaned up comments and unnecessary imports from Parser and Shortcut.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e382de318774c52b39c128a2dce60a11c3fdff53">e382de</a></td>
		<td>173 lines</td>
		<td>Created abstract class SystemTapParser that can be extended by all other parsers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e3953fa132bca352c411a1b44a25e23c17c794e4">e3953f</a></td>
		<td>55 lines</td>
		<td>2009-11-06  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/: Removed the ASTTranslationVisitor, which is never used.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e3e87a59692080c25b44b2136792ee4424854106">e3e87a</a></td>
		<td>8 lines</td>
		<td>Update ExportScript to ctrl+4 and CreateModuleAction to ctrl+5. Ctrl-alt-X and ctrl-alt-Y are available as shortcut keys, if those are felt to be better shortcuts.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e401727abcfe19634821ec79bd7ab4cadbeee894">e40172</a></td>
		<td>1 lines</td>
		<td>Added call to &quot;kill stap&quot; to prevent occasional problems with the CommandLineTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e430c1a5e776c7b74640712a02726b1c6eb2bc6c">e430c1</a></td>
		<td>121 lines</td>
		<td>Associated checkboxes with actions to save the tester some time.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e47fed82152cba8a4316b723d1f095d448cbb01f">e47fed</a></td>
		<td>39 lines</td>
		<td>2009-11-09  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/ConfigurationOptionsSetter.java: Use StringBuilder instead of String</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5f57d8c3689985f36214a5017be97c96b4790b3">e5f57d</a></td>
		<td>61 lines</td>
		<td>StapGraphParser now checks for the presence of the project name in the data file, LaunchStapGraph now prints the probe begin portion of the script, the partial script has had the probe begin portion removed. Currently an ICProject is (effectively) passed all the way to StapGraphParser from LaunchStapGraph</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e635d4ca7a95da662d9c2ee4688f4268e9244061">e635d4</a></td>
		<td>1 lines</td>
		<td>Removed import from SystemTapLaunchShortcut that caused conflict with latest profiling.launch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e65c9c6f1398fec70f6101059d5cd5bcdbe641ae">e65c9c</a></td>
		<td>190 lines</td>
		<td>Added goto_next, goto_previous actions to SystemTapView. Added corresponding hotkeys to KeyListener (N and P), added list of nodes in the order that they were called to StapGraphParser and StapGraph. Renamed getRootVisibleNode to getRootVisibleNodeNumber, which is a more apt description.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e671309a3a5666c2afedf001d123f22222b70882">e67130</a></td>
		<td>39 lines</td>
		<td>Modified launchShortcutsTest to use the launch(IBinary, String)  method isntead of calling submethods directly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e685be43cad5651f63cbe2639a86ff5834fe7c1e">e685be</a></td>
		<td>130 lines</td>
		<td>Added testMode variable to SystemTapLaunchShortcut. Added uncalled.c to force the selection dialog to trigger. Added calls to LaunchShortcutsTest to test dialog creation/function fetching</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e82cd7c56c825bfab8e2b2c7455df9d5615974ca">e82cd7</a></td>
		<td>25 lines</td>
		<td>Fix aggregate view so that it works with realtime. Add a while loop to increment a function's time by endTime if it is negative (this indicates that the given function has been called but has not returned at the time that the graph is generated. It is a tidy way to keep track of how many function calls have not yet been closed, but may be a bit slow in special cases (i.e. a function is called thousands of times). But we will probably run into problems with Long overflowing before we run into lag issues...</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e82d0c46606afaa85ed041372df7800ef49e8878">e82d0c</a></td>
		<td>70 lines</td>
		<td>Added capacity for text objects in xml parser/stap script</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e88a94ff25c85610559af180834d185ab2e72b3f">e88a94</a></td>
		<td>177 lines</td>
		<td>Deleted comments in LaunchWizard, changed method of getting binary name in launchWizard, commented subprocess == null statement in Delegate, created shell opener class for opening shells (circumvents invalid thread access errors by creating a new UIJob), added some comments to SystemTapErrorHandler</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e8b61adc13bcc943cbfa86b7b61282c958ce926d">e8b61a</a></td>
		<td>3 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Add check for nullity when attaching parent nodes. Add a missing newline to uncollapsed.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e8c2acb8d319313b010dcda89d2dc657d07d6fb4">e8c2ac</a></td>
		<td>58 lines</td>
		<td>Change parse_function_partial.stp to create a partial script that works in real and nonrealtime. Change StapGraphParser so nonRealTime and realTime Parsing methods will work with the same script.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e915f95454cfadde5d313891e032172dbaa9e5f1">e915f9</a></td>
		<td>25 lines</td>
		<td>2009-12-09  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java (getFirstUsefulNode): Return 0 if threaded * src/org/eclipse/linuxtools/callgraph/CallgraphView.java (loadData): Set StapGraph.threaded if the profiled program contains threads.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e97c4344c84f14f97b7ca2e23cb9921365f79db3">e97c43</a></td>
		<td>91 lines</td>
		<td>Added some additional error checking to finishHandling method of SystemTapLaunchShortcut</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e9dd334b992e00bcab169afa1853dfcfa8e8bb32">e9dd33</a></td>
		<td>1191 lines</td>
		<td>Adding files for tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ea5ab4631b542a9a1bf871bb3415fe49a36b1bcd">ea5ab4</a></td>
		<td>6 lines</td>
		<td>Externalized string for the AGGREGATE_NAME data key in StapGraph.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ea89767dfa1d666c8d82ab75b003ce1d75341052">ea8976</a></td>
		<td>31 lines</td>
		<td>Renamed stapact variable in GeneratorTest to stapgen Added toggle for activating/deactivating CommandLineTest in AllTests -- stored in TestConstants.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eaf78c6297d5a1c238c4bda3ac5640c039a42343">eaf78c</a></td>
		<td>15 lines</td>
		<td>2009-11-05  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/core/SystemTapView.java: Rename loadView --&gt; initializeView * src/org/eclipse/linuxtools/callgraph/core/SystemTapTextView.java: Rename loadView --&gt; initializeView * src/org/eclipse/linuxtools/callgraph/core/StapUIJob.java: Rename loadView --&gt; initializeView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eb5677bda1c33d02a88850284a63163cd6884d69">eb5677</a></td>
		<td>46 lines</td>
		<td>Added some text to the descriptions, copyright and examples fields of the schema for parser and view.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eb94514feb7b29cf050ed1e2fd8b6819a49926d5">eb9451</a></td>
		<td>65 lines</td>
		<td>Plethora of changes to make SystemTapTextView work properly for non-realtime functions Create an update method in SystemTapView -- this method is called by the view when it is initialized by a non-realtime parser. Add finalData object to SystemTapParser -- the user must define a setFinalData method which is called immediately after executeParsing, and the getFinalData object is used by view.update to update the view. For real-time functionality, leave these functions blank. Make the appropriate changes to GraphUIJob to call view.update, change SystemTapLaunchDelegate to properly pass a submonitor into the parser.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eca9f22704fc7ffb2eef4cce44887532b37cf964">eca9f2</a></td>
		<td>23 lines</td>
		<td>Set default mode for callgraph to 'true' in the plugin.xml. Have cancelJob and isJobCancelled set/check a flag jobCancelled in SystemTapParser.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ed8bc9bda5c8baeaebab5e14b9b851f38c551885">ed8bc9</a></td>
		<td>5 lines</td>
		<td>2009-12-11  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/CallgraphView.java: Do not graph Start Of Program</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ed95263f1c51081c8c6eee6f56b373ecbc25705c">ed9526</a></td>
		<td>4 lines</td>
		<td>Updated name and id in the Manifest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ee542e6ea5a3e8686e18d3f6c899da12bd3fddb4">ee542e</a></td>
		<td>10 lines</td>
		<td>Added print hooks for LaunchShortcutsTest, reorganized MANIFEST -- see if this works on rgrunbers' version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef3857623ad2c5a2dad00b00516908b62dbc7e21">ef3857</a></td>
		<td>17 lines</td>
		<td>2009-11-27  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/launch/SystemTapLaunchConfigurationDelegate.java: Add capacity to use the new command option in the CommandGenerator.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f0726b31877758677aca8f443127576315a293df">f0726b</a></td>
		<td>1588 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.local.tests =&gt;org.eclipse.linuxtools.systemtap.local.launch.tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f0863df395a592a4c43720650e6c16bf3034184d">f0863d</a></td>
		<td>26 lines</td>
		<td>Renamed some imports to match rename of org.eclipse.linuxtools.callgraph</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f0cd82d46632d6fdab569fff9c14d9d16f35e39c">f0cd82</a></td>
		<td>6 lines</td>
		<td>Commented initializers that were generating warnings. Uncomment when implementing tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f15029d357838d95a08e8b74f5310ada9d5d8c6f">f15029</a></td>
		<td>37 lines</td>
		<td>2009-12-10  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/StapGraphParser.java: Quit with error message if opening a file encounters an I/O error.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f18838250ace65074bfbd6856154af6617b3e34a">f18838</a></td>
		<td>53 lines</td>
		<td>Added checks for goto functions, got rid of off-by-one error in goto functions that was causing an error to be thrown, added capability to mark the node from which an exit() call was made (or, theoretically, anything else that forces the function to terminate without returning through the function stack.)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f19afbd03eec117ec71a7e7a2fd203314cd39504">f19afb</a></td>
		<td>17 lines</td>
		<td>Added realtime attribute to parser.exsd, made id in parser required. Added constants for the parser extension point, resource and name to PluginConstants and LaunchConfigurationConstants</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f1a2350b222d2ac0c60a1aa283e5261f4369a7f3">f1a235</a></td>
		<td>20 lines</td>
		<td>Removed references to text-viewer based methods in CallgraphView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f1d64b3b6625e2541c71d7a6ed6e8aebdeb7fd4e">f1d64b</a></td>
		<td>8 lines</td>
		<td>Change kill button to only call parser.cancelJob -- the cancel request should eventually trickle down to the delegate's busy loop, in which the stap process will be killed.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f24d64c4972d2239e6cf61571c93457f2c55dc59">f24d64</a></td>
		<td>144 lines</td>
		<td>Added SystemTapDisplayTest back to the test suite, removed use of system time in SystemTapLaunchShortcut, added null checks and a convenience method to SystemTapLaunchShortcut to generate a new ILaunchConfiguration</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f259f4b7e8c592ec5f908eb0936b7fc49cc50ac6">f259f4</a></td>
		<td>15 lines</td>
		<td>2009-11-03  chwang  &lt;chwang@toto&gt; * src/org/eclipse/linuxtools/callgraph/StapGraph.java: Enhance capability for collapse nodes by making collapse nodes take a negative ID.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f3a4012739fdacf853c2d485554dd0cd74149d77">f3a401</a></td>
		<td>5 lines</td>
		<td>2010-08-19  Charley Wang  &lt;chwang@redhat.com&gt; * linuxtools.map: Added Callgraph docs plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f4167b24ec5486f104a9b6e1fe03e026f5161a62">f4167b</a></td>
		<td>6 lines</td>
		<td>2010-02-01  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/graphlisteners/StapGraphMouseListener.java: ctrl+double-click go to actual function instead of its parent. Very confusing otherwise.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f436d27279ee89200c39fa238ee8343209994fa1">f436d2</a></td>
		<td>16 lines</td>
		<td>2009-11-12  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/callgraph/AggregateLayoutAlgorithm.java (postLayoutAlgorithm): Rearrange declarations, update documentation.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f460fdf6f90b823859d1a8ec5cbfda3d9a72e317">f460fd</a></td>
		<td>4 lines</td>
		<td>2009-11-10  Charley Wang  &lt;chwang@redhat.com&gt; * plugin.xml: Add icons to build.properties</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f49a79bb72702d2875f5efcf9d260044d99bd050">f49a79</a></td>
		<td>2 lines</td>
		<td>Set defaultEnablement to turn capabilities on by deafult</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f49d995dd60f5a878e6cc2a86f4c11cec4b80659">f49d99</a></td>
		<td>1 lines</td>
		<td>Add lttng.jni to psf file</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f55e61ae989acfa1d8181c15649db11edb819a81">f55e61</a></td>
		<td>14 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.localgui.graphing =&gt; org.eclipse.linuxtools.systemtap.local.graphing</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f5e1a9cd6416871ad03aa57adfd38372f36cdece">f5e1a9</a></td>
		<td>2496 lines</td>
		<td>Renamed SystemTapView to CallgraphView (it's a more fitting description). Haven't updated the plugin.xml files yet</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f628bdd241129cac36a9517192fdbdb0ff641cf6">f628bd</a></td>
		<td>35 lines</td>
		<td>Added a small semaphore to Projectionist to avoid too many concurrent schedulings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f63ca53b775ef251eab2fd22a9ef764cb623e1c5">f63ca5</a></td>
		<td>19 lines</td>
		<td>Adding files to the tests feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f8247b3e063beddc1276faaebbeb9c09f4be1103">f8247b</a></td>
		<td>22 lines</td>
		<td>Going from callgraph to the sleepingthreads test program was failing. Added an initialize function the the delegate to reset private variables, this seems to fix it fine.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f8721ae16db2eecf61cc98a4ec89c88bd97be4da">f8721a</a></td>
		<td>3266 lines</td>
		<td>RENAME =&gt; org.eclipse.linuxtools.ystemtap.local.core =&gt; ...callgraph.core</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f8b1b168ecbe64552b6d3c2d74d1e73d082de184">f8b1b1</a></td>
		<td>15 lines</td>
		<td>Fix for 316140 -- cancel New File dialog without throwing an NPE</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f998933a626000f06ef7343970de32ab53e89f1f">f99893</a></td>
		<td>13 lines</td>
		<td>Made setViewID a predefined function rather than an abstract</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fa464d3b40dedd6161a011610c3ca30a5ede02d9">fa464d</a></td>
		<td>2 lines</td>
		<td>Fixed quotation problem in errors.prop</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=faab53698d162666d3916f85f97dbf66ff1fe5f5">faab53</a></td>
		<td>17 lines</td>
		<td>2009-11-26  Charley Wang  &lt;chwang@redhat.com&gt; * src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Add generateCommand abstract function for command generation. This is called by createProcess()</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=faef71a9f0d9598c32411eaf8823203f32c66914">faef71</a></td>
		<td>7190 lines</td>
		<td>RENAME : org.eclipse.linuxtools.systemtap.localgui.launch =&gt;org.eclipse.linuxtools.systemtap.local.launch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fb06d7342f8e4e84874f67201cc3f13ed76d06ae">fb06d7</a></td>
		<td>190 lines</td>
		<td>RENAME : RunSystemTapActionTest =&gt; SystemTapCommandGeneratorTest</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fb1cb9bfe968e080cf3fe1c51d50aacfd41531f9">fb1cb9</a></td>
		<td>31 lines</td>
		<td>Catch and error message for null subProcess in SystemTapLaunchConfigurationDelegate</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fb78a8875a88a35cbb2f53d63aab390c71934a12">fb78a8</a></td>
		<td>53 lines</td>
		<td>Added parse(file) option to XMLParser.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fb859da11441e759939b1a13b1b617b0f888b224">fb859d</a></td>
		<td>6 lines</td>
		<td>Disabled the play button in aggregate mode</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fbb695782f35df1bcff6b1cd931ccfbcc83a0572">fbb695</a></td>
		<td>6 lines</td>
		<td>Change blank -- to --help in _OPD_HELP</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fc0362f677c868e529e0451c5ec766a9af6bee9b">fc0362</a></td>
		<td>7 lines</td>
		<td>Added a probe point for syscall.exit in parse_function_partial.stp. Obviates need to get finalTime again in probe end, but could create some timing 'roundoff' errors in programs that terminate unexpectedly due to non-syscall.exit-related issues. Note to self: parse_function_mark is not yet ready for consumption. When we return the capability for users to mark functions, we'll need to update it.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fc07f22789da046855ce7bc7b8d13305c1184ce4">fc07f2</a></td>
		<td>5 lines</td>
		<td>2009-11-03  chwang  &lt;chwang@toto&gt; * feature.properties: Change description for Callgraph feature. Add Changelog.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fc2d854e7c73bc74772217f041006d7cd3bf0463">fc2d85</a></td>
		<td>14 lines</td>
		<td>Update PluginConstants.STRING references to use the new getters.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fcc260e4b9d629819298bc848b4d2b76b3160367">fcc260</a></td>
		<td>28 lines</td>
		<td>Added asserts to check for the presence of function probes in the generated script.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fcd052f4a534273659f8bbf5dfd1a293ccaddb14">fcd052</a></td>
		<td>2 lines</td>
		<td>fixed changelog</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fcdadfb8fcfd6bf08a45f91f6a5f0c0e643df97c">fcdadf</a></td>
		<td>2 lines</td>
		<td>Changed id of the view to match the name of the actual class</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fd666b810a198bcafd45ad3e9528d6cdca9ef645">fd666b</a></td>
		<td>16 lines</td>
		<td>Forced quiet fail when null view is returned, added search for element 'view' instead of always taking elements[0]</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fe303f55b948573231d1196328584b88001a0ea8">fe303f</a></td>
		<td>11 lines</td>
		<td>Fix for <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=311780">Bug 311780</a> Allows the CreateModuleAction dialog to close when the dialog is closed. Also changes the hotkeys for Export Script and Create Module Action from &quot;ctrl-X&quot; and &quot;ctrl-Y&quot; to &quot;ctrl-1&quot; and &quot;ctrl-2&quot; respectively. The latter two actions do not appear to conflict with any major editing shortcut keys.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fe74906a5665963c60c5ec4e2ba9ee161f0b89a7">fe7490</a></td>
		<td>10 lines</td>
		<td>Callgraph.launch: Added externalized strings to messages.properties</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ff106ecdc83ad1b8b886d7f5d9a80c56fb586ed5">ff106e</a></td>
		<td>9 lines</td>
		<td>Removed unused class StapButton, deleted references to said class (apparently rgrunber already deleted StapButton, but did not remove references?)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ff30e332b8b33dc6b4e3b2e7e390644e3c662f8a">ff30e3</a></td>
		<td>203 lines</td>
		<td>Adding files to org.eclipse.linuxtools.systemtap.local.callgraph.tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ffcfeb14a7a234646cc5c8a2683fa06d2e327c64">ffcfeb</a></td>
		<td>26 lines</td>
		<td>Removed allsyscall.stp and basic.c</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ffd2b8ed8e20371868e75a88e5936c33791f3e72">ffd2b8</a></td>
		<td>14 lines</td>
		<td>Fixed condition on timeCheck</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ffe9b37f562ccc14b242af60a5abef6d3963a058">ffe9b3</a></td>
		<td>57620 lines</td>
		<td>2009-12-15  Charley Wang  &lt;chwang@redhat.com&gt; * (all).graph: Modify to remove semi-colon from ends of lines</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Charley&nbsp;Wang (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f5ed5563795f387f22c25c3a1d3146569aa74c9f">f5ed55</a></td>
		<td>20 lines</td>
		<td>Fix BZ #316609. Re-apply patch supplied in corresponding bug. Callgraph should properly execute a binary even with some special characters in the output, or binary path.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Chris&nbsp;Aniszczyk (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=04c8161bcfc63bf426e2bbc3460407c0de8357bc">04c816</a></td>
		<td>347 lines</td>
		<td>Add an initial tycho-based build for the man component Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0860cbd7aee3cb4baf374d489b5e9c0b0581c747">0860cb</a></td>
		<td>2 lines</td>
		<td>Fix pom.xml for org.eclipse.linuxtools.man-feature Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0a15b7510c522158ce675df5ffcd3ffbadcd2376">0a15b7</a></td>
		<td>582 lines</td>
		<td>Add source feature to man module Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=25fc1c354005141a402ec95f67453dba0801848e">25fc1c</a></td>
		<td>334 lines</td>
		<td>Add autotools to the tycho-based build Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=47d222d2e0ce7a1726da17ebaa873e739cc506c0">47d222</a></td>
		<td>2 lines</td>
		<td>Fix artifactId for releng module Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c63084db76f19b2c6049c44563fb801704da984">5c6308</a></td>
		<td>69 lines</td>
		<td>Add repo generation for changelog module Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=86e5e870c527671eab4967be2976b2b4982d7501">86e5e8</a></td>
		<td>674 lines</td>
		<td>Add repo and source feature to rpmstubby module Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9a25d6e9a278a575d8ecaa06185773fc8954a398">9a25d6</a></td>
		<td>80 lines</td>
		<td>Clean up the autotools tests for the tycho-build Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dc2b4bdacc7e285884defac096041dd1a7a82a91">dc2b4b</a></td>
		<td>135 lines</td>
		<td>Add rpmstubby to the tycho-based build Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dd01f95f74dde1f829609fa6e34c4f6a24306d22">dd01f9</a></td>
		<td>165 lines</td>
		<td>Add releng module Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f7006e46a61823cdcf89f510737df0cb86b96569">f7006e</a></td>
		<td>52 lines</td>
		<td>Add repo generation for the man module Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Chris&nbsp;Aniszczyk (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c4208347aea3d0438372d2b3491837be3aa13c93">c42083</a></td>
		<td>52 lines</td>
		<td>Add repo generation for the man module Signed-off-by: Chris Aniszczyk &lt;zx@redhat.com&gt;</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Christian&nbsp;Prochaska (googlemail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=267538">267538</a></td>
		<td>636 bytes</td>
		<td>problems with MSYS/MinGW, Autotools plugin and native Windows paths<br/>call configure script using absolute path with forward slashes and without a colon after the drive letter</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Christopher&nbsp;Daniel (pl.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=ae6a179b8cb6dbb8ef4f28beb43cbcfee831970a">ae6a17</a></td>
		<td>19 lines</td>
		<td>Apply patch from #350304. Works perfect. Thanks for doing it.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Corey&nbsp;Ashford (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0616ff686e4dc70af38d70543b7bf98a7a3bb460">0616ff</a></td>
		<td>2 lines</td>
		<td>linuxtools, oprofile: Improve error message when opcontrol returns a non-zero error code Add extra verbiage to give a clue as to what might have gone wrong if opcontrol returns a non-zero exit status, particularly for the case when /usr/bin/consolehelper is not installed on the system (e.g. consolehelper is not in the SuSE distro). Signed-off-by: Corey Ashford &lt;cjashfor@linux.vnet.ibm.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=32911ffcb217e7b3ad4b91b35cca8c361bfa20a9">32911f</a></td>
		<td>64 lines</td>
		<td>Fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=369468 RDTCommandLauncher#execute: Fix bugs with the loop that transfers the environment variable strings from the form &quot;&lt;var&gt;=&lt;value&gt;&quot; to a hash map. Signed-off-by: Corey Ashford &lt;cjashfor@linux.vnet.ibm.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7e17e752d40205a6a96d9a6b9e6d82d9ce4e0e9d">7e17e7</a></td>
		<td>116 lines</td>
		<td>Add ability to create the proxy using a URI in addition to an IProject In order to implement the RemoteConnection class in terms of this proxy, we need to have the ability to create a proxy based upon the URI of an executable, which may reside on a remote machine, but not the machine where the project is located.  A similar situation occurs when downloading a locally-built executable to a remote machine to run it.  In these cases we need to access a remote file system which is not related to where the project is located. In addition to these changes, I also sprinkled in a few @Override annotations on the methods of classes that implement an interface.  Note that I was not able to do this on the methods in org.eclipse.linuxtools.rdt.proxy because it uses Java 1.5 instead of 1.6, where @Override is not allowed on methods which directly implement an interface (i.e. not from a superclass). Signed-off-by: Corey Ashford &lt;cjashfor@linux.vnet.ibm.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=99a2ea3eb8585630e08cae96cc95c04b9fe912d6">99a2ea</a></td>
		<td>2 lines</td>
		<td>linuxtools, oprofile: Improve error message when opcontrol returns a non-zero error code Add extra verbiage to give a clue as to what might have gone wrong if opcontrol returns a non-zero exit status, particularly for the case when /usr/bin/consolehelper is not installed on the system (e.g. consolehelper is not in the SuSE distro). Signed-off-by: Corey Ashford &lt;cjashfor@linux.vnet.ibm.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f0eb69e75cabc00e154f308e8819b6b69fc18048">f0eb69</a></td>
		<td>116 lines</td>
		<td>Add ability to create the proxy using a URI in addition to an IProject In order to implement the RemoteConnection class in terms of this proxy, we need to have the ability to create a proxy based upon the URI of an executable, which may reside on a remote machine, but not the machine where the project is located.  A similar situation occurs when downloading a locally-built executable to a remote machine to run it.  In these cases we need to access a remote file system which is not related to where the project is located. In addition to these changes, I also sprinkled in a few @Override annotations on the methods of classes that implement an interface.  Note that I was not able to do this on the methods in org.eclipse.linuxtools.rdt.proxy because it uses Java 1.5 instead of 1.6, where @Override is not allowed on methods which directly implement an interface (i.e. not from a superclass). Signed-off-by: Corey Ashford &lt;cjashfor@linux.vnet.ibm.com&gt;</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Corey&nbsp;J&nbsp;Ashford (us.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c238cc92a617cec7f9c7169990c668827f1645b">2c238c</a></td>
		<td>21 lines</td>
		<td>Fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=369765 - Apply patch from bug - Modify patch to use NLS and refer to current plug-in id - Adds exception handling when remote connection cannot be made</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=341292">341292</a></td>
		<td>2586 bytes</td>
		<td>Error message when opcontrol script returns an error needs improvement<br/>Improves error message when opcontrol returns a non-zero status</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=342880">342880</a></td>
		<td>710 bytes</td>
		<td>Running install-noconsolehelper.sh after running install.sh causes corruption of /usr/bin/consolehelper<br/>Patch to remove pre-existing ./opcontrol link/file</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=342883">342883</a></td>
		<td>569 bytes</td>
		<td>OProfile plug-in uses /usr/bin/consolehelper when available, but needs /usr/bin/consolehelper-gtk  as well<br/>require /usr/bin/consolehelper-gtk is installed in install.sh</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=349720">349720</a></td>
		<td>210560 bytes</td>
		<td>SystemTap Help formatting doesn't conform to the rest of the Eclipse Help.<br/>Cleans up existing SystemTap docs in place</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=351368">351368</a></td>
		<td>6434 bytes</td>
		<td>Error handling of opcontrol needs improvement<br/>Patch to improve error handling of opcontrol</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=369765">369765</a></td>
		<td>2434 bytes</td>
		<td>RDTFileProxy needs improved error handling when a URL contains a bad connection id<br/>Patch that improves error handling of URLs containing bad connection ids</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Daniel&nbsp;Barboza&nbsp;Franco (motorola.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=07af71826d63b1f76a86b98523c080667baf04db">07af71</a></td>
		<td>9 lines</td>
		<td>Bug [257585] - Update provider name</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0c153a3391a071ad842738d9dbb129606045ed46">0c153a</a></td>
		<td>4 lines</td>
		<td>Updating 0.3 RC release information</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5703eb607706f3dcaacf74d1061cd42616c4a0f6">5703eb</a></td>
		<td>388 lines</td>
		<td>Fixing file encoding problems</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6521a847d80f75d363e45951cd4ea50337107ef2">6521a8</a></td>
		<td>72 lines</td>
		<td>Fixing file encoding problems</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=90972598e5f55eb6e9688833dc8ddf74dd11a142">909725</a></td>
		<td>4 lines</td>
		<td>Bug [257307] - Branding</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Daniel&nbsp;Drigo&nbsp;Pastore (motorola.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0f1459bb9387e823312ce15c7f19293a4968814a">0f1459</a></td>
		<td>1149 lines</td>
		<td>Merging changes from branch Refactoring.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=23389f35bded4da952d6f3e625561f4aaed4de6f">23389f</a></td>
		<td>5082 lines</td>
		<td>Refactoring TmL to Sequoyah</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4fdc2e7ea172420366ad8c4f89a9d78b18edf770">4fdc2e</a></td>
		<td>117 lines</td>
		<td>Refactoring TmL to Sequoyah</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=57cb62146271a56189a5795903f57dbadd304ec8">57cb62</a></td>
		<td>214 lines</td>
		<td>Updating Software User Agreement to comply with Helios train. https://bugs.eclipse.org/bugs/show_bug.cgi?id=306627</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=961a62f792cca6acbd6f89f87635f1916f071e90">961a62</a></td>
		<td>42 lines</td>
		<td>Merging changes from branch Refactoring.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=99271e36a1732c0c9dfef22de6dd9be46363ec65">99271e</a></td>
		<td>2804 lines</td>
		<td>Merging changes from branch Refactoring.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bcdad3cca4a578f19fa522e80b94cbb4ff6cf135">bcdad3</a></td>
		<td>128 lines</td>
		<td>Merging /branches/Branding</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c09569da3e516d57640272203d5b2e08c1d46f25">c09569</a></td>
		<td>42 lines</td>
		<td>Merging changes from branch Refactoring.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ea14a3300af0559cd08abe2154b7310d9cf64582">ea14a3</a></td>
		<td>440 lines</td>
		<td>Merging changes from branch Refactoring.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Daniel&nbsp;Henrique&nbsp;Barboza (br.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0422f9168aba49e775c9d94684da36dcbd0da5e1">0422f9</a></td>
		<td>46 lines</td>
		<td>Perf plug-in: added end of process messages.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=51f487f195686d420151d236fa13253bb1b33683">51f487</a></td>
		<td>7577 lines</td>
		<td>danielhb@br.ibm.com: Contributing Helgrind tests plug-in.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b392cc0ff192033391f2edfc90c729ae2132668b">b392cc</a></td>
		<td>11 lines</td>
		<td>Removing the -U flag of the Perf plug-in launch. Some systems/distros do not implement it. I'm removing this flag until we're secure that all of them, or at least the major ones, support it.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bbad9cb2d4b95fe1eb80635380fb6ddae4021b27">bbad9c</a></td>
		<td>214 lines</td>
		<td>Adding pom.xml files to enable Perf build.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c03a563c4b1042774c28d1a8cf910329d4309a7d">c03a56</a></td>
		<td>84 lines</td>
		<td>Fixing Helgrind tests plugin issue with Tycho.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cca821e50f99a47d400ab5d03d0d349d6f71126a">cca821</a></td>
		<td>4490 lines</td>
		<td>Helgrind.tests plug-in cleanup.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cdd81a6ee600ef97e14fa191743415ea6457f576">cdd81a</a></td>
		<td>7577 lines</td>
		<td>danielhb@br.ibm.com: Contributing Helgrind tests plug-in.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d94bf7de749e400a420d18aacdf2a96661d6e61a">d94bf7</a></td>
		<td>19 lines</td>
		<td>Fixing <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367505">Bug 367505</a> Removed the p.waitFor() call which proved to be problematic on some cases.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dba823b0d24f9cff97acfd67bc2439821a73d829">dba823</a></td>
		<td>84 lines</td>
		<td>Fixing Helgrind tests plugin issue with Tycho.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=344504">344504</a></td>
		<td>11466 bytes</td>
		<td>Contributing a Helgrind plugin for Linux Tools Project<br/>Tarball with the source code of Helgrind plugin</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=364198">364198</a></td>
		<td>116076 bytes</td>
		<td>*cachegrind* files in Helgrind test plugin<br/>Clean-up of the helgrind test plug-in.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=364747">364747</a></td>
		<td>3471 bytes</td>
		<td>[Perf plug-in] Fixing behavior when no events occurred<br/>Patch implementing the proposed change - updated</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=365303">365303</a></td>
		<td>11540 bytes</td>
		<td>Enabling perf build into linuxtools<br/>Patch that sets up pom files for Perf build</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=366734">366734</a></td>
		<td>1715 bytes</td>
		<td>Removing the -U flag from the plug-in<br/>Patch that removes the -U flag from execution.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367505">367505</a></td>
		<td>1978 bytes</td>
		<td>Perf hangs when clicking on or creating a configuration<br/>Patch to fix the p.waitFor() problem found</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=345863">345863</a></td>
		<td>128 bytes</td>
		<td>Create unit tests for Helgrind<br/>comment #11</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=363510">363510</a></td>
		<td>336 bytes</td>
		<td>Cachegrind: manual cache configuration is reseted after run<br/>comment #2</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Daniel&nbsp;Henrique&nbsp;Debonzi (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=61eb4c0d54fa650b825debf07f75429637782827">61eb4c</a></td>
		<td>104 lines</td>
		<td>Valgrind 3.6 massif new options included.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ba34c1cbd8fb91f59dd1e45928043bfa4138132c">ba34c1</a></td>
		<td>219 lines</td>
		<td>Valgrind 3.6 memcheck new options included.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=345482">345482</a></td>
		<td>227 bytes</td>
		<td>Valgrind tools options (massif, cachegrind, memcheck) does not reflect some options available on latest valgrind.<br/>comment #11</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Daniel&nbsp;U.&nbsp;Thibault (bigfoot.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=349987">349987</a></td>
		<td>22042 bytes</td>
		<td>[LTTng] org.eclipse.linuxtools.lttng StateStrings.java missing some code, other duplicated<br/>Various fixes and improvements to StateStrings.java</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Dmitry&nbsp;Kozlov (codesourcery.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=02dd417a7c62de33e6ae01b751ee8f909647d0c5">02dd41</a></td>
		<td>98 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.ui.model.UiModelDependent, org.eclipse.linuxtools.internal.oprofile.ui.model.UiModelEvent, org.eclipse.linuxtools.internal.oprofile.ui.model.UiModelImage.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0960bd3597eff9268912bfef380a9c4bc3fe88cb">0960bd</a></td>
		<td>14 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.linux.LinuxOpxmlProvider and org.eclipse.linuxtools.internal.oprofile.core.linux.OpxmlRunner.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0bcaaade2be4280881ad8a92834d13ee25f9dde5">0bcaaa</a></td>
		<td>134 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.launch.configuration.OprofileEventConfigTab. Part 2.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0ed4fb81ce2b4a3101c33f5c6f779ecd377cec77">0ed4fb</a></td>
		<td>88 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.daemon.OpUnitMask.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1ca4d3772db61bc0cf67eddafd30b2fbcf4981f1">1ca4d3</a></td>
		<td>18 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.launch.OprofileLaunchPlugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=21a3c1e7bec752b9daa409c4f6a817aa4d44a24d">21a3c1</a></td>
		<td>42 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.info.EventListProcessor. Part 2.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c2121bed265dfb0932d560d375ba64c989423f9">2c2121</a></td>
		<td>102 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.info.EventListProcessor. Part 1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e96cdadde293d596d1370d74043c934caedeca6">2e96cd</a></td>
		<td>78 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.launch.configuration.OprofileEventConfigTab. Part 1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3736ce1cd62615e20a3373f1089b8abc75fb8254">3736ce</a></td>
		<td>14 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.ui.OprofileUiPlugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4868144836a0c08b363cee677e5ba998d834b652">486814</a></td>
		<td>80 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.launch.configuration.OprofileSetupTab.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4b18be09cc3b90a39cbd41c28b94a6113c59405e">4b18be</a></td>
		<td>109 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.model.OpModelRoot, org.eclipse.linuxtools.internal.oprofile.core.model.OpModelSample, org.eclipse.linuxtools.internal.oprofile.core.model.OpModelSession.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a6bb329157312727be86080cd73f8cb2a75a3ac">5a6bb3</a></td>
		<td>34 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.launch.comfiguration.LaunchOptions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c5907b7a73ca6664e6eaae85c706649b25ab8a7">5c5907</a></td>
		<td>112 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.model.OpModelImage.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6eaf0377fe4eeaf3f7dc1f2361fb6c01a6031247">6eaf03</a></td>
		<td>42 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.checkevent.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8172b6d233470881554eb313d3b37a8d07a80983">8172b6</a></td>
		<td>66 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.launch.configuration.OprofileEventConfigTab. Part 3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8ad7ad7b06fb13fd35f6d7dc4fa31d8ac884711a">8ad7ad</a></td>
		<td>72 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.model.OpModelSymbol.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8c2d46f096d598e22e05dc1f76b945883fd3ff3e">8c2d46</a></td>
		<td>41 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.ui.view.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8dc931f45728d605c41eeb624e1cfed42311f0e0">8dc931</a></td>
		<td>40 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.daemon.OpEvent.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8dcd0d54caca79e859971e8b6aa06760c7e2e657">8dcd0d</a></td>
		<td>38 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.daemon.OprofileDaemonEvent.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=96cd7881e165726f5b094a6ecff9cafb690dd842">96cd78</a></td>
		<td>57 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.launch.launching.OprofileManualLaunchConfigurationDelegate.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=97e3ce592bb38bb81c1c0f6475ef1344080de887">97e3ce</a></td>
		<td>54 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4b943458b64b4bb253b23dc7620b840edfce7b8">a4b943</a></td>
		<td>82 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.modeldata.DependentProcessor, org.eclipse.linuxtools.internal.oprofile.core.opxml.modeldata.ModelDataProcessor, org.eclipse.linuxtools.internal.oprofile.core.opxml.modeldata.ModelDataProcessor.SamplesProcessor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a64e05b3fce807cab1455134125cace25a1f9bf6">a64e05</a></td>
		<td>45 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.daemon.OprofileDaemonOptions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a6807430939f44e60d57b225cbf6d4cee223af7d">a68074</a></td>
		<td>78 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.launch.configuration.OprofileCounter.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bd2a0ff4b5d22467f4c55287570791e07570f0a8">bd2a0f</a></td>
		<td>40 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.sessions.SessionsProcessor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c0d2108f6b149bae950cd808363706e2a609902b">c0d210</a></td>
		<td>56 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.OprofileSAXHandler.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c3066b2fe503b27cbf99e82d2b8268d3a35fdad2">c3066b</a></td>
		<td>66 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.linux.LinuxOpcontrolProvider. Part 2.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c3771121f7899e2f845616935baf8efef3207d2a">c37711</a></td>
		<td>43 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.ui.model.UiModelSymbol.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c50e342232ec1e5dff1cb5ac0ae35600b9d0d97b">c50e34</a></td>
		<td>40 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.XMLProcessor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c5a85154518193ac9ddd75603ea7ef19cafecedf">c5a851</a></td>
		<td>104 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.linux.LinuxOpcontrolProvider. Part 1.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ccc42ee3d16f262e2c5c68761dd684012d989612">ccc42e</a></td>
		<td>60 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.daemon.OpInfo.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e48143db62e97afcf46c9ad1f559b2646af33af1">e48143</a></td>
		<td>32 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.model.SymbolsProcessor.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef8bab8a736647e75bbf1520bacd7c01e087cd37">ef8bab</a></td>
		<td>42 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.model.OpModelEvent.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f63dd019121d73cd3cfc08ed53157a205e7c680e">f63dd0</a></td>
		<td>92 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.ui.model.UiModelRoot, org.eclipse.linuxtools.internal.oprofile.ui.model.UiModelSample, org.eclipse.linuxtools.internal.oprofile.ui.model.UiModelSession.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fd6f2240f82cf50784730cee75a54faaf050d940">fd6f22</a></td>
		<td>24 lines</td>
		<td>Cleanup leading underscores from identifiers' names in org.eclipse.linuxtools.internal.oprofile.core.opxml.info.DefaultsProcessor, org.eclipse.linuxtools.internal.oprofile.core.opxml.info.OpInfoProcessor.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Fabio&nbsp;Fantato (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1bc9a1e1b8d91f4df6c7a34f8b70337bc9944eb6">1bc9a1</a></td>
		<td>1118 lines</td>
		<td>fixing build scripts</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=269db0c940e33c459e66926db3fcee4a4ea8e825">269db0</a></td>
		<td>4555 lines</td>
		<td>fixing build scripts</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5e0003daaa049eaedc2d709fbe8456bf43b162a1">5e0003</a></td>
		<td>2 lines</td>
		<td>*** empty log message ***</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9ee58b1ea83eb9a1bb7d8922a271c3eea9e64d4c">9ee58b</a></td>
		<td>122 lines</td>
		<td>fixing build scripts</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=af27d689e0acd26c560b5e2fe0fe829fe82165db">af27d6</a></td>
		<td>2 lines</td>
		<td>fixing build scripts</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cad30eeef5c4cae354e4ad0075413bb6554d371f">cad30e</a></td>
		<td>4 lines</td>
		<td>*** empty log message ***</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cdced868959e542dc63f5b1020a873e768956a19">cdced8</a></td>
		<td>1118 lines</td>
		<td>fixing build scripts</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d0f0aa23b5f7adc7c1ccccdeceeb3942aaf98804">d0f0aa</a></td>
		<td>9 lines</td>
		<td>fixing build scripts</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=df78c3f16dfcdb3b30ae9d63b46d150d6b90b305">df78c3</a></td>
		<td>57 lines</td>
		<td>fixing build scripts</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Francois&nbsp;Chouinard (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=277520">277520</a></td>
		<td>4328 bytes</td>
		<td>Add an entry for LTTng on the project page<br/>LTTng project info</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Francois&nbsp;Godin (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=323611">323611</a></td>
		<td>1862 bytes</td>
		<td>[TMF] TmfVirtualTable scrolling and slider bugs<br/>Patch v2</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Igor&nbsp;Foox (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181102">181102</a></td>
		<td>1682 bytes</td>
		<td>Test failures due to change in SpecfileParser#parseSection<br/>Patch to fix the tests</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181238">181238</a></td>
		<td>480 bytes</td>
		<td>Superfluous junit entry in .classpath<br/>Remove junit from classpath</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181497">181497</a></td>
		<td>7599 bytes</td>
		<td>ChangeLog plugin should not have com.redhat.* stuff lying around<br/>Patch to change all com.redhat.eclipse references to org.eclipse.linuxtools</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Jeff&nbsp;Johnston (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=210144">210144</a></td>
		<td>49183 bytes</td>
		<td>Changelog plugin should not depend on CVS<br/>Changelog plugin patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Jeremy&nbsp;Handcock (aperte.org)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=82195">82195</a></td>
		<td>110055 bytes</td>
		<td>[RPM] Refactor org.eclipse.cdt.rpm.core<br/>Patch for org.eclipse.cdt.rpm.ui</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=82196">82196</a></td>
		<td>26856 bytes</td>
		<td>[RPM] Move propertypage plug-in to org.eclipse.cdt.rpm.ui<br/>Patch for org.eclipse.cdt.rpm.ui</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=96849">96849</a></td>
		<td>1694 bytes</td>
		<td>[OProfile] Build doesn't fail when opxml build fails<br/>Patch for org.eclipse.cdt.oprofile.core.linux</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">John&nbsp;Dallaway (dallaway.org.uk)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=329710">329710</a></td>
		<td>950 bytes</td>
		<td>getGCDALocations() implementation is not robust<br/>CovManager.java.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=330810">330810</a></td>
		<td>680 bytes</td>
		<td>Chart View viewer should be borderless<br/>ChartView.java.patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=340638">340638</a></td>
		<td>1608 bytes</td>
		<td>GProf view presents border around table<br/>GmonView.java.patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Jon&nbsp;Beniston (beniston.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=313748">313748</a></td>
		<td>5776 bytes</td>
		<td>Add ability to set autotools options in templates<br/>Patch to add support for SetAutotoolsStringOptionValue process</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=314122">314122</a></td>
		<td>1551 bytes</td>
		<td>&quot; in .autotools are not escaped as &amp;quot;<br/>Patch to escape characters &amp;'&quot;&lt;&gt;</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=314587">314587</a></td>
		<td>2041 bytes</td>
		<td>Add support for Cygwin in getPathString()<br/>Add support for cygwin paths</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Ken (msn.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=350593">350593</a></td>
		<td>1900 bytes</td>
		<td>ChangeLog does not consider a dirty ChangeLog editor as a change to the ChangeLog file and adds new ChangeLog entries to the editor<br/>Added dirty editor detection support by checking the boolean flag included by ChangeLogEditor.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Kent&nbsp;Sebastian (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=00433708caea103c5a84755f6aeb6e4acdbeff71">004337</a></td>
		<td>44 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0096d47caab52675b599640c7a65b48b3638d23a">0096d4</a></td>
		<td>2 lines</td>
		<td>remove use of isEmpty() to allow use of 1.5 JVMs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=00c2f8cedde5b794396123bf7c17f53b2afbef79">00c2f8</a></td>
		<td>2 lines</td>
		<td>Change plugin names to include &quot;Incubation&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=01649c3a8dabc48d5f28f9d6152d74febcbad5db">01649c</a></td>
		<td>45 lines</td>
		<td>Added parsing for sessions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=02598a242522df7f530588d6d34664d83b239b89">02598a</a></td>
		<td>2170 lines</td>
		<td>branch working towards 0.1 release</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0280c4ca7f031a313243f0c95f8493c22991f975">0280c4</a></td>
		<td>4876 lines</td>
		<td>Moving old packages to archive.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=03f0b0e77d8c79da8d19f116f8252742ffa39287">03f0b0</a></td>
		<td>12 lines</td>
		<td>fix test failure due to addition of UiModelError; increase unit test coverage of UiModelError to 100%</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0428255d011ac3959e13b76a4e63fda10c87931f">042825</a></td>
		<td>4 lines</td>
		<td>Added hasDependent() method (used in ui model parsing)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=04633f7de3e0d932e879fa2e9be1f2ae9d1b9e36">04633f</a></td>
		<td>4 lines</td>
		<td>Refreshes OprofileView instead of SystemProfileView</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0572a0888cb86f17526289168590e8b35a09856e">0572a0</a></td>
		<td>2 lines</td>
		<td>launch.launch -&gt; launch :)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0593eb1a191c804d65d54ab9468e129155047387">0593eb</a></td>
		<td>12 lines</td>
		<td>removed non-used menus</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=061d71cf3eee7ad638797668b9f54a3dea440525">061d71</a></td>
		<td>3 lines</td>
		<td>bundle-localization for externalizing strings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0692a6027ec5082ed6b585c436544e9c1aa45032">0692a6</a></td>
		<td>51 lines</td>
		<td>added a cache for checking the validity of event configurations (since for some reason the tab's isValid() method is called dozens of times before the tab is even loaded, each call potentially spawning opxml several times with the same values)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=06cf991e28df8375f94888d391316ca95f581080">06cf99</a></td>
		<td>6 lines</td>
		<td>Properly fixed bugs for installing</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=07473df4454f8c3618f3870168e16645c5d9eaaa">07473d</a></td>
		<td>21 lines</td>
		<td>added a few tests for changes in o.e.l.o.tests plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=07939284427b7a22fd947628a2d6c435e0d39c36">079392</a></td>
		<td>5 lines</td>
		<td>externalize parsing dialog message</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=07bc2e7630ed708dcedb356a3b34380811d9661a">07bc2e</a></td>
		<td>2 lines</td>
		<td>update sudo line as per BZ265646</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=092a65e2a2f849f5aa6c373e6c6017994a4f8571">092a65</a></td>
		<td>2 lines</td>
		<td>Change plugin names to include &quot;Incubation&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0954abb578d4dd01f7f2e6a342ab232b6bb2f944">0954ab</a></td>
		<td>81 lines</td>
		<td>change for proper fragment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=09fd3bbb07dd3c7b623f7b07750c3d1425fb9cbb">09fd3b</a></td>
		<td>2 lines</td>
		<td>merge commits from 0.2.0 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b2cb69e3b3cc109b7d32e5b0b9b84ffa9bd4d34">0b2cb6</a></td>
		<td>20 lines</td>
		<td>fixing build.properties and plugin version number for all plugins</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0b68d27f3a1d1d3dcc3c92c019cb600e91e49f9c">0b68d2</a></td>
		<td>3 lines</td>
		<td>Allow users to create opcontrol symlink and script will complete subsequent tasks (instead of always failing).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0ccb1f78e5e58db8d3684b6d79863bfb5c5b3d19">0ccb1f</a></td>
		<td>2 lines</td>
		<td>merge commits from 0.2.0 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0d38d3e26208b7f78af7fdd3a646c089251c8e93">0d38d3</a></td>
		<td>2 lines</td>
		<td>change missing opcontrol error message as described in BZ 260067</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0d62654791d7b1361bd735527392c857ab3d87e1">0d6265</a></td>
		<td>2 lines</td>
		<td>vm args in separate quotes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0f080cb0ff220045e5b7c187d6631ee66b9d987a">0f080c</a></td>
		<td>1 lines</td>
		<td>added id for oprofile plugin (used in setting focus/opening the view)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0f7aa40531b64a7317c31ea073d865c12615436e">0f7aa4</a></td>
		<td>18 lines</td>
		<td>extract method to run opxml; used for testing</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=10907d881903b7e8da3942dfcb481f656b63cf75">10907d</a></td>
		<td>2657 lines</td>
		<td>Moving old packages to archive.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=10978f400fcd155452ebd7e00eb289bd6db409c8">10978f</a></td>
		<td>57 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1132e891aa793df7e134522a9885b450e7a1da61">1132e8</a></td>
		<td>3 lines</td>
		<td>changed default to --separate=none</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=12839bce2bca849b2781da89764b20244dbc1d91">12839b</a></td>
		<td>34 lines</td>
		<td>style fixes and a null check</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=12b07b28a79b792cfa57b71bec9b0d770c0d12d1">12b07b</a></td>
		<td>10 lines</td>
		<td>remove unused code</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=12ef4a9f84b5c498f1f72ff54f636d28440cb3dc">12ef4a</a></td>
		<td>94 lines</td>
		<td>changed default verbosity to none (generates waaay too much data in the log -- 5 or 6 few runs made a 300mb log); fixed a bug the earlier verbosity changes introduced; fix a bug with --separate flag never being reset to none</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=13b011ce4e2f16e81126035cac008a0a3d466dd0">13b011</a></td>
		<td>91 lines</td>
		<td>start of new annotation model</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=14218b3d275e1515d4bd1f317b6183407a8759c9">14218b</a></td>
		<td>110 lines</td>
		<td>standardize the bundle name/vendor strings, removed some unused ones from ui</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1427c655b98fb37fcedb53bed76b43ff4f8e7cd1">1427c6</a></td>
		<td>7961 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=154b190ccf4b95e30c503c8e67056661529ba6c9">154b19</a></td>
		<td>330 lines</td>
		<td>fix externalizations</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=155fb0643162d9b06801cb2550b9dd26dbf82b5e">155fb0</a></td>
		<td>163 lines</td>
		<td>Initial commit</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=156e71e98b4eede746bd0633c3a4929a82aea8ff">156e71</a></td>
		<td>20 lines</td>
		<td>update oprofile source to release tag</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1581cd9d5708e602d1907487e03a417319794033">1581cd</a></td>
		<td>4 lines</td>
		<td>change to reflect recent build</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=15fb51a510f846aee156eea01723b52a8d74007d">15fb51</a></td>
		<td>6 lines</td>
		<td>changed prototype of postExec to allow testing objects access to launched process Process object</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=16a91ca8d8ce39bc03fd6a283d2b19a5ab48c5cf">16a91c</a></td>
		<td>108 lines</td>
		<td>Initial import. (of the proper way to do fragments!)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=16df574e87f7db1161c5d20b32ba6a9975060300">16df57</a></td>
		<td>2 lines</td>
		<td>remove .qualifier from version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=174693de665f092fe99c0f01fa4e53c1fec4c24d">174693</a></td>
		<td>2 lines</td>
		<td>'Profile with OProfile' -&gt; 'Profile With OProfile'</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=17680fc38a34b4d8aad8c9efab1fed9df6d1f180">17680f</a></td>
		<td>35 lines</td>
		<td>removed non-existant resource bundle + old code</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1a0b76d0bc5a1e227658da5baf0a72c31bc42136">1a0b76</a></td>
		<td>8 lines</td>
		<td>change valgrind specific strings to more generic profiling strings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1a57064b9d2c962cb33be4f0bf5f913bf86eefad">1a5706</a></td>
		<td>4 lines</td>
		<td>add errordialog strings for opxml parsing error</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1a90ac0f9fb04900285de22af9976755c44f384c">1a90ac</a></td>
		<td>11 lines</td>
		<td>fixing build.properties and plugin version number for all plugins</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1b52121f1aad703cb7ccfd78b750c4ba51f26134">1b5212</a></td>
		<td>295 lines</td>
		<td>added a check and test if oprofile was run outside of eclipse and the samples are read by opxml -- discard and display an error</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1bd3d5bff199958d1fe5dde5f1f49d01f82cfcca">1bd3d5</a></td>
		<td>3 lines</td>
		<td>oprofile ppc fragment, ui test plugin, main test plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1c23acc98a0ff5ec1e89be38921c28fc8be9c743">1c23ac</a></td>
		<td>13 lines</td>
		<td>check for timer mode when adding event config to setup line (otherwise launching opcontrol fails)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1c3988d1de75010269c27682558095e35cbd698e">1c3988</a></td>
		<td>44 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1c7bce5626aa81c0a5cb43979396cffea4cf7c23">1c7bce</a></td>
		<td>80 lines</td>
		<td>refactor method names; prefix with _ if only called from xml parser</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1cc811323e794c7f0e555b8af746ca3921a24b32">1cc811</a></td>
		<td>5 lines</td>
		<td>Changed comment as per comment 24 on Eclipse.org CQ2781.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1e52a53f6566be0d1bf8bf0b8e63d63fb1b61c58">1e52a5</a></td>
		<td>59 lines</td>
		<td>changed classpath settings and removed @Overrides as necessary</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1ecba7b288f6cf02f8ed1cbcaa6119d4cbc7e92b">1ecba7</a></td>
		<td>235 lines</td>
		<td>added info parser test and a few fixes to related core classes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2055d169972176e96362bc9284d7cc2d55290581">2055d1</a></td>
		<td>7 lines</td>
		<td>static strings for comparison in other test plugins</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=20a7c3c9f17992a93c33a71f7f57a9a2fd62e10d">20a7c3</a></td>
		<td>2055 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=22a823b4985790aacb06c3eee3709bd6bb376bea">22a823</a></td>
		<td>1 lines</td>
		<td>Changed comment as per comment 24 on Eclipse.org CQ2781.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=22c5b392046e3337cb5dc0a5024e9236209d3ace">22c5b3</a></td>
		<td>711 lines</td>
		<td>Icons for the tabs, change tabs' names</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=233f5845a922a0afd7bda9f405fbe47149faffb1">233f58</a></td>
		<td>14 lines</td>
		<td>builds opxml if it doesnt exist</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=23a16be19c232f36d475480f359112beb0f4bbc5">23a16b</a></td>
		<td>47 lines</td>
		<td>Initial import</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=24df6be16b3fb54d4955624b9fe3284bd10299b5">24df6b</a></td>
		<td>28 lines</td>
		<td>add arch to native plugin name</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2598f610b904c8cd5e0c642534b16b7b750e8739">2598f6</a></td>
		<td>236 lines</td>
		<td>Changes to separation mask config, code there to enable thread/cpu separation, but dont support it yet (would need changes to opxml)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2647c20e8df8af1a1742447319806c456993df36">2647c2</a></td>
		<td>2 lines</td>
		<td>launch.launch -&gt; launch :)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=286adef7c1f2ae58706bf3f91f946f3a7a93ee41">286ade</a></td>
		<td>7961 lines</td>
		<td>Initial import</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=29098e229be0e8a15b69d9d1bb5552f6dc80d70c">29098e</a></td>
		<td>8 lines</td>
		<td>fix to include natives directory (required for opcontrol wrapper)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2a4831e4f25b047b88479cd3fee4f7bb39af6371">2a4831</a></td>
		<td>92 lines</td>
		<td>extract private classes for overriding data model opxml use</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2bd34317fa10bf8434328389cf3ad56cdfa7df8c">2bd343</a></td>
		<td>62 lines</td>
		<td>Updated to parse data model.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c0d0fbc5432217551e0c01d2cc399f918210c11">2c0d0f</a></td>
		<td>3 lines</td>
		<td>fix when no opcontrol present and a launch is initiated -- launching is aborted due to an ExceptionInInitializerError being thrown</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2d1406be6f71a0bc6e969ca971097ebaa1dedd14">2d1406</a></td>
		<td>2 lines</td>
		<td>Commit rebuilt opxml as part of eclipse bz278681</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2d4ccfc69c16ced7b4c5eeb650f3967dacc5415f">2d4ccf</a></td>
		<td>2 lines</td>
		<td>merge commits from 0.2.0 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2d9d95aefcaeb006ebcd7a623cdbd8ff84b3bb0e">2d9d95</a></td>
		<td>144 lines</td>
		<td>add test for refreshModel() of opmodelroot</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e15c341ea944560429b2f87c3515ac6d575a126">2e15c3</a></td>
		<td>90 lines</td>
		<td>Move saving default session to actions menu instead of dbl-click, eclipse bz260324</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2e32cafbfe7c3aa66e8737b02a18223342b5e89d">2e32ca</a></td>
		<td>124 lines</td>
		<td>Fix for an exception when opxml is not executable; added checking and setting +x for opxml in the install script; changed (un)install script filename to .sh</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2f393ebe2cf1b5eb95b8cc6124bf686b9d66f373">2f393e</a></td>
		<td>42 lines</td>
		<td>add check for runprofile vmarg to not run launch tests if oprofile isnt present</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2fe7ff37fab7454d01636c14e78d50425de168f6">2fe7ff</a></td>
		<td>8 lines</td>
		<td>error checking if there is no opxml providel, and the dialog box properly shows now</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=316f51bc02ed3920cc4553748f7a5e6a2f27239b">316f51</a></td>
		<td>4 lines</td>
		<td>changed default profile event count</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=31c39b3d6416b3a5de59d7728f0ae56ef0724604">31c39b</a></td>
		<td>1 lines</td>
		<td>add oprofile test feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=32149b3af66e43d2dbfecaf81195dc5445721526">32149b</a></td>
		<td>1 lines</td>
		<td>add launch tests plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=329d123bc0f8121a535dafbff9cd773a8841af83">329d12</a></td>
		<td>120 lines</td>
		<td>changed classpath settings and removed warnings as necessary</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=32e664b2fabb2f184a1838f6149f3327810b835b">32e664</a></td>
		<td>2 lines</td>
		<td>Changed comment as per comment 24 on Eclipse.org CQ2781.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3359b25aa50a56b618b01768010daedff9fb92e2">3359b2</a></td>
		<td>9 lines</td>
		<td>add check for invalid unit mask type -- big error if so, error dialog directing user to file a bug</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=33c802a265c4c30d40d85d185ec42c3c65fc43f1">33c802</a></td>
		<td>95 lines</td>
		<td>new test for check-event parsers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=33fa57d9bd3bb68e6904b11b9d971a9b07623c24">33fa57</a></td>
		<td>14 lines</td>
		<td>update feature to include ppc fragment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=342e2c8848821f1db4af07d69f95b532cfa56adf">342e2c</a></td>
		<td>6 lines</td>
		<td>updated copyright headers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=346708f9cea9d9bc9f94590b523dc0cf682d83a9">346708</a></td>
		<td>1 lines</td>
		<td>update to include oprofile doc plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3533a21a7d0199aa38d261504dd5f0c5cd3aac28">3533a2</a></td>
		<td>1044 lines</td>
		<td>moved countersubtab into oprofileeventconfigtab, and javadoc'd it</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=35c4b00af11034e70f568f964092191bda35d1c4">35c4b0</a></td>
		<td>44 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3698963ac2933a1dd576ea69481748595bf53962">369896</a></td>
		<td>2 lines</td>
		<td>fixing version # with qualifier</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=369c59d5f57506974a72f2e3d3425a51b3805aa8">369c59</a></td>
		<td>4 lines</td>
		<td>standardize all localizations for Provider to be bundleProvider</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=36fb309702253ea41f230085d950c35143cecd5b">36fb30</a></td>
		<td>22 lines</td>
		<td>fixed tab scrolling composite issue, now resizes as needed</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=37ac9fcbc19d4bba04ea7bbc3e3cddefbc9ad046">37ac9f</a></td>
		<td>20 lines</td>
		<td>removed update-perms script</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=384ae1a44097d8d1714c4047190b1ac85f692c87">384ae1</a></td>
		<td>4 lines</td>
		<td>remove update site info</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3920f89a8b77bfffab2ef5d3b42047fc99a73858">3920f8</a></td>
		<td>39 lines</td>
		<td>data file for new test session</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3a749a90293b5f0fe1a365c724d50e693f8c0c8c">3a749a</a></td>
		<td>10 lines</td>
		<td>classpath settings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b0add4c6caa68b35420ad6ff8d45bc15632f96a">3b0add</a></td>
		<td>2480 lines</td>
		<td>initial-import</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b3913ee50637b3fcf1850fbfb1701515ad51593">3b3913</a></td>
		<td>4 lines</td>
		<td>standardize all localizations for Provider to be bundleProvider</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3b863190f9811d30ab53d1434f584c1bbed0b5c6">3b8631</a></td>
		<td>2 lines</td>
		<td>refresh view after 'reset session', otherwise can reset the default session and try to save it with inconsistent results</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3ca233ca5c6e1e26794fa5445c1d598c28aa39e0">3ca233</a></td>
		<td>128 lines</td>
		<td>removed unused code</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3e4563a1d370e0c1bdad7964847854c7f23d82ed">3e4563</a></td>
		<td>183 lines</td>
		<td>branch working towards 0.1 release</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=402218b4d8e2a69c0f6a401a99ac543f696d300b">402218</a></td>
		<td>13 lines</td>
		<td>dbl-click on a symbol brings you to line 1 of the corresponding file</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4077e75f1cf80f60ec7d518b1ae9cc9f0b844e68">4077e7</a></td>
		<td>2 lines</td>
		<td>changing Provider to Eclipse.org</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=40fb5a63732658ea3cb09db0ff589c945583c9f2">40fb5a</a></td>
		<td>2 lines</td>
		<td>Change plugin names to include &quot;Incubation&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=41530514ee719d975730398fc41dfe7c184aed14">415305</a></td>
		<td>11 lines</td>
		<td>fixing build.properties and plugin version number for all plugins</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4191a8875a141a9bf8cf2fe013a8bce4668798ca">4191a8</a></td>
		<td>2 lines</td>
		<td>fixed \t to \\t to properly escape a tab</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=41e719aa397d93bb57511a35cd005fe46985e918">41e719</a></td>
		<td>12 lines</td>
		<td>localization file</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4205614e2f8b4ef0c3283f02144e0b93294ad4d5">420561</a></td>
		<td>1 lines</td>
		<td>svnignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=42f85ee26cdd7507f9d46ef75614cd4f46a953a1">42f85e</a></td>
		<td>67 lines</td>
		<td>removed verbosity option in launch configs (always set to --verbosity=all, which it was already anyway)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4398e479ca281018dfd953a864fb9cc3cc828fc2">4398e4</a></td>
		<td>4 lines</td>
		<td>standardize all localizations for Provider to be bundleProvider</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=43a953c2083ba0ed246a8a132e7d880ce03741d8">43a953</a></td>
		<td>3 lines</td>
		<td>ppc fragment, ui test plugin, main test plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=44034bc1ff36d7652cb47a9dfac931816d90ce74">44034b</a></td>
		<td>22 lines</td>
		<td>removed old code (which was commented out anyway)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=447b5c7de808eb9196873161a712d34cf4e0ea11">447b5c</a></td>
		<td>11 lines</td>
		<td>fix classpath setting, add svnignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=448c84b33a1c9f544c1cc42ec476107dc96ba0f9">448c84</a></td>
		<td>170 lines</td>
		<td>Initial import. (of the proper way to do fragments!)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=44c59a6241c9b5bc7dafb1d5d8374288d2f606f9">44c59a</a></td>
		<td>2 lines</td>
		<td>merge commits from 0.2.0 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4551975d00c721caa9b481f0854d410e26a9b2c1">455197</a></td>
		<td>61 lines</td>
		<td>Fix for eclipse bz278681: malformed xml. Added a relevant test case as well.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=45b57a3a2ff551e2c6c557eb28727ab22899af4e">45b57a</a></td>
		<td>3 lines</td>
		<td>oprofile ppc fragment, ui test plugin, main test plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=463c8ed72b27ec89e201ca975ff2388b6f2f0644">463c8e</a></td>
		<td>2 lines</td>
		<td>remove .qualifier from version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4645d93ff58ab813715e67109897ebcf952d18ab">4645d9</a></td>
		<td>23 lines</td>
		<td>changes from OprofileUiMessages refactoring</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=464a70f1ca1fbeb65ec48c2b8f9855ed6a685953">464a70</a></td>
		<td>4342 lines</td>
		<td>Moving old packages to archive.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=46b2bb6409c50af0f1a363b349c77c9d54a2bf9d">46b2bb</a></td>
		<td>64 lines</td>
		<td>Able to display samples as children of symbols, shows line numbers.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=46e7d2f05e4d7d8add04159391f97b579902e943">46e7d2</a></td>
		<td>10 lines</td>
		<td>No NPE if modelroot is null; occurs if no opxml provider.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=471f6f7b2be2cc1e54b4e419c93b811fdcf725dd">471f6f</a></td>
		<td>25 lines</td>
		<td>put the default minimum percentage into the activator and standardized the code across the model toString() methods for calculating it</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=474390420175216487e6f7833622a842c229aac4">474390</a></td>
		<td>1 lines</td>
		<td>add launch tests plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4745bab580f071fe30c06bfcebd6b0f0430d3d92">4745ba</a></td>
		<td>9 lines</td>
		<td>remove section to build opxml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=474e60382b1a6167705e51854a6f320823881a12">474e60</a></td>
		<td>9 lines</td>
		<td>fix inclusions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=47b89cfe0b1788e15d2977a747b18033f6828dca">47b89c</a></td>
		<td>3304 lines</td>
		<td>Initial import</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=47c83a4cb607aece1165a2484a799e85131da788">47c83a</a></td>
		<td>2 lines</td>
		<td>Change plugin names to include &quot;Incubation&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=48e8f0b245eece268017e6e87ab7e1faa6641b32">48e8f0</a></td>
		<td>8 lines</td>
		<td>loads oprofile module as part of installing</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=490c3e5870a742c923aa8bbed6ae2286f6880e42">490c3e</a></td>
		<td>281 lines</td>
		<td>merge of eventconfigtab branch into trunk</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=499d706ea08673067fff19337840f0201b3502d7">499d70</a></td>
		<td>24 lines</td>
		<td>added comments</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4cac8ea2150001c34cdbcf7700712dfbd181915d">4cac8e</a></td>
		<td>2 lines</td>
		<td>merge commits from 0.2.0 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4e8cd1a11077624314937f2526d2ac50dd87bdf5">4e8cd1</a></td>
		<td>9 lines</td>
		<td>One-click profile w/ oprofile default run working, as well as a big code cleanup in the launch plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4ee1e1cd451184f3554242d63e04f41d04364c8e">4ee1e1</a></td>
		<td>10 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4f78506ce5762b75e2dcf364817a3e93f549cb55">4f7850</a></td>
		<td>25 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4f9f13823fa911a2ed152ce9f40468aa17891d41">4f9f13</a></td>
		<td>2 lines</td>
		<td>built opxml from newly changed sources</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4fd5fe2b59abb63b46d0d5eb1187772b57f87a9d">4fd5fe</a></td>
		<td>8 lines</td>
		<td>fixing copyright headers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=50a40f7288d24e8ed1294a29cf75df251d1b0ded">50a40f</a></td>
		<td>1 lines</td>
		<td>svnignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=50bb1171c8f38ee2bf3beac86044afb31ff030a9">50bb11</a></td>
		<td>2 lines</td>
		<td>built opxml from newly changed sources</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=51470ede8eb5c628b3d6c20396cfe81a1976ba90">51470e</a></td>
		<td>483 lines</td>
		<td>removed unused class</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=514749a927c5f133e02323f5985aacfb475d43a0">514749</a></td>
		<td>4 lines</td>
		<td>disable debug function</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=517d3a62e5152756ee98eeaf19784531ce4aefab">517d3a</a></td>
		<td>3 lines</td>
		<td>removed unused imports</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=53ad1db20a2ac4a30168a07caf5c97be84f4c81b">53ad1d</a></td>
		<td>1 lines</td>
		<td>symlink to new oprofile_view icon</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=54a1b86d390a362979071a529e59439128f55f21">54a1b8</a></td>
		<td>4 lines</td>
		<td>tweak message describing how to run install script</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=557eca991b3214d1d907dfcdc8e56b6ddff90715">557eca</a></td>
		<td>5 lines</td>
		<td>stylistic changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=567ebd4180e38e439f91faf62adf23769dd74254">567ebd</a></td>
		<td>10 lines</td>
		<td>extract method to run opxml for test class</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=56ad4205f3356ac9d2ea019a687cf24df618521f">56ad42</a></td>
		<td>2 lines</td>
		<td>put qualifier back on</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=56bfe3fe2b20d157f5169055ae3411da26f224ef">56bfe3</a></td>
		<td>2 lines</td>
		<td>fix EclipseBZ #273116: vmlinux text box not repopulated</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=56dc5ad27741499c6894990471b8f53e0cc392e9">56dc5a</a></td>
		<td>6 lines</td>
		<td>include resources dir. arrggghhh</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=572484fc2ac94fbc2293cf2a30e37146d469ff34">572484</a></td>
		<td>10 lines</td>
		<td>add test for other methods in opinfo</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=573cd9bad060be94232d5fa0302192609d0fa2e0">573cd9</a></td>
		<td>26 lines</td>
		<td>fixes to install script and install script instructions (merge from 0.1 branch)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=57641ba1b82d8aaff48f18c11a6edb96e513399c">57641b</a></td>
		<td>2 lines</td>
		<td>fixing version # with qualifier</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=57c767ac4debe0ab72667815e3b76c86a300d547">57c767</a></td>
		<td>2 lines</td>
		<td>fix source include flag</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=57d3e7a979d3ed2194d248f3853b87a19d982bc5">57d3e7</a></td>
		<td>1 lines</td>
		<td>svnignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=57fa76f8110b77b14b0d44a824782431438b2bfc">57fa76</a></td>
		<td>6 lines</td>
		<td>removed verbosity option in launch configs (always set to --verbosity=all, which it was already anyway)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5842c1938e3cbded6badb2972a6bd76dd94e17d2">5842c1</a></td>
		<td>12 lines</td>
		<td>updated copyright headers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=589229147e78b7276b29852eb93edb506ff38b93">589229</a></td>
		<td>539 lines</td>
		<td>branch working towards 0.1 release</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=58954417ef92efef33cdc660462a582bb9b60075">589544</a></td>
		<td>2 lines</td>
		<td>changed prototype of postExec</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=59d03be8171e155c1457294519f4d173ac48411d">59d03b</a></td>
		<td>34 lines</td>
		<td>change loading kernel module failure message to use _showErrorDialog</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a47f271960116d443ab93d0f6f2eeb45ad2bbd8">5a47f2</a></td>
		<td>7 lines</td>
		<td>show users only the source's filename, instead of full path; check for a null filename (happens with dependent images);  changed toString template</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a7fa3a33061e29bf18d45e97d49522bb1a32506">5a7fa3</a></td>
		<td>181 lines</td>
		<td>various refactorings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5ac4dfaaf4b2e7fbb0183c9eb9f4ec5cf35341ff">5ac4df</a></td>
		<td>20 lines</td>
		<td>eclipse bz265489; fixed issue when some fields are equal</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c45c14430f4a03bfb96a0476d5e66c1eb0bf1b1">5c45c1</a></td>
		<td>455 lines</td>
		<td>branch working towards 0.1 release</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5cf013e6d7dcae285e4b307d645120b3af0200ce">5cf013</a></td>
		<td>1 lines</td>
		<td>add oprofile test feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5eca356fbc656b2a436b9b1d818cfb214c3922aa">5eca35</a></td>
		<td>2 lines</td>
		<td>add final qualifier to static member</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5ecd5885c0dc3e73bd45c64a66652fcd96ff1c30">5ecd58</a></td>
		<td>4 lines</td>
		<td>clarify command to find install script</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6054d4d8548d5797f6f95f8055ddf5cdd50bfa68">6054d4</a></td>
		<td>10 lines</td>
		<td>fixing version # with qualifier</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=616833a4028cb9fc6d0815dce3a08dad81d95f6e">616833</a></td>
		<td>1 lines</td>
		<td>add oprofile launch tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=639b6bb1377234cb7d97fa5ba9f5c6a68b4e7460">639b6b</a></td>
		<td>4 lines</td>
		<td>Change plugin versions to 0.3.0.qualifier; change provider to Eclipse (from Eclipse.org)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=63e8e0ce6ac0aa74f96dd95f236755472beba92d">63e8e0</a></td>
		<td>2 lines</td>
		<td>Change plugin names to include &quot;Incubation&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6466b9e54e0e90248975c491cf840eab9ea10e91">6466b9</a></td>
		<td>69 lines</td>
		<td>fix isValid() for when default event is enabled</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=64f2763ab96fdbce829408b30cea1ef3241cde65">64f276</a></td>
		<td>2 lines</td>
		<td>fix source include flag</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6591b95aaddb1041f576bf5794311ea00f930c40">6591b9</a></td>
		<td>2 lines</td>
		<td>merge commits from 0.2.0 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=65b93fb294a22339bd822200126d6fc636af7ed7">65b93f</a></td>
		<td>8 lines</td>
		<td>change valgrind specific strings to more generic profiling strings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=65f3747070aa15e523f8472ed3824ebbc2bad7da">65f374</a></td>
		<td>2 lines</td>
		<td>put qualifier back on</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=669443ea53ebc8f6e098d88ff50c79aece1fe546">669443</a></td>
		<td>12 lines</td>
		<td>fixing build.properties and plugin version number for all plugins</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=66cfe3bd02da2af5a4cd3aff7f8cf005c12ea6a5">66cfe3</a></td>
		<td>327 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6739f0410733cfaa697b3411dcf60a3598014414">6739f0</a></td>
		<td>1218 lines</td>
		<td>One-click profile w/ oprofile default run working, as well as a big code cleanup in the launch plugin.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=68a6eac0cb6c37440932497bb2fc05423ebd5b50">68a6ea</a></td>
		<td>28 lines</td>
		<td>Initial import, plus uidatamodel tests.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=69ce87d23c8a5acda0d8dd6e5eeea070f1438441">69ce87</a></td>
		<td>4 lines</td>
		<td>fixed two very dumb mistakes :)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=69ec0cf71665510a85df7e02bd525a7c21cc3bb4">69ec0c</a></td>
		<td>1376 lines</td>
		<td>Moving old packages to archive.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=69ef4b548dbfbf3162982a5c82dcf1795b2c76c0">69ef4b</a></td>
		<td>2 lines</td>
		<td>popup if opcontrol doesnt exist, descriptive text to fix, fixes so things dont crash &amp; burn if that does happen</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6a0229d6fcad74e015a9503aadb436c933c33687">6a0229</a></td>
		<td>41 lines</td>
		<td>i don't remember why this was in the UI package.. but all the launch stuff is done in the launch package now, and this isn't needed</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6a7d1a1500b74f2fcebadd6fb0ba11f3b9147f67">6a7d1a</a></td>
		<td>10 lines</td>
		<td>working version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6b07e5c81c10d9e480fe3e89d4841e69bb6aaf00">6b07e5</a></td>
		<td>26 lines</td>
		<td>test for invalid counter number</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6c411ebb6597837a3362b81c53f348d828314d49">6c411e</a></td>
		<td>2 lines</td>
		<td>change description</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6d16bbef793dee3b4bfb7d9a69e6e422287ca928">6d16bb</a></td>
		<td>2 lines</td>
		<td>remove .qualifier from version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6dbbf2253a324b96f78de4df10155dee988d6df3">6dbbf2</a></td>
		<td>20 lines</td>
		<td>add check for runprofile vmarg to not run launch tests if oprofile isnt present</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6dffdc906e957da9fc041a729982d1696c99f618">6dffdc</a></td>
		<td>79 lines</td>
		<td>update documents to most recent wiki edits</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6e06e236d53df67cce1ccd293480fbaac5be99c1">6e06e2</a></td>
		<td>2 lines</td>
		<td>fix source include flag</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f1af82cdfc505d522f71e55781720a4f9c3482f">6f1af8</a></td>
		<td>215 lines</td>
		<td>new test + copyright additions + small fixes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f4a7e4d308b5c360f3472054abaa57c8a15da3f">6f4a7e</a></td>
		<td>25 lines</td>
		<td>Initial import</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f7bc8f78ab8cf5b0376f656a665ea0a2855591b">6f7bc8</a></td>
		<td>9 lines</td>
		<td>check for null added due to test failure</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f8707c64409e48c0479faff23460d867126ffe2">6f8707</a></td>
		<td>7 lines</td>
		<td>add explicit check for OK result</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6fd40f4e8409604a420ae87658f5fbbbf21be679">6fd40f</a></td>
		<td>16 lines</td>
		<td>changed dependencies to package imports</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=70004bef973991e56d4e1504a27577f64d3027cf">70004b</a></td>
		<td>28 lines</td>
		<td>add timer mode variable/functions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=721128761b6d911b0e4873558a836ddf7d10a648">721128</a></td>
		<td>6 lines</td>
		<td>fixed ebz277385 old glibc error message; incl 'no profiling data' error does not show up. also fixed a bug where refreshing the view when all sessions are deleted from the system does not show the 'no profiling data' error message</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7306a559086478f388c48d4b3793ca6f02b781f9">7306a5</a></td>
		<td>31 lines</td>
		<td>added invalid unit mask marker</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=760a409f78b101ca377e76fcea7686d6f712b138">760a40</a></td>
		<td>18 lines</td>
		<td>new - install script for linux distros with no consolehelper; direct users to install-noconsolehelper.sh if install.sh fails, update uninstall.sh</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=77529fe4fdd24cfd32b9c7a05949afd9319e4cd0">77529f</a></td>
		<td>2 lines</td>
		<td>Change plugin names to include &quot;Incubation&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=78488c5270ecac51902caf26b5aabc3444b49985">78488c</a></td>
		<td>18 lines</td>
		<td>changed prototype of postExec</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=798a9e9f00b9e1bd3c8adf2b2655f676d9edf2c6">798a9e</a></td>
		<td>6 lines</td>
		<td>add test.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a0a6878ab8e26709cf3131a8a2c4989e2c3910a">7a0a68</a></td>
		<td>106 lines</td>
		<td>localizing showErrorDialog to OprofileCorePlugin, making all uses of error dialogs use that method and changing error messages to something more useful</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a1986a040ade2c1a6269df9212a5ce2052d7c40">7a1986</a></td>
		<td>3 lines</td>
		<td>fixes for building rpms</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a3c13a8a3b4aaa203581886dd7683fdc3e80fe9">7a3c13</a></td>
		<td>20 lines</td>
		<td>icons for dependent, image, symbol and sample elements in the tree (im not satisfied with the symbol icon, revisit later) and corresponding code changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7c3d9d4a5e6f966bebb3732f713d4f39960e8856">7c3d9d</a></td>
		<td>3 lines</td>
		<td>add description comment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7d1c72b8dbda6808c67865a2ed14dbb13adff3d9">7d1c72</a></td>
		<td>148 lines</td>
		<td>remove legacy classes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7d6e850ee7b2b62f25bd6241891152e9dc07a77d">7d6e85</a></td>
		<td>49 lines</td>
		<td>fixed some bad syntax and added some more checks</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7da7f7af6a707107a4e8dd31706e808b0b8440a9">7da7f7</a></td>
		<td>680 lines</td>
		<td>Annotation feature initial commit and related changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7ec650eba735c2cb57f17d634a8ed38c14e2b57e">7ec650</a></td>
		<td>21 lines</td>
		<td>added qualifier to feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7faa886c5c0678d5f2797480eda516306e43f21c">7faa88</a></td>
		<td>2 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7fedb96871f57cd4d57a4406c8aba0e168efd704">7fedb9</a></td>
		<td>2 lines</td>
		<td>add timer-mode tag to info test, and check for proper parsing in TestInfoParse.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=80b19c4c6cdecca77d408deb60ef2b8d610fcdff">80b19c</a></td>
		<td>4 lines</td>
		<td>standardize all localizations for Provider to be bundleProvider</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=80c1fe5b361a2a050f7b927ab5fe087f33df7202">80c1fe</a></td>
		<td>12 lines</td>
		<td>removed strings no longer used</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=813605aa992ca22fcd71cd9fb1abf79ce42c8bbc">813605</a></td>
		<td>10 lines</td>
		<td>session icon</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=821c567a246d2af5c9ce3ae01048617bb88b43f2">821c56</a></td>
		<td>9 lines</td>
		<td>fix source include flag</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8315d4b87f59fd954ac5d15d8de519346b5f1960">8315d4</a></td>
		<td>229 lines</td>
		<td>Moving old packages to archive.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=83bd56ecf9b406a1f52ad6ee916631c906b34aae">83bd56</a></td>
		<td>97 lines</td>
		<td>fix the arraylist of arraylist madness in parsing events, removed some unused methods</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=862a37b70a183e165c68a890ec6a2c63c6bff09f">862a37</a></td>
		<td>47 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=86383bd518034197753efee5d772532be6c08757">86383b</a></td>
		<td>2 lines</td>
		<td>remove .qualifier from version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=86cb4f80c860c16019d4a388eba0123e9dc4b3bd">86cb4f</a></td>
		<td>20 lines</td>
		<td>fixing build.properties and plugin version number for all plugins</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=86eda315e68dfb1fa4abac384ae4b21eedb1afe7">86eda3</a></td>
		<td>4 lines</td>
		<td>standardize all localizations for Provider to be bundleProvider</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=876523775a077cb2f479f02137a58e4b7eff83ae">876523</a></td>
		<td>4 lines</td>
		<td>change to reflect new build</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=878b12ad68763b65d6033d4200b22947c839c360">878b12</a></td>
		<td>2 lines</td>
		<td>changing Provider to Eclipse.org</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=87913878482ca7fd1651d3021b24995536fa4464">879138</a></td>
		<td>3 lines</td>
		<td>fix qualifier and bundle-localization</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=87bfc8b154ebe27cf5cf46050833eff4d9128d2a">87bfc8</a></td>
		<td>108 lines</td>
		<td>beginnings of an oprofiled control dialog</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8832d3ef947364c19bd931caedd61a51a8f59407">8832d3</a></td>
		<td>2 lines</td>
		<td>guesses proper path for fedora vmlinuxes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=89315ebc90928dfe9f36b4edd054b5e793360167">89315e</a></td>
		<td>1 lines</td>
		<td>svnignore for bin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=894a240cfef1317ca029a9980ce4a2c6d7bc87ee">894a24</a></td>
		<td>2 lines</td>
		<td>fix bounds checking</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=89ce9b9446a05363d080ce6d3f44ffbea977f9ba">89ce9b</a></td>
		<td>2 lines</td>
		<td>fixing version # with qualifier</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=89e855c9ab7bccfffa9da59f0132f76fbdd7f23e">89e855</a></td>
		<td>72 lines</td>
		<td>removed warnings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8c1b6b231f720e902842abc45a429873a3e6201f">8c1b6b</a></td>
		<td>2 lines</td>
		<td>changing Provider to Eclipse.org</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8d5e64452be30a8ecd00c6ad0939fcb7892ead24">8d5e64</a></td>
		<td>48 lines</td>
		<td>Change plugin versions to 0.3.0.qualifier; change provider to Eclipse (from Eclipse.org)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8d9982096b7b9f297281870ff1e2aaa39fbbefd2">8d9982</a></td>
		<td>1 lines</td>
		<td>adding svnignore for bin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8db5a6e2e258bf2ecb5d7b6d87f35ef35e4707a5">8db5a6</a></td>
		<td>133 lines</td>
		<td>moved into OprofileViewLogReaderAction.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8e43d7daf6758cabfbc0d7975f40b47f72c8789d">8e43d7</a></td>
		<td>2 lines</td>
		<td>fix source include flag</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8f0da4807d060126c5b8f08d96213fd5711170cf">8f0da4</a></td>
		<td>44 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8f36ea853ccba4e08ed7461e2bc3fcfbeb66eab6">8f36ea</a></td>
		<td>414 lines</td>
		<td>Moving old packages to archive.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8fac2d6177885df2d4fbd02cde5fae9f54fe4c86">8fac2d</a></td>
		<td>183 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=90d632fe344450ba9c6859a54a73b08d649ae892">90d632</a></td>
		<td>21 lines</td>
		<td>update error checking for run of opcontrol -- if rootpw not entered correctly the first time, launch fails</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=91b80dc905c15bdb7248a5bde97d7a74f97a195b">91b80d</a></td>
		<td>5 lines</td>
		<td>minor changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=91c5c6f3810c7482e379ee6fe0901590c4845705">91c5c6</a></td>
		<td>1290 lines</td>
		<td>merge of eventconfigtab branch into trunk</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9251e1fa890a0f8fae8b249242ddd42455b94ba9">9251e1</a></td>
		<td>2 lines</td>
		<td>keep stack trace dump; a SaxException might pop up in other cases (which i cant reproduce) and need to debug it..</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=928bb4b25a4f03c32ffb1df26fbc4d4a77e55584">928bb4</a></td>
		<td>52 lines</td>
		<td>new session, image w/no deps</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=92e0ae54a70f44eead2313e6a48b74bad6fab145">92e0ae</a></td>
		<td>2 lines</td>
		<td>built opxml from newly changed sources</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=941e132ad997536f4bd677f80e3160dfd591601c">941e13</a></td>
		<td>29 lines</td>
		<td>Creates a treeviewer, populates data model with click from an action (only used for debugging atm).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=94985a5ada338d49308d90713076ed94f4d19417">94985a</a></td>
		<td>2 lines</td>
		<td>Cleared warnings.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=95376c577d03e87390c0d3417b5283de171cbf95">95376c</a></td>
		<td>3 lines</td>
		<td>add plugin.properties</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=95e732e4a3a810783f88394a651ecb95d30d1737">95e732</a></td>
		<td>122 lines</td>
		<td>update to oprofile control dialog -- mostly working</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9605d4ac0ead2d4a0e3badf9aaeb853d4551ccf8">9605d4</a></td>
		<td>4 lines</td>
		<td>fixed typo and externalized string when opcontrol binary not fonud</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=96348c7493fd1b4a63f10971b43c960760f41473">96348c</a></td>
		<td>2 lines</td>
		<td>put qualifier back on</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=96b67594e3f6ee917efd599498cb43326461277c">96b675</a></td>
		<td>115 lines</td>
		<td>merged changes with testing work; fixed swt thread error for dialog showing close of oprofile daemon after launch terminates</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=96e9ff0bcd245dd6872a57a3f718e03717f4defb">96e9ff</a></td>
		<td>5 lines</td>
		<td>Focuses on the oprofile view after parsing the data</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9728d39998c6fee8805b85e2bcc3c6af45f54a7b">9728d3</a></td>
		<td>10 lines</td>
		<td>check for null added due to test failure</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=97d6d70f35ee5a69b14ed6adc4dba5bc58459328">97d6d7</a></td>
		<td>2 lines</td>
		<td>fix url location to match changes on the wiki</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=99615f7d5b8964f1b5a95b02da312c39000acc20">99615f</a></td>
		<td>39 lines</td>
		<td>deleted as part of refactoring</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9c39e96fda215988eb7c13799a36ab536357e65b">9c39e9</a></td>
		<td>10 lines</td>
		<td>included plugins version #</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9c3dd149d09cbe08d2c9745b366eb0b23ad0e0ca">9c3dd1</a></td>
		<td>2 lines</td>
		<td>fix source include flag</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9d1f85d8abdc98c7e0cf0a8d383e3ac4651fbb06">9d1f85</a></td>
		<td>136 lines</td>
		<td>remove spec from svn</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9d383b813d9a73e6f2cb6a651ceab566e6383e49">9d383b</a></td>
		<td>2 lines</td>
		<td>added exits to failing conditions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9d4d0bd858aac277e7f57580fa213b02a44f1f63">9d4d0b</a></td>
		<td>15 lines</td>
		<td>style changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e60720eae66e96d69f096e182d29a77b65434dd">9e6072</a></td>
		<td>99 lines</td>
		<td>finished parsing test</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e89504287beb185242cb4e8b8016219477384fa">9e8950</a></td>
		<td>2 lines</td>
		<td>merge commits from 0.2.0 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f5ba6e587b86d52260bac902f47dfc94fc9ad56">9f5ba6</a></td>
		<td>22 lines</td>
		<td>added new test sessions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f9b094811a63210340626d95ebbb334eda792b6">9f9b09</a></td>
		<td>209 lines</td>
		<td>change colourization thresholds</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9fe0a6bf85d50e5d3e8376415d780e16a7b72dda">9fe0a6</a></td>
		<td>184 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a152d463c74699ab80f34af8fbef9a513334c7f7">a152d4</a></td>
		<td>211 lines</td>
		<td>double-click on the default session prompts allows the user to save it; removed the action class where this functionality was before</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a16a5f4bdcd6349ae8976908d60549b3223ea236">a16a5f</a></td>
		<td>100 lines</td>
		<td>modified to use opxml fragment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a18ee01b2348d88bbcf77f6ac544171e2589f667">a18ee0</a></td>
		<td>27 lines</td>
		<td>remove double click on symbol to open file</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a233fd20138907ee2fd4281a76bfc2637361a41a">a233fd</a></td>
		<td>1 lines</td>
		<td>import package fix</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a3b7fcca2c1cbb98ad511327ec1bb711c82eab91">a3b7fc</a></td>
		<td>4 lines</td>
		<td>remove use of isEmpty() to allow use of 1.5 JVMs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a3e2dc8faa48cf6c6fb911e29684c4719e626ff5">a3e2dc</a></td>
		<td>4343 lines</td>
		<td>Moving old packages to archive.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a40f4985043ee397256103ab1744661627e55e31">a40f49</a></td>
		<td>26 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a499e076dab08af869bc6c3cfbba5b6f9e0df0b9">a499e0</a></td>
		<td>12 lines</td>
		<td>change oprofile to use a 0.1 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a4c74dff0e64b65895a96289f2da11f2a31f5d24">a4c74d</a></td>
		<td>22 lines</td>
		<td>Focuses the view after a launch (opens the view if not already).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a584646595537c6e5f9f20e90dfa25e995c092d3">a58464</a></td>
		<td>7 lines</td>
		<td>popup if opcontrol doesnt exist, descriptive text to fix, fixes so things dont crash &amp; burn if that does happen</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a5938d4b4d4001bd2b98889abb4074c3c43b91a1">a5938d</a></td>
		<td>11 lines</td>
		<td>check for null added due to test failure</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a5bd58e412038c23cee70030be5c22467f173627">a5bd58</a></td>
		<td>34 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a6105785398318cb177ce53d655626c9eb4b2a7d">a61057</a></td>
		<td>6 lines</td>
		<td>fixing version # with qualifier</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a677b07ddc2b7a7f6c392e821c5ac84667f3fd69">a677b0</a></td>
		<td>6 lines</td>
		<td>include resources dir. arrggghhh</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a6954cb6034e28fda1b1a44c27c48a08628695fa">a6954c</a></td>
		<td>4 lines</td>
		<td>changed icon for manual profiling</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a6a3f43f867f6c62e483f7ac0bc8087a38383b46">a6a3f4</a></td>
		<td>8 lines</td>
		<td>remove unused vars</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a77032620164bb8293d3b4213c786b936c5a5c0d">a77032</a></td>
		<td>56 lines</td>
		<td>error checking if there is no opxml providel, and the dialog box properly shows now</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a89c5750c7e7084c7fbf8bfa7c1cd36d5915b4ac">a89c57</a></td>
		<td>23 lines</td>
		<td>changed scope of member variables to allow tests to access</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a962db636468deb220137e0cf9c2a968d67e0c83">a962db</a></td>
		<td>4 lines</td>
		<td>update build info from previous rebuild</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aa8579e3577c7f767d5d155f14a09299f1016547">aa8579</a></td>
		<td>32 lines</td>
		<td>changes to fix review request issues</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aaf37c9b7d739c3c972071740072310fa8a70161">aaf37c</a></td>
		<td>18 lines</td>
		<td>removed exception check in setUp (will be caught higher up and helps with execution flow)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ab87c9c1df6cf0c747d350dfd83a8abc3fb87f88">ab87c9</a></td>
		<td>2 lines</td>
		<td>merge commits from 0.2.0 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ac31f94942390953b3daa524d0f7244ac05c4705">ac31f9</a></td>
		<td>6 lines</td>
		<td>fixing version # with qualifier</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ac82f265116ecc63d324c8c20c183cecabf9c619">ac82f2</a></td>
		<td>45 lines</td>
		<td>style changes + some removing some unnecessary code</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ae4f100a317907112b7ba07791667e9d04f9d2b2">ae4f10</a></td>
		<td>2 lines</td>
		<td>standardize all localizations for Provider to be bundleProvider</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=af6dfccb279b2345f6010eda9f64a0c600118392">af6dfc</a></td>
		<td>107 lines</td>
		<td>moved install scripts and modified opcontrolprovider accordingly; updated README</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=afb699ebf30c6f0251cd67a1c3c53976a7a6c508">afb699</a></td>
		<td>71 lines</td>
		<td>added timer-mode tag to info output denoting if oprofile is in time mode</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b041eeedc6a17a7b216f67c46db83653eb5ff9fd">b041ee</a></td>
		<td>92 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b1059b4275cc6273846885f9966f54c2228dfb66">b1059b</a></td>
		<td>4 lines</td>
		<td>Annotation feature initial commit and related changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b14153bc7618f9e5fab9130bb0af22b8cf8eae0a">b14153</a></td>
		<td>73 lines</td>
		<td>test class for new test session</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b24d91233f282c0acb62bf17dd931852e9190934">b24d91</a></td>
		<td>92 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b409db914485d6d27272d89a6735879b46b57f01">b409db</a></td>
		<td>919 lines</td>
		<td>cleanup and refactoring of xml parsing classes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b433e1df27b8f339a05afb50d12bb286ea541797">b433e1</a></td>
		<td>4 lines</td>
		<td>Change plugin names to include &quot;Incubation&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b4ed45fb92f69289d3aebd87b8f9080d2f4e9d17">b4ed45</a></td>
		<td>2 lines</td>
		<td>ignore for opcontrol wrappers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b57e157de3372a155cc227d5fb39990749f37fda">b57e15</a></td>
		<td>1365 lines</td>
		<td>various refactorings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b5a10a2d75dc05176fc849cdeffa6c42937e284a">b5a10a</a></td>
		<td>4127 lines</td>
		<td>reorganizing plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b61db23a15cb5544ca5e8712a272b31d343da693">b61db2</a></td>
		<td>2 lines</td>
		<td>remove cflags</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b681b6293df3f11669702f7896cb1b122fbbdb4d">b681b6</a></td>
		<td>59 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b69d469d7a353949578985d3236f2f49d05fe652">b69d46</a></td>
		<td>177 lines</td>
		<td>unit mask exclusive, mandatory tests, extended others</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b7fb28815881be8a0e11cece2d7a21ced07054b5">b7fb28</a></td>
		<td>27 lines</td>
		<td>fix a bug with multiple image elements in opxml output (error)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b81d83c66f59d2ba9fcb00eae90d5b543eb867fa">b81d83</a></td>
		<td>2 lines</td>
		<td>change icon path for view</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b85070d1fd8bd142fbd8bd1dfac7ae4f03114c11">b85070</a></td>
		<td>10 lines</td>
		<td>check for null added due to test failure</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b8b73327239770c01ae8e265eed8bfb64d0bb8e4">b8b733</a></td>
		<td>22 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b96efdd0a113b57a4d48ae852c4b129f86f57bed">b96efd</a></td>
		<td>18 lines</td>
		<td>svnignore</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ba1ccb999624e2d82912405a119d804ec9bebd91">ba1ccb</a></td>
		<td>3 lines</td>
		<td>no default guess for kernel image</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ba51b646cbb4ddc05bf7f27c796828d9f39dff15">ba51b6</a></td>
		<td>196 lines</td>
		<td>add check for oprofile in timer mode -- no event setup allowed in timer mode, so display a message explaining such instead of the regular controls</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bac6327c8826c985e585edd01090043ce993e727">bac632</a></td>
		<td>8 lines</td>
		<td>minor changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bacf095baaea57049924ccfca16e0992e51102ac">bacf09</a></td>
		<td>1994 lines</td>
		<td>update doc plugin with recent build of user guide; add doc plugin to feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bc1480dd63239ab6d4b05bed6845355fa2700025">bc1480</a></td>
		<td>1 lines</td>
		<td>export ui data model package</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bc9b46241765bef4573bd9ac59b83dff7d5746b8">bc9b46</a></td>
		<td>4 lines</td>
		<td>fix source include flag</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bcbcd4f86b4089cdd1afe7b8d451260971e48d18">bcbcd4</a></td>
		<td>135 lines</td>
		<td>Added functionality to double click on samples, bring up editor at the appropriate line number. Note the plugin now depends on org.eclipse.linuxtools.profiling.ui as well.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bd0ae3cf3673d0a32e189b99e33877ebe3e8ca28">bd0ae3</a></td>
		<td>6 lines</td>
		<td>fixing copyright headers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=be4ecdd267c2fc6f30349ccb7b428f1e8e4f6ca9">be4ecd</a></td>
		<td>1 lines</td>
		<td>adding svnignore for bin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bf79ca498525fb225c047c896463a1fd4b8c72c6">bf79ca</a></td>
		<td>7 lines</td>
		<td>recognize timer mode tag; add to opinfo data object</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bf91f7c063bba35a6a195ac5e921814bae132635">bf91f7</a></td>
		<td>20 lines</td>
		<td>changed dependencies to package imports</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c074aaf97c24cb0180335b76ca29fd2310f71668">c074aa</a></td>
		<td>2 lines</td>
		<td>put qualifier back on</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c0dcca7a951aa5441ea1d76b481e72352596507e">c0dcca</a></td>
		<td>2 lines</td>
		<td>fix source include flag</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c263c194645ef5f80d030c7a283319218d5fe534">c263c1</a></td>
		<td>4 lines</td>
		<td>standardize all localizations for Provider to be bundleProvider</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c27a3714c3f21ba8e75d59f63064953d6cdb0438">c27a37</a></td>
		<td>165 lines</td>
		<td>Initial commit</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c30a4585d64ee5ebdab41dba5cf7b71d72200446">c30a45</a></td>
		<td>90 lines</td>
		<td>removed action sets for actions not used any longer</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c3b6dc6ae2e0c8a3999ac44b95a6341aef23853d">c3b6dc</a></td>
		<td>30 lines</td>
		<td>test class for new test session</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c4035612f1165e1835d366a5b448c4f2b0716c79">c40356</a></td>
		<td>59 lines</td>
		<td>symbols sorted by count, descending, eclipse bz265489</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c4c5479ce399ec47db1ad5877381b79d4ee208df">c4c547</a></td>
		<td>217 lines</td>
		<td>data for new test session</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c4dbd14cb79cc7e4ce9a8191b3ff3a5424298993">c4dbd1</a></td>
		<td>685 lines</td>
		<td>remove annotation for now</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c52cda27a1227d13e2d197a6f81e749b01a4310f">c52cda</a></td>
		<td>107 lines</td>
		<td>changed layout of the dialog; added a List for feedback messages from users; added save and reset session buttons; added a progress dialog for post-shutdown of oprofile; tested and seems to be working well</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c55f0d8582f94dc116ba512d7947db64864b1611">c55f0d</a></td>
		<td>33 lines</td>
		<td>Check box option in global options tab to determine if the launch is a manual or normal profile.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c5ae96913e15c1d87462b1079d7469bd3e08c3e6">c5ae96</a></td>
		<td>11 lines</td>
		<td>popup if opcontrol doesnt exist, descriptive text to fix, fixes so things dont crash &amp; burn if that does happen</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c68ae9c3bb3a85aeffcf5c2987839e1006c97ab4">c68ae9</a></td>
		<td>4 lines</td>
		<td>Commit rebuilt opxml as part of eclipse bz278681</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c6919e580f893152044bebd5575dd73d9eb023bd">c6919e</a></td>
		<td>2 lines</td>
		<td>fix source include flag</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c6bac1b97149b2980b7bfd87e812e056b033d0e6">c6bac1</a></td>
		<td>4 lines</td>
		<td>reverse ordering for session names</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c820a5214a889439b872026f48fa5a999c1f64c8">c820a5</a></td>
		<td>89 lines</td>
		<td>added some code to ensure the default session is always output first (and the rest are properly sorted) when executing `opxml sessions`</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c86ec5a392507e808feaee73ce1d0f7ff01123dc">c86ec5</a></td>
		<td>2 lines</td>
		<td>remove unused string</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c92fafee82d97c061fed9410db0c55ca2aa608f2">c92faf</a></td>
		<td>7 lines</td>
		<td>shouldn't be committed</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ca567274ab24585864d7e4a673337bd4c378c267">ca5672</a></td>
		<td>7 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cad3f9cf45af0c45f35f1773eabb30e431edb91a">cad3f9</a></td>
		<td>16 lines</td>
		<td>style changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cb2984e3268ecfc28302305830229001fcf7e626">cb2984</a></td>
		<td>2 lines</td>
		<td>With vs with for consistency with valgrind plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cb7d25afe99d96a1ebf9a6162d9cbea796ecc0f6">cb7d25</a></td>
		<td>16 lines</td>
		<td>Fix for eclipse bz278681: malformed xml. Added a relevant test case as well.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ce33b0d8534baa656b711195542eb2c5489f1967">ce33b0</a></td>
		<td>14 lines</td>
		<td>changed dependencies to package imports</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ce3ac08215aae6332771237acac45e5fe198b971">ce3ac0</a></td>
		<td>2 lines</td>
		<td>platform filter arch fix</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cef78d8f32b4f7c54ec99ece207054b4e77823a2">cef78d</a></td>
		<td>2 lines</td>
		<td>fix source include flag</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d00d4f58c47418a6e5c547f9f10ce9719be71227">d00d4f</a></td>
		<td>2 lines</td>
		<td>remove .qualifier from version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d122c781642611fc198a8d1926938bf907c7fb7a">d122c7</a></td>
		<td>3 lines</td>
		<td>fixed copyright header</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d188d0750f76899b233572dd3411dd6323953738">d188d0</a></td>
		<td>2 lines</td>
		<td>Commit rebuilt opxml as part of eclipse bz278681</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d282a8b67a17968c6e82afb6796b045b337950d9">d282a8</a></td>
		<td>7400 lines</td>
		<td>refactoring for fragment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d37084017ae8884f2a3dfc8fdee9906a18ab1dd8">d37084</a></td>
		<td>2 lines</td>
		<td>use of refactored method name</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d435adc0290104c161511a9dc09acee30d4590da">d435ad</a></td>
		<td>2798 lines</td>
		<td>Removed a bunch of old UI code; parsing the oprofile data/ui model runs in a separate thread w/ a progress monitor; profile launching refreshes the view's model</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d4f2421a2e1f728f044b1f660ca0a6739cd4d19b">d4f242</a></td>
		<td>9 lines</td>
		<td>include resources dir</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d4f43b9f22479af85dcae6517b45a2756d5a667f">d4f43b</a></td>
		<td>19 lines</td>
		<td>add static field for setting default mask value</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d6bd6f740bdad171145f2660a57e5db526428512">d6bd6f</a></td>
		<td>10 lines</td>
		<td>remove qualifier from plugin version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d7ed824a65441b9ff3fef85aebd43f652e610345">d7ed82</a></td>
		<td>15 lines</td>
		<td>refactor method names; prefix with _ if only called from xml parser</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d7ff8744d62d83220cd7118d4df3e860400f3b5d">d7ff87</a></td>
		<td>2 lines</td>
		<td>merge commits from 0.2.0 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d8cdd702de3424d02c5b84daac9f3497860b0942">d8cdd7</a></td>
		<td>2 lines</td>
		<td>change fragment host version from 0.1 to 0.1.0 as per https://bugs.eclipse.org/265495.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d9e51a885f1d43244bc25b7aa5e02ab678058e2d">d9e51a</a></td>
		<td>7 lines</td>
		<td>merge commits from 0.2.0 branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=da6b21324d0859c1d735fc41cde962d860f2db7f">da6b21</a></td>
		<td>361 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dae6bd9f191f228e66ce6b8d37f6dc066c586de7">dae6bd</a></td>
		<td>10 lines</td>
		<td>classpath settings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=db81f0d3a321b074757758d4fd1adf2c88614bfd">db81f0</a></td>
		<td>33 lines</td>
		<td>manual launch dialog terminates when launch terminates</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dcefb0cb2471f5364c2bef9ea57f85289c69486d">dcefb0</a></td>
		<td>4 lines</td>
		<td>add vmarg to not run oprofile's launch tests</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dd57f28033977b7aa5aaeccc643ab7d5fb9c40ac">dd57f2</a></td>
		<td>14 lines</td>
		<td>Added copyright header.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dfbbc9819f5dfbdd209c0b3795847f97713a6aae">dfbbc9</a></td>
		<td>6369 lines</td>
		<td>initial-import</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e0b24a328ff3097ef24365e1151ecc53a502c799">e0b24a</a></td>
		<td>2 lines</td>
		<td>put qualifier back on</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e0b6ba679fe5321c6400e7a8856bb1c8395b144c">e0b6ba</a></td>
		<td>59 lines</td>
		<td>Changes to separation mask config, code there to enable thread/cpu separation, but dont support it yet (would need changes to opxml)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e13bad1dda9f16865e5beb6cab4daf4cb173fd72">e13bad</a></td>
		<td>4 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e18d703b1afce4673ab8c24bea28e481a382ee8b">e18d70</a></td>
		<td>184 lines</td>
		<td>branch working towards 0.1 release</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e1e2c7a8ea2729836a37ced439b32338d5a66cc4">e1e2c7</a></td>
		<td>18 lines</td>
		<td>fixed several stupid bugs</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e21c68e00db38ae401f3c2d7a6178ccc987b422b">e21c68</a></td>
		<td>928 lines</td>
		<td>Added second oprofile launch type to allow separate configuration of manual vs non-manual profiles. Split the launch delegate into an abstract class and two subclasses. Also added fix for manual profile where the dialog will never close if the launch terminates before it opens.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e29a7cd7bbe9a9f6e5c9b116dd07ea03aaf3abf1">e29a7c</a></td>
		<td>21 lines</td>
		<td>add indicator when there are no samples to display in the session; part of ebz274361</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5013d8819b1d2bc5cd06f02ab6152a1e6dd1de6">e5013d</a></td>
		<td>2 lines</td>
		<td>fix ant target</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e52002f782daa3fa241eca7f91828444ec35df07">e52002</a></td>
		<td>199 lines</td>
		<td>Added 2nd launch shortcut and code path in the launchdelegate for a manual launch of oprofile, under one launch config</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e7ec2add80fb565bb57cf9090babf0c46d926b19">e7ec2a</a></td>
		<td>8 lines</td>
		<td>remove unused method</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e807432e386528d01dbfd6402474f2882411b6cc">e80743</a></td>
		<td>4 lines</td>
		<td>more directed opxml find command</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eaad12f115e32eb7f466ef679ea4ab3496e2468a">eaad12</a></td>
		<td>3 lines</td>
		<td>remove unnecessary check (taken care of in the called method)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eb5abf4fe54ec30ddeba58e811ff68b934d4ba74">eb5abf</a></td>
		<td>1 lines</td>
		<td>added refreshModel to the ui for debugging</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eb6b0bf8d3440c15262f43b0dec22af128df0467">eb6b0b</a></td>
		<td>3703 lines</td>
		<td>refactoring for fragment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ec890c55361ab85d9da98a4bbdfffb5c407947d2">ec890c</a></td>
		<td>36 lines</td>
		<td>fix how opcontrol exceptions are thrown if opcontrol doesnt exist</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ed7f45c0e3843ed27e20962408c3a0843415d094">ed7f45</a></td>
		<td>8 lines</td>
		<td>update build info from previous rebuild</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ed8c1b9cd1f5ba46c79f809d22592d00d7c08f6a">ed8c1b</a></td>
		<td>14 lines</td>
		<td>refactored refresh view action to be its own class, added log reader action, updated externalized strings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ee6351ebab8d7dd0bb90fcc413de63935730278d">ee6351</a></td>
		<td>2 lines</td>
		<td>fix ant target</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef318e58b3a65cfd871504790d896abfe433eb9f">ef318e</a></td>
		<td>28 lines</td>
		<td>fixing copyright headers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=efddd36e42b02b886746fbc85974c6465927442f">efddd3</a></td>
		<td>2 lines</td>
		<td>change fragment host version from 0.1 to 0.1.0 as per https://bugs.eclipse.org/265495.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f0a3a741799d6b24f5ae4acfd50c29d2995e6d92">f0a3a7</a></td>
		<td>101 lines</td>
		<td>refactor method names; prefix with _ if only called from xml parser</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f0ea69584125a1fcbc94116e1f95ef352de31f24">f0ea69</a></td>
		<td>9 lines</td>
		<td>fixed bug where the view wouldn't open if it was never opened before</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f1405f16c0bf0171aa715093f40a06d6cb5db25a">f1405f</a></td>
		<td>34 lines</td>
		<td>added/fixed bounds checking to some functions</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f21b694c6e117bccc44e155ac591964d1875d59b">f21b69</a></td>
		<td>2 lines</td>
		<td>change getter method name to include get</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f29930abf5532d649799e19c8a033644a2a57ab4">f29930</a></td>
		<td>70 lines</td>
		<td>fixed a bug launching the project from the CDT's 'binary' project element</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f3332a945913ab0632e9ec434056308104ca79fc">f3332a</a></td>
		<td>58 lines</td>
		<td>fixed ebz277385 old glibc error message; incl 'no profiling data' error does not show up. also fixed a bug where refreshing the view when all sessions are deleted from the system does not show the 'no profiling data' error message</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f37809ee831bca2a8cdc0b381c9403367d571a49">f37809</a></td>
		<td>5 lines</td>
		<td>event icon + related code to show it</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f3ae5c64eeee844332ae5d1328963719fe758900">f3ae5c</a></td>
		<td>1 lines</td>
		<td>remove incorrect comment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f4a2577004d4a27a14cd591edca0e1f75eb44f61">f4a257</a></td>
		<td>22 lines</td>
		<td>include opxml fragments; list profiling framework as a dependency</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f63683b57f8a9b99c12e83773a2214a56f8a7e5e">f63683</a></td>
		<td>2 lines</td>
		<td>Change plugin names to include &quot;Incubation&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f7b345e3f4c3fb7d38700d5f52d973e9ebbffb08">f7b345</a></td>
		<td>1198 lines</td>
		<td>branch working towards 0.1 release</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f83f518315d8a9ab9dd9fddd2edcd5d04d012184">f83f51</a></td>
		<td>2 lines</td>
		<td>Change plugin names to include &quot;Incubation&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f882cfcb8c4ebbe119d1013485451f8f74ddb9ab">f882cf</a></td>
		<td>1 lines</td>
		<td>add tests plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f91155bc3648b748c0129ddb3f344a807e58ee38">f91155</a></td>
		<td>74 lines</td>
		<td>perspective not used nor needed nor wanted</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fa433b9be4d82a4a1f9fbc5904adc84af76bb9e7">fa433b</a></td>
		<td>395 lines</td>
		<td>Able to display events -&gt; sessions -&gt; images -&gt; symbols, and dependents -&gt; images -&gt; symbols</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fab5d4e5b26811d4bf5f0c0ea36d76868c017b71">fab5d4</a></td>
		<td>30 lines</td>
		<td>remove individual oprofile test plugins and add new oprofile test feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fade59957828cc9ac62279d0c928e33eea4aa56f">fade59</a></td>
		<td>12 lines</td>
		<td>slightly more portable</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=faff92709c85c40fce6909d8e9c52ca4a69ac087">faff92</a></td>
		<td>2 lines</td>
		<td>Change plugin names to include &quot;Incubation&quot;.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fc77056a506281fa5270815c7e81adc6291db00d">fc7705</a></td>
		<td>2 lines</td>
		<td>added opxml fragments</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fca05a0441a1c06e41ae7a52f292d524efde9651">fca05a</a></td>
		<td>256 lines</td>
		<td>dont need these anymore -- the running/stopping of oprofiled is done from launching, and the other useful classes are now actions in the view package</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fcb856e6b5fd1fed5f548e03922d8f0ea96294fe">fcb856</a></td>
		<td>4 lines</td>
		<td>include oprofile feature and other profiling framework plugins</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fcb9a4622b6d31ad344b3788839ba0563b38f2c1">fcb9a4</a></td>
		<td>128 lines</td>
		<td>initial commit</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fcf262e055dadcda69d8c7d76fff78546dd844cf">fcf262</a></td>
		<td>69 lines</td>
		<td>part of unit mask test</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fdb6921f02deb847a13bdbbe2cd67553777258a1">fdb692</a></td>
		<td>70 lines</td>
		<td>extracted methods to be overridden by test object; changed scope of member variables to allow tests to access</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fe7a1963b9f0318e5b13b2a7a84b57c2a4032103">fe7a19</a></td>
		<td>453 lines</td>
		<td>Initial import.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=feedb1586aba2e393f411dd3cbfd2d8691964b44">feedb1</a></td>
		<td>6 lines</td>
		<td>add oprofile.tests plugin</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ff74b3e6182e72262c4d7c423cf45c067bc24043">ff74b3</a></td>
		<td>34 lines</td>
		<td>add default callgraph depth of 0 (if it is nonzero, the current display shows very odd results)</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Krzysztof&nbsp;Daniel (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=070bf1896a5c21af6ebd7c44af670bd2f2e2866e">070bf1</a></td>
		<td>16 lines</td>
		<td>Removed hack to rebuild plugin from source - it is no longer delivered in a binary format</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0a66ab0f7cade2aa2e28c76d7c13b38092eb38c6">0a66ab</a></td>
		<td>17 lines</td>
		<td>Patch update to 3.8 M4</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=128188c35f99f2ca9f841e8f7ec8716e83ff4c35">128188</a></td>
		<td>19 lines</td>
		<td>Implicit build of org.eclipse.equinox.initializer org.eclipse.equinox.initializer is no longer built by Eclipse.org, however, it is still required by eclipse-builder to do native library operations. It needs to be checked out and built by eclipse-builder explicitly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=4c116876d963a180dab2309a2155764af5a56bae">4c1168</a></td>
		<td>2 lines</td>
		<td>Revert &quot;Revert &quot;Removed deprecated bundles from bootstrap config.ini&quot;&quot; This reverts commit d9dd9fbba7bf600b426baa9ebc48af9902e70197.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=6341c7fa78863c6e1c975a9438f80cdea938e053">6341c7</a></td>
		<td>23 lines</td>
		<td>Removed dependencies from pdebuild.xml</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=72e5de7729ba992d9897261eff7b931b4e9b10b8">72e5de</a></td>
		<td>12207 lines</td>
		<td>Dependencies has been upgraded. icu requires update in fedora repository felix-gogo dependency has been introduced org.eclipse.jetty* have been introduced org.mortbay.jetty* have been removed. manifests in dependencyManifests were also updated.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=7d303e15c0fed77e309a813dfcf882bb8bcd78a6">7d303e</a></td>
		<td>50 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=366698">Bug 366698</a> - Kill old install and provision targets Two targets (provision.sdk and install were removed). installSDKinDropins is the default target now. installPlatform and installPlatformAndCVS were also removed</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=aec369f605a83aec45135f739659c25b9fa3be39">aec369</a></td>
		<td>2 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367942">Bug 367942</a> - setPDEBuildPath does nothing currently Incorporated akurtakov suggestion and now setPDEBuildPath uses the installation that was produced earlier, not the bootstrap.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=d101b3290df308930f6e0f69336289a0e18dd8dd">d101b3</a></td>
		<td>12 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367940">Bug 367940</a> - ant buildTests should fail if underlying equinox returns 13 &lt;exec&gt; tasks that invoke equinox got failonerror=true.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=d9dd9fbba7bf600b426baa9ebc48af9902e70197">d9dd9f</a></td>
		<td>2 lines</td>
		<td>Revert &quot;Removed deprecated bundles from bootstrap config.ini&quot; This reverts commit da733c79566e807a1a06bc159eaa7ed90b5dc024.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=da733c79566e807a1a06bc159eaa7ed90b5dc024">da733c</a></td>
		<td>2 lines</td>
		<td>Removed deprecated bundles from bootstrap config.ini</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=e1c08ca6219bc20285599665409016c58c5f5c89">e1c08c</a></td>
		<td>40 lines</td>
		<td>Source building is more error-resistance. While building source multiple times, it is possible that target directory already contains some files, and therefore mv will fail. In this patch mv has been replaced with cp -rf and rm -rf sequence. Existance of some directories is also verified before they are accessed.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=350304">350304</a></td>
		<td>2051 bytes</td>
		<td>[pdebuild] Clean up unnecessary logging<br/>Patch proposition</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=366698">366698</a></td>
		<td>4588 bytes</td>
		<td>Kill old install and provision targets<br/>Second proposition</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367727">367727</a></td>
		<td>3442 bytes</td>
		<td>Incorrect error message when eclipse-build version does not match the source tarbals<br/>Fix proposition</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367744">367744</a></td>
		<td>1294 bytes</td>
		<td>Verify if the JAVA_HOME is set before build starts<br/>Patch v4 in git format</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367940">367940</a></td>
		<td>2737 bytes</td>
		<td>ant buildTests should fail if underlying equinox returns 13<br/>Fix proposition</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367942">367942</a></td>
		<td>894 bytes</td>
		<td>setPDEBuildPath does nothing currently<br/>Fix in line with Alex suggestions</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Krzysztof&nbsp;Daniel (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=0c3a5d17d9aeeadf57141aeaba3b65d1ff533584">0c3a5d</a></td>
		<td>10 lines</td>
		<td>Verify if the JAVA_HOME is set before build starts A check if JAVA_HOME is set and points to an existing directory.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=1ed0c8b36c2b4512fbdfc78948010c57a7b0531b">1ed0c8</a></td>
		<td>10 lines</td>
		<td>Verify if the JAVA_HOME is set before build starts A check if JAVA_HOME is set and points to an existing directory.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=5226c06ce6c694af86addba36c396d92a48d632c">5226c0</a></td>
		<td>8 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367727">Bug 367727</a> - Incorrect error message when eclipse-build version does not match the source tarbals Changed error messaged to display which file actually is missing and what can be done about that.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=90afd93ab5f0d085229b81971e5391107df0ef42">90afd9</a></td>
		<td>8 lines</td>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367727">Bug 367727</a> - Incorrect error message when eclipse-build version does not match the source tarbals Changed error messaged to display which file actually is missing and what can be done about that.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Kyu&nbsp;Lee (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=00f7612f3c75fdd966125f79a9c8f6b34d5ffb5d">00f761</a></td>
		<td>826 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0547e97b9fdbd13bcfda18d8d529d9bf45b835f8">0547e9</a></td>
		<td>192 lines</td>
		<td>initial import of java parser fragment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0c0fabbf000817016750d8e05745850e31c41616">0c0fab</a></td>
		<td>2 lines</td>
		<td>made (STATIC INITIALIZER) to be lower cases</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=107fb569c8bdf74e81d9194b74898aa457281bb0">107fb5</a></td>
		<td>500 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1e1264503741eda7d0f9fd2ed7e40009dedccf65">1e1264</a></td>
		<td>413 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1ea7d694e245ea2bfec0ae1b6f5c57e31f15c4b5">1ea7d6</a></td>
		<td>250 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2185a499abb58458dcaf4c714044eab4a0c6ff99">2185a4</a></td>
		<td>500 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=27a37f546274c929a36c554f15df950f63c95ff9">27a37f</a></td>
		<td>81 lines</td>
		<td>2007-03-26  Kyu Lee  &lt;klee@redhat.com&gt; * META-INF/MANIFEST.MF: Added. * plugin.xml: Migrated require and other declarations to MANIFEST.MF. Fixed extension declarations to work with new namespace.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2c38d6686a7871ff173faf6783693ef9871192cb">2c38d6</a></td>
		<td>8 lines</td>
		<td>2007-08-07  klee  &lt;klee@redhat.com&gt; * feature.xml: Version bump to 2.0.0 and fixed requirements.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=30c470f405be76747aaa3a68643631dcfb03445d">30c470</a></td>
		<td>500 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=30d4dc015cf196c767c611e597329d7ed6251e41">30d4dc</a></td>
		<td>12 lines</td>
		<td>Added changelog and name changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=358531bca3e22d8b974256e66e6889465547a3df">358531</a></td>
		<td>500 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=35ab4a4308afad8da42ce57697ac51c2906c3180">35ab4a</a></td>
		<td>185 lines</td>
		<td>initial import of c parser fragment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3acc2d253dd01660aa76fcf954b821ae1d3765d2">3acc2d</a></td>
		<td>58 lines</td>
		<td>2007-05-14  Kyu Lee  &lt;klee@redhat.com&gt; * feature.xml: Version bump to 2.4.0. Added parser fragments. Removed JDT requirements.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=41f94b48227d29e7476fc46eaa69f3375345a1de">41f94b</a></td>
		<td>516 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=47770f93b70771645ff121ea9b7df53c682b3715">47770f</a></td>
		<td>3 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=49675636c2a9dbaa86248564816730e38f43a61f">496756</a></td>
		<td>413 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4c6e4a1ed055798d8708f803462830d7d7fc68af">4c6e4a</a></td>
		<td>6 lines</td>
		<td>2007-05-15  Kyu Lee  &lt;klee@redhat.com&gt; * build.xml: version bump to 2.4.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4cb6cdeda5a941c513f6c041b97bb57ea419d1ac">4cb6cd</a></td>
		<td>1122 lines</td>
		<td>parsers are now plugins not fragments</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4defcd2ee5212d342450a7634d5bb4eb871619ff">4defcd</a></td>
		<td>63 lines</td>
		<td>2007-05-15  Kyu Lee  &lt;klee@redhat.com&gt; * feature.xml: Added new parser features.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=557c5b8c8a5e53a6251f11300e57475a1d352957">557c5b</a></td>
		<td>426 lines</td>
		<td>2007-05-09 	Kyu Lee  &lt;klee@redhat.com&gt; * src/org/eclipse/linuxtools/changelog/core/parsers/JavaParser.java: Removed. Now separate javaparser plugin will provide parsing. * src/org/eclipse/linuxtools/changelog/core/parsers/CParser.java: Ditto. * src/org/eclipse/linuxtools/changelog/core/parsers/PythonParser.java: Ditto. * src/org/eclipse/linuxtools/changelog/core/parsers/CompareParser.java: Ditto. * src/org/eclipse/linuxtools/changelog/core/actions/PrepareChangeLogAction.java: Removed JDT import for JavaModelException which we don't really need. * META-INF/MANIFEST.MF: Removed JDT and CDT dependency because now Java/C parsers are in separate plug-ins. * plugin.xml: Version bump to 2.4.0 and remove parser extensions.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=55eb262d573b3b5f8e8ab1e71587f33615391845">55eb26</a></td>
		<td>10 lines</td>
		<td>2007-04-10 	Kyu Lee  &lt;klee@redhat.com&gt; * plugin.xml: Igor's patch to renamespace old com.redhat strings <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181497">Bug 181497</a>. * src/org/eclipse/linuxtools/changelog/core/parsers/JavaParser.java: Removed use of internal classes.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5a1d6cc490d97a1581bb7b9a25ed9d6d10662520">5a1d6c</a></td>
		<td>16 lines</td>
		<td>2007-08-07  klee  &lt;klee@redhat.com&gt; * feature.xml: Fixed dependencies.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5dea7aadd57cdcd4b5e751371a06d19be0b43eb5">5dea7a</a></td>
		<td>642 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5ea7dbc35588b72a9791e43d55a49329ed6b811c">5ea7db</a></td>
		<td>5 lines</td>
		<td>2007-06-25  Kyu Lee  &lt;klee@redhat.com&gt; * feature.xml : Includes new parser plugin instead of fragment.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5fe94cedf91587cb7ad6dbda97c912289695c93d">5fe94c</a></td>
		<td>16 lines</td>
		<td>2007-08-07  klee  &lt;klee@redhat.com&gt; * feature.xml: Version bump to 2.0.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6371a0fd348ec6af7febca25bf2b0000b3cd5d11">6371a0</a></td>
		<td>510 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7273f430392aa3174b0ffffb004fd140e4c7205d">7273f4</a></td>
		<td>250 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=777a7d27e24676994e68b311a90168ad92f0a6cb">777a7d</a></td>
		<td>514 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=80fda9bafc9eda942f636817de23ca1dbc5a17f0">80fda9</a></td>
		<td>392 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=86134979fdf604f4b31ebdc256d76a8b3abd0d79">861349</a></td>
		<td>250 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8879185f51c64a1b24c9d934125f9efb6de8924e">887918</a></td>
		<td>55 lines</td>
		<td>Initial import of java parser fragment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=890462320c6965fb03eee2e324aa267750cf23e6">890462</a></td>
		<td>12 lines</td>
		<td>Added changelog and name changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8a8776a927ffabcd8817d20421354a006287cb55">8a8776</a></td>
		<td>9 lines</td>
		<td>2007-08-02  Kyu Lee  &lt;klee@redhat.com&gt; * feature.xml: Version bump to 2.5.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=94f1f9a60e1e9b55181648b82a15d81635ff3981">94f1f9</a></td>
		<td>59 lines</td>
		<td>2007-04-10 	Kyu Lee  &lt;klee@redhat.com&gt; * plugin.xml: Igor's patch to renamespace old com.redhat strings <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181497">Bug 181497</a>.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=99c9766d60ca5e4a905e7a882e5686491202b4db">99c976</a></td>
		<td>376 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e50b6509f4736f7c5f41b46cc2e6ae115cac245">9e50b6</a></td>
		<td>6 lines</td>
		<td>2007-08-07  klee  &lt;klee@redhat.com&gt; * META-INF/MANIFEST.MF: Fixed requirements.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a84dcfc6c5c4b331b73c12d7a79943abf4291505">a84dcf</a></td>
		<td>15 lines</td>
		<td>Added changelog and name changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ad40a18f2b7b88d749cc1d01202ad5647c2e3353">ad40a1</a></td>
		<td>4 lines</td>
		<td>2007-06-25  Kyu Lee  &lt;klee@redhat.com&gt; * feature.xml : Includes new parser plugin instead of fragment.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=adb496357655914824c7a685b057cf4d328bf472">adb496</a></td>
		<td>120 lines</td>
		<td>2007-06-25  Kyu Lee  &lt;klee@redhat.com&gt; * src/org/eclipse/linuxtools/changelog/core/actions/StringDiffOperation.java (StringDiffOperation): Added support for Eclipse 3.3 * META-INF/MANIFEST.MF: Version bump to 2.4.1 and add dependency for Eclipse 3.3.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b14a9a751a00589b630a21073b0973a966e0d7a9">b14a9a</a></td>
		<td>5 lines</td>
		<td>2007-08-07  klee  &lt;klee@redhat.com&gt; * META-INF/MANIFEST.MF: Version bump to 2.0.0 and fixed requirements.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b5d1184b35ed41a6ffcb48d815a4948f80b52468">b5d118</a></td>
		<td>14 lines</td>
		<td>Added changelog and name changes</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ba5e9ef50411e3255dfc6a3676ccc898fc94b1cd">ba5e9e</a></td>
		<td>500 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=bc185ded63ebeb3c77098b1380feda213f5766dd">bc185d</a></td>
		<td>251 lines</td>
		<td>2007-07-31  Kyu Lee  &lt;klee@redhat.com&gt; * META-INF/MANIFEST.MF: Version bump to 2.5.0. * src/org/eclipse/linuxtools/changelog/core/actions/FormatChangeLogAction.java: Removed unused imports. * src/org/eclipse/linuxtools/changelog/core/editors/ChangeLogEditor.java: Ditto. * src/org/eclipse/linuxtools/changelog/core/ui/ChangeLogActionProvider.java: Ditto. * src/org/eclipse/linuxtools/changelog/core/actions/PatchFile.java: Added support for new files. * src/org/eclipse/linuxtools/changelog/core/actions/PrepareChangeLogAction.java: Ditto. + Removed internal class reference. * src/org/eclipse/linuxtools/changelog/core/actions/PrepareChangelogKeyHandler.java: Removed internal class reference. * src/org/eclipse/linuxtools/changelog/core/actions/PrepareCommitAction.java: Ditto. * src/org/eclipse/linuxtools/changelog/core/actions/PrepareCommitHandler.java: Removed internal class reference. * src/org/eclipse/linuxtools/changelog/core/actions/StringDiffOperation.java: Added a
  constructor with default options for DiffOper</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=be53bd880397a6c8142787ac72d91b3cfdef42e2">be53bd</a></td>
		<td>20 lines</td>
		<td>updated optional features</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c28ba54b79f877482219220eb10c84ef40b1a416">c28ba5</a></td>
		<td>123 lines</td>
		<td>initial import of python parser fragment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c68fd468db30f0e2a875c4c2c4dbb87fd8fdfbc9">c68fd4</a></td>
		<td>255 lines</td>
		<td>C parser feature import</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c882df9baa1990eacc6adaccfc5bf16bd7c60512">c882df</a></td>
		<td>250 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1524fb6fe5d3a73b8e8dbd4b5f0868821ee3e78">d1524f</a></td>
		<td>189 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d3f427c4408e4011195d0c5a0364530fb6fa9f03">d3f427</a></td>
		<td>297 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=df595b6bf06a3fb8d05255d6a4381bbaacbf249a">df595b</a></td>
		<td>226 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e3d6ca2f27c509a96e0cc866f7653dd16f7dd340">e3d6ca</a></td>
		<td>192 lines</td>
		<td>wrong folder</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e51bc9d32e3fb6c50d2591c30143451c49a4a32b">e51bc9</a></td>
		<td>5 lines</td>
		<td>2007-08-07  klee  &lt;klee@redhat.com&gt; * META-INF/MANIFEST.MF: Fixed requirements and version bump to 2.0.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e6ff8c8e18c24059597872f871b663eea0dab3ed">e6ff8c</a></td>
		<td>6 lines</td>
		<td>2007-05-14  Kyu Lee  &lt;klee@redhat.com&gt; * plugin.xml: version bump to 2.4.0.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e9a7eef058bdfec508dbceda81ab485aa264e1fa">e9a7ee</a></td>
		<td>7 lines</td>
		<td>modified to include plugins not fragments</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ebc0ee89aed4a9647c1e1a544200d0fb8095ce7f">ebc0ee</a></td>
		<td>279 lines</td>
		<td>import of 3.2 support branch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ecd54707b1fb6ddb6391a28d5b3f60ace9b07e9d">ecd547</a></td>
		<td>195 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f178d2365c62abd52003b80eab4beec4d0de74a8">f178d2</a></td>
		<td>642 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f5a4a83ac3b5d7598fdac32aca6513feade7082b">f5a4a8</a></td>
		<td>116 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f601668a04d5911a263d5f0390e37ad404282a1a">f60166</a></td>
		<td>111 lines</td>
		<td>initial import of compare editor parser fragment</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fbd84c47f624c72f7c03be4e68cf57b30c56a8cf">fbd84c</a></td>
		<td>500 lines</td>
		<td></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fd95986792f145e32a0236648b3e059dea38dcb5">fd9598</a></td>
		<td>12 lines</td>
		<td>2007-03-28  Remy Chi Jian Suen  &lt;remy.suen@gmail.com&gt; * src/org/eclipse/linuxtools/changelog/core/parsers/JavaParser.java: Add support for identifying static initializing blocks per <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=179549">Bug 179549</a>.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=179327">179327</a></td>
		<td>18470 bytes</td>
		<td>Separate *Parser classes into plug-ins<br/>removing dependencies for JDT, CDT and parsers</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Lawrie&nbsp;Nichols (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=296228">296228</a></td>
		<td>1853 bytes</td>
		<td>No profiling data generated - wrong image filter?<br/>Patch for oprofile abstract launcher</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">lmcpata (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=17429dca4b2a18c5691642864f7daf757588f394">17429d</a></td>
		<td>3671 lines</td>
		<td>Fix for custom parsers</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cc215be76b9c25a1ee7640a3e8df1f92bb56fe4d">cc215b</a></td>
		<td>15 lines</td>
		<td>Fix for state experiment manager coalescing.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Marc&nbsp;Dumais (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=316455">316455</a></td>
		<td>39515 bytes</td>
		<td>[LTTng] State system minor improvements<br/>Updated patch, following rebase to latest of TRUNK as of 2010-10-14</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Marc&nbsp;Khouzam (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=292172">292172</a></td>
		<td>390 bytes</td>
		<td>Wrong release version on oprofile move_opxml script<br/>Fix</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Marc-Andre&nbsp;Laperle (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=322698">322698</a></td>
		<td>2507 bytes</td>
		<td>Can't create a new C/C++ project<br/>AutotoolsBuildWizard messages patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Markus&nbsp;Knauer (eclipsesource.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=603509f79a48d11f633e21d93d5be7a55dd8d999">603509</a></td>
		<td>2 lines</td>
		<td>testing access rights in SVN</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Martin&nbsp;Oberhuber (windriver.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=354342">354342</a></td>
		<td>1955 bytes</td>
		<td>The version number can not be changed after the ValgrindOptionTab has been initialized<br/>patch v1</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=360085">360085</a></td>
		<td>2619 bytes</td>
		<td>Valgrind doesn't always clear its error markers when it should<br/>patch v1</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Mathieu&nbsp;Denis (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d1de21ae88fefb31d1edd81e509ca93222b5259f">d1de21</a></td>
		<td>8 lines</td>
		<td>Fixed lost event bug. Signed-off-by: Matthew Khouzam &lt;matthew.khouzam@ericsson.com&gt;</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=355084">355084</a></td>
		<td>2067 bytes</td>
		<td>[LTTng] latency analysis - the second trace to be selected sometimes doesn't appear<br/>Clear the histogram selected timerange for the latency view</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Matthew&nbsp;Khouzam (ericsson.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=0733f3b80816cf25a275ed72e54918abbcad570e">0733f3</a></td>
		<td>254 lines</td>
		<td>improve test coverage and fix go to last event bug</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=099df0107b394ad0abd9f40e88919052b6f7766d">099df0</a></td>
		<td>92 lines</td>
		<td>Fix seek bug. Adds indexing. Conflicts: lttng/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfTrace.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=117c2cdb3591bc8797cdfa73e4d938d90f1bc55b">117c2c</a></td>
		<td>79 lines</td>
		<td>Generalized trace test added. Can be useful for profiling.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=200ad02b0211ee13abbca3a2e28c965233625a17">200ad0</a></td>
		<td>108 lines</td>
		<td>Added a headless test</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=24107ab70633b4a3229fc57dae2af02d5296ee62">24107a</a></td>
		<td>67 lines</td>
		<td>Added getOffset to a trace and updated benchmark.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=264ffaa8e283fa1668bb5c57d1e230b9dbaee38e">264ffa</a></td>
		<td>228 lines</td>
		<td>Added faster indexed seeks.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2919a69f6f41680224803d99f3acec8590370540">2919a6</a></td>
		<td>343 lines</td>
		<td>Change certain classes to use ITmfEvent instead of TmfEvent. Signed-off-by: Matthew Khouzam &lt;matthew.khouzam@ericsson.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2fd7a9dc550d8df9d9a2cb9be39b4de2ef98880d">2fd7a9</a></td>
		<td>1 lines</td>
		<td>add LTTng icon to LTTng Traces</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3f5276094101a6b3fd7da0fefb83421d2ed92278">3f5276</a></td>
		<td>7 lines</td>
		<td>Add Lttng 2.0 trace to Lttng View</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=408f27d3450e68e9bbc3a543ef925fed170e2bb9">408f27</a></td>
		<td>8 lines</td>
		<td>fix seek with offsetted timestamps.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=43ddc7d7856715dab1be8b85eee892ec13733b92">43ddc7</a></td>
		<td>88 lines</td>
		<td>fix post-merge to get it to compile.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=584361456d5e30e042c4d1514229a1188be44587">584361</a></td>
		<td>7 lines</td>
		<td>update events table in lttng.ui to have an ITmfEvent.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5d2c183b768109a95154b4a0f2e8374b6cf9560e">5d2c18</a></td>
		<td>2 lines</td>
		<td>Change Icon from a giant mole to a reasonable penguin. Signed-off-by: Matthew Khouzam &lt;matthew.khouzam@ericsson.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5e260bf62b056088f0862337d0ab95c6b0ca3d12">5e260b</a></td>
		<td>18 lines</td>
		<td>Add a headless test Conflicts: lttng/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/ctfadaptor/headless/Benchmark.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7a47bb780be058a2ab9f47b22cd141f808a5580c">7a47bb</a></td>
		<td>89 lines</td>
		<td>Fix warnings</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8c5b11f630b587e89547a612f62f9effd6d85eb1">8c5b11</a></td>
		<td>21 lines</td>
		<td>add Environment variables to ctf interface</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a3fcc17f5102de27f1d2e4cd71f77952f944c859">a3fcc1</a></td>
		<td>4 lines</td>
		<td>Add support for offsets in event creation</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a97888f084252debbb4543f8d38e424f1fe973df">a97888</a></td>
		<td>6 lines</td>
		<td>Added an interesting headless test. It is more there to show how someone can use the trace. Signed-off-by: Matthew Khouzam &lt;matthew.khouzam@ericsson.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aa098c35f8ee377445e288493063a266b81264fc">aa098c</a></td>
		<td>7062 lines</td>
		<td>internalize some CTF API</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d0bf7c0ef35d7f04fd7f07848d8a8a90d78ff515">d0bf7c</a></td>
		<td>149 lines</td>
		<td>Improved test coverage.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d2ada18550e299323a68a43746f6b5d23406dcf5">d2ada1</a></td>
		<td>467 lines</td>
		<td>Add support for seeks by index.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d98555f4d955e1838171372f54907c26b4c4033d">d98555</a></td>
		<td>117 lines</td>
		<td>Added clocks to integer definitions and removed warnings from IOStructGen.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=dad5bdc62af79bbf033f289556d0d8716e66fe44">dad5bd</a></td>
		<td>74 lines</td>
		<td>add benchmarks Conflicts: lttng/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/headless/ReadTrace.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e01715736570787024910bdb3cf25dfa30ae4469">e01715</a></td>
		<td>137 lines</td>
		<td>Add environment variables view widget</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e82442d1b98114579637f1cd4139a25216ccd833">e82442</a></td>
		<td>8 lines</td>
		<td>Added getOffset to a trace and updated benchmark.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=eb53d527a2cadcb4f367ecbcc9e0a127c39c2a4d">eb53d5</a></td>
		<td>143 lines</td>
		<td>Add support in the UI for LTTng 2.0. signed-off by: YEAH BABY</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ef3e3f83bea4e1c1071f1d692096eafb9a444f65">ef3e3f</a></td>
		<td>70 lines</td>
		<td>add fallback for seeking by unindexed traces</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f61e1b03d280a1f7b634db545c315b655d955a12">f61e1b</a></td>
		<td>219 lines</td>
		<td>Change output of ctf toStrings to be more human readable.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f83095792d29998aaa60da3fb2a5da7fb247e8ca">f83095</a></td>
		<td>2666 lines</td>
		<td>Define CTF API</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f92741bd358479a51bc4ab56fb10f953a52cb6bd">f92741</a></td>
		<td>123 lines</td>
		<td>changed TmfEvent to ITmfEvent</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=292414">292414</a></td>
		<td>16532 bytes</td>
		<td>[LTTng] Include Legend in Control Flow and Resources View<br/>Includes legends in control flow view and resource view</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Mauren&nbsp;Brenner (motorola.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1c064c848524bf06ae2074ac5f4647dcce80cb38">1c064c</a></td>
		<td>4 lines</td>
		<td>Fixed <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=280090">Bug 280090</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2fe91cbd138b4eed08c74ab1c986ec795a1ccd54">2fe91c</a></td>
		<td>4 lines</td>
		<td>Fixed <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=280178">Bug 280178</a></td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">minoo&nbsp;ziaei (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=353447">353447</a></td>
		<td>2618 bytes</td>
		<td>Missing exported rpmstubby package<br/>rpmstubby and rpm.ui.editor patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Niels&nbsp;Thykier (thykier.net)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=322271">322271</a></td>
		<td>2277 bytes</td>
		<td>[eclipse-build][debian] eclipse-pdebuild.sh does not pass -data and uses -vmargs<br/>Refreshed the original patch for the git migration</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Otavio&nbsp;Luiz&nbsp;Ferranti (motorola.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8bb7d1b47a8f8c6c03bd2611bae23b266e47b501">8bb7d1</a></td>
		<td>39 lines</td>
		<td>Creating the project area</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Otavio&nbsp;Pontes (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=104be8caedb2f54a28a716d86803beb817101ea1">104be8</a></td>
		<td>21 lines</td>
		<td>Fix <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=351477">Bug 351477</a> When SystemTap script is run with 'run w/Graph' option and the connection to remote host fails the wizard to continue with creation of graph appears in spite of the error message/failure https://bugs.eclipse.org/bugs/show_bug.cgi?id=351477 * systemtap/org.eclipse.linuxtools.systemtap.ui.consolelog/src/org/eclipse/linuxtools/systemtap/ui/consolelog/ScpClient.java * systemtap/org.eclipse.linuxtools.systemtap.ui.graphicalrun/src/org/eclipse/linuxtools/systemtap/ui/graphicalrun/actions/RunScriptChartAction.java</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=270dbfff315e44cb10bfc3018f894f6671f859f5">270dbf</a></td>
		<td>2 lines</td>
		<td>Documentation, Import Modules task has a broken link  <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=353635">Bug 353635</a> 'Module Browser' link in 'Importing Modules' help page is broken. The href from link is incorrect. https://bugs.eclipse.org/bugs/show_bug.cgi?id=353635 * systemtap/org.eclipse.linuxtools.systemtap.ui.dashboard/documentation/html/tasks/importModules.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=40a1d6661fadc9b72fcf73bddd0e10b588e9a738">40a1d6</a></td>
		<td>57 lines</td>
		<td>Modify verbosity flag to accept levels of verbosity. <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=353809">Bug 353809</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5c82d8af7aed5b9536622b9f6cc358ec8827c8c2">5c82d8</a></td>
		<td>57 lines</td>
		<td>Modify verbosity flag to accept levels of verbosity. <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=353809">Bug 353809</a></td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=5fa024f8085275d28e1d1a2cfd51f796d4341cb3">5fa024</a></td>
		<td>2 lines</td>
		<td>Documentation, Import Modules task has a broken link  <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=353635">Bug 353635</a> 'Module Browser' link in 'Importing Modules' help page is broken. The href from link is incorrect. https://bugs.eclipse.org/bugs/show_bug.cgi?id=353635 * systemtap/org.eclipse.linuxtools.systemtap.ui.dashboard/documentation/html/tasks/importModules.html</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d18c50b53b0741b79b4cb2a38a5a7e2cd345eee3">d18c50</a></td>
		<td>23 lines</td>
		<td>NPE when opening .h/.c file in SystemTap IDE Null Pointer Exception is raised when opening a file in Kernel Source view in Systemtap IDE https://bugs.eclipse.org/bugs/show_bug.cgi?id=345010</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=345010">345010</a></td>
		<td>4014 bytes</td>
		<td>Null Pointer Exception is raised when I open a file in Kernel Source view in Systemtap IDE<br/>Systemtap: Using only stp editors to open files in stap perspective</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=351355">351355</a></td>
		<td>5347 bytes</td>
		<td>gprof: support 64-bit gmon files in ppc64<br/>Getting Symbol table correctly in ppc64</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=351477">351477</a></td>
		<td>3512 bytes</td>
		<td>When running a systemtap plugin to draw a graph it displays the graph wizard even if the connection fails.<br/>Improved patch to fix the problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=353635">353635</a></td>
		<td>1396 bytes</td>
		<td>Help: systemtap Dashboard Guide -&gt; Importing Modules has a broken link<br/>Patch to fix the reported problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=353809">353809</a></td>
		<td>10784 bytes</td>
		<td>Function Callgraph profile configuration does not support -vv and -vvv options<br/>Using a spinner instead of checkboxes</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=353903">353903</a></td>
		<td>13039 bytes</td>
		<td>&quot;Function Callgraph&quot; should use the most recently used launch config<br/>Fill default configuration with the same attributes that are used by LaunchStapGraph</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Otavio&nbsp;Pontes (br.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f67202d9f6817dc7dd16e46c02d110708167254f">f67202</a></td>
		<td>132 lines</td>
		<td>Fill the default callgraph launch configuration with new attributes The default attributes from callgraph launch configuration are now the same attributes used by LaunchStapGraph to run systemtap.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Patrick&nbsp;Hofer (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=275685">275685</a></td>
		<td>1455 bytes</td>
		<td>[valgrind] doesn't launch on debian based system<br/>proposed patch with copyright info</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Patrick&nbsp;Tasse (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=310709">310709</a></td>
		<td>11240 bytes</td>
		<td>[TMF] Time Analysis Viewer widget single event trace and fixed time interval problems<br/> Proposed patch on org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=319428">319428</a></td>
		<td>228807 bytes</td>
		<td>[TMF] Generalization of Project View<br/>Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=319429">319429</a></td>
		<td>4662 bytes</td>
		<td>[TMF] Implementation of Custom Parsers<br/>Icons zip file for org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=325638">325638</a></td>
		<td>25209 bytes</td>
		<td>[TMF] Virtual Table widget improvements and bug fixes<br/>Proposed patch on TmfVirtualTable.java and TmfEventsTable.java</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=327265">327265</a></td>
		<td>38018 bytes</td>
		<td>[TMF] Custom parsers NPE, extra columns and event type &amp; content fixes<br/>Proposed patch in org.eclipse.linuxtools.tmf.ui</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=337872">337872</a></td>
		<td>5981 bytes</td>
		<td>[TMF] Progress monitor feedback for indexing and constructor trigger<br/>Proposed patch in org.eclipse.linuxtools.tmf</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=337891">337891</a></td>
		<td>1699 bytes</td>
		<td>[TMF] Event clone erases content<br/>Proposed patch in org.eclipse.linuxtools.tmf</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=337900">337900</a></td>
		<td>5003 bytes</td>
		<td>[TMF] Buffered random access file<br/>Proposed patch in org.eclipse.linuxtools.tmf</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=337914">337914</a></td>
		<td>11114 bytes</td>
		<td>[TMF] Implementation of filter model<br/>Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=338016">338016</a></td>
		<td>80544 bytes</td>
		<td>[TMF] Consolidation of externalization strings<br/>Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=338112">338112</a></td>
		<td>867 bytes</td>
		<td>[TMF] Projects view improvements and bug fixes<br/>icons zip file for org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=338151">338151</a></td>
		<td>1975 bytes</td>
		<td>[TMF] Implementation of Filters view<br/>icons zip file for org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=338155">338155</a></td>
		<td>512 bytes</td>
		<td>[TMF] Implementation of Colors view<br/>icons zip file for org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=338162">338162</a></td>
		<td>1219 bytes</td>
		<td>[TMF] Implementation of raw event viewer<br/>Proposed patch in org.eclipse.linuxtools.tmf.tests package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=338253">338253</a></td>
		<td>2193 bytes</td>
		<td>[TMF] Implementation of searching, filtering, highlighting and bookmarking in events table<br/>icons zip file for org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=342769">342769</a></td>
		<td>47389 bytes</td>
		<td>[TMF] Refactoring of event cache with filter support and optimization of GUI refresh<br/>Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=348010">348010</a></td>
		<td>849 bytes</td>
		<td>[TMF] NullPointerException in custom XML parser wizard<br/>Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=348020">348020</a></td>
		<td>3620 bytes</td>
		<td>[TMF] Color resource leak in Colors view<br/>Proposed patch in org.eclipse.linuxtools.tmf.ui package</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=353020">353020</a></td>
		<td>222892 bytes</td>
		<td>[TMF, LTTng] Changes for streaming support, background and event request refactoring, trace control updates and minor bug fixes<br/>Proposed patch in org.eclipse.linuxtools packages</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Rafael&nbsp;Medeiros&nbsp;Teixeira (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9bc82fd9c00ca95a2f14f3fa78ac18b3e2921402">9bc82f</a></td>
		<td>38 lines</td>
		<td>Fix for <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=333315">Bug 333315</a> - Add text to Valgrind view when no errors were found.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b976523cbb21e6b64b4c3ab25dcc0d28b411741c">b97652</a></td>
		<td>10 lines</td>
		<td>Further fix for <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=333315">Bug 333315</a>. Since the last fix doesn't allow empty messages array anymore (there's at least a ValgrindInfo message in it), verification for executions with no output must be different. Messages are also cleaned-up from console before starting a new execution; it might be confusing to have a &quot;no output&quot; message related to a previous execution written in the console while current profiling is running.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cba9b8bec9ddc7834969f649c06d5cd675ae01d5">cba9b8</a></td>
		<td>197 lines</td>
		<td>oprofile: Modifications to use the linuxtools' path set for the project. If there's a Linuxtools path defined for the project being profiled, the plugin will try to run opcontrol as root. If it doesn't work, user will be prompted to add this opcontrol in the sudoers file with NOPASSWD. If no path is defined for the project, the plugin will try to use the opcontrol link/wrapper created by the install scripts.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=cccffee4b8128975dbad6d966e286147c08cdde2">cccffe</a></td>
		<td>27 lines</td>
		<td>oprofile: Edited ChangeLog, removed unnecessary import in OpInfo.java, removed version for org.eclipse.linuxtools.tools.launch.core in MANIFEST.MF</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e5b4d2c098f6bc0fda0b132fe24edd989e923c05">e5b4d2</a></td>
		<td>131 lines</td>
		<td>Change RuntimeProcessFactory to use file and process proxies</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=364941">364941</a></td>
		<td>3880 bytes</td>
		<td>Add support for multiple Oprofile launch configs<br/>Minor fixes</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=333315">333315</a></td>
		<td>251 bytes</td>
		<td>Add text to Valgrind view when no errors were found<br/>comment #3</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Remy&nbsp;Suen (ca.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=179141">179141</a></td>
		<td>5531 bytes</td>
		<td>ChangeLog plug-in should migrate away from plugin.xml to MANIFEST.MF<br/>Patch to remove stuff in plugin.xml and move them to a MANIFEST.MF file.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=179549">179549</a></td>
		<td>2082 bytes</td>
		<td>function guess fails when making changelog entry in static code block<br/>Patch to mark the static block as &quot;static initializer&quot;.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=181249">181249</a></td>
		<td>3858 bytes</td>
		<td>Plug-ins do not specify execution environments and/or does not use OSGi manifests<br/>Patch to correct org.eclipse.linuxtools.rpm.ui.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Renato&nbsp;Stoffalette&nbsp;Joao (br.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ce8794d35d256aad1eaefda71308dc54375320d2">ce8794</a></td>
		<td>410 lines</td>
		<td>This is a piechart implementation. PieChart class extends Chart from SWTChart. It adds a PaintListener and a PieChartSeries methods. PieChartPaintListener implements a PaintListener, gets the PieSeriesArray and calculates the angles to draws the primitives in the paintControl method. IColorsConstants is an interface of swt.graphics.RGB  colors.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=373552">373552</a></td>
		<td>17516 bytes</td>
		<td>Switch Systemtap Charting from BIRT to using SWTChart<br/>A piechart implementation extending Chart from SWTChart</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Rodrigo&nbsp;Fraxino&nbsp;Araujo (br.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b178c605f58fe9d56abfcfa2d6c98b95df079dbd">b178c6</a></td>
		<td>296 lines</td>
		<td>Added support to create and export RPM files remotely.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Rodrigo&nbsp;Fraxino&nbsp;Araujo (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=377671">377671</a></td>
		<td>18865 bytes</td>
		<td>Remote support for RPM plug-in<br/>Patch to add remote support to RPM using linuxtools profiling package</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Ryan&nbsp;Xu (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=360950">360950</a></td>
		<td>1205 bytes</td>
		<td>When open the preference page of valgrind on windows host, the whole eclipse will hang.<br/>patch</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Sami&nbsp;Wagiaalla (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=348260">348260</a></td>
		<td>18327 bytes</td>
		<td>Add a shared library template to new project wizard<br/>Add Autotools shared library template</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=348432">348432</a></td>
		<td>23461 bytes</td>
		<td>Add support for individual element validation to Autoconf parser<br/>Add support for individual element validation.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Severin&nbsp;Gehwolf (redhat.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=319742">319742</a></td>
		<td>965 bytes</td>
		<td>NPE: An internal error occurred during: &quot;Update RPM packages proposal list&quot;<br/>Bugfix</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=321905">321905</a></td>
		<td>18360 bytes</td>
		<td>IMAGE_FILTER set incorrectly if project is external<br/>Regression-test for this bug.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Stephen&nbsp;Shaw (decriptor.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.eclipse-build.git/commit?id=9eea85dd783db3bb37a458f21365ffb4a9ffa7d0">9eea85</a></td>
		<td>82 lines</td>
		<td>Now accounts for jvm being in /usr/lib64 on 64bit machines Signed-off-by: Alexander Kurtakov &lt;akurtako@redhat.com&gt;</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Uwe&nbsp;Stieber (windriver.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=265494">265494</a></td>
		<td>632 bytes</td>
		<td>MacroProposalsPreferencePage fails to compile with Eclipse 3.5M5<br/>Set the visibility of selectionChanged to protected</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=265495">265495</a></td>
		<td>1474 bytes</td>
		<td>oprofile linux x86 and x86_64 cannot find fragment host<br/>Setting fragment host version constraint to 0.1.0 instead of 0.1</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Wainer&nbsp;S.&nbsp;Moschetta (linux.vnet.ibm.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1ad5b184dad25305b7f98943810ebc98bf31ba19">1ad5b1</a></td>
		<td>10 lines</td>
		<td>Perf: read events list also from stderr Old versions of Perf used to send events list to stderr instead of stdout This patch changes the plug-in to check whether stdout is empty or not Signed-off-by: Wainer S. Moschetta &lt;wainersm@linux.vnet.ibm.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=63afc3c97a7df4ebf67662145f7b9b6d4af68038">63afc3</a></td>
		<td>9 lines</td>
		<td>Perf: refactoring on events parser. Fixes <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367555">Bug 367555</a> Events parser used to rely on line length of 'perf list' output. However, length might change between perf versions. This patch changes events parser to use regex instead. Signed-off-by: Wainer S. Moschetta &lt;wainersm@linux.vnet.ibm.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6d63d525a4e4e62c1701abd872bc549940f52a4b">6d63d5</a></td>
		<td>2 lines</td>
		<td>Perf: fix handler of single event selection Changed PerfEventsTab to handle a single event selection in the same case as multiple events. Signed-off-by: Wainer S. Moschetta &lt;wainersm@linux.vnet.ibm.com&gt;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=fb1815a62778569315afc3a9f4207b6e8a735674">fb1815</a></td>
		<td>11 lines</td>
		<td>Polishing Perf plug-in Added plugin.properties file with bundleName and bundleProvider properties Changed display &quot;Profile as Perf!&quot; with &quot;Profile as Perf&quot; Signed-off-by: Wainer S. Moschetta &lt;wainersm@linux.vnet.ibm.com&gt;</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=351355">351355</a></td>
		<td>1372 bytes</td>
		<td>gprof: support 64-bit gmon files in ppc64<br/>Patch to fix the problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=366075">366075</a></td>
		<td>2918 bytes</td>
		<td>Polish Perf plug-in<br/>Patch with cosmetic changes</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=366611">366611</a></td>
		<td>1888 bytes</td>
		<td>Perf: read events list also from stderr<br/>Patch to fix the problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367555">367555</a></td>
		<td>3027 bytes</td>
		<td>Perf: use regex to parse events<br/>Patch to fix the problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=367625">367625</a></td>
		<td>1441 bytes</td>
		<td>Perf: fix handler of single event selection<br/>Patch to fix the problem</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=333315">333315</a></td>
		<td>192 bytes</td>
		<td>Add text to Valgrind view when no errors were found<br/>comment #5</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=363510">363510</a></td>
		<td>0 bytes</td>
		<td>Cachegrind: manual cache configuration is reseted after run<br/>comment #1</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Will (gmail.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=341621">341621</a></td>
		<td>3528 bytes</td>
		<td>oprofile: hangs on Parsing OProfile Data<br/>decided it should be cleaned up a bit. purely aesthetic changes from previous patch.</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">William&nbsp;Bourque (polymtl.ca)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=287745">287745</a></td>
		<td>52326 bytes</td>
		<td>[TMF] Switch to JUnit3<br/>Convert org.eclipse.linuxtools.lttng.tests to junit3. </td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=290060">290060</a></td>
		<td>22134 bytes</td>
		<td>[LTTng] Add a HOWTO to integrate the C library<br/>LTTv installation guide, in HTML format.</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=291662">291662</a></td>
		<td>14753 bytes</td>
		<td>[LTTng] Refactoring of the LTTng JNI<br/>&quot;New way&quot; to Add a &quot;endTime&quot; for a trace </td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=292393">292393</a></td>
		<td>7007 bytes</td>
		<td>[LTTng] Improve search of a process within the State model<br/>Cchanges in FlowContainer and ResourceContainer to add debug and better &quot;equals&quot;</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Xavier&nbsp;Raynaud (st.com)</td>
		</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=180b61b5ac51b965ed5e17ded58efe700ac44b70">180b61</a></td>
		<td>450 lines</td>
		<td>add feature</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=1c2b0a063570c116529993a30653e578aa85a029">1c2b0a</a></td>
		<td>7 lines</td>
		<td>Partial fix of https://bugs.eclipse.org/bugs/show_bug.cgi?id=285328 Remove 4 warnings (Discouraged access: The type CSourceLookupDirector is not accessible due to restriction on classpath entry /opt/users/hudsonbuild/.hudson/jobs/cbi-linuxtools-Galileo/workspace/build/N200910130003/eclipse/plugins/org.eclipse.cdt.debug.core_6.0.0.200906161748.jar)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=207e432f224426906cd59cff41ac929a30110534">207e43</a></td>
		<td>19 lines</td>
		<td>Dump more explanation when a test fails.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=25ac2d2716a19284cb79cb57b0b74dda4e9680d0">25ac2d</a></td>
		<td>31 lines</td>
		<td>add about.html files in build.properties</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=25ea1da4804a13f63714ba54fcd56d36e2de04e2">25ea1d</a></td>
		<td>2 lines</td>
		<td>trying to re-add gprof test</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=288c1abfce66e19e2770ea7452fcd35120487318">288c1a</a></td>
		<td>4 lines</td>
		<td>Oups: fix a bug in tests: comparison was not made correctly</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=2db411b95cb910d50c730fcb53229ca5d6521cc5">2db411</a></td>
		<td>168 lines</td>
		<td>change test refs - previous one were buggy</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=33942c1c0cf07d38cd6e84ce3c4f24fb137fd9b9">33942c</a></td>
		<td>112 lines</td>
		<td>fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=339297 (gcov error with cygwin).</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=36536f750f09d67afe83799c828230727fbd6dc5">36536f</a></td>
		<td>7 lines</td>
		<td>add a new dependency on org.eclipse.linuxtools.dataviewers.charts</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=383d432f8b043b3ea231ef3f7e5b01f93e1d0bf3">383d43</a></td>
		<td>408 lines</td>
		<td>fix a bug in histogam decoder: scale was not calculated correctly in some cases. Also enhance test suite accordingly.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=386ba22844e1f96c7408e0cd290ec9ac76182723">386ba2</a></td>
		<td>8 lines</td>
		<td>fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=315302</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3981c755b1891aaa6725a241700b1ce65d4a6bc6">3981c7</a></td>
		<td>3 lines</td>
		<td>remove unused import statements</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3ae11a1ba3133f2257dad079e12862481ac266d9">3ae11a</a></td>
		<td>10 lines</td>
		<td>fix 340638 - thanks to John Dallaway who provides the patch</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3ae7d8e1e985999d90c2f8e6aa9bdb24b5a47f4d">3ae7d8</a></td>
		<td>167 lines</td>
		<td>Partial fix of https://bugs.eclipse.org/bugs/show_bug.cgi?id=285328 Remove warnings (Discouraged access...)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3efb661208a04cea67f32d3b7d32a74f71303531">3efb66</a></td>
		<td>33 lines</td>
		<td>partial fix of https://bugs.eclipse.org/bugs/show_bug.cgi?id=285328</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=3f084d53090898df73c356db88ea185124e3e616">3f084d</a></td>
		<td>22 lines</td>
		<td>Remove plugin.xml (no extension provided by this plugin)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=461cc1d24d94809675c0ff771742d47d7baae3f3">461cc1</a></td>
		<td>97 lines</td>
		<td>fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=282021</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4658f8662834b2842d0fee2c878b12cb47dae628">4658f8</a></td>
		<td>125 lines</td>
		<td>enhance a bit management of binary objects</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4b10435d991f88cf27ed2f248a9c1886334a7d77">4b1043</a></td>
		<td>161 lines</td>
		<td>fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=306202 fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=304163</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=4e6a70a2c85e9c26d97dfb521ca53b5689627617">4e6a70</a></td>
		<td>2 lines</td>
		<td>fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=282020</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=57bba3b69685045f93554974edbb6f69385b111d">57bba3</a></td>
		<td>150 lines</td>
		<td>Enhance JUnit test, to be tolerant to binutils output variations</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=6f76f5a8ff03c96800f5ef47ae1103de2e24261c">6f76f5</a></td>
		<td>1196 lines</td>
		<td>refactor: from com.st.stgcov to org.eclipse.linuxtools.gcov</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=76f937fb3aedb31d18ea3757dede5a33c3cd6173">76f937</a></td>
		<td>2 lines</td>
		<td>fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=330810</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=7937f422a30da36c19002d90c3f273efc884cf26">7937f4</a></td>
		<td>95372 lines</td>
		<td>Rename plugin directories</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=846656c25c3716301d3250ae125a76ea9317b4c2">846656</a></td>
		<td>34540 lines</td>
		<td>Rename all plugins, packages and extension ids from &quot;com.st...&quot; to &quot;org.eclipse.linuxtools&quot;</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=8d4cf6c021306b40384bbe6a910c6b73f7db347b">8d4cf6</a></td>
		<td>1 lines</td>
		<td>Oups... a statement was deleted. reintroduce it now</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=995328dec62c3c4eecb87560465d58b4f1b56e74">995328</a></td>
		<td>64 lines</td>
		<td>also fix special refs for binutils-2.16</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9aac417b50597727dab08206f1b9549eba6e3d3f">9aac41</a></td>
		<td>1 lines</td>
		<td>remove unused import statement</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9e2f06c565ddd1be7b97a3ca3c90bd0fc00f538a">9e2f06</a></td>
		<td>207 lines</td>
		<td>remove some odd ^M line ending</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=9f647907d2d7fed150ef71b650e2c7f5f92ad7ac">9f6479</a></td>
		<td>13506 lines</td>
		<td>initial import of gcov plugins</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a1349585c8c33c4951782f25cb8ef6cd5985b429">a13495</a></td>
		<td>491 lines</td>
		<td>fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=332269</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=a1d2fc6a0fbdc29a77eca454426baebd853f09a3">a1d2fc</a></td>
		<td>7 lines</td>
		<td>integrate patch proposal from [Bugzilla 329710]</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=aa14ffee344e3a02ae26df8ff8d8341eb5b3759a">aa14ff</a></td>
		<td>4152 lines</td>
		<td>add missing test references</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b0e823e9fcd8925971c3adc993d07e23a58206e6">b0e823</a></td>
		<td>2 lines</td>
		<td>change version to 0.5</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b56b3295ddebd764c824d500120d0c2099d04c40">b56b32</a></td>
		<td>4 lines</td>
		<td>fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=328475 for gcov</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=b7f9f63ab539ff14d2312b4381d484980b7269fc">b7f9f6</a></td>
		<td>35 lines</td>
		<td>fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=285328</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ba97356a6707ec4e9b03b357b93d23d162a8afe6">ba9735</a></td>
		<td>2 lines</td>
		<td>fix a wrong eclipse location</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c2a347781343bfcef615394bb92942f5faaa61ff">c2a347</a></td>
		<td>59 lines</td>
		<td>fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=282027</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=c6ecc7ca5fd2be5f5ac6c80963283f4534e4ba19">c6ecc7</a></td>
		<td>10 lines</td>
		<td>Dump more explanation when a test fails.</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=d6045962bc77ced94ab07201fe87f2ca2268c2de">d60459</a></td>
		<td>35 lines</td>
		<td>(oups)... revert last commit - not accurate</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e16f7be2cfffe463a5ca68b6e64b2b3a82b4cbc5">e16f7b</a></td>
		<td>6 lines</td>
		<td>(oups) forgot to commit 64b version</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=e72c5bd18f98c48bc6103652caa1a482c52acb77">e72c5b</a></td>
		<td>4 lines</td>
		<td>fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=328475 for gprof</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ea5d32954c75e3d11fae5fdeb94e6ebafa7c2afa">ea5d32</a></td>
		<td>165 lines</td>
		<td>Fix https://bugs.eclipse.org/bugs/show_bug.cgi?id=285309. tests now handle gracefully binutils-2.16.xxx</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ea7739e7224647d169059fe4213136a01f5289f3">ea7739</a></td>
		<td>10 lines</td>
		<td>Change a bit gprof aggregation test</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=f413fa2ae1c1025228db544c60ed75fcd5b49bd4">f413fa</a></td>
		<td>260 lines</td>
		<td>Partial fix of https://bugs.eclipse.org/bugs/show_bug.cgi?id=333984 Gprof plugin now support Cygwin/mingW- generated gmon files However, call graph is not yet supported, due to another issue in CDT PO Parser (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=337821)</td>
				</tr>
	<tr>
		<td><a href="http://git.eclipse.org/c/linuxtools/org.eclipse.linuxtools.git/commit?id=ff07e3520ec5cbce5e8dcefbec9d749b2d32abdf">ff07e3</a></td>
		<td>3 lines</td>
		<td>add test.xml</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Xavier&nbsp;Raynaud (kalray.eu)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=357355">357355</a></td>
		<td>7808 bytes</td>
		<td>[TMF] Enhancement of class TmfVirtualTable<br/>patch proposal</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Yufen&nbsp;Kuo (mvista.com)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=340341">340341</a></td>
		<td>15183 bytes</td>
		<td>[LTTng] Missing liblttngtrace format not handled gracefully at all<br/>patch to display error dialog when native trace library fails to load instead of displaying stack trace in console</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=354541">354541</a></td>
		<td>6035 bytes</td>
		<td>LTTng plugins requires to set LD_LIBRARY_PATH to point to the path of native parsing libraries<br/>patch for runpath setting note on loader parser library</td>
				</tr>
	<tr><td colspan="3" style="background-color: #DDDDDD">Yuriy&nbsp;Vashchuk (polymtl.ca)</td>
		</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=311930">311930</a></td>
		<td>36020 bytes</td>
		<td>[LTTng] HistogramView : Make sure time interval are small enought in very long trace<br/>Patch corrections</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=315889">315889</a></td>
		<td>59146 bytes</td>
		<td>[LTTng] HistogramView improvements<br/>Histogram patch</td>
				</tr>
	<tr>
		<td><a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=323503">323503</a></td>
		<td>13228 bytes</td>
		<td>[LTTng] Histogram View design and draw improvements<br/>The Histogram design and draw corrections</td>
				</tr>
	</table>
<h2>Repositories</h2>
<p>The information contained in this log was generated by using commit information from the following repositories:</p>
<div style='padding-left: 2em'>/gitroot/linuxtools/org.eclipse.linuxtools.eclipse-build.git</div>
<div style='padding-left: 2em'>/gitroot/linuxtools/org.eclipse.linuxtools.git</div>
<p>
</div><!-- midcolumn -->
</div><!-- maincontent -->

