Examples with Names org.gradle.language.nativeplatform.internal.Names used on opensource projects

Example 6 with Names

use of org.gradle.language.nativeplatform.internal.Names in project gradle by gradle.

the class NativeBasePlugin method addOutgoingConfigurationForLinkUsage.

private void addOutgoingConfigurationForLinkUsage(SoftwareComponentContainer components, final ConfigurationContainer configurations) {
    components.withType(ConfigurableComponentWithLinkUsage.class, component -> {
        Names names = component.getNames();
        Configuration linkElements = configurations.create(names.withSuffix("linkElements"));
        linkElements.extendsFrom(component.getImplementationDependencies());
        linkElements.setCanBeResolved(false);
        AttributeContainer attributes = component.getLinkAttributes();
        copyAttributesTo(attributes, linkElements);
        linkElements.getOutgoing().artifact(component.getLinkFile());
        component.getLinkElements().set(linkElements);
    });
}

Example 7 with Names

use of org.gradle.language.nativeplatform.internal.Names in project gradle by gradle.

the class NativeBasePlugin method addTasksForComponentWithStaticLibrary.

private void addTasksForComponentWithStaticLibrary(final TaskContainer tasks, final DirectoryProperty buildDirectory, SoftwareComponentContainer components) {
    components.withType(ConfigurableComponentWithStaticLibrary.class, library -> {
        final Names names = library.getNames();
        // Add a create task
        final TaskProvider<CreateStaticLibrary> createTask = tasks.register(names.getTaskName("create"), CreateStaticLibrary.class, task -> {
            task.source(library.getObjects());
            final PlatformToolProvider toolProvider = library.getPlatformToolProvider();
            Provider<RegularFile> linktimeFile = buildDirectory.file(library.getBaseName().map(baseName -> toolProvider.getStaticLibraryName("lib/" + names.getDirName() + baseName)));
            task.getOutputFile().set(linktimeFile);
            task.getTargetPlatform().set(library.getNativePlatform());
            task.getToolChain().set(library.getToolChain());
        });
        // Wire the task into the library model
        library.getLinkFile().set(createTask.flatMap(task -> task.getBinaryFile()));
        library.getLinkFileProducer().set(createTask);
        library.getCreateTask().set(createTask);
        library.getOutputs().from(library.getLinkFile());
    });
}

Example 8 with Names

use of org.gradle.language.nativeplatform.internal.Names in project gradle by gradle.

the class NativeBasePlugin method addTasksForComponentWithSharedLibrary.

private void addTasksForComponentWithSharedLibrary(final TaskContainer tasks, final DirectoryProperty buildDirectory, SoftwareComponentContainer components) {
    components.withType(ConfigurableComponentWithSharedLibrary.class, library -> {
        final Names names = library.getNames();
        final NativePlatform targetPlatform = library.getNativePlatform();
        final NativeToolChain toolChain = library.getToolChain();
        final PlatformToolProvider toolProvider = library.getPlatformToolProvider();
        // Add a link task
        final TaskProvider<LinkSharedLibrary> link = tasks.register(names.getTaskName("link"), LinkSharedLibrary.class, task -> {
            task.source(library.getObjects());
            task.lib(library.getLinkLibraries());
            task.getLinkedFile().set(buildDirectory.file(library.getBaseName().map(baseName -> toolProvider.getSharedLibraryName("lib/" + names.getDirName() + baseName))));
            // when Swift depends on C++ libraries built by Gradle.
            if (!targetPlatform.getOperatingSystem().isMacOsX()) {
                Provider<String> installName = task.getLinkedFile().getLocationOnly().map(linkedFile -> linkedFile.getAsFile().getName());
                task.getInstallName().set(installName);
            }
            task.getTargetPlatform().set(targetPlatform);
            task.getToolChain().set(toolChain);
            task.getDebuggable().set(library.isDebuggable());
        });
        Provider<RegularFile> linkFile = link.flatMap(task -> task.getLinkedFile());
        Provider<RegularFile> runtimeFile = link.flatMap(task -> task.getLinkedFile());
        Provider<? extends Task> linkFileTask = link;
        if (toolProvider.producesImportLibrary()) {
            link.configure(linkSharedLibrary -> {
                linkSharedLibrary.getImportLibrary().set(buildDirectory.file(library.getBaseName().map(baseName -> toolProvider.getImportLibraryName("lib/" + names.getDirName() + baseName))));
            });
            linkFile = link.flatMap(task -> task.getImportLibrary());
        }
        if (library.isDebuggable() && library.isOptimized() && toolProvider.requiresDebugBinaryStripping()) {
            Provider<RegularFile> symbolLocation = buildDirectory.file(library.getBaseName().map(baseName -> toolProvider.getLibrarySymbolFileName("lib/" + names.getDirName() + "stripped/" + baseName)));
            Provider<RegularFile> strippedLocation = buildDirectory.file(library.getBaseName().map(baseName -> toolProvider.getSharedLibraryName("lib/" + names.getDirName() + "stripped/" + baseName)));
            TaskProvider<StripSymbols> stripSymbols = stripSymbols(link, names, tasks, toolChain, targetPlatform, strippedLocation);
            linkFile = runtimeFile = stripSymbols.flatMap(task -> task.getOutputFile());
            TaskProvider<ExtractSymbols> extractSymbols = extractSymbols(link, names, tasks, toolChain, targetPlatform, symbolLocation);
            library.getOutputs().from(extractSymbols.flatMap(task -> task.getSymbolFile()));
            linkFileTask = stripSymbols;
        }
        library.getLinkTask().set(link);
        library.getLinkFile().set(linkFile);
        library.getLinkFileProducer().set(linkFileTask);
        library.getRuntimeFile().set(runtimeFile);
        library.getOutputs().from(library.getLinkFile());
        library.getOutputs().from(library.getRuntimeFile());
    });
}

