Java Gcc类代码示例

import org.gradle.nativeplatform.toolchain.Gcc; //导入依赖的package包/类
@Defaults
public static void addToolChain(NativeToolChainRegistryInternal toolChainRegistry, ServiceRegistry serviceRegistry) {
    final FileResolver fileResolver = serviceRegistry.get(FileResolver.class);
    final ExecActionFactory execActionFactory = serviceRegistry.get(ExecActionFactory.class);
    final Instantiator instantiator = serviceRegistry.get(Instantiator.class);

    final BuildOperationProcessor buildOperationProcessor = serviceRegistry.get(BuildOperationProcessor.class);

    final CompilerMetaDataProviderFactory metaDataProviderFactory = serviceRegistry.get(CompilerMetaDataProviderFactory.class);

    toolChainRegistry.registerFactory(Gcc.class, new NamedDomainObjectFactory<Gcc>() {
        public Gcc create(String name) {
            return instantiator.newInstance(GccToolChain.class, instantiator, name, buildOperationProcessor, OperatingSystem.current(), fileResolver, execActionFactory, metaDataProviderFactory);
        }
    });
    toolChainRegistry.registerDefaultToolChain(GccToolChain.DEFAULT_NAME, Gcc.class);
}
 

import org.gradle.nativeplatform.toolchain.Gcc; //导入依赖的package包/类
private void installWindows() {
    final File destination = getDestinationDir();
    final File executable = getExecutable();

    installToDir(new File(destination, "lib"));

    StringBuilder toolChainPath = new StringBuilder();
    if (toolChain instanceof Gcc) {
        // Gcc on windows requires the path to be set
        toolChainPath.append("SET PATH=");
        for (File pathEntry : ((Gcc) toolChain).getPath()) {
            toolChainPath.append(pathEntry.getAbsolutePath()).append(";");
        }

        toolChainPath.append("%PATH%");
    }


    String runScriptText =
          "\[email protected] off"
        + "\nSETLOCAL"
        + "\n" + toolChainPath
        + "\nCALL \"%~dp0lib\\" + executable.getName() + "\" %*"
        + "\nEXIT /B %ERRORLEVEL%"
        + "\nENDLOCAL"
        + "\n";
    GFileUtils.writeFile(runScriptText, getRunScript());
}
 

import org.gradle.nativeplatform.toolchain.Gcc; //导入依赖的package包/类
public IncrementalNativeCompiler(TaskInternal task, FileHasher hasher, CompilationStateCacheFactory compilationStateCacheFactory, Compiler<T> delegateCompiler, NativeToolChain toolChain, DirectoryFileTreeFactory directoryFileTreeFactory) {
    this.task = task;
    this.hasher = hasher;
    this.compilationStateCacheFactory = compilationStateCacheFactory;
    this.delegateCompiler = delegateCompiler;
    this.directoryFileTreeFactory = directoryFileTreeFactory;
    this.importsAreIncludes = Clang.class.isAssignableFrom(toolChain.getClass()) || Gcc.class.isAssignableFrom(toolChain.getClass());
}
 

import org.gradle.nativeplatform.toolchain.Gcc; //导入依赖的package包/类
@Mutate
public static void addGccToolChain(NativeToolChainRegistryInternal toolChainRegistry, ServiceRegistry serviceRegistry) {
    final FileResolver fileResolver = serviceRegistry.get(FileResolver.class);
    final ExecActionFactory execActionFactory = serviceRegistry.get(ExecActionFactory.class);
    final Instantiator instantiator = serviceRegistry.get(Instantiator.class);
    final CompilerMetaDataProviderFactory metaDataProviderFactory = serviceRegistry.get(CompilerMetaDataProviderFactory.class);

    toolChainRegistry.registerFactory(Gcc.class, new NamedDomainObjectFactory<Gcc>() {
        public Gcc create(String name) {
            return instantiator.newInstance(GccToolChain.class, instantiator, name, OperatingSystem.current(), fileResolver, execActionFactory, metaDataProviderFactory);
        }
    });
    toolChainRegistry.registerDefaultToolChain(GccToolChain.DEFAULT_NAME, Gcc.class);
}
 

import org.gradle.nativeplatform.toolchain.Gcc; //导入依赖的package包/类
public IncrementalNativeCompiler(TaskInternal task, TaskArtifactStateCacheAccess cacheAccess, FileSnapshotter fileSnapshotter, Compiler<NativeCompileSpec> delegateCompiler, NativeToolChain toolChain) {
    this.task = task;
    this.cacheAccess = cacheAccess;
    this.fileSnapshotter = fileSnapshotter;
    this.delegateCompiler = delegateCompiler;
    this.importsAreIncludes = Clang.class.isAssignableFrom(toolChain.getClass()) || Gcc.class.isAssignableFrom(toolChain.getClass());
}
 

import org.gradle.nativeplatform.toolchain.Gcc; //导入依赖的package包/类
/**
 * Configure toolchain for a platform.
 */
public static void configureToolchain(
        NativeToolChainRegistry toolchainRegistry,
        final String toolchainName,
        final NdkHandler ndkHandler) {
    final Toolchain ndkToolchain = Toolchain.getByName(toolchainName);
    toolchainRegistry.create("ndk-" + toolchainName,
            toolchainName.equals("gcc") ? Gcc.class : Clang.class,
            new Action<GccCompatibleToolChain>() {
                @Override
                public void execute(GccCompatibleToolChain toolchain) {
                    // Configure each platform.
                    for (Abi it : ndkHandler.getSupportedAbis()) {
                        final Abi abi = it;
                        toolchain.target(abi.getName(), new Action<GccPlatformToolChain>() {
                            @Override
                            public void execute(GccPlatformToolChain targetPlatform) {
                                if (Toolchain.GCC.equals(ndkToolchain)) {
                                    String gccPrefix = abi.getGccExecutablePrefix();
                                    targetPlatform.getcCompiler()
                                            .setExecutable(gccPrefix + "-gcc");
                                    targetPlatform.getCppCompiler()
                                            .setExecutable(gccPrefix + "-g++");
                                    targetPlatform.getLinker()
                                            .setExecutable(gccPrefix + "-g++");
                                    targetPlatform.getAssembler()
                                            .setExecutable(gccPrefix + "-as");
                                    targetPlatform.getStaticLibArchiver()
                                            .setExecutable(gccPrefix + "-ar");
                                }

                                // By default, gradle will use -Xlinker to pass arguments to the linker.
                                // Removing it as it prevents -sysroot from being properly set.
                                targetPlatform.getLinker().withArguments(
                                        new Action<List<String>>() {
                                            @Override
                                            public void execute(List<String> args) {
                                                args.removeAll(Collections.singleton("-Xlinker"));
                                            }
                                        });
                            }

                        });
                        toolchain.path(ndkHandler.getCCompiler(abi).getParentFile());
                    }
                }
            });
}