tree d450a70d971c3c50ee240118f17d52d978c4447a
parent c8317d1896e2daa98eed6715d6912f2584338b3c
author Marco Miller <marco.miller@ericsson.com> 1625001775 -0400
committer Matthew Khouzam <matthew.khouzam@ericsson.com> 1625102716 -0400

skeleton: Remove extra ending in build.properties

Remove the extra trailing comma+continuation line ending in core's
build.properties file. Make the latter consistent with its siblings that
way too.

Change-Id: Ic0566547bfd3134b1eb2495892d18f492b139cd3
Signed-off-by: Marco Miller <marco.miller@ericsson.com>
Reviewed-on: https://git.eclipse.org/r/c/tracecompass.incubator/org.eclipse.tracecompass.incubator/+/182627
Tested-by: Trace Compass Bot <tracecompass-bot@eclipse.org>
Tested-by: Bernd Hufmann <bernd.hufmann@ericsson.com>
Reviewed-by: Bernd Hufmann <bernd.hufmann@ericsson.com>
Reviewed-by: Matthew Khouzam <matthew.khouzam@ericsson.com>