Example 9 with Names

use of org.gradle.language.nativeplatform.internal.Names in project gradle by gradle.

the class SwiftLibraryPlugin method apply.

@Override
public void apply(final Project project) {
    project.getPluginManager().apply(SwiftBasePlugin.class);
    final ConfigurationContainer configurations = project.getConfigurations();
    final ObjectFactory objectFactory = project.getObjects();
    final ProviderFactory providers = project.getProviders();
    final DefaultSwiftLibrary library = componentFactory.newInstance(SwiftLibrary.class, DefaultSwiftLibrary.class, "main");
    project.getExtensions().add(SwiftLibrary.class, "library", library);
    project.getComponents().add(library);
    // Setup component
    final Property<String> module = library.getModule();
    module.set(GUtil.toCamelCase(project.getName()));
    library.getTargetMachines().convention(useHostAsDefaultTargetMachine(targetMachineFactory));
    library.getDevelopmentBinary().convention(project.provider(new Callable<SwiftBinary>() {

        @Override
        public SwiftBinary call() throws Exception {
            return getDebugSharedHostStream().findFirst().orElse(getDebugStaticHostStream().findFirst().orElse(getDebugSharedStream().findFirst().orElse(getDebugStaticStream().findFirst().orElse(null))));
        }

        private Stream<SwiftBinary> getDebugStream() {
            return library.getBinaries().get().stream().filter(binary -> !binary.isOptimized());
        }

        private Stream<SwiftBinary> getDebugSharedStream() {
            return getDebugStream().filter(SwiftSharedLibrary.class::isInstance);
        }

        private Stream<SwiftBinary> getDebugSharedHostStream() {
            return getDebugSharedStream().filter(binary -> Architectures.forInput(binary.getTargetMachine().getArchitecture().getName()).equals(DefaultNativePlatform.host().getArchitecture()));
        }

        private Stream<SwiftBinary> getDebugStaticStream() {
            return getDebugStream().filter(SwiftStaticLibrary.class::isInstance);
        }

        private Stream<SwiftBinary> getDebugStaticHostStream() {
            return getDebugStaticStream().filter(binary -> Architectures.forInput(binary.getTargetMachine().getArchitecture().getName()).equals(DefaultNativePlatform.host().getArchitecture()));
        }
    }));
    project.afterEvaluate(p -> {
        // TODO: make build type configurable for components
        Dimensions.libraryVariants(library.getModule(), library.getLinkage(), library.getTargetMachines(), objectFactory, attributesFactory, providers.provider(() -> project.getGroup().toString()), providers.provider(() -> project.getVersion().toString()), variantIdentity -> {
            if (tryToBuildOnHost(variantIdentity)) {
                library.getSourceCompatibility().finalizeValue();
                ToolChainSelector.Result<SwiftPlatform> result = toolChainSelector.select(SwiftPlatform.class, new DefaultSwiftPlatform(variantIdentity.getTargetMachine(), library.getSourceCompatibility().getOrNull()));
                if (variantIdentity.getLinkage().equals(Linkage.SHARED)) {
                    library.addSharedLibrary(variantIdentity, variantIdentity.isDebuggable() && !variantIdentity.isOptimized(), result.getTargetPlatform(), result.getToolChain(), result.getPlatformToolProvider());
                } else {
                    library.addStaticLibrary(variantIdentity, variantIdentity.isDebuggable() && !variantIdentity.isOptimized(), result.getTargetPlatform(), result.getToolChain(), result.getPlatformToolProvider());
                }
            }
        });
        library.getBinaries().whenElementKnown(SwiftSharedLibrary.class, sharedLibrary -> {
            Names names = ((ComponentWithNames) sharedLibrary).getNames();
            Configuration apiElements = configurations.create(names.withSuffix("SwiftApiElements"));
            // TODO This should actually extend from the api dependencies, but since Swift currently
            // requires all dependencies to be treated like api dependencies (with transitivity) we just
            // use the implementation dependencies here.  See https://bugs.swift.org/browse/SR-1393.
            apiElements.extendsFrom(((DefaultSwiftSharedLibrary) sharedLibrary).getImplementationDependencies());
            apiElements.setCanBeResolved(false);
            apiElements.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, objectFactory.named(Usage.class, Usage.SWIFT_API));
            apiElements.getAttributes().attribute(LINKAGE_ATTRIBUTE, Linkage.SHARED);
            apiElements.getAttributes().attribute(DEBUGGABLE_ATTRIBUTE, sharedLibrary.isDebuggable());
            apiElements.getAttributes().attribute(OPTIMIZED_ATTRIBUTE, sharedLibrary.isOptimized());
            apiElements.getAttributes().attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, sharedLibrary.getTargetMachine().getOperatingSystemFamily());
            apiElements.getOutgoing().artifact(sharedLibrary.getModuleFile());
        });
        library.getBinaries().whenElementKnown(SwiftStaticLibrary.class, staticLibrary -> {
            Names names = ((ComponentWithNames) staticLibrary).getNames();
            Configuration apiElements = configurations.create(names.withSuffix("SwiftApiElements"));
            // TODO This should actually extend from the api dependencies, but since Swift currently
            // requires all dependencies to be treated like api dependencies (with transitivity) we just
            // use the implementation dependencies here.  See https://bugs.swift.org/browse/SR-1393.
            apiElements.extendsFrom(((DefaultSwiftStaticLibrary) staticLibrary).getImplementationDependencies());
            apiElements.setCanBeResolved(false);
            apiElements.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, objectFactory.named(Usage.class, Usage.SWIFT_API));
            apiElements.getAttributes().attribute(LINKAGE_ATTRIBUTE, Linkage.STATIC);
            apiElements.getAttributes().attribute(DEBUGGABLE_ATTRIBUTE, staticLibrary.isDebuggable());
            apiElements.getAttributes().attribute(OPTIMIZED_ATTRIBUTE, staticLibrary.isOptimized());
            apiElements.getAttributes().attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, staticLibrary.getTargetMachine().getOperatingSystemFamily());
            apiElements.getOutgoing().artifact(staticLibrary.getModuleFile());
        });
        library.getBinaries().realizeNow();
    });
}

