if (sigaction(SIGUSR1, &sa, NULL) != 0) {
		perror("failed to register SIGUSR1 handler");
		exit(EXIT_FAILURE);
	}
}
*/
import "C"

func main() {
	ch := make(chan os.Signal, 1)
	signal.Notify(ch, syscall.SIGUSR2)

	C.register_handler(C.int(syscall.SIGUSR1))
	syscall.Kill(syscall.Getpid(), syscall.SIGUSR1)

	<-ch

	go func() {
		io.Copy(io.Discard, os.Stdin)
		log.Fatal("stdin is closed; terminating")
	}()

	// Register to receive all signals.
	c := make(chan os.Signal, 1)
	signal.Notify(c)

	// Get console window handle.
	kernel32 := syscall.NewLazyDLL("kernel32.dll")
	getConsoleWindow := kernel32.NewProc("GetConsoleWindow")
	hwnd, _, err := getConsoleWindow.Call()
	if hwnd == 0 {

        if (!buildModelParameters.isConfigureOnDemand() || !gradle.isRootBuild()) {
            projectConfigurer.configureHierarchy(gradle.getRootProject());
            new ProjectsEvaluatedNotifier(buildOperationRunner).notify(gradle);
        }
    }

     * fails.
     */
    void registerLocked(ResourceLock resourceLock);

    /**
     * Registers a resource lock that has been unlocked during the transform so that the coordination service can
     * notify threads waiting on a lock.
     */
    void registerUnlocked(ResourceLock resourceLock);

    /**
     * Release any locks that have been acquired during the transform.
     */
    void releaseLocks();

            buildTaskScheduler.scheduleRequestedTasks(gradle, selector, plan);

            if (buildModelParameters.isConfigureOnDemand() && gradle.isRootBuild()) {
                new ProjectsEvaluatedNotifier(buildOperationRunner).notify(gradle);
            }
        });
    }

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.operations.notify

import org.gradle.integtests.fixtures.AbstractContinuousIntegrationTest
import org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache
import org.gradle.launcher.exec.RunBuildBuildOperationType

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.operations.notify;

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Controls an instance of build operation notifications.
 * <p>

                        stopSeen = true;
                        break;
                    } else if (runnableClass == FlushOperationsCommand.class) {
                        // not holding the cache lock, flush is done so notify flush thread and continue
                        FlushOperationsCommand flushOperationsCommand = (FlushOperationsCommand) runnable;
                        flushOperationsCommand.completed();
                    } else {

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.operations.notify;

import org.gradle.internal.scan.UsedByScanPlugin;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**

     * For example, an IDE should notify Gradle when the user saves a changed file, or
     * after some refactoring finished.
     * This will guarantee that Gradle picks up changes when trigerring a build, even
     * if the file system is too slow to notify file watchers.
     *
     * The caller shouldn't notify Gradle about changes detected by using other file