From 623cfcd04b0c4662e614cb6a3bf52536abc02d5a Mon Sep 17 00:00:00 2001 From: Alan Bateman Date: Mon, 10 Jul 2023 12:33:29 +0000 Subject: [PATCH 1/7] 8310892: ScopedValue throwing StructureViolationException should be clearer Reviewed-by: dfuchs, jpai --- .../share/classes/java/lang/ScopedValue.java | 102 +++++++++--------- 1 file changed, 54 insertions(+), 48 deletions(-) diff --git a/src/java.base/share/classes/java/lang/ScopedValue.java b/src/java.base/share/classes/java/lang/ScopedValue.java index 9aab6669a7c..7fea72469e2 100644 --- a/src/java.base/share/classes/java/lang/ScopedValue.java +++ b/src/java.base/share/classes/java/lang/ScopedValue.java @@ -394,19 +394,20 @@ public T get(ScopedValue key) { * to its value in the current thread. * When the operation completes (normally or with an exception), each scoped value * in the mapping will revert to being unbound, or revert to its previous value - * when previously bound, in the current thread. + * when previously bound, in the current thread. If {@code op} completes with an + * exception then it propagated by this method. * - *

Scoped values are intended to be used in a structured manner. - * If {@code op} creates a {@link StructuredTaskScope} but does not {@linkplain - * StructuredTaskScope#close() close} it, then exiting {@code op} causes the - * underlying construct of each {@code StructuredTaskScope} created in the - * dynamic scope to be closed. This may require blocking until all child threads - * have completed their sub-tasks. The closing is done in the reverse order that - * they were created. Once closed, {@link StructureViolationException} is thrown. + *

Scoped values are intended to be used in a structured manner. If code + * invoked directly or indirectly by the operation creates a {@link StructuredTaskScope} + * but does not {@linkplain StructuredTaskScope#close() close} it, then it is detected + * as a structure violation when the operation completes (normally or with an + * exception). In that case, the underlying construct of the {@code StructuredTaskScope} + * is closed and {@link StructureViolationException} is thrown. * * @param op the operation to run * @param the type of the result of the operation * @return the result + * @throws StructureViolationException if a structure violation is detected * @throws Exception if {@code op} completes with an exception * @see ScopedValue#callWhere(ScopedValue, Object, Callable) */ @@ -423,19 +424,20 @@ public R call(Callable op) throws Exception { * to its value in the current thread. * When the operation completes (normally or with an exception), each scoped value * in the mapping will revert to being unbound, or revert to its previous value - * when previously bound, in the current thread. + * when previously bound, in the current thread. If {@code op} completes with an + * exception then it propagated by this method. * - *

Scoped values are intended to be used in a structured manner. - * If {@code op} creates a {@link StructuredTaskScope} but does not {@linkplain - * StructuredTaskScope#close() close} it, then exiting {@code op} causes the - * underlying construct of each {@code StructuredTaskScope} created in the - * dynamic scope to be closed. This may require blocking until all child threads - * have completed their sub-tasks. The closing is done in the reverse order that - * they were created. Once closed, {@link StructureViolationException} is thrown. + *

Scoped values are intended to be used in a structured manner. If code + * invoked directly or indirectly by the operation creates a {@link StructuredTaskScope} + * but does not {@linkplain StructuredTaskScope#close() close} it, then it is detected + * as a structure violation when the operation completes (normally or with an + * exception). In that case, the underlying construct of the {@code StructuredTaskScope} + * is closed and {@link StructureViolationException} is thrown. * * @param op the operation to run * @param the type of the result of the operation * @return the result + * @throws StructureViolationException if a structure violation is detected * @see ScopedValue#getWhere(ScopedValue, Object, Supplier) */ public R get(Supplier op) { @@ -486,17 +488,18 @@ private R runWith(Snapshot newSnapshot, Callable op) { * in the current thread. * When the operation completes (normally or with an exception), each scoped value * in the mapping will revert to being unbound, or revert to its previous value - * when previously bound, in the current thread. + * when previously bound, in the current thread. If {@code op} completes with an + * exception then it propagated by this method. * - *

Scoped values are intended to be used in a structured manner. - * If {@code op} creates a {@link StructuredTaskScope} but does not {@linkplain - * StructuredTaskScope#close() close} it, then exiting {@code op} causes the - * underlying construct of each {@code StructuredTaskScope} created in the - * dynamic scope to be closed. This may require blocking until all child threads - * have completed their sub-tasks. The closing is done in the reverse order that - * they were created. Once closed, {@link StructureViolationException} is thrown. + *

Scoped values are intended to be used in a structured manner. If code + * invoked directly or indirectly by the operation creates a {@link StructuredTaskScope} + * but does not {@linkplain StructuredTaskScope#close() close} it, then it is detected + * as a structure violation when the operation completes (normally or with an + * exception). In that case, the underlying construct of the {@code StructuredTaskScope} + * is closed and {@link StructureViolationException} is thrown. * * @param op the operation to run + * @throws StructureViolationException if a structure violation is detected * @see ScopedValue#runWhere(ScopedValue, Object, Runnable) */ public void run(Runnable op) { @@ -553,15 +556,15 @@ public static Carrier where(ScopedValue key, T value) { * Calls a value-returning operation with a {@code ScopedValue} bound to a value * in the current thread. When the operation completes (normally or with an * exception), the {@code ScopedValue} will revert to being unbound, or revert to - * its previous value when previously bound, in the current thread. + * its previous value when previously bound, in the current thread. If {@code op} + * completes with an exception then it propagated by this method. * - *

Scoped values are intended to be used in a structured manner. - * If {@code op} creates a {@link StructuredTaskScope} but does not {@linkplain - * StructuredTaskScope#close() close} it, then exiting {@code op} causes the - * underlying construct of each {@code StructuredTaskScope} created in the - * dynamic scope to be closed. This may require blocking until all child threads - * have completed their sub-tasks. The closing is done in the reverse order that - * they were created. Once closed, {@link StructureViolationException} is thrown. + *

Scoped values are intended to be used in a structured manner. If code + * invoked directly or indirectly by the operation creates a {@link StructuredTaskScope} + * but does not {@linkplain StructuredTaskScope#close() close} it, then it is detected + * as a structure violation when the operation completes (normally or with an + * exception). In that case, the underlying construct of the {@code StructuredTaskScope} + * is closed and {@link StructureViolationException} is thrown. * * @implNote * This method is implemented to be equivalent to: @@ -576,6 +579,7 @@ public static Carrier where(ScopedValue key, T value) { * @param the result type * @param op the operation to call * @return the result + * @throws StructureViolationException if a structure violation is detected * @throws Exception if the operation completes with an exception */ public static R callWhere(ScopedValue key, @@ -588,15 +592,15 @@ public static R callWhere(ScopedValue key, * Invokes a supplier of results with a {@code ScopedValue} bound to a value * in the current thread. When the operation completes (normally or with an * exception), the {@code ScopedValue} will revert to being unbound, or revert to - * its previous value when previously bound, in the current thread. + * its previous value when previously bound, in the current thread. If {@code op} + * completes with an exception then it propagated by this method. * - *

Scoped values are intended to be used in a structured manner. - * If {@code op} creates a {@link StructuredTaskScope} but does not {@linkplain - * StructuredTaskScope#close() close} it, then exiting {@code op} causes the - * underlying construct of each {@code StructuredTaskScope} created in the - * dynamic scope to be closed. This may require blocking until all child threads - * have completed their sub-tasks. The closing is done in the reverse order that - * they were created. Once closed, {@link StructureViolationException} is thrown. + *

Scoped values are intended to be used in a structured manner. If code + * invoked directly or indirectly by the operation creates a {@link StructuredTaskScope} + * but does not {@linkplain StructuredTaskScope#close() close} it, then it is detected + * as a structure violation when the operation completes (normally or with an + * exception). In that case, the underlying construct of the {@code StructuredTaskScope} + * is closed and {@link StructureViolationException} is thrown. * * @implNote * This method is implemented to be equivalent to: @@ -611,6 +615,7 @@ public static R callWhere(ScopedValue key, * @param the result type * @param op the operation to call * @return the result + * @throws StructureViolationException if a structure violation is detected */ public static R getWhere(ScopedValue key, T value, @@ -622,15 +627,15 @@ public static R getWhere(ScopedValue key, * Run an operation with a {@code ScopedValue} bound to a value in the current * thread. When the operation completes (normally or with an exception), the * {@code ScopedValue} will revert to being unbound, or revert to its previous value - * when previously bound, in the current thread. + * when previously bound, in the current thread. If {@code op} completes with an + * exception then it propagated by this method. * - *

Scoped values are intended to be used in a structured manner. - * If {@code op} creates a {@link StructuredTaskScope} but does not {@linkplain - * StructuredTaskScope#close() close} it, then exiting {@code op} causes the - * underlying construct of each {@code StructuredTaskScope} created in the - * dynamic scope to be closed. This may require blocking until all child threads - * have completed their sub-tasks. The closing is done in the reverse order that - * they were created. Once closed, {@link StructureViolationException} is thrown. + *

Scoped values are intended to be used in a structured manner. If code + * invoked directly or indirectly by the operation creates a {@link StructuredTaskScope} + * but does not {@linkplain StructuredTaskScope#close() close} it, then it is detected + * as a structure violation when the operation completes (normally or with an + * exception). In that case, the underlying construct of the {@code StructuredTaskScope} + * is closed and {@link StructureViolationException} is thrown. * * @implNote * This method is implemented to be equivalent to: @@ -643,6 +648,7 @@ public static R getWhere(ScopedValue key, * @param value the value, can be {@code null} * @param the type of the value * @param op the operation to call + * @throws StructureViolationException if a structure violation is detected */ public static void runWhere(ScopedValue key, T value, Runnable op) { where(key, value).run(op); From 6569b252b9e61e3eed77039c483529154feffbba Mon Sep 17 00:00:00 2001 From: Maurizio Cimadamore Date: Mon, 10 Jul 2023 15:04:21 +0000 Subject: [PATCH 2/7] 8311593: Minor doc issue in MemorySegment::copy Reviewed-by: jvernee --- .../share/classes/java/lang/foreign/MemorySegment.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/java.base/share/classes/java/lang/foreign/MemorySegment.java b/src/java.base/share/classes/java/lang/foreign/MemorySegment.java index c074cc8f896..2c2332018f0 100644 --- a/src/java.base/share/classes/java/lang/foreign/MemorySegment.java +++ b/src/java.base/share/classes/java/lang/foreign/MemorySegment.java @@ -1252,7 +1252,7 @@ static MemorySegment ofAddress(long address) { * {@code srcOffset} through {@code srcOffset + bytes - 1} in the source segment are copied into the destination * segment at offset {@code dstOffset} through {@code dstOffset + bytes - 1}. *

- * If the source segment overlaps with this segment, then the copying is performed as if the bytes at + * If the source segment overlaps with the destination segment, then the copying is performed as if the bytes at * offset {@code srcOffset} through {@code srcOffset + bytes - 1} in the source segment were first copied into a * temporary segment with size {@code bytes}, and then the contents of the temporary segment were copied into * the destination segment at offset {@code dstOffset} through {@code dstOffset + bytes - 1}. @@ -1300,7 +1300,7 @@ static void copy(MemorySegment srcSegment, long srcOffset, * If the byte order of the two element layouts differ, the bytes corresponding to each element to be copied * are swapped accordingly during the copy operation. *

- * If the source segment overlaps with this segment, then the copying is performed as if the bytes at + * If the source segment overlaps with the destination segment, then the copying is performed as if the bytes at * offset {@code srcOffset} through {@code srcOffset + (elementCount * S) - 1} in the source segment were first copied into a * temporary segment with size {@code bytes}, and then the contents of the temporary segment were copied into * the destination segment at offset {@code dstOffset} through {@code dstOffset + (elementCount * S) - 1}. From b285ed72aebe2d802fa9c071372cea6c09870b9a Mon Sep 17 00:00:00 2001 From: Liam Miller-Cushon Date: Mon, 10 Jul 2023 16:13:06 +0000 Subject: [PATCH 3/7] 8311666: Disabled tests in test/jdk/sun/java2d/marlin Reviewed-by: prr --- test/jdk/sun/java2d/marlin/ScaleTest.java | 6 +++++- test/jdk/sun/java2d/marlin/StrokeShapeTest.java | 6 ++++++ test/jdk/sun/java2d/marlin/ThinLineTest.java | 6 ++++++ 3 files changed, 17 insertions(+), 1 deletion(-) diff --git a/test/jdk/sun/java2d/marlin/ScaleTest.java b/test/jdk/sun/java2d/marlin/ScaleTest.java index bfd56422ba4..c9778a6477a 100644 --- a/test/jdk/sun/java2d/marlin/ScaleTest.java +++ b/test/jdk/sun/java2d/marlin/ScaleTest.java @@ -21,13 +21,17 @@ * questions. */ +/* @test + * @summary Circle is rendered in C shape + * @bug 6829659 8311666 + */ + import java.awt.*; import java.awt.geom.Ellipse2D; import java.awt.image.BufferedImage; import java.io.File; import javax.imageio.ImageIO; - public class ScaleTest { public static void main(String[] args) throws Exception { BufferedImage image = new BufferedImage(200, 200, BufferedImage.TYPE_INT_RGB); diff --git a/test/jdk/sun/java2d/marlin/StrokeShapeTest.java b/test/jdk/sun/java2d/marlin/StrokeShapeTest.java index 41413bff3e4..bc23f29e15d 100644 --- a/test/jdk/sun/java2d/marlin/StrokeShapeTest.java +++ b/test/jdk/sun/java2d/marlin/StrokeShapeTest.java @@ -20,6 +20,12 @@ * or visit www.oracle.com if you need additional information or have any * questions. */ + +/* @test + * @summary StrokeShapeTest: createStrokedShape() behaves differently + * @bug 6829678 8311666 + */ + import java.awt.*; import java.awt.geom.Ellipse2D; import java.awt.geom.GeneralPath; diff --git a/test/jdk/sun/java2d/marlin/ThinLineTest.java b/test/jdk/sun/java2d/marlin/ThinLineTest.java index a1a033c0bd4..7450f4e421d 100644 --- a/test/jdk/sun/java2d/marlin/ThinLineTest.java +++ b/test/jdk/sun/java2d/marlin/ThinLineTest.java @@ -20,6 +20,12 @@ * or visit www.oracle.com if you need additional information or have any * questions. */ + +/* @test + * @summary ThinLineTest: A line < 1 pixel disappears. + * @bug 6829673 8311666 + */ + import java.awt.*; import java.awt.geom.Ellipse2D; import java.awt.image.BufferedImage; From 63f32fbe9771b8200f707ed5d1d0e6555ad90f8b Mon Sep 17 00:00:00 2001 From: Naoto Sato Date: Mon, 10 Jul 2023 17:07:26 +0000 Subject: [PATCH 4/7] 8311528: Remove IDE specific SuppressWarnings Reviewed-by: lancea, bpb, jlu --- .../share/classes/java/util/Calendar.java | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/src/java.base/share/classes/java/util/Calendar.java b/src/java.base/share/classes/java/util/Calendar.java index 6e3fa4a561d..e7149c4dfe1 100644 --- a/src/java.base/share/classes/java/util/Calendar.java +++ b/src/java.base/share/classes/java/util/Calendar.java @@ -2701,25 +2701,25 @@ public String getCalendarType() { * @return {@code true} if this object is equal to {@code obj}; * {@code false} otherwise. */ - @SuppressWarnings("EqualsWhichDoesntCheckParameterClass") @Override public boolean equals(Object obj) { if (this == obj) { return true; } - try { - Calendar that = (Calendar)obj; - return compareTo(getMillisOf(that)) == 0 && - lenient == that.lenient && - firstDayOfWeek == that.firstDayOfWeek && - minimalDaysInFirstWeek == that.minimalDaysInFirstWeek && - (zone instanceof ZoneInfo ? - zone.equals(that.zone) : - zone.equals(that.getTimeZone())); - } catch (Exception e) { - // Note: GregorianCalendar.computeTime throws - // IllegalArgumentException if the ERA value is invalid - // even it's in lenient mode. + if (obj instanceof Calendar that) { + try { + return compareTo(getMillisOf(that)) == 0 && + lenient == that.lenient && + firstDayOfWeek == that.firstDayOfWeek && + minimalDaysInFirstWeek == that.minimalDaysInFirstWeek && + (zone instanceof ZoneInfo ? + zone.equals(that.zone) : + zone.equals(that.getTimeZone())); + } catch (Exception e) { + // Note: GregorianCalendar.computeTime throws + // IllegalArgumentException if the ERA value is invalid + // even it's in lenient mode. + } } return false; } From 57e7e82fa1cfb82bee6ff242d9a730c42bde663f Mon Sep 17 00:00:00 2001 From: Patricio Chilano Mateo Date: Mon, 10 Jul 2023 19:09:27 +0000 Subject: [PATCH 5/7] 8309637: runtime/handshake/HandshakeTimeoutTest.java fails with "has not cleared handshake op" and SIGILL Reviewed-by: dholmes, coleenp --- src/hotspot/share/runtime/java.cpp | 4 +-- src/hotspot/share/runtime/nonJavaThread.cpp | 30 ++++++++++++--------- src/hotspot/share/runtime/nonJavaThread.hpp | 8 +++--- src/hotspot/share/runtime/task.cpp | 4 +-- src/hotspot/share/runtime/threads.cpp | 22 +++++++-------- 5 files changed, 34 insertions(+), 34 deletions(-) diff --git a/src/hotspot/share/runtime/java.cpp b/src/hotspot/share/runtime/java.cpp index 140d0281e2f..8746efebc21 100644 --- a/src/hotspot/share/runtime/java.cpp +++ b/src/hotspot/share/runtime/java.cpp @@ -471,9 +471,7 @@ void before_exit(JavaThread* thread, bool halt) { // Stop the WatcherThread. We do this before disenrolling various // PeriodicTasks to reduce the likelihood of races. - if (PeriodicTask::num_tasks() > 0) { - WatcherThread::stop(); - } + WatcherThread::stop(); // shut down the StatSampler task StatSampler::disengage(); diff --git a/src/hotspot/share/runtime/nonJavaThread.cpp b/src/hotspot/share/runtime/nonJavaThread.cpp index 3fbfa080e1f..f537afcaa06 100644 --- a/src/hotspot/share/runtime/nonJavaThread.cpp +++ b/src/hotspot/share/runtime/nonJavaThread.cpp @@ -156,7 +156,7 @@ void NamedThread::print_on(outputStream* st) const { // timer interrupts exists on the platform. WatcherThread* WatcherThread::_watcher_thread = nullptr; -bool WatcherThread::_startable = false; +bool WatcherThread::_run_all_tasks = false; volatile bool WatcherThread::_should_terminate = false; WatcherThread::WatcherThread() : NonJavaThread() { @@ -185,6 +185,11 @@ int WatcherThread::sleep() const { return 0; // we did not sleep. } + if (!_run_all_tasks) { + ml.wait(100); + return 0; + } + // remaining will be zero if there are no tasks, // causing the WatcherThread to sleep until a task is // enrolled @@ -280,7 +285,10 @@ void WatcherThread::run() { break; } - PeriodicTask::real_time_tick(time_waited); + // Don't process enrolled tasks until VM is fully initialized. + if (_run_all_tasks) { + PeriodicTask::real_time_tick(time_waited); + } } // Signal that it is terminated @@ -293,18 +301,16 @@ void WatcherThread::run() { } void WatcherThread::start() { - assert(PeriodicTask_lock->owned_by_self(), "PeriodicTask_lock required"); - - if (watcher_thread() == nullptr && _startable) { - _should_terminate = false; - // Create the single instance of WatcherThread - new WatcherThread(); - } + MonitorLocker ml(PeriodicTask_lock); + _should_terminate = false; + // Create the single instance of WatcherThread + new WatcherThread(); } -void WatcherThread::make_startable() { - assert(PeriodicTask_lock->owned_by_self(), "PeriodicTask_lock required"); - _startable = true; +void WatcherThread::run_all_tasks() { + MonitorLocker ml(PeriodicTask_lock); + _run_all_tasks = true; + ml.notify(); } void WatcherThread::stop() { diff --git a/src/hotspot/share/runtime/nonJavaThread.hpp b/src/hotspot/share/runtime/nonJavaThread.hpp index 7807af6e228..6d9095924d9 100644 --- a/src/hotspot/share/runtime/nonJavaThread.hpp +++ b/src/hotspot/share/runtime/nonJavaThread.hpp @@ -110,7 +110,7 @@ class WatcherThread: public NonJavaThread { private: static WatcherThread* _watcher_thread; - static bool _startable; + static bool _run_all_tasks; // volatile due to at least one lock-free read volatile static bool _should_terminate; public: @@ -137,9 +137,9 @@ class WatcherThread: public NonJavaThread { // Create and start the single instance of WatcherThread, or stop it on shutdown static void start(); static void stop(); - // Only allow start once the VM is sufficiently initialized - // Otherwise the first task to enroll will trigger the start - static void make_startable(); + // Allow executing registered tasks once the VM is sufficiently + // initialized. Meanwhile only error reporting will be checked. + static void run_all_tasks(); private: int sleep() const; }; diff --git a/src/hotspot/share/runtime/task.cpp b/src/hotspot/share/runtime/task.cpp index d38c1d145d0..9eccd368d25 100644 --- a/src/hotspot/share/runtime/task.cpp +++ b/src/hotspot/share/runtime/task.cpp @@ -29,6 +29,7 @@ #include "runtime/mutexLocker.hpp" #include "runtime/nonJavaThread.hpp" #include "runtime/task.hpp" +#include "runtime/threads.hpp" #include "runtime/timer.hpp" int PeriodicTask::_num_tasks = 0; @@ -95,10 +96,9 @@ void PeriodicTask::enroll() { } WatcherThread* thread = WatcherThread::watcher_thread(); + assert(thread != nullptr || !Threads::is_vm_complete(), "vm created but no WatcherThread"); if (thread != nullptr) { thread->unpark(); - } else { - WatcherThread::start(); } } diff --git a/src/hotspot/share/runtime/threads.cpp b/src/hotspot/share/runtime/threads.cpp index 4f6fcf76db1..302c3672ce0 100644 --- a/src/hotspot/share/runtime/threads.cpp +++ b/src/hotspot/share/runtime/threads.cpp @@ -553,6 +553,10 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { return status; } + // Create WatcherThread as soon as we can since we need it in case + // of hangs during error reporting. + WatcherThread::start(); + // Add main_thread to threads list to finish barrier setup with // on_thread_attach. Should be before starting to build Java objects in // init_globals2, which invokes barriers. @@ -792,19 +796,11 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { CLEAR_PENDING_EXCEPTION; } - { - MutexLocker ml(PeriodicTask_lock); - // Make sure the WatcherThread can be started by WatcherThread::start() - // or by dynamic enrollment. - WatcherThread::make_startable(); - // Start up the WatcherThread if there are any periodic tasks - // NOTE: All PeriodicTasks should be registered by now. If they - // aren't, late joiners might appear to start slowly (we might - // take a while to process their first tick). - if (PeriodicTask::num_tasks() > 0) { - WatcherThread::start(); - } - } + // Let WatcherThread run all registered periodic tasks now. + // NOTE: All PeriodicTasks should be registered by now. If they + // aren't, late joiners might appear to start slowly (we might + // take a while to process their first tick). + WatcherThread::run_all_tasks(); create_vm_timer.end(); #ifdef ASSERT From 940a4e12d1b304fb841f5bcdbd2b62fac692f3b1 Mon Sep 17 00:00:00 2001 From: Eirik Bjorsnos Date: Mon, 10 Jul 2023 21:48:03 +0000 Subject: [PATCH 6/7] 8304503: Modernize debugging jvm args in demo netbeans projects Reviewed-by: prr --- .../share/nbproject/jfc/FileChooserDemo/build.properties | 2 +- .../jfc/FileChooserDemo/nbproject/netbeans-targets.xml | 7 ++----- src/demo/share/nbproject/jfc/Font2DTest/build.properties | 2 +- .../jfc/Font2DTest/nbproject/netbeans-targets.xml | 7 ++----- src/demo/share/nbproject/jfc/Metalworks/build.properties | 2 +- .../jfc/Metalworks/nbproject/netbeans-targets.xml | 7 ++----- src/demo/share/nbproject/jfc/Notepad/build.properties | 2 +- .../nbproject/jfc/Notepad/nbproject/netbeans-targets.xml | 7 ++----- src/demo/share/nbproject/jfc/SampleTree/build.properties | 2 +- .../jfc/SampleTree/nbproject/netbeans-targets.xml | 7 ++----- src/demo/share/nbproject/jfc/TableExample/build.properties | 2 +- .../jfc/TableExample/nbproject/netbeans-targets.xml | 7 ++----- .../share/nbproject/jfc/TransparentRuler/build.properties | 2 +- .../jfc/TransparentRuler/nbproject/netbeans-targets.xml | 7 ++----- 14 files changed, 21 insertions(+), 42 deletions(-) diff --git a/src/demo/share/nbproject/jfc/FileChooserDemo/build.properties b/src/demo/share/nbproject/jfc/FileChooserDemo/build.properties index cc794cf4f5d..354c3bbdabc 100644 --- a/src/demo/share/nbproject/jfc/FileChooserDemo/build.properties +++ b/src/demo/share/nbproject/jfc/FileChooserDemo/build.properties @@ -1,6 +1,6 @@ main.dir=${basedir}/../../../jfc/FileChooserDemo -src.dir=${main.dir}/src +src.dir=${main.dir}/ build.dir=build classes.dir=${build.dir}/classes diff --git a/src/demo/share/nbproject/jfc/FileChooserDemo/nbproject/netbeans-targets.xml b/src/demo/share/nbproject/jfc/FileChooserDemo/nbproject/netbeans-targets.xml index ac5178cfa30..a95dd376609 100644 --- a/src/demo/share/nbproject/jfc/FileChooserDemo/nbproject/netbeans-targets.xml +++ b/src/demo/share/nbproject/jfc/FileChooserDemo/nbproject/netbeans-targets.xml @@ -1,7 +1,7 @@