Example 10 with Names

use of org.gradle.language.nativeplatform.internal.Names in project gradle by gradle.

the class CppBasePlugin method apply.

@Override
public void apply(final Project project) {
    project.getPluginManager().apply(NativeBasePlugin.class);
    project.getPluginManager().apply(StandardToolChainsPlugin.class);
    final TaskContainer tasks = project.getTasks();
    final DirectoryProperty buildDirectory = project.getLayout().getBuildDirectory();
    // Create the tasks for each C++ binary that is registered
    project.getComponents().withType(DefaultCppBinary.class, binary -> {
        final Names names = binary.getNames();
        String language = "cpp";
        TaskProvider<CppCompile> compile = tasks.register(names.getCompileTaskName(language), CppCompile.class, task -> {
            final Callable<List<File>> systemIncludes = () -> binary.getPlatformToolProvider().getSystemLibraries(ToolType.CPP_COMPILER).getIncludeDirs();
            task.includes(binary.getCompileIncludePath());
            task.getSystemIncludes().from(systemIncludes);
            task.source(binary.getCppSource());
            if (binary.isDebuggable()) {
                task.setDebuggable(true);
            }
            if (binary.isOptimized()) {
                task.setOptimized(true);
            }
            task.getTargetPlatform().set(binary.getNativePlatform());
            task.getToolChain().set(binary.getToolChain());
            task.getObjectFileDir().set(buildDirectory.dir("obj/" + names.getDirName()));
            if (binary instanceof CppSharedLibrary) {
                task.setPositionIndependentCode(true);
            }
        });
        binary.getObjectsDir().set(compile.flatMap(task -> task.getObjectFileDir()));
        binary.getCompileTask().set(compile);
    });
    project.getComponents().withType(ProductionCppComponent.class, component -> {
        project.afterEvaluate(p -> {
            DefaultCppComponent componentInternal = (DefaultCppComponent) component;
            publicationRegistry.registerPublication((ProjectInternal) project, new NativeProjectPublication(componentInternal.getDisplayName(), new SwiftPmTarget(component.getBaseName().get())));
        });
    });
}