| // Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| package com.android.tools.r8; |
| |
| import com.android.tools.r8.origin.Origin; |
| import com.android.tools.r8.references.MethodReference; |
| import com.android.tools.r8.references.Reference; |
| import com.android.tools.r8.utils.CliParserUtils; |
| import com.android.tools.r8.utils.DescriptorUtils; |
| import com.android.tools.r8.utils.Reporter; |
| import com.android.tools.r8.utils.StringDiagnostic; |
| import com.android.tools.r8.utils.internal.collections.Pair; |
| import com.android.tools.r8.utils.internal.exceptions.Unreachable; |
| import java.nio.file.Paths; |
| import java.util.function.Consumer; |
| |
| public class BaseCompilerCommandParser { |
| |
| protected static final String ART_PROFILE_FLAG = "--art-profile"; |
| protected static final String BUILD_METADATA_OUTPUT_FLAG = "--build-metadata-output"; |
| public static final String LIB_FLAG = "--lib"; |
| public static final String MIN_API_FLAG = "--min-api"; |
| public static final String OUTPUT_FLAG = "--output"; |
| protected static final String STARTUP_PROFILE_FLAG = "--startup-profile"; |
| public static final String THREAD_COUNT_FLAG = "--thread-count"; |
| public static final String MAP_DIAGNOSTICS = "--map-diagnostics"; |
| protected static final String DUMP_INPUT_TO_FILE = "--dumpinputtofile"; |
| protected static final String DUMP_INPUT_TO_DIRECTORY = "--dumpinputtodirectory"; |
| protected static final String VERBOSE_SYNTHETIC_NAMES = "--verbose-synthetic-names"; |
| public static final String API_DATABASE_FLAG = "--api-database"; |
| |
| public static void parsePositiveIntArgument( |
| Consumer<Diagnostic> errorConsumer, |
| String flag, |
| String argument, |
| Origin origin, |
| Consumer<Integer> setter) { |
| int value; |
| try { |
| value = Integer.parseInt(argument); |
| } catch (NumberFormatException e) { |
| errorConsumer.accept( |
| new StringDiagnostic("Invalid argument to " + flag + ": " + argument, origin)); |
| return; |
| } |
| if (value < 1) { |
| errorConsumer.accept( |
| new StringDiagnostic("Invalid argument to " + flag + ": " + argument, origin)); |
| return; |
| } |
| setter.accept(value); |
| } |
| |
| private static final String PACKAGE_ASSERTION_POSTFIX = "..."; |
| |
| private enum AssertionTransformationType { |
| ENABLE, |
| DISABLE, |
| PASSTHROUGH, |
| HANDLER |
| } |
| |
| private static AssertionsConfiguration.Builder prepareBuilderForScope( |
| AssertionsConfiguration.Builder builder, |
| AssertionTransformationType transformation, |
| MethodReference assertionHandler) { |
| switch (transformation) { |
| case ENABLE: |
| return builder.setCompileTimeEnable(); |
| case DISABLE: |
| return builder.setCompileTimeDisable(); |
| case PASSTHROUGH: |
| return builder.setPassthrough(); |
| case HANDLER: |
| return builder.setAssertionHandler(assertionHandler); |
| default: |
| throw new Unreachable(); |
| } |
| } |
| |
| private static <C extends BaseCompilerCommand, B extends BaseCompilerCommand.Builder<C, B>> |
| void addAssertionTransformation( |
| B builder, |
| AssertionTransformationType transformation, |
| MethodReference assertionHandler, |
| String scope) { |
| if (scope == null) { |
| builder.addAssertionsConfiguration( |
| b -> prepareBuilderForScope(b, transformation, assertionHandler).setScopeAll().build()); |
| } else { |
| assert !scope.isEmpty(); |
| if (scope.endsWith(PACKAGE_ASSERTION_POSTFIX)) { |
| builder.addAssertionsConfiguration( |
| b -> |
| prepareBuilderForScope(b, transformation, assertionHandler) |
| .setScopePackage( |
| scope.substring(0, scope.length() - PACKAGE_ASSERTION_POSTFIX.length())) |
| .build()); |
| } else { |
| builder.addAssertionsConfiguration( |
| b -> |
| prepareBuilderForScope(b, transformation, assertionHandler) |
| .setScopeClass(scope) |
| .build()); |
| } |
| } |
| } |
| |
| protected static <C extends BaseCompilerCommand, B extends BaseCompilerCommand.Builder<C, B>> |
| String parseAssertionScope(B builder, String suffix, Origin origin) { |
| if (suffix.isEmpty()) { |
| return null; |
| } |
| if (suffix.equals(":")) { |
| throw builder.fatalError(new StringDiagnostic("Missing optional argument", origin)); |
| } |
| if (!suffix.startsWith(":")) { |
| builder.error(new StringDiagnostic("Illegal assertion scope: " + suffix, origin)); |
| return suffix; |
| } |
| String classOrPackageScope = suffix.substring(1); |
| if (classOrPackageScope.contains(";") |
| || classOrPackageScope.contains("[") |
| || classOrPackageScope.contains("/")) { |
| builder.error( |
| new StringDiagnostic("Illegal assertion scope: " + classOrPackageScope, origin)); |
| } |
| return classOrPackageScope; |
| } |
| |
| static <C extends BaseCompilerCommand, B extends BaseCompilerCommand.Builder<C, B>> |
| Pair<MethodReference, String> parseAssertionHandler(B builder, String suffix, Origin origin) { |
| if (suffix.isEmpty() || suffix.equals(":")) { |
| throw builder.fatalError( |
| new StringDiagnostic("Missing required argument <handler method>", origin)); |
| } |
| if (!suffix.startsWith(":")) { |
| throw builder.fatalError( |
| new StringDiagnostic("Missing required argument <handler method>", origin)); |
| } |
| String remaining = suffix.substring(1); |
| int index = remaining.indexOf(':'); |
| if (index == 0) { |
| throw builder.fatalError( |
| new StringDiagnostic("Missing required argument <handler method>", origin)); |
| } |
| String assertionsHandlerString = index > 0 ? remaining.substring(0, index) : remaining; |
| int lastDotIndex = assertionsHandlerString.lastIndexOf('.'); |
| if (assertionsHandlerString.length() < 3 |
| || lastDotIndex <= 0 |
| || lastDotIndex == assertionsHandlerString.length() - 1 |
| || !DescriptorUtils.isValidJavaType(assertionsHandlerString.substring(0, lastDotIndex))) { |
| throw builder.fatalError( |
| new StringDiagnostic( |
| "Invalid argument <handler method>: " + assertionsHandlerString, origin)); |
| } |
| MethodReference assertionsHandler = |
| Reference.methodFromDescriptor( |
| DescriptorUtils.javaTypeToDescriptor( |
| assertionsHandlerString.substring(0, lastDotIndex)), |
| assertionsHandlerString.substring(lastDotIndex + 1), |
| "(Ljava/lang/Throwable;)V"); |
| String scopeSuffix = remaining.substring(assertionsHandlerString.length()); |
| String scope = parseAssertionScope(builder, scopeSuffix, origin); |
| return Pair.create(assertionsHandler, scope); |
| } |
| |
| static <C extends BaseCompilerCommand, B extends BaseCompilerCommand.Builder<C, B>> |
| void parseForceEnableAssertions(B builder, String suffix, Origin origin) { |
| String scope = parseAssertionScope(builder, suffix, origin); |
| addAssertionTransformation(builder, AssertionTransformationType.ENABLE, null, scope); |
| } |
| |
| static <C extends BaseCompilerCommand, B extends BaseCompilerCommand.Builder<C, B>> |
| void parseForceDisableAssertions(B builder, String suffix, Origin origin) { |
| String scope = parseAssertionScope(builder, suffix, origin); |
| addAssertionTransformation(builder, AssertionTransformationType.DISABLE, null, scope); |
| } |
| |
| static <C extends BaseCompilerCommand, B extends BaseCompilerCommand.Builder<C, B>> |
| void parseForcePassthroughAssertions(B builder, String suffix, Origin origin) { |
| String scope = parseAssertionScope(builder, suffix, origin); |
| addAssertionTransformation(builder, AssertionTransformationType.PASSTHROUGH, null, scope); |
| } |
| |
| static <C extends BaseCompilerCommand, B extends BaseCompilerCommand.Builder<C, B>> |
| void parseForceAssertionsHandler(B builder, String suffix, Origin origin) { |
| Pair<MethodReference, String> handlerAndScope = parseAssertionHandler(builder, suffix, origin); |
| addAssertionTransformation( |
| builder, |
| AssertionTransformationType.HANDLER, |
| handlerAndScope.getFirst(), |
| handlerAndScope.getSecond()); |
| } |
| |
| static <C extends BaseCompilerCommand, B extends BaseCompilerCommand.Builder<C, B>> |
| boolean tryParseAssertionArgument(B builder, String arg, Origin origin) { |
| String FORCE_ENABLE_ASSERTIONS = "--force-enable-assertions"; |
| String FORCE_EA = "--force-ea"; |
| String FORCE_DISABLE_ASSERTIONS = "--force-disable-assertions"; |
| String FORCE_DA = "--force-da"; |
| String FORCE_PASSTHROUGH_ASSERTIONS = "--force-passthrough-assertions"; |
| String FORCE_PA = "--force-pa"; |
| String FORCE_ASSERTIONS_HANDLER = "--force-assertions-handler"; |
| String FORCE_AH = "--force-ah"; |
| |
| AssertionTransformationType transformation = null; |
| String remaining = null; |
| if (arg.startsWith(FORCE_ENABLE_ASSERTIONS)) { |
| transformation = AssertionTransformationType.ENABLE; |
| remaining = arg.substring(FORCE_ENABLE_ASSERTIONS.length()); |
| } else if (arg.startsWith(FORCE_EA)) { |
| transformation = AssertionTransformationType.ENABLE; |
| remaining = arg.substring(FORCE_EA.length()); |
| } else if (arg.startsWith(FORCE_DISABLE_ASSERTIONS)) { |
| transformation = AssertionTransformationType.DISABLE; |
| remaining = arg.substring(FORCE_DISABLE_ASSERTIONS.length()); |
| } else if (arg.startsWith(FORCE_DA)) { |
| transformation = AssertionTransformationType.DISABLE; |
| remaining = arg.substring(FORCE_DA.length()); |
| } else if (arg.startsWith(FORCE_PASSTHROUGH_ASSERTIONS)) { |
| transformation = AssertionTransformationType.PASSTHROUGH; |
| remaining = arg.substring(FORCE_PASSTHROUGH_ASSERTIONS.length()); |
| } else if (arg.startsWith(FORCE_PA)) { |
| transformation = AssertionTransformationType.PASSTHROUGH; |
| remaining = arg.substring(FORCE_PA.length()); |
| } else if (arg.startsWith(FORCE_ASSERTIONS_HANDLER)) { |
| transformation = AssertionTransformationType.HANDLER; |
| remaining = arg.substring(FORCE_ASSERTIONS_HANDLER.length()); |
| } else if (arg.startsWith(FORCE_AH)) { |
| transformation = AssertionTransformationType.HANDLER; |
| remaining = arg.substring(FORCE_AH.length()); |
| } |
| if (transformation == null) { |
| return false; |
| } |
| if (!remaining.isEmpty() && remaining.charAt(0) != ':') { |
| return false; |
| } |
| switch (transformation) { |
| case ENABLE: |
| parseForceEnableAssertions(builder, remaining, origin); |
| return true; |
| case DISABLE: |
| parseForceDisableAssertions(builder, remaining, origin); |
| return true; |
| case PASSTHROUGH: |
| parseForcePassthroughAssertions(builder, remaining, origin); |
| return true; |
| case HANDLER: |
| parseForceAssertionsHandler(builder, remaining, origin); |
| return true; |
| default: |
| throw new Unreachable(); |
| } |
| } |
| |
| protected static <C extends BaseCompilerCommand, B extends BaseCompilerCommand.Builder<C, B>> |
| int tryParseMapDiagnostics( |
| B builder, String arg, String[] args, int argsIndex, Origin origin) { |
| return tryParseMapDiagnostics( |
| builder::error, builder.getReporter(), arg, args, argsIndex, origin); |
| } |
| |
| public static int tryParseMapDiagnostics( |
| Consumer<Diagnostic> errorHandler, |
| Reporter reporter, |
| String arg, |
| String[] args, |
| int argsIndex, |
| Origin origin) { |
| if (!arg.startsWith(MAP_DIAGNOSTICS)) { |
| return -1; |
| } |
| if (args.length <= argsIndex + 2) { |
| errorHandler.accept(new StringDiagnostic("Missing argument(s) for " + arg + ".", origin)); |
| return args.length - argsIndex; |
| } |
| String remaining = arg.substring(MAP_DIAGNOSTICS.length()); |
| |
| CliParserUtils.parseDiagnosticsMapping( |
| remaining, |
| args[argsIndex + 1], |
| args[argsIndex + 2], |
| mapping -> |
| reporter.addDiagnosticsLevelMapping(mapping.from, mapping.diagnosticType, mapping.to), |
| errorHandler, |
| origin); |
| return 2; |
| } |
| |
| protected static <C extends BaseCompilerCommand, B extends BaseCompilerCommand.Builder<C, B>> |
| int tryParseDump(B builder, String arg, String[] args, int argsIndex, Origin origin) { |
| if (!arg.equals(DUMP_INPUT_TO_FILE) && !arg.equals(DUMP_INPUT_TO_DIRECTORY)) { |
| return -1; |
| } |
| if (args.length <= argsIndex + 1) { |
| builder.error(new StringDiagnostic("Missing argument(s) for " + arg + ".", origin)); |
| return args.length - argsIndex; |
| } |
| if (arg.equals(DUMP_INPUT_TO_FILE)) { |
| builder.dumpInputToFile(Paths.get(args[argsIndex + 1])); |
| } else { |
| assert arg.equals(DUMP_INPUT_TO_DIRECTORY); |
| builder.dumpInputToDirectory(Paths.get(args[argsIndex + 1])); |
| } |
| return 1; |
| } |
| |
| static void addLibraryArgument(BaseCommand.Builder<?, ?> builder, String arg, Origin origin) { |
| CompilerCommandParserUtils.addLibraryArgument( |
| builder.getAppBuilder(), arg, origin, builder.getReporter()); |
| } |
| } |
