Merge "Add OWNERS to finder's cache"
diff --git a/Android.bp b/Android.bp
index dcbc030..ac50166 100644
--- a/Android.bp
+++ b/Android.bp
@@ -235,6 +235,7 @@
"java/genrule.go",
"java/jacoco.go",
"java/java.go",
+ "java/jdeps.go",
"java/java_resources.go",
"java/prebuilt_apis.go",
"java/proto.go",
@@ -245,6 +246,7 @@
testSrcs: [
"java/app_test.go",
"java/java_test.go",
+ "java/jdeps_test.go",
],
pluginFor: ["soong_build"],
}
diff --git a/android/androidmk.go b/android/androidmk.go
index 1d11161..44c266a 100644
--- a/android/androidmk.go
+++ b/android/androidmk.go
@@ -141,6 +141,13 @@
}
func translateAndroidMkModule(ctx SingletonContext, w io.Writer, mod blueprint.Module) error {
+ defer func() {
+ if r := recover(); r != nil {
+ panic(fmt.Errorf("%s in translateAndroidMkModule for module %s variant %s",
+ r, ctx.ModuleName(mod), ctx.ModuleSubDir(mod)))
+ }
+ }()
+
provider, ok := mod.(AndroidMkDataProvider)
if !ok {
return nil
diff --git a/android/arch.go b/android/arch.go
index 6971bc8..57899cd 100644
--- a/android/arch.go
+++ b/android/arch.go
@@ -959,6 +959,7 @@
{"arm", "armv7-a-neon", "cortex-a15", []string{"armeabi-v7a"}},
{"arm", "armv7-a-neon", "cortex-a53", []string{"armeabi-v7a"}},
{"arm", "armv7-a-neon", "cortex-a53.a57", []string{"armeabi-v7a"}},
+ {"arm", "armv7-a-neon", "cortex-a72", []string{"armeabi-v7a"}},
{"arm", "armv7-a-neon", "cortex-a73", []string{"armeabi-v7a"}},
{"arm", "armv7-a-neon", "cortex-a75", []string{"armeabi-v7a"}},
{"arm", "armv7-a-neon", "denver", []string{"armeabi-v7a"}},
@@ -967,6 +968,7 @@
{"arm", "armv7-a-neon", "exynos-m1", []string{"armeabi-v7a"}},
{"arm", "armv7-a-neon", "exynos-m2", []string{"armeabi-v7a"}},
{"arm64", "armv8-a", "cortex-a53", []string{"arm64-v8a"}},
+ {"arm64", "armv8-a", "cortex-a72", []string{"arm64-v8a"}},
{"arm64", "armv8-a", "cortex-a73", []string{"arm64-v8a"}},
{"arm64", "armv8-a", "denver64", []string{"arm64-v8a"}},
{"arm64", "armv8-a", "kryo", []string{"arm64-v8a"}},
@@ -1100,11 +1102,11 @@
return ret
}
-func preferTargets(targets []Target, filters ...string) []Target {
+func firstTarget(targets []Target, filters ...string) []Target {
for _, filter := range filters {
buildTargets := filterMultilibTargets(targets, filter)
if len(buildTargets) > 0 {
- return buildTargets
+ return buildTargets[:1]
}
}
return nil
@@ -1120,9 +1122,9 @@
case "common_first":
buildTargets = getCommonTargets(targets)
if prefer32 {
- buildTargets = append(buildTargets, preferTargets(targets, "lib32", "lib64")...)
+ buildTargets = append(buildTargets, firstTarget(targets, "lib32", "lib64")...)
} else {
- buildTargets = append(buildTargets, preferTargets(targets, "lib64", "lib32")...)
+ buildTargets = append(buildTargets, firstTarget(targets, "lib64", "lib32")...)
}
case "both":
if prefer32 {
@@ -1138,12 +1140,15 @@
buildTargets = filterMultilibTargets(targets, "lib64")
case "first":
if prefer32 {
- buildTargets = preferTargets(targets, "lib32", "lib64")
+ buildTargets = firstTarget(targets, "lib32", "lib64")
} else {
- buildTargets = preferTargets(targets, "lib64", "lib32")
+ buildTargets = firstTarget(targets, "lib64", "lib32")
}
case "prefer32":
- buildTargets = preferTargets(targets, "lib32", "lib64")
+ buildTargets = filterMultilibTargets(targets, "lib32")
+ if len(buildTargets) == 0 {
+ buildTargets = filterMultilibTargets(targets, "lib64")
+ }
default:
return nil, fmt.Errorf(`compile_multilib must be "both", "first", "32", "64", or "prefer32" found %q`,
multilib)
diff --git a/android/config.go b/android/config.go
index 3a2a005..3ef202b 100644
--- a/android/config.go
+++ b/android/config.go
@@ -572,6 +572,10 @@
return Bool(c.productVariables.MinimizeJavaDebugInfo) && !Bool(c.productVariables.Eng)
}
+func (c *config) Debuggable() bool {
+ return Bool(c.productVariables.Debuggable)
+}
+
func (c *config) DevicePrefer32BitExecutables() bool {
return Bool(c.productVariables.DevicePrefer32BitExecutables)
}
diff --git a/android/module.go b/android/module.go
index 77765f1..4dc4e9c 100644
--- a/android/module.go
+++ b/android/module.go
@@ -23,6 +23,7 @@
"github.com/google/blueprint"
"github.com/google/blueprint/pathtools"
+ "github.com/google/blueprint/proptools"
)
var (
@@ -601,6 +602,10 @@
return Bool(p.commonProperties.Recovery)
}
+func (a *ModuleBase) Owner() string {
+ return String(a.commonProperties.Owner)
+}
+
func (a *ModuleBase) generateModuleTarget(ctx ModuleContext) {
allInstalledFiles := Paths{}
allCheckbuildFiles := Paths{}
@@ -844,6 +849,13 @@
bparams.Implicits = append(bparams.Implicits, params.Implicit.String())
}
+ bparams.Outputs = proptools.NinjaEscape(bparams.Outputs)
+ bparams.ImplicitOutputs = proptools.NinjaEscape(bparams.ImplicitOutputs)
+ bparams.Inputs = proptools.NinjaEscape(bparams.Inputs)
+ bparams.Implicits = proptools.NinjaEscape(bparams.Implicits)
+ bparams.OrderOnly = proptools.NinjaEscape(bparams.OrderOnly)
+ bparams.Depfile = proptools.NinjaEscape([]string{bparams.Depfile})[0]
+
return bparams
}
@@ -1535,3 +1547,27 @@
}
}
func (s AndroidModulesByName) Swap(i, j int) { s.slice[i], s.slice[j] = s.slice[j], s.slice[i] }
+
+// Collect information for opening IDE project files in java/jdeps.go.
+type IDEInfo interface {
+ IDEInfo(ideInfo *IdeInfo)
+ BaseModuleName() string
+}
+
+// Extract the base module name from the Import name.
+// Often the Import name has a prefix "prebuilt_".
+// Remove the prefix explicitly if needed
+// until we find a better solution to get the Import name.
+type IDECustomizedModuleName interface {
+ IDECustomizedModuleName() string
+}
+
+type IdeInfo struct {
+ Deps []string `json:"dependencies,omitempty"`
+ Srcs []string `json:"srcs,omitempty"`
+ Aidl_include_dirs []string `json:"aidl_include_dirs,omitempty"`
+ Jarjar_rules []string `json:"jarjar_rules,omitempty"`
+ Jars []string `json:"jars,omitempty"`
+ Classes []string `json:"class,omitempty"`
+ Installed_paths []string `json:"installed,omitempty"`
+}
diff --git a/android/package_ctx.go b/android/package_ctx.go
index e228bba..00b99ff 100644
--- a/android/package_ctx.go
+++ b/android/package_ctx.go
@@ -124,7 +124,11 @@
// package-scoped variable's initialization.
func (p PackageContext) SourcePathVariable(name, path string) blueprint.Variable {
return p.VariableFunc(name, func(ctx PackageVarContext) string {
- return safePathForSource(ctx, path).String()
+ p, err := safePathForSource(ctx, path)
+ if err != nil {
+ ctx.Errorf("%s", err.Error())
+ }
+ return p.String()
})
}
@@ -136,7 +140,10 @@
return p.VariableFunc(name, func(ctx PackageVarContext) string {
var ret []string
for _, path := range paths {
- p := safePathForSource(ctx, path)
+ p, err := safePathForSource(ctx, path)
+ if err != nil {
+ ctx.Errorf("%s", err.Error())
+ }
ret = append(ret, p.String())
}
return strings.Join(ret, separator)
@@ -150,7 +157,10 @@
// as part of a package-scoped variable's initialization.
func (p PackageContext) SourcePathVariableWithEnvOverride(name, path, env string) blueprint.Variable {
return p.VariableFunc(name, func(ctx PackageVarContext) string {
- p := safePathForSource(ctx, path)
+ p, err := safePathForSource(ctx, path)
+ if err != nil {
+ ctx.Errorf("%s", err.Error())
+ }
return ctx.Config().GetenvWithDefault(env, p.String())
})
}
diff --git a/android/paths.go b/android/paths.go
index 57ebae2..daaf857 100644
--- a/android/paths.go
+++ b/android/paths.go
@@ -230,6 +230,8 @@
// pathsForModuleSrcFromFullPath returns Paths rooted from the module's local
// source directory, but strip the local source directory from the beginning of
// each string. If incDirs is false, strip paths with a trailing '/' from the list.
+// It intended for use in globs that only list files that exist, so it allows '$' in
+// filenames.
func pathsForModuleSrcFromFullPath(ctx ModuleContext, paths []string, incDirs bool) Paths {
prefix := filepath.Join(ctx.Config().srcDir, ctx.ModuleDir()) + "/"
if prefix == "./" {
@@ -246,7 +248,7 @@
continue
}
- srcPath, err := pathForSource(ctx, ctx.ModuleDir(), path[len(prefix):])
+ srcPath, err := safePathForSource(ctx, ctx.ModuleDir(), path[len(prefix):])
if err != nil {
reportPathError(ctx, err)
continue
@@ -494,29 +496,26 @@
// safePathForSource is for paths that we expect are safe -- only for use by go
// code that is embedding ninja variables in paths
-func safePathForSource(ctx PathContext, path string) SourcePath {
- p, err := validateSafePath(path)
- if err != nil {
- reportPathError(ctx, err)
- }
+func safePathForSource(ctx PathContext, pathComponents ...string) (SourcePath, error) {
+ p, err := validateSafePath(pathComponents...)
ret := SourcePath{basePath{p, ctx.Config(), ""}}
+ if err != nil {
+ return ret, err
+ }
abs, err := filepath.Abs(ret.String())
if err != nil {
- reportPathError(ctx, err)
- return ret
+ return ret, err
}
buildroot, err := filepath.Abs(ctx.Config().buildDir)
if err != nil {
- reportPathError(ctx, err)
- return ret
+ return ret, err
}
if strings.HasPrefix(abs, buildroot) {
- reportPathErrorf(ctx, "source path %s is in output", abs)
- return ret
+ return ret, fmt.Errorf("source path %s is in output", abs)
}
- return ret
+ return ret, err
}
// pathForSource creates a SourcePath from pathComponents, but does not check that it exists.
@@ -555,7 +554,7 @@
var deps []string
// We cannot add build statements in this context, so we fall back to
// AddNinjaFileDeps
- files, deps, err = pathtools.Glob(path.String(), nil)
+ files, deps, err = pathtools.Glob(path.String(), nil, pathtools.FollowSymlinks)
ctx.AddNinjaFileDeps(deps...)
}
diff --git a/cc/androidmk.go b/cc/androidmk.go
index 9258bd4..5daacb7 100644
--- a/cc/androidmk.go
+++ b/cc/androidmk.go
@@ -60,24 +60,17 @@
ret := android.AndroidMkData{
OutputFile: c.outputFile,
Required: c.Properties.AndroidMkRuntimeLibs,
+ Include: "$(BUILD_SYSTEM)/soong_cc_prebuilt.mk",
Extra: []android.AndroidMkExtraFunc{
func(w io.Writer, outputFile android.Path) {
if len(c.Properties.Logtags) > 0 {
fmt.Fprintln(w, "LOCAL_LOGTAGS_FILES :=", strings.Join(c.Properties.Logtags, " "))
}
- fmt.Fprintln(w, "LOCAL_SANITIZE := never")
if len(c.Properties.AndroidMkSharedLibs) > 0 {
fmt.Fprintln(w, "LOCAL_SHARED_LIBRARIES := "+strings.Join(c.Properties.AndroidMkSharedLibs, " "))
}
- if c.Target().Os == android.Android &&
- String(c.Properties.Sdk_version) != "" && !c.useVndk() && !c.inRecovery() {
- fmt.Fprintln(w, "LOCAL_SDK_VERSION := "+String(c.Properties.Sdk_version))
- fmt.Fprintln(w, "LOCAL_NDK_STL_VARIANT := none")
- } else {
- // These are already included in LOCAL_SHARED_LIBRARIES
- fmt.Fprintln(w, "LOCAL_CXX_STL := none")
- }
+ fmt.Fprintln(w, "LOCAL_SOONG_LINK_TYPE :=", c.getMakeLinkType())
if c.useVndk() {
fmt.Fprintln(w, "LOCAL_USE_VNDK := true")
}
@@ -140,44 +133,13 @@
if library.static() {
ret.Class = "STATIC_LIBRARIES"
} else if library.shared() {
- ctx.subAndroidMk(ret, &library.stripper)
-
ret.Class = "SHARED_LIBRARIES"
+ ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
+ fmt.Fprintln(w, "LOCAL_SOONG_TOC :=", library.toc().String())
+ fmt.Fprintln(w, "LOCAL_SOONG_UNSTRIPPED_BINARY :=", library.unstrippedOutputFile.String())
+ })
} else if library.header() {
- ret.Custom = func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) {
- fmt.Fprintln(w, "\ninclude $(CLEAR_VARS)")
- fmt.Fprintln(w, "LOCAL_PATH :=", moduleDir)
- fmt.Fprintln(w, "LOCAL_MODULE :=", name+data.SubName)
-
- archStr := ctx.Target().Arch.ArchType.String()
- var host bool
- switch ctx.Target().Os.Class {
- case android.Host:
- fmt.Fprintln(w, "LOCAL_MODULE_HOST_ARCH := ", archStr)
- host = true
- case android.HostCross:
- fmt.Fprintln(w, "LOCAL_MODULE_HOST_CROSS_ARCH := ", archStr)
- host = true
- case android.Device:
- fmt.Fprintln(w, "LOCAL_MODULE_TARGET_ARCH := ", archStr)
- }
-
- if host {
- makeOs := ctx.Target().Os.String()
- if ctx.Target().Os == android.Linux || ctx.Target().Os == android.LinuxBionic {
- makeOs = "linux"
- }
- fmt.Fprintln(w, "LOCAL_MODULE_HOST_OS :=", makeOs)
- fmt.Fprintln(w, "LOCAL_IS_HOST_MODULE := true")
- } else if ctx.useVndk() {
- fmt.Fprintln(w, "LOCAL_USE_VNDK := true")
- }
-
- library.androidMkWriteExportedFlags(w)
- fmt.Fprintln(w, "include $(BUILD_HEADER_LIBRARY)")
- }
-
- return
+ ret.Class = "HEADER_LIBRARIES"
}
ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
@@ -195,8 +157,6 @@
fmt.Fprintln(w, "LOCAL_BUILT_MODULE_STEM := $(LOCAL_MODULE)"+ext)
- fmt.Fprintln(w, "LOCAL_SYSTEM_SHARED_LIBRARIES :=")
-
if library.coverageOutputFile.Valid() {
fmt.Fprintln(w, "LOCAL_PREBUILT_COVERAGE_ARCHIVE :=", library.coverageOutputFile.String())
}
@@ -204,29 +164,29 @@
if library.shared() {
ctx.subAndroidMk(ret, library.baseInstaller)
+ } else {
+ ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
+ fmt.Fprintln(w, "LOCAL_UNINSTALLABLE_MODULE := true")
+ })
}
}
func (object *objectLinker) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) {
ret.Custom = func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) {
out := ret.OutputFile.Path()
+ varname := fmt.Sprintf("SOONG_%sOBJECT_%s%s", prefix, name, data.SubName)
- fmt.Fprintln(w, "\n$("+prefix+"OUT_INTERMEDIATE_LIBRARIES)/"+name+data.SubName+objectExtension+":", out.String())
- fmt.Fprintln(w, "\t$(copy-file-to-target)")
+ fmt.Fprintf(w, "\n%s := %s\n", varname, out.String())
+ fmt.Fprintln(w, ".KATI_READONLY: "+varname)
}
}
func (binary *binaryDecorator) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) {
ctx.subAndroidMk(ret, binary.baseInstaller)
- ctx.subAndroidMk(ret, &binary.stripper)
ret.Class = "EXECUTABLES"
ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
- fmt.Fprintln(w, "LOCAL_SYSTEM_SHARED_LIBRARIES :=")
- if Bool(binary.Properties.Static_executable) {
- fmt.Fprintln(w, "LOCAL_FORCE_STATIC_EXECUTABLE := true")
- }
-
+ fmt.Fprintln(w, "LOCAL_SOONG_UNSTRIPPED_BINARY :=", binary.unstrippedOutputFile.String())
if len(binary.symlinks) > 0 {
fmt.Fprintln(w, "LOCAL_MODULE_SYMLINKS := "+strings.Join(binary.symlinks, " "))
}
@@ -287,25 +247,6 @@
ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
_, suffix, _ := splitFileExt(outputFile.Base())
fmt.Fprintln(w, "LOCAL_MODULE_SUFFIX := "+suffix)
- fmt.Fprintln(w, "LOCAL_SYSTEM_SHARED_LIBRARIES :=")
- })
-}
-
-func (stripper *stripper) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) {
- // Make only supports stripping target modules
- if ctx.Target().Os != android.Android {
- return
- }
-
- ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
- if Bool(stripper.StripProperties.Strip.None) {
-
- fmt.Fprintln(w, "LOCAL_STRIP_MODULE := false")
- } else if Bool(stripper.StripProperties.Strip.Keep_symbols) {
- fmt.Fprintln(w, "LOCAL_STRIP_MODULE := keep_symbols")
- } else {
- fmt.Fprintln(w, "LOCAL_STRIP_MODULE := mini-debug-info")
- }
})
}
@@ -333,16 +274,10 @@
ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
path, file := filepath.Split(c.installPath.String())
stem, suffix, _ := splitFileExt(file)
- fmt.Fprintln(w, "LOCAL_SYSTEM_SHARED_LIBRARIES :=")
fmt.Fprintln(w, "LOCAL_MODULE_SUFFIX := "+suffix)
fmt.Fprintln(w, "LOCAL_MODULE_PATH := "+path)
fmt.Fprintln(w, "LOCAL_MODULE_STEM := "+stem)
fmt.Fprintln(w, "LOCAL_NO_NOTICE_FILE := true")
-
- // Prevent make from installing the libraries to obj/lib (since we have
- // dozens of libraries with the same name, they'll clobber each other
- // and the real versions of the libraries from the platform).
- fmt.Fprintln(w, "LOCAL_COPY_TO_INTERMEDIATE_LIBRARIES := false")
})
}
@@ -355,11 +290,9 @@
_, _, ext := splitFileExt(outputFile.Base())
fmt.Fprintln(w, "LOCAL_BUILT_MODULE_STEM := $(LOCAL_MODULE)"+ext)
- fmt.Fprintln(w, "LOCAL_STRIP_MODULE := false")
- fmt.Fprintln(w, "LOCAL_SYSTEM_SHARED_LIBRARIES :=")
fmt.Fprintln(w, "LOCAL_UNINSTALLABLE_MODULE := true")
fmt.Fprintln(w, "LOCAL_NO_NOTICE_FILE := true")
- fmt.Fprintln(w, "LOCAL_USE_VNDK := true")
+ fmt.Fprintln(w, "LOCAL_SOONG_TOC :=", c.toc().String())
})
}
@@ -374,9 +307,6 @@
path := c.path.RelPathString()
dir, file := filepath.Split(path)
stem, suffix, ext := splitFileExt(file)
- fmt.Fprintln(w, "LOCAL_STRIP_MODULE := false")
- fmt.Fprintln(w, "LOCAL_SYSTEM_SHARED_LIBRARIES :=")
- fmt.Fprintln(w, "LOCAL_USE_VNDK := true")
fmt.Fprintln(w, "LOCAL_BUILT_MODULE_STEM := $(LOCAL_MODULE)"+ext)
fmt.Fprintln(w, "LOCAL_MODULE_SUFFIX := "+suffix)
fmt.Fprintln(w, "LOCAL_MODULE_PATH := $(OUT_DIR)/"+filepath.Clean(dir))
@@ -386,13 +316,6 @@
func (c *ndkPrebuiltStlLinker) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) {
ret.Class = "SHARED_LIBRARIES"
-
- ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
- // Prevent make from installing the libraries to obj/lib (since we have
- // dozens of libraries with the same name, they'll clobber each other
- // and the real versions of the libraries from the platform).
- fmt.Fprintln(w, "LOCAL_COPY_TO_INTERMEDIATE_LIBRARIES := false")
- })
}
func (c *vendorPublicLibraryStubDecorator) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) {
@@ -404,8 +327,6 @@
_, _, ext := splitFileExt(outputFile.Base())
fmt.Fprintln(w, "LOCAL_BUILT_MODULE_STEM := $(LOCAL_MODULE)"+ext)
- fmt.Fprintln(w, "LOCAL_STRIP_MODULE := false")
- fmt.Fprintln(w, "LOCAL_SYSTEM_SHARED_LIBRARIES :=")
fmt.Fprintln(w, "LOCAL_UNINSTALLABLE_MODULE := true")
fmt.Fprintln(w, "LOCAL_NO_NOTICE_FILE := true")
})
diff --git a/cc/binary.go b/cc/binary.go
index be79032..07d503b 100644
--- a/cc/binary.go
+++ b/cc/binary.go
@@ -78,6 +78,9 @@
toolPath android.OptionalPath
+ // Location of the linked, unstripped binary
+ unstrippedOutputFile android.Path
+
// Names of symlinks to be installed for use in LOCAL_MODULE_SYMLINKS
symlinks []string
@@ -205,7 +208,7 @@
func (binary *binaryDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags {
flags = binary.baseLinker.linkerFlags(ctx, flags)
- if ctx.Host() && !binary.static() {
+ if ctx.Host() && !ctx.Windows() && !binary.static() {
if !ctx.Config().IsEnvTrue("DISABLE_HOST_PIE") {
flags.LdFlags = append(flags.LdFlags, "-pie")
}
@@ -306,6 +309,8 @@
binary.stripper.strip(ctx, outputFile, strippedOutputFile, builderFlags)
}
+ binary.unstrippedOutputFile = outputFile
+
if String(binary.Properties.Prefix_symbols) != "" {
afterPrefixSymbols := outputFile
outputFile = android.PathForModuleOut(ctx, "unprefixed", fileName)
diff --git a/cc/builder.go b/cc/builder.go
index be63fd7..58196f4 100644
--- a/cc/builder.go
+++ b/cc/builder.go
@@ -144,11 +144,11 @@
blueprint.RuleParams{
Depfile: "${out}.d",
Deps: blueprint.DepsGCC,
- Command: "CROSS_COMPILE=$crossCompile $tocPath -i ${in} -o ${out} -d ${out}.d",
+ Command: "CROSS_COMPILE=$crossCompile $tocPath $format -i ${in} -o ${out} -d ${out}.d",
CommandDeps: []string{"$tocPath"},
Restat: true,
},
- "crossCompile")
+ "crossCompile", "format")
clangTidy = pctx.AndroidStaticRule("clangTidy",
blueprint.RuleParams{
@@ -759,7 +759,18 @@
func TransformSharedObjectToToc(ctx android.ModuleContext, inputFile android.Path,
outputFile android.WritablePath, flags builderFlags) {
- crossCompile := gccCmd(flags.toolchain, "")
+ var format string
+ var crossCompile string
+ if ctx.Darwin() {
+ format = "--macho"
+ crossCompile = "${config.MacToolPath}"
+ } else if ctx.Windows() {
+ format = "--pe"
+ crossCompile = gccCmd(flags.toolchain, "")
+ } else {
+ format = "--elf"
+ crossCompile = gccCmd(flags.toolchain, "")
+ }
ctx.Build(pctx, android.BuildParams{
Rule: toc,
@@ -768,6 +779,7 @@
Input: inputFile,
Args: map[string]string{
"crossCompile": crossCompile,
+ "format": format,
},
})
}
diff --git a/cc/cc.go b/cc/cc.go
index 2d967ed..d31a38a 100644
--- a/cc/cc.go
+++ b/cc/cc.go
@@ -366,6 +366,10 @@
staticVariant *Module
}
+func (c *Module) OutputFile() android.OptionalPath {
+ return c.outputFile
+}
+
func (c *Module) Init() android.Module {
c.AddProperties(&c.Properties, &c.VendorProperties)
if c.compiler != nil {
@@ -1089,10 +1093,6 @@
ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
}
- if !c.toolchain(ctx).ClangSupported() {
- panic("GCC is no longer supported")
- }
-
return !c.Properties.Gcc
}
@@ -1181,7 +1181,7 @@
// We can be permissive with the system "STL" since it is only the C++
// ABI layer, but in the future we should make sure that everyone is
// using either libc++ or nothing.
- } else if getNdkStlFamily(ctx, from) != getNdkStlFamily(ctx, to) {
+ } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
from.stl.Properties.SelectedStl, ctx.OtherModuleName(to),
to.stl.Properties.SelectedStl)
@@ -1491,6 +1491,29 @@
return false
}
+func (c *Module) getMakeLinkType() string {
+ if c.useVndk() {
+ if inList(c.Name(), vndkCoreLibraries) || inList(c.Name(), vndkSpLibraries) || inList(c.Name(), llndkLibraries) {
+ if inList(c.Name(), vndkPrivateLibraries) {
+ return "native:vndk_private"
+ } else {
+ return "native:vndk"
+ }
+ } else {
+ return "native:vendor"
+ }
+ } else if c.inRecovery() {
+ return "native:recovery"
+ } else if c.Target().Os == android.Android && String(c.Properties.Sdk_version) != "" {
+ return "native:ndk:none:none"
+ // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
+ //family, link := getNdkStlFamilyAndLinkType(c)
+ //return fmt.Sprintf("native:ndk:%s:%s", family, link)
+ } else {
+ return "native:platform"
+ }
+}
+
//
// Defaults
//
diff --git a/cc/compiler.go b/cc/compiler.go
index f3cf040..5ef9e4e 100644
--- a/cc/compiler.go
+++ b/cc/compiler.go
@@ -444,16 +444,6 @@
cppStd = strings.Replace(String(compiler.Properties.Cpp_std), "17", "1z", 1)
}
- if !flags.Clang {
- // GCC uses an invalid C++14 ABI (emits calls to
- // __cxa_throw_bad_array_length, which is not a valid C++ RT ABI).
- // http://b/25022512
- // The host GCC doesn't support C++14 (and is deprecated, so likely
- // never will).
- // Build these modules with C++11.
- cppStd = config.GccCppStdVersion
- }
-
if compiler.Properties.Gnu_extensions != nil && *compiler.Properties.Gnu_extensions == false {
cStd = gnuToCReplacer.Replace(cStd)
cppStd = gnuToCReplacer.Replace(cppStd)
diff --git a/cc/config/arm64_device.go b/cc/config/arm64_device.go
index 6fdd524..12e9114 100644
--- a/cc/config/arm64_device.go
+++ b/cc/config/arm64_device.go
@@ -86,6 +86,7 @@
"armv8_2a",
"cortex-a53",
"cortex-a55",
+ "cortex-a72",
"cortex-a73",
"cortex-a75",
"kryo",
@@ -146,6 +147,7 @@
"": "",
"cortex-a53": "${config.Arm64CortexA53Cflags}",
"cortex-a55": "${config.Arm64CortexA55Cflags}",
+ "cortex-a72": "${config.Arm64CortexA53Cflags}",
"cortex-a73": "${config.Arm64CortexA53Cflags}",
"cortex-a75": "${config.Arm64CortexA55Cflags}",
"kryo": "${config.Arm64KryoCflags}",
@@ -162,6 +164,7 @@
"": "",
"cortex-a53": "${config.Arm64ClangCortexA53Cflags}",
"cortex-a55": "${config.Arm64ClangCortexA55Cflags}",
+ "cortex-a72": "${config.Arm64ClangCortexA53Cflags}",
"cortex-a73": "${config.Arm64ClangCortexA53Cflags}",
"cortex-a75": "${config.Arm64ClangCortexA55Cflags}",
"kryo": "${config.Arm64ClangKryoCflags}",
@@ -257,7 +260,7 @@
var extraLdflags string
switch arch.CpuVariant {
- case "cortex-a53", "cortex-a73", "kryo", "exynos-m1", "exynos-m2",
+ case "cortex-a53", "cortex-a72", "cortex-a73", "kryo", "exynos-m1", "exynos-m2",
// This variant might not need the workaround but leave it
// in the list since it has had the workaround on before.
"denver64":
diff --git a/cc/config/arm_device.go b/cc/config/arm_device.go
index 4135179..c1c2c7b 100644
--- a/cc/config/arm_device.go
+++ b/cc/config/arm_device.go
@@ -162,6 +162,7 @@
"cortex-a53",
"cortex-a53-a57",
"cortex-a55",
+ "cortex-a72",
"cortex-a73",
"cortex-a75",
"krait",
@@ -269,6 +270,7 @@
"cortex-a53": "${config.ArmCortexA53Cflags}",
"cortex-a53.a57": "${config.ArmCortexA53Cflags}",
"cortex-a55": "${config.ArmCortexA55Cflags}",
+ "cortex-a72": "${config.ArmCortexA53Cflags}",
"cortex-a73": "${config.ArmCortexA53Cflags}",
"cortex-a75": "${config.ArmCortexA55Cflags}",
"krait": "${config.ArmKraitCflags}",
@@ -292,6 +294,7 @@
"cortex-a53": "${config.ArmClangCortexA53Cflags}",
"cortex-a53.a57": "${config.ArmClangCortexA53Cflags}",
"cortex-a55": "${config.ArmClangCortexA55Cflags}",
+ "cortex-a72": "${config.ArmClangCortexA53Cflags}",
"cortex-a73": "${config.ArmClangCortexA53Cflags}",
"cortex-a75": "${config.ArmClangCortexA55Cflags}",
"krait": "${config.ArmClangKraitCflags}",
diff --git a/cc/config/global.go b/cc/config/global.go
index 8b02f02..000aab6 100644
--- a/cc/config/global.go
+++ b/cc/config/global.go
@@ -119,7 +119,6 @@
CStdVersion = "gnu99"
CppStdVersion = "gnu++14"
- GccCppStdVersion = "gnu++11"
ExperimentalCStdVersion = "gnu11"
ExperimentalCppStdVersion = "gnu++1z"
diff --git a/cc/config/tidy.go b/cc/config/tidy.go
index 67f92a2..2e49c16 100644
--- a/cc/config/tidy.go
+++ b/cc/config/tidy.go
@@ -36,6 +36,7 @@
"performance*",
"-google-readability*",
"-google-runtime-references",
+ "-performance-noexcept-move-constructor",
}, ",")
})
@@ -61,20 +62,30 @@
// Give warnings to header files only in selected directories.
// Do not give warnings to external or vendor header files, which contain too
// many warnings.
- pctx.StaticVariable("TidyDefaultHeaderDirs", strings.Join([]string{
- "art/",
- "bionic/",
- "bootable/",
- "build/",
- "cts/",
- "dalvik/",
- "developers/",
- "development/",
- "frameworks/",
- "libcore/",
- "libnativehelper/",
- "system/",
- }, "|"))
+ pctx.VariableFunc("TidyDefaultHeaderDirs", func(ctx android.PackageVarContext) string {
+ if override := ctx.Config().Getenv("DEFAULT_TIDY_HEADER_DIRS"); override != "" {
+ return override
+ }
+ return strings.Join([]string{
+ "art/",
+ "bionic/",
+ "bootable/",
+ "build/",
+ "cts/",
+ "dalvik/",
+ "developers/",
+ "development/",
+ "frameworks/",
+ "libcore/",
+ "libnativehelper/",
+ "system/",
+ }, "|")
+ })
+
+ // Use WTIH_TIDY_FLAGS to pass extra global default clang-tidy flags.
+ pctx.VariableFunc("TidyWithTidyFlags", func(ctx android.PackageVarContext) string {
+ return ctx.Config().Getenv("WITH_TIDY_FLAGS")
+ })
}
type PathBasedTidyCheck struct {
diff --git a/cc/config/toolchain.go b/cc/config/toolchain.go
index fefe7c2..930b18f 100644
--- a/cc/config/toolchain.go
+++ b/cc/config/toolchain.go
@@ -57,7 +57,6 @@
IncludeFlags() string
InstructionSetFlags(string) (string, error)
- ClangSupported() bool
ClangTriple() string
ToolchainClangCflags() string
ToolchainClangLdflags() string
@@ -132,10 +131,6 @@
return ""
}
-func (toolchainBase) ClangSupported() bool {
- return true
-}
-
func (toolchainBase) ShlibSuffix() string {
return ".so"
}
diff --git a/cc/config/x86_windows_host.go b/cc/config/x86_windows_host.go
index 9003e85..65b9e6c 100644
--- a/cc/config/x86_windows_host.go
+++ b/cc/config/x86_windows_host.go
@@ -233,10 +233,6 @@
return "-F pe-x86-64"
}
-func (t *toolchainWindows) ClangSupported() bool {
- return true
-}
-
func (t *toolchainWindowsX86) ClangTriple() string {
return "i686-windows-gnu"
}
diff --git a/cc/library.go b/cc/library.go
index 7886c35..0e45af9 100644
--- a/cc/library.go
+++ b/cc/library.go
@@ -237,6 +237,9 @@
// not included in the NDK.
ndkSysrootPath android.Path
+ // Location of the linked, unstripped library for shared libraries
+ unstrippedOutputFile android.Path
+
// Decorated interafaces
*baseCompiler
*baseLinker
@@ -544,15 +547,13 @@
builderFlags := flagsToBuilderFlags(flags)
- if !ctx.Darwin() && !ctx.Windows() {
- // Optimize out relinking against shared libraries whose interface hasn't changed by
- // depending on a table of contents file instead of the library itself.
- tocPath := outputFile.RelPathString()
- tocPath = pathtools.ReplaceExtension(tocPath, flags.Toolchain.ShlibSuffix()[1:]+".toc")
- tocFile := android.PathForOutput(ctx, tocPath)
- library.tocFile = android.OptionalPathForPath(tocFile)
- TransformSharedObjectToToc(ctx, outputFile, tocFile, builderFlags)
- }
+ // Optimize out relinking against shared libraries whose interface hasn't changed by
+ // depending on a table of contents file instead of the library itself.
+ tocPath := outputFile.RelPathString()
+ tocPath = pathtools.ReplaceExtension(tocPath, flags.Toolchain.ShlibSuffix()[1:]+".toc")
+ tocFile := android.PathForOutput(ctx, tocPath)
+ library.tocFile = android.OptionalPathForPath(tocFile)
+ TransformSharedObjectToToc(ctx, outputFile, tocFile, builderFlags)
if library.stripper.needsStrip(ctx) {
// b/80093681, GNU strip/objcopy bug.
@@ -564,6 +565,8 @@
library.stripper.strip(ctx, outputFile, strippedOutputFile, builderFlags)
}
+ library.unstrippedOutputFile = outputFile
+
if Bool(library.baseLinker.Properties.Use_version_lib) && ctx.Host() {
versionedOutputFile := outputFile
outputFile = android.PathForModuleOut(ctx, "unversioned", fileName)
diff --git a/cc/llndk_library.go b/cc/llndk_library.go
index 6e64acf..c23dfd4 100644
--- a/cc/llndk_library.go
+++ b/cc/llndk_library.go
@@ -172,6 +172,7 @@
libraryDecorator: library,
}
stub.Properties.Vendor_available = BoolPtr(true)
+ module.Properties.UseVndk = true
module.compiler = stub
module.linker = stub
module.installer = nil
diff --git a/cc/makevars.go b/cc/makevars.go
index c4ef5f1..b7fb575 100644
--- a/cc/makevars.go
+++ b/cc/makevars.go
@@ -130,24 +130,28 @@
ctx.Strict("HWADDRESS_SANITIZER_CONFIG_EXTRA_CFLAGS", strings.Join(hwasanCflags, " "))
ctx.Strict("CFI_EXTRA_CFLAGS", strings.Join(cfiCflags, " "))
+ ctx.Strict("CFI_EXTRA_ASFLAGS", strings.Join(cfiAsflags, " "))
ctx.Strict("CFI_EXTRA_LDFLAGS", strings.Join(cfiLdflags, " "))
ctx.Strict("INTEGER_OVERFLOW_EXTRA_CFLAGS", strings.Join(intOverflowCflags, " "))
ctx.Strict("DEFAULT_C_STD_VERSION", config.CStdVersion)
ctx.Strict("DEFAULT_CPP_STD_VERSION", config.CppStdVersion)
- ctx.Strict("DEFAULT_GCC_CPP_STD_VERSION", config.GccCppStdVersion)
ctx.Strict("EXPERIMENTAL_C_STD_VERSION", config.ExperimentalCStdVersion)
ctx.Strict("EXPERIMENTAL_CPP_STD_VERSION", config.ExperimentalCppStdVersion)
ctx.Strict("DEFAULT_GLOBAL_TIDY_CHECKS", "${config.TidyDefaultGlobalChecks}")
ctx.Strict("DEFAULT_LOCAL_TIDY_CHECKS", joinLocalTidyChecks(config.DefaultLocalTidyChecks))
ctx.Strict("DEFAULT_TIDY_HEADER_DIRS", "${config.TidyDefaultHeaderDirs}")
+ ctx.Strict("WITH_TIDY_FLAGS", "${config.TidyWithTidyFlags}")
ctx.Strict("AIDL_CPP", "${aidlCmd}")
ctx.Strict("RS_GLOBAL_INCLUDES", "${config.RsGlobalIncludes}")
+ ctx.Strict("SOONG_STRIP_PATH", "${stripPath}")
+ ctx.Strict("XZ", "${xzCmd}")
+
nativeHelperIncludeFlags, err := ctx.Eval("${config.CommonNativehelperInclude}")
if err != nil {
panic(err)
@@ -217,34 +221,6 @@
productExtraLdflags += "-static"
}
- ctx.Strict(makePrefix+"GLOBAL_CFLAGS", strings.Join([]string{
- toolchain.Cflags(),
- "${config.CommonGlobalCflags}",
- fmt.Sprintf("${config.%sGlobalCflags}", hod),
- toolchain.ToolchainCflags(),
- productExtraCflags,
- }, " "))
- ctx.Strict(makePrefix+"GLOBAL_CONLYFLAGS", strings.Join([]string{
- "${config.CommonGlobalConlyflags}",
- }, " "))
- ctx.Strict(makePrefix+"GLOBAL_CPPFLAGS", strings.Join([]string{
- "${config.CommonGlobalCppflags}",
- fmt.Sprintf("${config.%sGlobalCppflags}", hod),
- toolchain.Cppflags(),
- }, " "))
- ctx.Strict(makePrefix+"GLOBAL_LDFLAGS", strings.Join([]string{
- fmt.Sprintf("${config.%sGlobalLdflags}", hod),
- toolchain.Ldflags(),
- toolchain.ToolchainLdflags(),
- productExtraLdflags,
- }, " "))
- ctx.Strict(makePrefix+"GLOBAL_LLDFLAGS", strings.Join([]string{
- fmt.Sprintf("${config.%sGlobalLldflags}", hod),
- toolchain.Ldflags(),
- toolchain.ToolchainLdflags(),
- productExtraLdflags,
- }, " "))
-
includeFlags, err := ctx.Eval(toolchain.IncludeFlags())
if err != nil {
panic(err)
@@ -267,60 +243,51 @@
ctx.Strict(makePrefix+"thumb_CFLAGS", flags)
}
- if toolchain.ClangSupported() {
- clangPrefix := secondPrefix + "CLANG_" + typePrefix
- clangExtras := "-target " + toolchain.ClangTriple()
- clangExtras += " -B" + config.ToolPath(toolchain)
+ clangPrefix := secondPrefix + "CLANG_" + typePrefix
+ clangExtras := "-target " + toolchain.ClangTriple()
+ clangExtras += " -B" + config.ToolPath(toolchain)
- ctx.Strict(clangPrefix+"GLOBAL_CFLAGS", strings.Join([]string{
- toolchain.ClangCflags(),
- "${config.CommonClangGlobalCflags}",
- fmt.Sprintf("${config.%sClangGlobalCflags}", hod),
- toolchain.ToolchainClangCflags(),
- clangExtras,
- productExtraCflags,
- }, " "))
- ctx.Strict(clangPrefix+"GLOBAL_CPPFLAGS", strings.Join([]string{
- "${config.CommonClangGlobalCppflags}",
- fmt.Sprintf("${config.%sGlobalCppflags}", hod),
- toolchain.ClangCppflags(),
- }, " "))
- ctx.Strict(clangPrefix+"GLOBAL_LDFLAGS", strings.Join([]string{
- fmt.Sprintf("${config.%sGlobalLdflags}", hod),
- toolchain.ClangLdflags(),
- toolchain.ToolchainClangLdflags(),
- productExtraLdflags,
- clangExtras,
- }, " "))
- ctx.Strict(clangPrefix+"GLOBAL_LLDFLAGS", strings.Join([]string{
- fmt.Sprintf("${config.%sGlobalLldflags}", hod),
- toolchain.ClangLldflags(),
- toolchain.ToolchainClangLdflags(),
- productExtraLdflags,
- clangExtras,
- }, " "))
+ ctx.Strict(clangPrefix+"GLOBAL_CFLAGS", strings.Join([]string{
+ toolchain.ClangCflags(),
+ "${config.CommonClangGlobalCflags}",
+ fmt.Sprintf("${config.%sClangGlobalCflags}", hod),
+ toolchain.ToolchainClangCflags(),
+ clangExtras,
+ productExtraCflags,
+ }, " "))
+ ctx.Strict(clangPrefix+"GLOBAL_CPPFLAGS", strings.Join([]string{
+ "${config.CommonClangGlobalCppflags}",
+ fmt.Sprintf("${config.%sGlobalCppflags}", hod),
+ toolchain.ClangCppflags(),
+ }, " "))
+ ctx.Strict(clangPrefix+"GLOBAL_LDFLAGS", strings.Join([]string{
+ fmt.Sprintf("${config.%sGlobalLdflags}", hod),
+ toolchain.ClangLdflags(),
+ toolchain.ToolchainClangLdflags(),
+ productExtraLdflags,
+ clangExtras,
+ }, " "))
+ ctx.Strict(clangPrefix+"GLOBAL_LLDFLAGS", strings.Join([]string{
+ fmt.Sprintf("${config.%sGlobalLldflags}", hod),
+ toolchain.ClangLldflags(),
+ toolchain.ToolchainClangLdflags(),
+ productExtraLdflags,
+ clangExtras,
+ }, " "))
- if target.Os.Class == android.Device {
- ctx.Strict(secondPrefix+"ADDRESS_SANITIZER_RUNTIME_LIBRARY", strings.TrimSuffix(config.AddressSanitizerRuntimeLibrary(toolchain), ".so"))
- ctx.Strict(secondPrefix+"HWADDRESS_SANITIZER_RUNTIME_LIBRARY", strings.TrimSuffix(config.HWAddressSanitizerRuntimeLibrary(toolchain), ".so"))
- ctx.Strict(secondPrefix+"HWADDRESS_SANITIZER_STATIC_LIBRARY", strings.TrimSuffix(config.HWAddressSanitizerStaticLibrary(toolchain), ".a"))
- ctx.Strict(secondPrefix+"UBSAN_RUNTIME_LIBRARY", strings.TrimSuffix(config.UndefinedBehaviorSanitizerRuntimeLibrary(toolchain), ".so"))
- ctx.Strict(secondPrefix+"UBSAN_MINIMAL_RUNTIME_LIBRARY", strings.TrimSuffix(config.UndefinedBehaviorSanitizerMinimalRuntimeLibrary(toolchain), ".a"))
- ctx.Strict(secondPrefix+"TSAN_RUNTIME_LIBRARY", strings.TrimSuffix(config.ThreadSanitizerRuntimeLibrary(toolchain), ".so"))
- ctx.Strict(secondPrefix+"SCUDO_RUNTIME_LIBRARY", strings.TrimSuffix(config.ScudoRuntimeLibrary(toolchain), ".so"))
- }
-
- // This is used by external/gentoo/...
- ctx.Strict("CLANG_CONFIG_"+target.Arch.ArchType.Name+"_"+typePrefix+"TRIPLE",
- toolchain.ClangTriple())
-
- ctx.Strict(makePrefix+"CLANG_SUPPORTED", "true")
- } else {
- ctx.Strict(makePrefix+"CLANG_SUPPORTED", "")
+ if target.Os.Class == android.Device {
+ ctx.Strict(secondPrefix+"ADDRESS_SANITIZER_RUNTIME_LIBRARY", strings.TrimSuffix(config.AddressSanitizerRuntimeLibrary(toolchain), ".so"))
+ ctx.Strict(secondPrefix+"HWADDRESS_SANITIZER_RUNTIME_LIBRARY", strings.TrimSuffix(config.HWAddressSanitizerRuntimeLibrary(toolchain), ".so"))
+ ctx.Strict(secondPrefix+"HWADDRESS_SANITIZER_STATIC_LIBRARY", strings.TrimSuffix(config.HWAddressSanitizerStaticLibrary(toolchain), ".a"))
+ ctx.Strict(secondPrefix+"UBSAN_RUNTIME_LIBRARY", strings.TrimSuffix(config.UndefinedBehaviorSanitizerRuntimeLibrary(toolchain), ".so"))
+ ctx.Strict(secondPrefix+"UBSAN_MINIMAL_RUNTIME_LIBRARY", strings.TrimSuffix(config.UndefinedBehaviorSanitizerMinimalRuntimeLibrary(toolchain), ".a"))
+ ctx.Strict(secondPrefix+"TSAN_RUNTIME_LIBRARY", strings.TrimSuffix(config.ThreadSanitizerRuntimeLibrary(toolchain), ".so"))
+ ctx.Strict(secondPrefix+"SCUDO_RUNTIME_LIBRARY", strings.TrimSuffix(config.ScudoRuntimeLibrary(toolchain), ".so"))
}
- ctx.Strict(makePrefix+"CC", gccCmd(toolchain, "gcc"))
- ctx.Strict(makePrefix+"CXX", gccCmd(toolchain, "g++"))
+ // This is used by external/gentoo/...
+ ctx.Strict("CLANG_CONFIG_"+target.Arch.ArchType.Name+"_"+typePrefix+"TRIPLE",
+ toolchain.ClangTriple())
if target.Os == android.Darwin {
ctx.Strict(makePrefix+"AR", "${config.MacArPath}")
diff --git a/cc/ndk_library.go b/cc/ndk_library.go
index 3bffacd..2709a89 100644
--- a/cc/ndk_library.go
+++ b/cc/ndk_library.go
@@ -39,6 +39,7 @@
ndkPrebuiltSharedLibs = []string{
"android",
+ "binder_ndk",
"c",
"dl",
"EGL",
diff --git a/cc/prebuilt.go b/cc/prebuilt.go
index ff8a878..47994a8 100644
--- a/cc/prebuilt.go
+++ b/cc/prebuilt.go
@@ -76,8 +76,28 @@
p.libraryDecorator.exportIncludes(ctx, "-I")
p.libraryDecorator.reexportFlags(deps.ReexportedFlags)
p.libraryDecorator.reexportDeps(deps.ReexportedFlagsDeps)
- // TODO(ccross): .toc optimization, stripping, packing
- return p.Prebuilt.SingleSourcePath(ctx)
+
+ builderFlags := flagsToBuilderFlags(flags)
+
+ in := p.Prebuilt.SingleSourcePath(ctx)
+
+ if p.shared() {
+ p.unstrippedOutputFile = in
+ libName := ctx.baseModuleName() + flags.Toolchain.ShlibSuffix()
+ if p.needsStrip(ctx) {
+ stripped := android.PathForModuleOut(ctx, "stripped", libName)
+ p.strip(ctx, in, stripped, builderFlags)
+ in = stripped
+ }
+
+ // Optimize out relinking against shared libraries whose interface hasn't changed by
+ // depending on a table of contents file instead of the library itself.
+ tocFile := android.PathForModuleOut(ctx, libName+".toc")
+ p.tocFile = android.OptionalPathForPath(tocFile)
+ TransformSharedObjectToToc(ctx, in, tocFile, builderFlags)
+ }
+
+ return in
}
return nil
@@ -136,17 +156,26 @@
flags Flags, deps PathDeps, objs Objects) android.Path {
// TODO(ccross): verify shared library dependencies
if len(p.properties.Srcs) > 0 {
- // TODO(ccross): .toc optimization, stripping, packing
+ builderFlags := flagsToBuilderFlags(flags)
+
+ fileName := p.getStem(ctx) + flags.Toolchain.ExecutableSuffix()
+ in := p.Prebuilt.SingleSourcePath(ctx)
+
+ p.unstrippedOutputFile = in
+
+ if p.needsStrip(ctx) {
+ stripped := android.PathForModuleOut(ctx, "stripped", fileName)
+ p.strip(ctx, in, stripped, builderFlags)
+ in = stripped
+ }
// Copy binaries to a name matching the final installed name
- fileName := p.getStem(ctx) + flags.Toolchain.ExecutableSuffix()
outputFile := android.PathForModuleOut(ctx, fileName)
-
ctx.Build(pctx, android.BuildParams{
Rule: android.CpExecutable,
Description: "prebuilt",
Output: outputFile,
- Input: p.Prebuilt.SingleSourcePath(ctx),
+ Input: in,
})
return outputFile
diff --git a/cc/sanitize.go b/cc/sanitize.go
index a522a60..b2fc63f 100644
--- a/cc/sanitize.go
+++ b/cc/sanitize.go
@@ -40,6 +40,9 @@
cfiCflags = []string{"-flto", "-fsanitize-cfi-cross-dso",
"-fsanitize-blacklist=external/compiler-rt/lib/cfi/cfi_blacklist.txt"}
+ // -flto and -fvisibility are required by clang when -fsanitize=cfi is
+ // used, but have no effect on assembly files
+ cfiAsflags = []string{"-flto", "-fvisibility=default"}
cfiLdflags = []string{"-flto", "-fsanitize-cfi-cross-dso", "-fsanitize=cfi",
"-Wl,-plugin-opt,O1"}
cfiExportsMapPath = "build/soong/cc/config/cfi_exports.map"
@@ -460,6 +463,7 @@
sanitizers = append(sanitizers, "cfi")
flags.CFlags = append(flags.CFlags, cfiCflags...)
+ flags.AsFlags = append(flags.AsFlags, cfiAsflags...)
// Only append the default visibility flag if -fvisibility has not already been set
// to hidden.
if !inList("-fvisibility=hidden", flags.CFlags) {
@@ -495,6 +499,7 @@
sanitizeArg := "-fsanitize=" + strings.Join(sanitizers, ",")
flags.CFlags = append(flags.CFlags, sanitizeArg)
+ flags.AsFlags = append(flags.AsFlags, sanitizeArg)
if ctx.Host() {
flags.CFlags = append(flags.CFlags, "-fno-sanitize-recover=all")
flags.LdFlags = append(flags.LdFlags, sanitizeArg)
diff --git a/cc/stl.go b/cc/stl.go
index 6f63835..f44902e 100644
--- a/cc/stl.go
+++ b/cc/stl.go
@@ -19,18 +19,24 @@
"fmt"
)
-func getNdkStlFamily(ctx android.ModuleContext, m *Module) string {
+func getNdkStlFamily(m *Module) string {
+ family, _ := getNdkStlFamilyAndLinkType(m)
+ return family
+}
+
+func getNdkStlFamilyAndLinkType(m *Module) (string, string) {
stl := m.stl.Properties.SelectedStl
switch stl {
- case "ndk_libc++_shared", "ndk_libc++_static":
- return "libc++"
+ case "ndk_libc++_shared":
+ return "libc++", "shared"
+ case "ndk_libc++_static":
+ return "libc++", "static"
case "ndk_system":
- return "system"
+ return "system", "shared"
case "":
- return "none"
+ return "none", "none"
default:
- ctx.ModuleErrorf("stl: %q is not a valid STL", stl)
- return ""
+ panic(fmt.Errorf("stl: %q is not a valid STL", stl))
}
}
@@ -207,10 +213,9 @@
hostDynamicGccLibs = map[android.OsType][]string{
android.Linux: []string{"-lgcc_s", "-lgcc", "-lc", "-lgcc_s", "-lgcc"},
android.Darwin: []string{"-lc", "-lSystem"},
- android.Windows: []string{"-lmsvcr110", "-lmingw32", "-lgcc", "-lmoldname",
- "-lmingwex", "-lmsvcrt", "-ladvapi32", "-lshell32", "-luser32",
- "-lkernel32", "-lmingw32", "-lgcc", "-lmoldname", "-lmingwex",
- "-lmsvcrt"},
+ android.Windows: []string{"-lmingw32", "-lgcc", "-lmoldname", "-lmingwex", "-lmsvcr110",
+ "-lmsvcrt", "-ladvapi32", "-lshell32", "-luser32", "-lkernel32", "-lmingw32",
+ "-lgcc", "-lmoldname", "-lmingwex", "-lmsvcrt"},
}
hostStaticGccLibs = map[android.OsType][]string{
android.Linux: []string{"-Wl,--start-group", "-lgcc", "-lgcc_eh", "-lc", "-Wl,--end-group"},
diff --git a/cc/strip.go b/cc/strip.go
index a7c2d4e..02397f4 100644
--- a/cc/strip.go
+++ b/cc/strip.go
@@ -21,6 +21,7 @@
type StripProperties struct {
Strip struct {
None *bool
+ All *bool
Keep_symbols *bool
}
}
@@ -30,17 +31,23 @@
}
func (stripper *stripper) needsStrip(ctx ModuleContext) bool {
- return !ctx.Config().EmbeddedInMake() && !Bool(stripper.StripProperties.Strip.None)
+ // TODO(ccross): enable host stripping when embedded in make? Make never had support for stripping host binaries.
+ return (!ctx.Config().EmbeddedInMake() || ctx.Device()) && !Bool(stripper.StripProperties.Strip.None)
}
-func (stripper *stripper) strip(ctx ModuleContext, in, out android.ModuleOutPath,
+func (stripper *stripper) strip(ctx ModuleContext, in android.Path, out android.ModuleOutPath,
flags builderFlags) {
if ctx.Darwin() {
TransformDarwinStrip(ctx, in, out)
} else {
- flags.stripKeepSymbols = Bool(stripper.StripProperties.Strip.Keep_symbols)
- // TODO(ccross): don't add gnu debuglink for user builds
- flags.stripAddGnuDebuglink = true
+ if Bool(stripper.StripProperties.Strip.Keep_symbols) {
+ flags.stripKeepSymbols = true
+ } else if !Bool(stripper.StripProperties.Strip.All) {
+ flags.stripKeepMiniDebugInfo = true
+ }
+ if ctx.Config().Debuggable() && !flags.stripKeepMiniDebugInfo {
+ flags.stripAddGnuDebuglink = true
+ }
TransformStrip(ctx, in, out, flags)
}
}
diff --git a/cc/tidy.go b/cc/tidy.go
index 491cc22..0a6b413 100644
--- a/cc/tidy.go
+++ b/cc/tidy.go
@@ -69,9 +69,14 @@
flags.Tidy = true
+ // Add global WITH_TIDY_FLAGS and local tidy_flags.
+ withTidyFlags := ctx.Config().Getenv("WITH_TIDY_FLAGS")
+ if len(withTidyFlags) > 0 {
+ flags.TidyFlags = append(flags.TidyFlags, withTidyFlags)
+ }
esc := proptools.NinjaAndShellEscape
-
flags.TidyFlags = append(flags.TidyFlags, esc(tidy.Properties.Tidy_flags)...)
+ // If TidyFlags is empty, add default header filter.
if len(flags.TidyFlags) == 0 {
headerFilter := "-header-filter=\"(" + ctx.ModuleDir() + "|${config.TidyDefaultHeaderDirs})\""
flags.TidyFlags = append(flags.TidyFlags, headerFilter)
diff --git a/cc/vndk_prebuilt.go b/cc/vndk_prebuilt.go
index 849bb3f..2d7274d 100644
--- a/cc/vndk_prebuilt.go
+++ b/cc/vndk_prebuilt.go
@@ -149,6 +149,7 @@
module.stl = nil
module.sanitize = nil
library.StripProperties.Strip.None = BoolPtr(true)
+ module.Properties.UseVndk = true
prebuilt := &vndkPrebuiltLibraryDecorator{
libraryDecorator: library,
diff --git a/genrule/genrule.go b/genrule/genrule.go
index 8fedc60..e3823c5 100644
--- a/genrule/genrule.go
+++ b/genrule/genrule.go
@@ -344,6 +344,17 @@
g.outputDeps = append(g.outputDeps, task.out[0])
}
+// Collect information for opening IDE project files in java/jdeps.go.
+func (g *Module) IDEInfo(dpInfo *android.IdeInfo) {
+ dpInfo.Srcs = append(dpInfo.Srcs, g.Srcs().Strings()...)
+ for _, src := range g.properties.Srcs {
+ if strings.HasPrefix(src, ":") {
+ src = strings.Trim(src, ":")
+ dpInfo.Deps = append(dpInfo.Deps, src)
+ }
+ }
+}
+
func generatorFactory(taskGenerator taskFunc, props ...interface{}) *Module {
module := &Module{
taskGenerator: taskGenerator,
diff --git a/java/android_manifest.go b/java/android_manifest.go
index 6577475..168a22d 100644
--- a/java/android_manifest.go
+++ b/java/android_manifest.go
@@ -25,10 +25,14 @@
var manifestFixerRule = pctx.AndroidStaticRule("manifestFixer",
blueprint.RuleParams{
- Command: `${config.ManifestFixerCmd} --minSdkVersion ${minSdkVersion} $args $in $out`,
+ Command: `${config.ManifestFixerCmd} ` +
+ `--minSdkVersion ${minSdkVersion} ` +
+ `--targetSdkVersion ${targetSdkVersion} ` +
+ `--raise-min-sdk-version ` +
+ `$args $in $out`,
CommandDeps: []string{"${config.ManifestFixerCmd}"},
},
- "minSdkVersion", "args")
+ "minSdkVersion", "targetSdkVersion", "args")
var manifestMergerRule = pctx.AndroidStaticRule("manifestMerger",
blueprint.RuleParams{
@@ -53,8 +57,9 @@
Input: manifest,
Output: fixedManifest,
Args: map[string]string{
- "minSdkVersion": sdkVersionOrDefault(ctx, sdkContext.minSdkVersion()),
- "args": strings.Join(args, " "),
+ "minSdkVersion": sdkVersionOrDefault(ctx, sdkContext.minSdkVersion()),
+ "targetSdkVersion": sdkVersionOrDefault(ctx, sdkContext.sdkVersion()),
+ "args": strings.Join(args, " "),
},
})
manifest = fixedManifest
diff --git a/java/androidmk.go b/java/androidmk.go
index bd88a1d..313a144 100644
--- a/java/androidmk.go
+++ b/java/androidmk.go
@@ -319,15 +319,12 @@
Include: "$(BUILD_SYSTEM)/soong_droiddoc_prebuilt.mk",
Extra: []android.AndroidMkExtraFunc{
func(w io.Writer, outputFile android.Path) {
- if BoolDefault(ddoc.Javadoc.properties.Installable, true) {
+ if BoolDefault(ddoc.Javadoc.properties.Installable, true) && ddoc.Javadoc.docZip != nil {
fmt.Fprintln(w, "LOCAL_DROIDDOC_DOC_ZIP := ", ddoc.Javadoc.docZip.String())
}
if ddoc.Javadoc.stubsSrcJar != nil {
fmt.Fprintln(w, "LOCAL_DROIDDOC_STUBS_SRCJAR := ", ddoc.Javadoc.stubsSrcJar.String())
}
- if ddoc.annotationsZip != nil {
- fmt.Fprintln(w, "LOCAL_DROIDDOC_ANNOTATIONS_ZIP := ", ddoc.annotationsZip.String())
- }
if ddoc.checkCurrentApiTimestamp != nil {
fmt.Fprintln(w, ".PHONY:", ddoc.Name()+"-check-current-api")
fmt.Fprintln(w, ddoc.Name()+"-check-current-api:",
@@ -387,6 +384,81 @@
}
}
+func (dstubs *Droidstubs) AndroidMk() android.AndroidMkData {
+ return android.AndroidMkData{
+ Class: "JAVA_LIBRARIES",
+ OutputFile: android.OptionalPathForPath(dstubs.stubsSrcJar),
+ Include: "$(BUILD_SYSTEM)/soong_droiddoc_prebuilt.mk",
+ Extra: []android.AndroidMkExtraFunc{
+ func(w io.Writer, outputFile android.Path) {
+ if dstubs.Javadoc.stubsSrcJar != nil {
+ fmt.Fprintln(w, "LOCAL_DROIDDOC_STUBS_SRCJAR := ", dstubs.Javadoc.stubsSrcJar.String())
+ }
+ if dstubs.apiVersionsXml != nil {
+ fmt.Fprintln(w, "LOCAL_DROIDDOC_API_VERSIONS_XML := ", dstubs.apiVersionsXml.String())
+ }
+ if dstubs.annotationsZip != nil {
+ fmt.Fprintln(w, "LOCAL_DROIDDOC_ANNOTATIONS_ZIP := ", dstubs.annotationsZip.String())
+ }
+ if dstubs.jdiffDocZip != nil {
+ fmt.Fprintln(w, "LOCAL_DROIDDOC_JDIFF_DOC_ZIP := ", dstubs.jdiffDocZip.String())
+ }
+ if dstubs.checkCurrentApiTimestamp != nil {
+ fmt.Fprintln(w, ".PHONY:", dstubs.Name()+"-check-current-api")
+ fmt.Fprintln(w, dstubs.Name()+"-check-current-api:",
+ dstubs.checkCurrentApiTimestamp.String())
+
+ fmt.Fprintln(w, ".PHONY: checkapi")
+ fmt.Fprintln(w, "checkapi:",
+ dstubs.checkCurrentApiTimestamp.String())
+
+ fmt.Fprintln(w, ".PHONY: droidcore")
+ fmt.Fprintln(w, "droidcore: checkapi")
+ }
+ if dstubs.updateCurrentApiTimestamp != nil {
+ fmt.Fprintln(w, ".PHONY:", dstubs.Name()+"-update-current-api")
+ fmt.Fprintln(w, dstubs.Name()+"-update-current-api:",
+ dstubs.updateCurrentApiTimestamp.String())
+
+ fmt.Fprintln(w, ".PHONY: update-api")
+ fmt.Fprintln(w, "update-api:",
+ dstubs.updateCurrentApiTimestamp.String())
+ }
+ if dstubs.checkLastReleasedApiTimestamp != nil {
+ fmt.Fprintln(w, ".PHONY:", dstubs.Name()+"-check-last-released-api")
+ fmt.Fprintln(w, dstubs.Name()+"-check-last-released-api:",
+ dstubs.checkLastReleasedApiTimestamp.String())
+ }
+ apiFilePrefix := "INTERNAL_PLATFORM_"
+ if String(dstubs.properties.Api_tag_name) != "" {
+ apiFilePrefix += String(dstubs.properties.Api_tag_name) + "_"
+ }
+ if dstubs.apiFile != nil {
+ fmt.Fprintln(w, apiFilePrefix+"API_FILE := ", dstubs.apiFile.String())
+ }
+ if dstubs.dexApiFile != nil {
+ fmt.Fprintln(w, apiFilePrefix+"DEX_API_FILE := ", dstubs.dexApiFile.String())
+ }
+ if dstubs.privateApiFile != nil {
+ fmt.Fprintln(w, apiFilePrefix+"PRIVATE_API_FILE := ", dstubs.privateApiFile.String())
+ }
+ if dstubs.privateDexApiFile != nil {
+ fmt.Fprintln(w, apiFilePrefix+"PRIVATE_DEX_API_FILE := ", dstubs.privateDexApiFile.String())
+ }
+ if dstubs.removedApiFile != nil {
+ fmt.Fprintln(w, apiFilePrefix+"REMOVED_API_FILE := ", dstubs.removedApiFile.String())
+ }
+ if dstubs.removedDexApiFile != nil {
+ fmt.Fprintln(w, apiFilePrefix+"REMOVED_DEX_API_FILE := ", dstubs.removedDexApiFile.String())
+ }
+ if dstubs.exactApiFile != nil {
+ fmt.Fprintln(w, apiFilePrefix+"EXACT_API_FILE := ", dstubs.exactApiFile.String())
+ }
+ },
+ },
+ }
+}
+
func androidMkWriteTestData(data android.Paths, ret *android.AndroidMkData) {
var testFiles []string
for _, d := range data {
diff --git a/java/app.go b/java/app.go
index 3f72ec9..e90c388 100644
--- a/java/app.go
+++ b/java/app.go
@@ -250,6 +250,8 @@
module := &AndroidTest{}
module.Module.deviceProperties.Optimize.Enabled = proptools.BoolPtr(true)
+
+ module.Module.properties.Instrument = true
module.Module.properties.Installable = proptools.BoolPtr(true)
module.AddProperties(
diff --git a/java/app_builder.go b/java/app_builder.go
index 954ca44..e27b1b7 100644
--- a/java/app_builder.go
+++ b/java/app_builder.go
@@ -103,10 +103,10 @@
`cp ${manifest} ${outDir}/AndroidManifest.xml && ` +
`cp ${classesJar} ${outDir}/classes.jar && ` +
`cp ${rTxt} ${outDir}/R.txt && ` +
- `${config.SoongZipCmd} -jar -o $out -C ${outDir} -D ${outDir} ${resArgs}`,
+ `${config.SoongZipCmd} -jar -o $out -C ${outDir} -D ${outDir}`,
CommandDeps: []string{"${config.SoongZipCmd}"},
},
- "manifest", "classesJar", "rTxt", "resArgs", "outDir")
+ "manifest", "classesJar", "rTxt", "outDir")
func BuildAAR(ctx android.ModuleContext, outputFile android.WritablePath,
classesJar, manifest, rTxt android.Path, res android.Paths) {
diff --git a/java/builder.go b/java/builder.go
index c645ee2..07af8eb 100644
--- a/java/builder.go
+++ b/java/builder.go
@@ -24,6 +24,7 @@
"strings"
"github.com/google/blueprint"
+ "github.com/google/blueprint/proptools"
"android/soong/android"
)
@@ -61,12 +62,12 @@
kotlinc = pctx.AndroidGomaStaticRule("kotlinc",
blueprint.RuleParams{
- Command: `rm -rf "$outDir" "$srcJarDir" && mkdir -p "$outDir" "$srcJarDir" && ` +
+ Command: `rm -rf "$classesDir" "$srcJarDir" "$kotlinBuildFile" && mkdir -p "$classesDir" "$srcJarDir" && ` +
`${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` +
- `${config.GenKotlinBuildFileCmd} $classpath $outDir $out.rsp $srcJarDir/list > $outDir/kotlinc-build.xml &&` +
+ `${config.GenKotlinBuildFileCmd} $classpath $classesDir $out.rsp $srcJarDir/list > $kotlinBuildFile &&` +
`${config.KotlincCmd} $kotlincFlags ` +
- `-jvm-target $kotlinJvmTarget -Xbuild-file=$outDir/kotlinc-build.xml && ` +
- `${config.SoongZipCmd} -jar -o $out -C $outDir -D $outDir`,
+ `-jvm-target $kotlinJvmTarget -Xbuild-file=$kotlinBuildFile && ` +
+ `${config.SoongZipCmd} -jar -o $out -C $classesDir -D $classesDir`,
CommandDeps: []string{
"${config.KotlincCmd}",
"${config.KotlinCompilerJar}",
@@ -77,7 +78,7 @@
Rspfile: "$out.rsp",
RspfileContent: `$in`,
},
- "kotlincFlags", "classpath", "srcJars", "srcJarDir", "outDir", "kotlinJvmTarget")
+ "kotlincFlags", "classpath", "srcJars", "srcJarDir", "classesDir", "kotlinJvmTarget", "kotlinBuildFile")
turbine = pctx.AndroidStaticRule("turbine",
blueprint.RuleParams{
@@ -173,11 +174,12 @@
Inputs: inputs,
Implicits: deps,
Args: map[string]string{
- "classpath": flags.kotlincClasspath.FormJavaClassPath("-classpath"),
- "kotlincFlags": flags.kotlincFlags,
- "srcJars": strings.Join(srcJars.Strings(), " "),
- "outDir": android.PathForModuleOut(ctx, "kotlinc", "classes").String(),
- "srcJarDir": android.PathForModuleOut(ctx, "kotlinc", "srcJars").String(),
+ "classpath": flags.kotlincClasspath.FormJavaClassPath("-classpath"),
+ "kotlincFlags": flags.kotlincFlags,
+ "srcJars": strings.Join(srcJars.Strings(), " "),
+ "classesDir": android.PathForModuleOut(ctx, "kotlinc", "classes").String(),
+ "srcJarDir": android.PathForModuleOut(ctx, "kotlinc", "srcJars").String(),
+ "kotlinBuildFile": android.PathForModuleOut(ctx, "kotlinc-build.xml").String(),
// http://b/69160377 kotlinc only supports -jvm-target 1.6 and 1.8
"kotlinJvmTarget": "1.8",
},
@@ -319,7 +321,7 @@
Output: outputFile,
Implicits: deps,
Args: map[string]string{
- "jarArgs": strings.Join(jarArgs, " "),
+ "jarArgs": strings.Join(proptools.NinjaAndShellEscape(jarArgs), " "),
},
})
}
diff --git a/java/dex.go b/java/dex.go
index 054a176..6445940 100644
--- a/java/dex.go
+++ b/java/dex.go
@@ -42,6 +42,7 @@
`rm -f "$outDict" && ` +
`${config.R8Cmd} -injars $in --output $outDir ` +
`--force-proguard-compatibility ` +
+ `--no-data-resources ` +
`-printmapping $outDict ` +
`$dxFlags $r8Flags && ` +
`touch "$outDict" && ` +
diff --git a/java/droiddoc.go b/java/droiddoc.go
index 68d7861..bfe72f6 100644
--- a/java/droiddoc.go
+++ b/java/droiddoc.go
@@ -31,7 +31,7 @@
Command: `rm -rf "$outDir" "$srcJarDir" "$stubsDir" && mkdir -p "$outDir" "$srcJarDir" "$stubsDir" && ` +
`${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` +
`${config.JavadocCmd} -encoding UTF-8 @$out.rsp @$srcJarDir/list ` +
- `$opts $bootclasspathArgs $classpathArgs -sourcepath $sourcepath ` +
+ `$opts $bootclasspathArgs $classpathArgs $sourcepathArgs ` +
`-d $outDir -quiet && ` +
`${config.SoongZipCmd} -write_if_changed -d -o $docZip -C $outDir -D $outDir && ` +
`${config.SoongZipCmd} -write_if_changed -jar -o $out -C $stubsDir -D $stubsDir $postDoclavaCmds`,
@@ -45,7 +45,7 @@
Restat: true,
},
"outDir", "srcJarDir", "stubsDir", "srcJars", "opts",
- "bootclasspathArgs", "classpathArgs", "sourcepath", "docZip", "postDoclavaCmds")
+ "bootclasspathArgs", "classpathArgs", "sourcepathArgs", "docZip", "postDoclavaCmds")
apiCheck = pctx.AndroidStaticRule("apiCheck",
blueprint.RuleParams{
@@ -60,41 +60,39 @@
updateApi = pctx.AndroidStaticRule("updateApi",
blueprint.RuleParams{
- Command: `( ( cp -f $apiFileToCheck $apiFile && cp -f $removedApiFileToCheck $removedApiFile ) ` +
+ Command: `( ( cp -f $srcApiFile $destApiFile && cp -f $srcRemovedApiFile $destRemovedApiFile ) ` +
`&& touch $out ) || (echo failed to update public API ; exit 38)`,
},
- "apiFile", "apiFileToCheck", "removedApiFile", "removedApiFileToCheck")
+ "srcApiFile", "destApiFile", "srcRemovedApiFile", "destRemovedApiFile")
metalava = pctx.AndroidStaticRule("metalava",
blueprint.RuleParams{
- Command: `rm -rf "$outDir" "$srcJarDir" "$stubsDir" "$docStubsDir" && ` +
- `mkdir -p "$outDir" "$srcJarDir" "$stubsDir" "$docStubsDir" && ` +
+ Command: `rm -rf "$outDir" "$srcJarDir" "$stubsDir" && ` +
+ `mkdir -p "$outDir" "$srcJarDir" "$stubsDir" && ` +
`${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` +
`${config.JavaCmd} -jar ${config.MetalavaJar} -encoding UTF-8 -source $javaVersion @$out.rsp @$srcJarDir/list ` +
- `$bootclasspathArgs $classpathArgs -sourcepath $sourcepath --no-banner --color --quiet ` +
- `--stubs $stubsDir $opts && ` +
- `${config.SoongZipCmd} -write_if_changed -d -o $docZip -C $outDir -D $outDir && ` +
+ `$bootclasspathArgs $classpathArgs $sourcepathArgs --no-banner --color --quiet ` +
+ `$opts && ` +
`${config.SoongZipCmd} -write_if_changed -jar -o $out -C $stubsDir -D $stubsDir`,
CommandDeps: []string{
"${config.ZipSyncCmd}",
"${config.JavaCmd}",
"${config.MetalavaJar}",
- "${config.JavadocCmd}",
"${config.SoongZipCmd}",
},
Rspfile: "$out.rsp",
RspfileContent: "$in",
Restat: true,
},
- "outDir", "srcJarDir", "stubsDir", "docStubsDir", "srcJars", "javaVersion", "bootclasspathArgs",
- "classpathArgs", "sourcepath", "opts", "docZip")
+ "outDir", "srcJarDir", "stubsDir", "srcJars", "javaVersion", "bootclasspathArgs",
+ "classpathArgs", "sourcepathArgs", "opts")
metalavaApiCheck = pctx.AndroidStaticRule("metalavaApiCheck",
blueprint.RuleParams{
Command: `( rm -rf "$srcJarDir" && mkdir -p "$srcJarDir" && ` +
`${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` +
`${config.JavaCmd} -jar ${config.MetalavaJar} -encoding UTF-8 -source $javaVersion @$out.rsp @$srcJarDir/list ` +
- `$bootclasspathArgs $classpathArgs -sourcepath $sourcepath --no-banner --color --quiet ` +
+ `$bootclasspathArgs $classpathArgs $sourcepathArgs --no-banner --color --quiet ` +
`$opts && touch $out ) || ` +
`( echo -e "$msg" ; exit 38 )`,
CommandDeps: []string{
@@ -105,17 +103,40 @@
Rspfile: "$out.rsp",
RspfileContent: "$in",
},
- "srcJarDir", "srcJars", "javaVersion", "bootclasspathArgs", "classpathArgs", "sourcepath", "opts", "msg")
+ "srcJarDir", "srcJars", "javaVersion", "bootclasspathArgs", "classpathArgs", "sourcepathArgs", "opts", "msg")
+
+ dokka = pctx.AndroidStaticRule("dokka",
+ blueprint.RuleParams{
+ Command: `rm -rf "$outDir" "$srcJarDir" "$stubsDir" && ` +
+ `mkdir -p "$outDir" "$srcJarDir" "$stubsDir" && ` +
+ `${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` +
+ `${config.JavaCmd} -jar ${config.DokkaJar} $srcJarDir ` +
+ `$classpathArgs -format dac -dacRoot /reference/kotlin -output $outDir $opts && ` +
+ `${config.SoongZipCmd} -write_if_changed -d -o $docZip -C $outDir -D $outDir && ` +
+ `${config.SoongZipCmd} -write_if_changed -jar -o $out -C $stubsDir -D $stubsDir`,
+ CommandDeps: []string{
+ "${config.ZipSyncCmd}",
+ "${config.DokkaJar}",
+ "${config.MetalavaJar}",
+ "${config.SoongZipCmd}",
+ },
+ Restat: true,
+ },
+ "outDir", "srcJarDir", "stubsDir", "srcJars", "classpathArgs", "opts", "docZip")
)
func init() {
android.RegisterModuleType("doc_defaults", DocDefaultsFactory)
+ android.RegisterModuleType("stubs_defaults", StubsDefaultsFactory)
android.RegisterModuleType("droiddoc", DroiddocFactory)
android.RegisterModuleType("droiddoc_host", DroiddocHostFactory)
android.RegisterModuleType("droiddoc_exported_dir", ExportedDroiddocDirFactory)
android.RegisterModuleType("javadoc", JavadocFactory)
android.RegisterModuleType("javadoc_host", JavadocHostFactory)
+
+ android.RegisterModuleType("droidstubs", DroidstubsFactory)
+ android.RegisterModuleType("droidstubs_host", DroidstubsHostFactory)
}
var (
@@ -139,6 +160,10 @@
// list of java libraries that will be in the classpath.
Libs []string `android:"arch_variant"`
+ // don't build against the default libraries (bootclasspath, legacy-test, core-junit,
+ // ext, and framework for device targets)
+ No_standard_libs *bool
+
// don't build against the framework libraries (legacy-test, core-junit,
// ext, and framework for device targets)
No_framework_libs *bool
@@ -168,6 +193,18 @@
// If not blank, set the java version passed to javadoc as -source
Java_version *string
+
+ // local files that are used within user customized droiddoc options.
+ Arg_files []string
+
+ // user customized droiddoc args.
+ // Available variables for substitution:
+ //
+ // $(location <label>): the path to the arg_files with name <label>
+ Args *string
+
+ // names of the output files used in args that will be generated
+ Out []string
}
type ApiToCheck struct {
@@ -208,18 +245,6 @@
// resources output directory under out/soong/.intermediates.
Resourcesoutdir *string
- // local files that are used within user customized droiddoc options.
- Arg_files []string
-
- // user customized droiddoc args.
- // Available variables for substitution:
- //
- // $(location <label>): the path to the arg_files with name <label>
- Args *string
-
- // names of the output files used in args that will be generated
- Out []string
-
// if set to true, collect the values used by the Dev tools and
// write them in files packaged with the SDK. Defaults to false.
Write_sdk_values *bool
@@ -274,31 +299,85 @@
Current ApiToCheck
}
- // if set to true, create stubs through Metalava instead of Doclava. Javadoc/Doclava is
- // currently still used for documentation generation, and will be replaced by Dokka soon.
- Metalava_enabled *bool
+ // if set to true, generate docs through Dokka instead of Doclava.
+ Dokka_enabled *bool
+}
+
+type DroidstubsProperties struct {
+ // the tag name used to distinguish if the API files belong to public/system/test.
+ Api_tag_name *string
+
+ // the generated public API filename by Metalava.
+ Api_filename *string
+
+ // the generated public Dex API filename by Metalava.
+ Dex_api_filename *string
+
+ // the generated private API filename by Metalava.
+ Private_api_filename *string
+
+ // the generated private Dex API filename by Metalava.
+ Private_dex_api_filename *string
+
+ // the generated removed API filename by Metalava.
+ Removed_api_filename *string
+
+ // the generated removed Dex API filename by Metalava.
+ Removed_dex_api_filename *string
+
+ // mapping of dex signatures to source file and line number. This is a temporary property and
+ // will be deleted; you probably shouldn't be using it.
+ Dex_mapping_filename *string
+
+ // the generated exact API filename by Metalava.
+ Exact_api_filename *string
+
+ // the generated proguard filename by Metalava.
+ Proguard_filename *string
+
+ Check_api struct {
+ Last_released ApiToCheck
+
+ Current ApiToCheck
+ }
// user can specify the version of previous released API file in order to do compatibility check.
- Metalava_previous_api *string
+ Previous_api *string
// is set to true, Metalava will allow framework SDK to contain annotations.
- Metalava_annotations_enabled *bool
+ Annotations_enabled *bool
- // a list of top-level directories containing files to merge annotations from.
- Metalava_merge_annotations_dirs []string
+ // a list of top-level directories containing files to merge qualifier annotations (i.e. those intended to be included in the stubs written) from.
+ Merge_annotations_dirs []string
- // if set to true, generate docs through Dokka instead of Doclava. Valid only when
- // metalava_enabled is set to true.
- Dokka_enabled *bool
+ // a list of top-level directories containing Java stub files to merge show/hide annotations from.
+ Merge_inclusion_annotations_dirs []string
+
+ // if set to true, allow Metalava to generate doc_stubs source files. Defaults to false.
+ Create_doc_stubs *bool
+
+ // is set to true, Metalava will allow framework SDK to contain API levels annotations.
+ Api_levels_annotations_enabled *bool
+
+ // the dirs which Metalava extracts API levels annotations from.
+ Api_levels_annotations_dirs []string
+
+ // if set to true, collect the values used by the Dev tools and
+ // write them in files packaged with the SDK. Defaults to false.
+ Write_sdk_values *bool
+
+ // If set to true, .xml based public API file will be also generated, and
+ // JDiff tool will be invoked to genreate javadoc files. Defaults to false.
+ Jdiff_enabled *bool
}
//
// Common flags passed down to build rule
//
type droiddocBuilderFlags struct {
- args string
bootClasspathArgs string
classpathArgs string
+ sourcepathArgs string
dokkaClasspathArgs string
aidlFlags string
@@ -306,11 +385,11 @@
doclavaDocsFlags string
postDoclavaCmds string
- metalavaStubsFlags string
- metalavaAnnotationsFlags string
- metalavaJavadocFlags string
+ metalavaStubsFlags string
+ metalavaAnnotationsFlags string
+ metalavaApiLevelsAnnotationsFlags string
- metalavaDokkaFlags string
+ metalavaApiToXmlFlags string
}
func InitDroiddocModule(module android.DefaultableModule, hod android.HostOrDeviceSupported) {
@@ -318,6 +397,39 @@
android.InitDefaultableModule(module)
}
+func apiCheckEnabled(apiToCheck ApiToCheck, apiVersionTag string) bool {
+ if String(apiToCheck.Api_file) != "" && String(apiToCheck.Removed_api_file) != "" {
+ return true
+ } else if String(apiToCheck.Api_file) != "" {
+ panic("for " + apiVersionTag + " removed_api_file has to be non-empty!")
+ } else if String(apiToCheck.Removed_api_file) != "" {
+ panic("for " + apiVersionTag + " api_file has to be non-empty!")
+ }
+
+ return false
+}
+
+type ApiFilePath interface {
+ ApiFilePath() android.Path
+}
+
+func transformUpdateApi(ctx android.ModuleContext, destApiFile, destRemovedApiFile,
+ srcApiFile, srcRemovedApiFile android.Path, output android.WritablePath) {
+ ctx.Build(pctx, android.BuildParams{
+ Rule: updateApi,
+ Description: "Update API",
+ Output: output,
+ Implicits: append(android.Paths{}, srcApiFile, srcRemovedApiFile,
+ destApiFile, destRemovedApiFile),
+ Args: map[string]string{
+ "destApiFile": destApiFile.String(),
+ "srcApiFile": srcApiFile.String(),
+ "destRemovedApiFile": destRemovedApiFile.String(),
+ "srcRemovedApiFile": srcRemovedApiFile.String(),
+ },
+ })
+}
+
//
// Javadoc
//
@@ -330,6 +442,9 @@
srcJars android.Paths
srcFiles android.Paths
sourcepaths android.Paths
+ argFiles android.Paths
+
+ args string
docZip android.WritablePath
stubsSrcJar android.WritablePath
@@ -369,20 +484,22 @@
func (j *Javadoc) addDeps(ctx android.BottomUpMutatorContext) {
if ctx.Device() {
- sdkDep := decodeSdkDep(ctx, sdkContext(j))
- if sdkDep.useDefaultLibs {
- ctx.AddVariationDependencies(nil, bootClasspathTag, config.DefaultBootclasspathLibraries...)
- if ctx.Config().TargetOpenJDK9() {
- ctx.AddVariationDependencies(nil, systemModulesTag, config.DefaultSystemModules)
+ if !Bool(j.properties.No_standard_libs) {
+ sdkDep := decodeSdkDep(ctx, sdkContext(j))
+ if sdkDep.useDefaultLibs {
+ ctx.AddVariationDependencies(nil, bootClasspathTag, config.DefaultBootclasspathLibraries...)
+ if ctx.Config().TargetOpenJDK9() {
+ ctx.AddVariationDependencies(nil, systemModulesTag, config.DefaultSystemModules)
+ }
+ if !Bool(j.properties.No_framework_libs) {
+ ctx.AddVariationDependencies(nil, libTag, config.DefaultLibraries...)
+ }
+ } else if sdkDep.useModule {
+ if ctx.Config().TargetOpenJDK9() {
+ ctx.AddVariationDependencies(nil, systemModulesTag, sdkDep.systemModules)
+ }
+ ctx.AddVariationDependencies(nil, bootClasspathTag, sdkDep.modules...)
}
- if !Bool(j.properties.No_framework_libs) {
- ctx.AddVariationDependencies(nil, libTag, config.DefaultLibraries...)
- }
- } else if sdkDep.useModule {
- if ctx.Config().TargetOpenJDK9() {
- ctx.AddVariationDependencies(nil, systemModulesTag, sdkDep.systemModules)
- }
- ctx.AddVariationDependencies(nil, bootClasspathTag, sdkDep.modules...)
}
}
@@ -395,6 +512,9 @@
// exclude_srcs may contain filegroup or genrule.
android.ExtractSourcesDeps(ctx, j.properties.Exclude_srcs)
+
+ // arg_files may contains filegroup or genrule.
+ android.ExtractSourcesDeps(ctx, j.properties.Arg_files)
}
func (j *Javadoc) genWhitelistPathPrefixes(whitelistPathPrefixes map[string]bool) {
@@ -514,7 +634,7 @@
if _, ok := src.(android.WritablePath); ok { // generated sources
deps.srcs = append(deps.srcs, src)
} else { // select source path for documentation based on whitelist path prefixs.
- for k, _ := range whitelistPathPrefixes {
+ for k := range whitelistPathPrefixes {
if strings.HasPrefix(src.Rel(), k) {
deps.srcs = append(deps.srcs, src)
break
@@ -553,11 +673,42 @@
j.docZip = android.PathForModuleOut(ctx, ctx.ModuleName()+"-"+"docs.zip")
j.stubsSrcJar = android.PathForModuleOut(ctx, ctx.ModuleName()+"-"+"stubs.srcjar")
- if j.properties.Local_sourcepaths == nil {
+ if j.properties.Local_sourcepaths == nil && len(j.srcFiles) > 0 {
j.properties.Local_sourcepaths = append(j.properties.Local_sourcepaths, ".")
}
j.sourcepaths = android.PathsForModuleSrc(ctx, j.properties.Local_sourcepaths)
+ j.argFiles = ctx.ExpandSources(j.properties.Arg_files, nil)
+ argFilesMap := map[string]android.Path{}
+
+ for _, f := range j.argFiles {
+ if _, exists := argFilesMap[f.Rel()]; !exists {
+ argFilesMap[f.Rel()] = f
+ } else {
+ ctx.ModuleErrorf("multiple arg_files for %q, %q and %q",
+ f, argFilesMap[f.Rel()], f.Rel())
+ }
+ }
+
+ var err error
+ j.args, err = android.Expand(String(j.properties.Args), func(name string) (string, error) {
+ if strings.HasPrefix(name, "location ") {
+ label := strings.TrimSpace(strings.TrimPrefix(name, "location "))
+ if f, ok := argFilesMap[label]; ok {
+ return f.String(), nil
+ } else {
+ return "", fmt.Errorf("unknown location label %q", label)
+ }
+ } else if name == "genDir" {
+ return android.PathForModuleGen(ctx).String(), nil
+ }
+ return "", fmt.Errorf("unknown variable '$(%s)'", name)
+ })
+
+ if err != nil {
+ ctx.PropertyErrorf("args", "%s", err.Error())
+ }
+
return deps
}
@@ -572,7 +723,7 @@
implicits = append(implicits, deps.bootClasspath...)
implicits = append(implicits, deps.classpath...)
- var bootClasspathArgs, classpathArgs string
+ var bootClasspathArgs, classpathArgs, sourcepathArgs string
javaVersion := getJavaVersion(ctx, String(j.properties.Java_version), sdkContext(j))
if len(deps.bootClasspath) > 0 {
@@ -588,9 +739,12 @@
}
implicits = append(implicits, j.srcJars...)
+ implicits = append(implicits, j.argFiles...)
opts := "-source " + javaVersion + " -J-Xmx1024m -XDignore.symbol.file -Xdoclint:none"
+ sourcepathArgs = "-sourcepath " + strings.Join(j.sourcepaths.Strings(), ":")
+
ctx.Build(pctx, android.BuildParams{
Rule: javadoc,
Description: "Javadoc",
@@ -606,7 +760,7 @@
"opts": opts,
"bootclasspathArgs": bootClasspathArgs,
"classpathArgs": classpathArgs,
- "sourcepath": strings.Join(j.sourcepaths.Strings(), ":"),
+ "sourcepathArgs": sourcepathArgs,
"docZip": j.docZip.String(),
},
})
@@ -633,15 +787,9 @@
updateCurrentApiTimestamp android.WritablePath
checkLastReleasedApiTimestamp android.WritablePath
- annotationsZip android.WritablePath
-
apiFilePath android.Path
}
-type ApiFilePath interface {
- ApiFilePath() android.Path
-}
-
func DroiddocFactory() android.Module {
module := &Droiddoc{}
@@ -666,32 +814,6 @@
return d.apiFilePath
}
-func (d *Droiddoc) checkCurrentApi() bool {
- if String(d.properties.Check_api.Current.Api_file) != "" &&
- String(d.properties.Check_api.Current.Removed_api_file) != "" {
- return true
- } else if String(d.properties.Check_api.Current.Api_file) != "" {
- panic("check_api.current.removed_api_file: has to be non empty!")
- } else if String(d.properties.Check_api.Current.Removed_api_file) != "" {
- panic("check_api.current.api_file: has to be non empty!")
- }
-
- return false
-}
-
-func (d *Droiddoc) checkLastReleasedApi() bool {
- if String(d.properties.Check_api.Last_released.Api_file) != "" &&
- String(d.properties.Check_api.Last_released.Removed_api_file) != "" {
- return true
- } else if String(d.properties.Check_api.Last_released.Api_file) != "" {
- panic("check_api.last_released.removed_api_file: has to be non empty!")
- } else if String(d.properties.Check_api.Last_released.Removed_api_file) != "" {
- panic("check_api.last_released.api_file: has to be non empty!")
- }
-
- return false
-}
-
func (d *Droiddoc) DepsMutator(ctx android.BottomUpMutatorContext) {
d.Javadoc.addDeps(ctx)
@@ -699,9 +821,6 @@
ctx.AddDependency(ctx.Module(), droiddocTemplateTag, String(d.properties.Custom_template))
}
- // arg_files may contains filegroup or genrule.
- android.ExtractSourcesDeps(ctx, d.properties.Arg_files)
-
// knowntags may contain filegroup or genrule.
android.ExtractSourcesDeps(ctx, d.properties.Knowntags)
@@ -713,25 +832,15 @@
android.ExtractSourceDeps(ctx, d.properties.Static_doc_properties)
}
- if d.checkCurrentApi() {
+ if apiCheckEnabled(d.properties.Check_api.Current, "current") {
android.ExtractSourceDeps(ctx, d.properties.Check_api.Current.Api_file)
android.ExtractSourceDeps(ctx, d.properties.Check_api.Current.Removed_api_file)
}
- if d.checkLastReleasedApi() {
+ if apiCheckEnabled(d.properties.Check_api.Last_released, "last_released") {
android.ExtractSourceDeps(ctx, d.properties.Check_api.Last_released.Api_file)
android.ExtractSourceDeps(ctx, d.properties.Check_api.Last_released.Removed_api_file)
}
-
- if String(d.properties.Metalava_previous_api) != "" {
- android.ExtractSourceDeps(ctx, d.properties.Metalava_previous_api)
- }
-
- if len(d.properties.Metalava_merge_annotations_dirs) != 0 {
- for _, mergeAnnotationsDir := range d.properties.Metalava_merge_annotations_dirs {
- ctx.AddDependency(ctx.Module(), metalavaMergeAnnotationsDirTag, mergeAnnotationsDir)
- }
- }
}
func (d *Droiddoc) initBuilderFlags(ctx android.ModuleContext, implicits *android.Paths,
@@ -741,51 +850,28 @@
*implicits = append(*implicits, deps.bootClasspath...)
*implicits = append(*implicits, deps.classpath...)
- // continue to use -bootclasspath even if Metalava under -source 1.9 is enabled
- // since it doesn't support system modules yet.
if len(deps.bootClasspath.Strings()) > 0 {
// For OpenJDK 8 we can use -bootclasspath to define the core libraries code.
flags.bootClasspathArgs = deps.bootClasspath.FormJavaClassPath("-bootclasspath")
}
flags.classpathArgs = deps.classpath.FormJavaClassPath("-classpath")
- // Dokka doesn't support boocClasspath, so combine these two classpath vars for Dokka.
+ // Dokka doesn't support bootClasspath, so combine these two classpath vars for Dokka.
dokkaClasspath := classpath{}
dokkaClasspath = append(dokkaClasspath, deps.bootClasspath...)
dokkaClasspath = append(dokkaClasspath, deps.classpath...)
flags.dokkaClasspathArgs = dokkaClasspath.FormJavaClassPath("-classpath")
- argFiles := ctx.ExpandSources(d.properties.Arg_files, nil)
- argFilesMap := map[string]android.Path{}
-
- for _, f := range argFiles {
- *implicits = append(*implicits, f)
- if _, exists := argFilesMap[f.Rel()]; !exists {
- argFilesMap[f.Rel()] = f
- } else {
- ctx.ModuleErrorf("multiple arg_files for %q, %q and %q",
- f, argFilesMap[f.Rel()], f.Rel())
- }
+ // TODO(nanzhang): Remove this if- statement once we finish migration for all Doclava
+ // based stubs generation.
+ // In the future, all the docs generation depends on Metalava stubs (droidstubs) srcjar
+ // dir. We need add the srcjar dir to -sourcepath arg, so that Javadoc can figure out
+ // the correct package name base path.
+ if len(d.Javadoc.properties.Local_sourcepaths) > 0 {
+ flags.sourcepathArgs = "-sourcepath " + strings.Join(d.Javadoc.sourcepaths.Strings(), ":")
+ } else {
+ flags.sourcepathArgs = "-sourcepath " + android.PathForModuleOut(ctx, "srcjars").String()
}
- var err error
- flags.args, err = android.Expand(String(d.properties.Args), func(name string) (string, error) {
- if strings.HasPrefix(name, "location ") {
- label := strings.TrimSpace(strings.TrimPrefix(name, "location "))
- if f, ok := argFilesMap[label]; ok {
- return f.String(), nil
- } else {
- return "", fmt.Errorf("unknown location label %q", label)
- }
- } else if name == "genDir" {
- return android.PathForModuleGen(ctx).String(), nil
- }
- return "", fmt.Errorf("unknown variable '$(%s)'", name)
- })
-
- if err != nil {
- ctx.PropertyErrorf("args", "%s", err.Error())
- return droiddocBuilderFlags{}, err
- }
return flags, nil
}
@@ -877,69 +963,65 @@
return args
}
-func (d *Droiddoc) collectStubsFlags(ctx android.ModuleContext, implicitOutputs *android.WritablePaths) (string, string) {
- var doclavaFlags, MetalavaFlags string
- if d.checkCurrentApi() || d.checkLastReleasedApi() || String(d.properties.Api_filename) != "" {
+func (d *Droiddoc) collectStubsFlags(ctx android.ModuleContext,
+ implicitOutputs *android.WritablePaths) string {
+ var doclavaFlags string
+ if apiCheckEnabled(d.properties.Check_api.Current, "current") ||
+ apiCheckEnabled(d.properties.Check_api.Last_released, "last_released") ||
+ String(d.properties.Api_filename) != "" {
d.apiFile = android.PathForModuleOut(ctx, ctx.ModuleName()+"_api.txt")
doclavaFlags += " -api " + d.apiFile.String()
- MetalavaFlags = MetalavaFlags + " --api " + d.apiFile.String()
*implicitOutputs = append(*implicitOutputs, d.apiFile)
d.apiFilePath = d.apiFile
}
- if d.checkCurrentApi() || d.checkLastReleasedApi() || String(d.properties.Removed_api_filename) != "" {
+ if apiCheckEnabled(d.properties.Check_api.Current, "current") ||
+ apiCheckEnabled(d.properties.Check_api.Last_released, "last_released") ||
+ String(d.properties.Removed_api_filename) != "" {
d.removedApiFile = android.PathForModuleOut(ctx, ctx.ModuleName()+"_removed.txt")
doclavaFlags += " -removedApi " + d.removedApiFile.String()
- MetalavaFlags = MetalavaFlags + " --removed-api " + d.removedApiFile.String()
*implicitOutputs = append(*implicitOutputs, d.removedApiFile)
}
if String(d.properties.Private_api_filename) != "" {
d.privateApiFile = android.PathForModuleOut(ctx, String(d.properties.Private_api_filename))
doclavaFlags += " -privateApi " + d.privateApiFile.String()
- MetalavaFlags = MetalavaFlags + " --private-api " + d.privateApiFile.String()
*implicitOutputs = append(*implicitOutputs, d.privateApiFile)
}
if String(d.properties.Dex_api_filename) != "" {
d.dexApiFile = android.PathForModuleOut(ctx, String(d.properties.Dex_api_filename))
doclavaFlags += " -dexApi " + d.dexApiFile.String()
- MetalavaFlags += " --dex-api " + d.dexApiFile.String()
*implicitOutputs = append(*implicitOutputs, d.dexApiFile)
}
if String(d.properties.Private_dex_api_filename) != "" {
d.privateDexApiFile = android.PathForModuleOut(ctx, String(d.properties.Private_dex_api_filename))
doclavaFlags += " -privateDexApi " + d.privateDexApiFile.String()
- MetalavaFlags = MetalavaFlags + " --private-dex-api " + d.privateDexApiFile.String()
*implicitOutputs = append(*implicitOutputs, d.privateDexApiFile)
}
if String(d.properties.Removed_dex_api_filename) != "" {
d.removedDexApiFile = android.PathForModuleOut(ctx, String(d.properties.Removed_dex_api_filename))
doclavaFlags += " -removedDexApi " + d.removedDexApiFile.String()
- MetalavaFlags = MetalavaFlags + " --removed-dex-api " + d.removedDexApiFile.String()
*implicitOutputs = append(*implicitOutputs, d.removedDexApiFile)
}
if String(d.properties.Exact_api_filename) != "" {
d.exactApiFile = android.PathForModuleOut(ctx, String(d.properties.Exact_api_filename))
doclavaFlags += " -exactApi " + d.exactApiFile.String()
- MetalavaFlags = MetalavaFlags + " --exact-api " + d.exactApiFile.String()
*implicitOutputs = append(*implicitOutputs, d.exactApiFile)
}
if String(d.properties.Dex_mapping_filename) != "" {
d.apiMappingFile = android.PathForModuleOut(ctx, String(d.properties.Dex_mapping_filename))
doclavaFlags += " -apiMapping " + d.apiMappingFile.String()
- // Omitted: metalava support
*implicitOutputs = append(*implicitOutputs, d.apiMappingFile)
}
if String(d.properties.Proguard_filename) != "" {
d.proguardFile = android.PathForModuleOut(ctx, String(d.properties.Proguard_filename))
doclavaFlags += " -proguard " + d.proguardFile.String()
- // Omitted: metalava support
*implicitOutputs = append(*implicitOutputs, d.proguardFile)
}
@@ -950,7 +1032,8 @@
if Bool(d.properties.Write_sdk_values) {
doclavaFlags += " -sdkvalues " + android.PathForModuleOut(ctx, "out").String()
}
- return doclavaFlags, MetalavaFlags
+
+ return doclavaFlags
}
func (d *Droiddoc) getPostDoclavaCmds(ctx android.ModuleContext, implicits *android.Paths) string {
@@ -973,93 +1056,9 @@
return cmds
}
-func (d *Droiddoc) collectMetalavaAnnotationsFlags(
- ctx android.ModuleContext, implicits *android.Paths, implicitOutputs *android.WritablePaths) string {
- var flags string
- if Bool(d.properties.Metalava_annotations_enabled) {
- if String(d.properties.Metalava_previous_api) == "" {
- ctx.PropertyErrorf("metalava_previous_api",
- "has to be non-empty if annotations was enabled!")
- }
- previousApi := ctx.ExpandSource(String(d.properties.Metalava_previous_api),
- "metalava_previous_api")
- *implicits = append(*implicits, previousApi)
-
- flags += " --include-annotations --migrate-nullness " + previousApi.String()
-
- d.annotationsZip = android.PathForModuleOut(ctx, ctx.ModuleName()+"_annotations.zip")
- *implicitOutputs = append(*implicitOutputs, d.annotationsZip)
-
- flags += " --extract-annotations " + d.annotationsZip.String()
-
- if len(d.properties.Metalava_merge_annotations_dirs) == 0 {
- ctx.PropertyErrorf("metalava_merge_annotations_dirs",
- "has to be non-empty if annotations was enabled!")
- }
- ctx.VisitDirectDepsWithTag(metalavaMergeAnnotationsDirTag, func(m android.Module) {
- if t, ok := m.(*ExportedDroiddocDir); ok {
- *implicits = append(*implicits, t.deps...)
- flags += " --merge-annotations " + t.dir.String()
- } else {
- ctx.PropertyErrorf("metalava_merge_annotations_dirs",
- "module %q is not a metalava merge-annotations dir", ctx.OtherModuleName(m))
- }
- })
- // TODO(tnorbye): find owners to fix these warnings when annotation was enabled.
- flags += " --hide HiddenTypedefConstant --hide SuperfluousPrefix --hide AnnotationExtraction "
- }
-
- return flags
-}
-
-func (d *Droiddoc) collectMetalavaJavadocFlags(ctx android.ModuleContext,
- bootClasspathArgs, classpathArgs, outDir, docStubsDir string) string {
- return " --doc-stubs " + docStubsDir +
- " --write-doc-stubs-source-list " + android.PathForModuleOut(ctx, "doc_stubs.srclist").String() +
- " --generate-documentation ${config.JavadocCmd} -encoding UTF-8 DOC_STUBS_SOURCE_LIST " +
- bootClasspathArgs + " " + classpathArgs + " " + " -sourcepath " +
- docStubsDir + " -quiet -d " + outDir
-}
-
-func (d *Droiddoc) collectMetalavaDokkaFlags(ctx android.ModuleContext, implicits *android.Paths,
- classpathArgs, outDir, docStubsDir string) string {
- dokka := android.PathForOutput(ctx, "host", ctx.Config().PrebuiltOS(), "framework", "dokka.jar")
- *implicits = append(*implicits, dokka)
-
- return " --doc-stubs " + docStubsDir + " --write-doc-stubs-source-list " +
- android.PathForModuleOut(ctx, "doc_stubs.srclist").String() +
- " --generate-documentation ${config.JavaCmd} -jar " + dokka.String() + " " +
- docStubsDir + " " + classpathArgs + " -format dac -dacRoot /reference/kotlin -output " + outDir
-}
-
-func (d *Droiddoc) transformMetalava(ctx android.ModuleContext, implicits android.Paths,
- implicitOutputs android.WritablePaths, outDir, docStubsDir, javaVersion,
- bootclasspathArgs, classpathArgs, opts string) {
- ctx.Build(pctx, android.BuildParams{
- Rule: metalava,
- Description: "Metalava",
- Output: d.Javadoc.stubsSrcJar,
- Inputs: d.Javadoc.srcFiles,
- Implicits: implicits,
- ImplicitOutputs: implicitOutputs,
- Args: map[string]string{
- "outDir": outDir,
- "srcJarDir": android.PathForModuleOut(ctx, "srcjars").String(),
- "stubsDir": android.PathForModuleOut(ctx, "stubsDir").String(),
- "docStubsDir": docStubsDir,
- "srcJars": strings.Join(d.Javadoc.srcJars.Strings(), " "),
- "javaVersion": javaVersion,
- "bootclasspathArgs": bootclasspathArgs,
- "classpathArgs": classpathArgs,
- "sourcepath": strings.Join(d.Javadoc.sourcepaths.Strings(), ":"),
- "docZip": d.Javadoc.docZip.String(),
- "opts": opts,
- },
- })
-}
-
func (d *Droiddoc) transformDoclava(ctx android.ModuleContext, implicits android.Paths,
- implicitOutputs android.WritablePaths, bootclasspathArgs, classpathArgs, opts, postDoclavaCmds string) {
+ implicitOutputs android.WritablePaths,
+ bootclasspathArgs, classpathArgs, sourcepathArgs, opts, postDoclavaCmds string) {
ctx.Build(pctx, android.BuildParams{
Rule: javadoc,
Description: "Doclava",
@@ -1075,7 +1074,7 @@
"opts": opts,
"bootclasspathArgs": bootclasspathArgs,
"classpathArgs": classpathArgs,
- "sourcepath": strings.Join(d.Javadoc.sourcepaths.Strings(), ":"),
+ "sourcepathArgs": sourcepathArgs,
"docZip": d.Javadoc.docZip.String(),
"postDoclavaCmds": postDoclavaCmds,
},
@@ -1092,19 +1091,445 @@
Implicits: append(android.Paths{apiFile, removedApiFile, d.apiFile, d.removedApiFile},
checkApiClasspath...),
Args: map[string]string{
+ "msg": msg,
"classpath": checkApiClasspath.FormJavaClassPath(""),
"opts": opts,
"apiFile": apiFile.String(),
"apiFileToCheck": d.apiFile.String(),
"removedApiFile": removedApiFile.String(),
"removedApiFileToCheck": d.removedApiFile.String(),
- "msg": msg,
},
})
}
-func (d *Droiddoc) transformMetalavaCheckApi(ctx android.ModuleContext, apiFile, removedApiFile android.Path,
- implicits android.Paths, javaVersion, bootclasspathArgs, classpathArgs, opts, msg string,
+func (d *Droiddoc) transformDokka(ctx android.ModuleContext, implicits android.Paths,
+ classpathArgs, opts string) {
+ ctx.Build(pctx, android.BuildParams{
+ Rule: dokka,
+ Description: "Dokka",
+ Output: d.Javadoc.stubsSrcJar,
+ Inputs: d.Javadoc.srcFiles,
+ Implicits: implicits,
+ Args: map[string]string{
+ "outDir": android.PathForModuleOut(ctx, "out").String(),
+ "srcJarDir": android.PathForModuleOut(ctx, "srcjars").String(),
+ "stubsDir": android.PathForModuleOut(ctx, "stubsDir").String(),
+ "srcJars": strings.Join(d.Javadoc.srcJars.Strings(), " "),
+ "classpathArgs": classpathArgs,
+ "opts": opts,
+ "docZip": d.Javadoc.docZip.String(),
+ },
+ })
+}
+
+func (d *Droiddoc) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+ deps := d.Javadoc.collectDeps(ctx)
+
+ jsilver := android.PathForOutput(ctx, "host", ctx.Config().PrebuiltOS(), "framework", "jsilver.jar")
+ doclava := android.PathForOutput(ctx, "host", ctx.Config().PrebuiltOS(), "framework", "doclava.jar")
+ java8Home := ctx.Config().Getenv("ANDROID_JAVA8_HOME")
+ checkApiClasspath := classpath{jsilver, doclava, android.PathForSource(ctx, java8Home, "lib/tools.jar")}
+
+ var implicits android.Paths
+ implicits = append(implicits, d.Javadoc.srcJars...)
+ implicits = append(implicits, d.Javadoc.argFiles...)
+
+ var implicitOutputs android.WritablePaths
+ implicitOutputs = append(implicitOutputs, d.Javadoc.docZip)
+ for _, o := range d.Javadoc.properties.Out {
+ implicitOutputs = append(implicitOutputs, android.PathForModuleGen(ctx, o))
+ }
+
+ flags, err := d.initBuilderFlags(ctx, &implicits, deps)
+ if err != nil {
+ return
+ }
+
+ flags.doclavaStubsFlags = d.collectStubsFlags(ctx, &implicitOutputs)
+ if Bool(d.properties.Dokka_enabled) {
+ d.transformDokka(ctx, implicits, flags.classpathArgs, d.Javadoc.args)
+ } else {
+ flags.doclavaDocsFlags = d.collectDoclavaDocsFlags(ctx, &implicits, jsilver, doclava)
+ flags.postDoclavaCmds = d.getPostDoclavaCmds(ctx, &implicits)
+ d.transformDoclava(ctx, implicits, implicitOutputs, flags.bootClasspathArgs, flags.classpathArgs,
+ flags.sourcepathArgs, flags.doclavaDocsFlags+flags.doclavaStubsFlags+" "+d.Javadoc.args,
+ flags.postDoclavaCmds)
+ }
+
+ if apiCheckEnabled(d.properties.Check_api.Current, "current") &&
+ !ctx.Config().IsPdkBuild() {
+ apiFile := ctx.ExpandSource(String(d.properties.Check_api.Current.Api_file),
+ "check_api.current.api_file")
+ removedApiFile := ctx.ExpandSource(String(d.properties.Check_api.Current.Removed_api_file),
+ "check_api.current_removed_api_file")
+
+ d.checkCurrentApiTimestamp = android.PathForModuleOut(ctx, "check_current_api.timestamp")
+ d.transformCheckApi(ctx, apiFile, removedApiFile, checkApiClasspath,
+ fmt.Sprintf(`\n******************************\n`+
+ `You have tried to change the API from what has been previously approved.\n\n`+
+ `To make these errors go away, you have two choices:\n`+
+ ` 1. You can add '@hide' javadoc comments to the methods, etc. listed in the\n`+
+ ` errors above.\n\n`+
+ ` 2. You can update current.txt by executing the following command:\n`+
+ ` make %s-update-current-api\n\n`+
+ ` To submit the revised current.txt to the main Android repository,\n`+
+ ` you will need approval.\n`+
+ `******************************\n`, ctx.ModuleName()), String(d.properties.Check_api.Current.Args),
+ d.checkCurrentApiTimestamp)
+
+ d.updateCurrentApiTimestamp = android.PathForModuleOut(ctx, "update_current_api.timestamp")
+ transformUpdateApi(ctx, apiFile, removedApiFile, d.apiFile, d.removedApiFile,
+ d.updateCurrentApiTimestamp)
+ }
+
+ if apiCheckEnabled(d.properties.Check_api.Last_released, "last_released") &&
+ !ctx.Config().IsPdkBuild() {
+ apiFile := ctx.ExpandSource(String(d.properties.Check_api.Last_released.Api_file),
+ "check_api.last_released.api_file")
+ removedApiFile := ctx.ExpandSource(String(d.properties.Check_api.Last_released.Removed_api_file),
+ "check_api.last_released.removed_api_file")
+
+ d.checkLastReleasedApiTimestamp = android.PathForModuleOut(ctx, "check_last_released_api.timestamp")
+ d.transformCheckApi(ctx, apiFile, removedApiFile, checkApiClasspath,
+ `\n******************************\n`+
+ `You have tried to change the API from what has been previously released in\n`+
+ `an SDK. Please fix the errors listed above.\n`+
+ `******************************\n`, String(d.properties.Check_api.Last_released.Args),
+ d.checkLastReleasedApiTimestamp)
+ }
+}
+
+//
+// Droidstubs
+//
+type Droidstubs struct {
+ Javadoc
+
+ properties DroidstubsProperties
+ apiFile android.WritablePath
+ apiXmlFile android.WritablePath
+ lastReleasedApiXmlFile android.WritablePath
+ dexApiFile android.WritablePath
+ privateApiFile android.WritablePath
+ privateDexApiFile android.WritablePath
+ removedApiFile android.WritablePath
+ removedDexApiFile android.WritablePath
+ apiMappingFile android.WritablePath
+ exactApiFile android.WritablePath
+ proguardFile android.WritablePath
+
+ checkCurrentApiTimestamp android.WritablePath
+ updateCurrentApiTimestamp android.WritablePath
+ checkLastReleasedApiTimestamp android.WritablePath
+
+ annotationsZip android.WritablePath
+ apiVersionsXml android.WritablePath
+
+ apiFilePath android.Path
+
+ jdiffDocZip android.WritablePath
+ jdiffStubsSrcJar android.WritablePath
+}
+
+func DroidstubsFactory() android.Module {
+ module := &Droidstubs{}
+
+ module.AddProperties(&module.properties,
+ &module.Javadoc.properties)
+
+ InitDroiddocModule(module, android.HostAndDeviceSupported)
+ return module
+}
+
+func DroidstubsHostFactory() android.Module {
+ module := &Droidstubs{}
+
+ module.AddProperties(&module.properties,
+ &module.Javadoc.properties)
+
+ InitDroiddocModule(module, android.HostSupported)
+ return module
+}
+
+func (d *Droidstubs) ApiFilePath() android.Path {
+ return d.apiFilePath
+}
+
+func (d *Droidstubs) DepsMutator(ctx android.BottomUpMutatorContext) {
+ d.Javadoc.addDeps(ctx)
+
+ if apiCheckEnabled(d.properties.Check_api.Current, "current") {
+ android.ExtractSourceDeps(ctx, d.properties.Check_api.Current.Api_file)
+ android.ExtractSourceDeps(ctx, d.properties.Check_api.Current.Removed_api_file)
+ }
+
+ if apiCheckEnabled(d.properties.Check_api.Last_released, "last_released") {
+ android.ExtractSourceDeps(ctx, d.properties.Check_api.Last_released.Api_file)
+ android.ExtractSourceDeps(ctx, d.properties.Check_api.Last_released.Removed_api_file)
+ }
+
+ if String(d.properties.Previous_api) != "" {
+ android.ExtractSourceDeps(ctx, d.properties.Previous_api)
+ }
+
+ if len(d.properties.Merge_annotations_dirs) != 0 {
+ for _, mergeAnnotationsDir := range d.properties.Merge_annotations_dirs {
+ ctx.AddDependency(ctx.Module(), metalavaMergeAnnotationsDirTag, mergeAnnotationsDir)
+ }
+ }
+
+ if len(d.properties.Merge_inclusion_annotations_dirs) != 0 {
+ for _, mergeInclusionAnnotationsDir := range d.properties.Merge_inclusion_annotations_dirs {
+ ctx.AddDependency(ctx.Module(), metalavaMergeInclusionAnnotationsDirTag, mergeInclusionAnnotationsDir)
+ }
+ }
+
+ if len(d.properties.Api_levels_annotations_dirs) != 0 {
+ for _, apiLevelsAnnotationsDir := range d.properties.Api_levels_annotations_dirs {
+ ctx.AddDependency(ctx.Module(), metalavaAPILevelsAnnotationsDirTag, apiLevelsAnnotationsDir)
+ }
+ }
+}
+
+func (d *Droidstubs) initBuilderFlags(ctx android.ModuleContext, implicits *android.Paths,
+ deps deps) (droiddocBuilderFlags, error) {
+ var flags droiddocBuilderFlags
+
+ *implicits = append(*implicits, deps.bootClasspath...)
+ *implicits = append(*implicits, deps.classpath...)
+
+ // continue to use -bootclasspath even if Metalava under -source 1.9 is enabled
+ // since it doesn't support system modules yet.
+ if len(deps.bootClasspath.Strings()) > 0 {
+ // For OpenJDK 8 we can use -bootclasspath to define the core libraries code.
+ flags.bootClasspathArgs = deps.bootClasspath.FormJavaClassPath("-bootclasspath")
+ }
+ flags.classpathArgs = deps.classpath.FormJavaClassPath("-classpath")
+
+ flags.sourcepathArgs = "-sourcepath " + strings.Join(d.Javadoc.sourcepaths.Strings(), ":")
+
+ return flags, nil
+}
+
+func (d *Droidstubs) collectStubsFlags(ctx android.ModuleContext,
+ implicitOutputs *android.WritablePaths) string {
+ var metalavaFlags string
+ if apiCheckEnabled(d.properties.Check_api.Current, "current") ||
+ apiCheckEnabled(d.properties.Check_api.Last_released, "last_released") ||
+ String(d.properties.Api_filename) != "" {
+ d.apiFile = android.PathForModuleOut(ctx, ctx.ModuleName()+"_api.txt")
+ metalavaFlags = metalavaFlags + " --api " + d.apiFile.String()
+ *implicitOutputs = append(*implicitOutputs, d.apiFile)
+ d.apiFilePath = d.apiFile
+ }
+
+ if apiCheckEnabled(d.properties.Check_api.Current, "current") ||
+ apiCheckEnabled(d.properties.Check_api.Last_released, "last_released") ||
+ String(d.properties.Removed_api_filename) != "" {
+ d.removedApiFile = android.PathForModuleOut(ctx, ctx.ModuleName()+"_removed.txt")
+ metalavaFlags = metalavaFlags + " --removed-api " + d.removedApiFile.String()
+ *implicitOutputs = append(*implicitOutputs, d.removedApiFile)
+ }
+
+ if String(d.properties.Private_api_filename) != "" {
+ d.privateApiFile = android.PathForModuleOut(ctx, String(d.properties.Private_api_filename))
+ metalavaFlags = metalavaFlags + " --private-api " + d.privateApiFile.String()
+ *implicitOutputs = append(*implicitOutputs, d.privateApiFile)
+ }
+
+ if String(d.properties.Dex_api_filename) != "" {
+ d.dexApiFile = android.PathForModuleOut(ctx, String(d.properties.Dex_api_filename))
+ metalavaFlags += " --dex-api " + d.dexApiFile.String()
+ *implicitOutputs = append(*implicitOutputs, d.dexApiFile)
+ }
+
+ if String(d.properties.Private_dex_api_filename) != "" {
+ d.privateDexApiFile = android.PathForModuleOut(ctx, String(d.properties.Private_dex_api_filename))
+ metalavaFlags = metalavaFlags + " --private-dex-api " + d.privateDexApiFile.String()
+ *implicitOutputs = append(*implicitOutputs, d.privateDexApiFile)
+ }
+
+ if String(d.properties.Removed_dex_api_filename) != "" {
+ d.removedDexApiFile = android.PathForModuleOut(ctx, String(d.properties.Removed_dex_api_filename))
+ metalavaFlags = metalavaFlags + " --removed-dex-api " + d.removedDexApiFile.String()
+ *implicitOutputs = append(*implicitOutputs, d.removedDexApiFile)
+ }
+
+ if String(d.properties.Exact_api_filename) != "" {
+ d.exactApiFile = android.PathForModuleOut(ctx, String(d.properties.Exact_api_filename))
+ metalavaFlags = metalavaFlags + " --exact-api " + d.exactApiFile.String()
+ *implicitOutputs = append(*implicitOutputs, d.exactApiFile)
+ }
+
+ if String(d.properties.Dex_mapping_filename) != "" {
+ d.apiMappingFile = android.PathForModuleOut(ctx, String(d.properties.Dex_mapping_filename))
+ metalavaFlags = metalavaFlags + " --dex-api-mapping " + d.apiMappingFile.String()
+ *implicitOutputs = append(*implicitOutputs, d.apiMappingFile)
+ }
+
+ if String(d.properties.Proguard_filename) != "" {
+ d.proguardFile = android.PathForModuleOut(ctx, String(d.properties.Proguard_filename))
+ metalavaFlags += " --proguard " + d.proguardFile.String()
+ *implicitOutputs = append(*implicitOutputs, d.proguardFile)
+ }
+
+ if Bool(d.properties.Write_sdk_values) {
+ metalavaFlags = metalavaFlags + " --sdk-values " + android.PathForModuleOut(ctx, "out").String()
+ }
+
+ if Bool(d.properties.Create_doc_stubs) {
+ metalavaFlags += " --doc-stubs " + android.PathForModuleOut(ctx, "stubsDir").String()
+ } else {
+ metalavaFlags += " --stubs " + android.PathForModuleOut(ctx, "stubsDir").String()
+ }
+
+ return metalavaFlags
+}
+
+func (d *Droidstubs) collectAnnotationsFlags(ctx android.ModuleContext,
+ implicits *android.Paths, implicitOutputs *android.WritablePaths) string {
+ var flags string
+ if Bool(d.properties.Annotations_enabled) {
+ if String(d.properties.Previous_api) == "" {
+ ctx.PropertyErrorf("metalava_previous_api",
+ "has to be non-empty if annotations was enabled!")
+ }
+ previousApi := ctx.ExpandSource(String(d.properties.Previous_api),
+ "metalava_previous_api")
+ *implicits = append(*implicits, previousApi)
+
+ flags += " --include-annotations --migrate-nullness " + previousApi.String()
+
+ d.annotationsZip = android.PathForModuleOut(ctx, ctx.ModuleName()+"_annotations.zip")
+ *implicitOutputs = append(*implicitOutputs, d.annotationsZip)
+
+ flags += " --extract-annotations " + d.annotationsZip.String()
+
+ if len(d.properties.Merge_annotations_dirs) == 0 {
+ ctx.PropertyErrorf("merge_annotations_dirs",
+ "has to be non-empty if annotations was enabled!")
+ }
+ ctx.VisitDirectDepsWithTag(metalavaMergeAnnotationsDirTag, func(m android.Module) {
+ if t, ok := m.(*ExportedDroiddocDir); ok {
+ *implicits = append(*implicits, t.deps...)
+ flags += " --merge-qualifier-annotations " + t.dir.String()
+ } else {
+ ctx.PropertyErrorf("merge_annotations_dirs",
+ "module %q is not a metalava merge-annotations dir", ctx.OtherModuleName(m))
+ }
+ })
+ // TODO(tnorbye): find owners to fix these warnings when annotation was enabled.
+ flags += " --hide HiddenTypedefConstant --hide SuperfluousPrefix --hide AnnotationExtraction "
+ }
+ ctx.VisitDirectDepsWithTag(metalavaMergeInclusionAnnotationsDirTag, func(m android.Module) {
+ if t, ok := m.(*ExportedDroiddocDir); ok {
+ *implicits = append(*implicits, t.deps...)
+ flags += " --merge-inclusion-annotations " + t.dir.String()
+ } else {
+ ctx.PropertyErrorf("merge_inclusion_annotations_dirs",
+ "module %q is not a metalava merge-annotations dir", ctx.OtherModuleName(m))
+ }
+ })
+
+ return flags
+}
+
+func (d *Droidstubs) collectAPILevelsAnnotationsFlags(ctx android.ModuleContext,
+ implicits *android.Paths, implicitOutputs *android.WritablePaths) string {
+ var flags string
+ if Bool(d.properties.Api_levels_annotations_enabled) {
+ d.apiVersionsXml = android.PathForModuleOut(ctx, "api-versions.xml")
+ *implicitOutputs = append(*implicitOutputs, d.apiVersionsXml)
+
+ if len(d.properties.Api_levels_annotations_dirs) == 0 {
+ ctx.PropertyErrorf("api_levels_annotations_dirs",
+ "has to be non-empty if api levels annotations was enabled!")
+ }
+
+ flags = " --generate-api-levels " + d.apiVersionsXml.String() + " --apply-api-levels " +
+ d.apiVersionsXml.String() + " --current-version " + ctx.Config().PlatformSdkVersion() +
+ " --current-codename " + ctx.Config().PlatformSdkCodename() + " "
+
+ ctx.VisitDirectDepsWithTag(metalavaAPILevelsAnnotationsDirTag, func(m android.Module) {
+ if t, ok := m.(*ExportedDroiddocDir); ok {
+ var androidJars android.Paths
+ for _, dep := range t.deps {
+ if strings.HasSuffix(dep.String(), "android.jar") {
+ androidJars = append(androidJars, dep)
+ }
+ }
+ *implicits = append(*implicits, androidJars...)
+ flags += " --android-jar-pattern " + t.dir.String() + "/%/android.jar "
+ } else {
+ ctx.PropertyErrorf("api_levels_annotations_dirs",
+ "module %q is not a metalava api-levels-annotations dir", ctx.OtherModuleName(m))
+ }
+ })
+
+ }
+
+ return flags
+}
+
+func (d *Droidstubs) collectApiToXmlFlags(ctx android.ModuleContext, implicits *android.Paths,
+ implicitOutputs *android.WritablePaths) string {
+ var flags string
+ if Bool(d.properties.Jdiff_enabled) && !ctx.Config().IsPdkBuild() {
+ if d.apiFile.String() == "" {
+ ctx.ModuleErrorf("API signature file has to be specified in Metalava when jdiff is enabled.")
+ }
+
+ d.apiXmlFile = android.PathForModuleOut(ctx, ctx.ModuleName()+"_api.xml")
+ *implicitOutputs = append(*implicitOutputs, d.apiXmlFile)
+
+ flags = " --api-xml " + d.apiXmlFile.String()
+
+ if String(d.properties.Check_api.Last_released.Api_file) == "" {
+ ctx.PropertyErrorf("check_api.last_released.api_file",
+ "has to be non-empty if jdiff was enabled!")
+ }
+ lastReleasedApi := ctx.ExpandSource(String(d.properties.Check_api.Last_released.Api_file),
+ "check_api.last_released.api_file")
+ *implicits = append(*implicits, lastReleasedApi)
+
+ d.lastReleasedApiXmlFile = android.PathForModuleOut(ctx, ctx.ModuleName()+"_last_released_api.xml")
+ *implicitOutputs = append(*implicitOutputs, d.lastReleasedApiXmlFile)
+
+ flags += " --convert-to-jdiff " + lastReleasedApi.String() + " " +
+ d.lastReleasedApiXmlFile.String()
+ }
+
+ return flags
+}
+
+func (d *Droidstubs) transformMetalava(ctx android.ModuleContext, implicits android.Paths,
+ implicitOutputs android.WritablePaths, javaVersion,
+ bootclasspathArgs, classpathArgs, sourcepathArgs, opts string) {
+
+ ctx.Build(pctx, android.BuildParams{
+ Rule: metalava,
+ Description: "Metalava",
+ Output: d.Javadoc.stubsSrcJar,
+ Inputs: d.Javadoc.srcFiles,
+ Implicits: implicits,
+ ImplicitOutputs: implicitOutputs,
+ Args: map[string]string{
+ "outDir": android.PathForModuleOut(ctx, "out").String(),
+ "srcJarDir": android.PathForModuleOut(ctx, "srcjars").String(),
+ "stubsDir": android.PathForModuleOut(ctx, "stubsDir").String(),
+ "srcJars": strings.Join(d.Javadoc.srcJars.Strings(), " "),
+ "javaVersion": javaVersion,
+ "bootclasspathArgs": bootclasspathArgs,
+ "classpathArgs": classpathArgs,
+ "sourcepathArgs": sourcepathArgs,
+ "opts": opts,
+ },
+ })
+}
+
+func (d *Droidstubs) transformCheckApi(ctx android.ModuleContext,
+ apiFile, removedApiFile android.Path, implicits android.Paths,
+ javaVersion, bootclasspathArgs, classpathArgs, sourcepathArgs, opts, msg string,
output android.WritablePath) {
ctx.Build(pctx, android.BuildParams{
Rule: metalavaApiCheck,
@@ -1119,161 +1544,148 @@
"javaVersion": javaVersion,
"bootclasspathArgs": bootclasspathArgs,
"classpathArgs": classpathArgs,
- "sourcepath": strings.Join(d.Javadoc.sourcepaths.Strings(), ":"),
+ "sourcepathArgs": sourcepathArgs,
"opts": opts,
"msg": msg,
},
})
}
-func (d *Droiddoc) transformUpdateApi(ctx android.ModuleContext, apiFile, removedApiFile android.Path,
- output android.WritablePath) {
+func (d *Droidstubs) transformJdiff(ctx android.ModuleContext, implicits android.Paths,
+ implicitOutputs android.WritablePaths,
+ bootclasspathArgs, classpathArgs, sourcepathArgs, opts string) {
ctx.Build(pctx, android.BuildParams{
- Rule: updateApi,
- Description: "Update API",
- Output: output,
- Implicits: append(android.Paths{}, apiFile, removedApiFile, d.apiFile, d.removedApiFile),
+ Rule: javadoc,
+ Description: "Jdiff",
+ Output: d.jdiffStubsSrcJar,
+ Inputs: d.Javadoc.srcFiles,
+ Implicits: implicits,
+ ImplicitOutputs: implicitOutputs,
Args: map[string]string{
- "apiFile": apiFile.String(),
- "apiFileToCheck": d.apiFile.String(),
- "removedApiFile": removedApiFile.String(),
- "removedApiFileToCheck": d.removedApiFile.String(),
+ "outDir": android.PathForModuleOut(ctx, "jdiff-out").String(),
+ "srcJarDir": android.PathForModuleOut(ctx, "jdiff-srcjars").String(),
+ "stubsDir": android.PathForModuleOut(ctx, "jdiff-stubsDir").String(),
+ "srcJars": strings.Join(d.Javadoc.srcJars.Strings(), " "),
+ "opts": opts,
+ "bootclasspathArgs": bootclasspathArgs,
+ "classpathArgs": classpathArgs,
+ "sourcepathArgs": sourcepathArgs,
+ "docZip": d.jdiffDocZip.String(),
},
})
}
-func (d *Droiddoc) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+func (d *Droidstubs) GenerateAndroidBuildActions(ctx android.ModuleContext) {
deps := d.Javadoc.collectDeps(ctx)
javaVersion := getJavaVersion(ctx, String(d.Javadoc.properties.Java_version), sdkContext(d))
- jsilver := android.PathForOutput(ctx, "host", ctx.Config().PrebuiltOS(), "framework", "jsilver.jar")
- doclava := android.PathForOutput(ctx, "host", ctx.Config().PrebuiltOS(), "framework", "doclava.jar")
- java8Home := ctx.Config().Getenv("ANDROID_JAVA8_HOME")
- checkApiClasspath := classpath{jsilver, doclava, android.PathForSource(ctx, java8Home, "lib/tools.jar")}
var implicits android.Paths
implicits = append(implicits, d.Javadoc.srcJars...)
+ implicits = append(implicits, d.Javadoc.argFiles...)
var implicitOutputs android.WritablePaths
- implicitOutputs = append(implicitOutputs, d.Javadoc.docZip)
- for _, o := range d.properties.Out {
+ for _, o := range d.Javadoc.properties.Out {
implicitOutputs = append(implicitOutputs, android.PathForModuleGen(ctx, o))
}
flags, err := d.initBuilderFlags(ctx, &implicits, deps)
metalavaCheckApiImplicits := implicits
+ jdiffImplicits := implicits
+
if err != nil {
return
}
- flags.doclavaStubsFlags, flags.metalavaStubsFlags = d.collectStubsFlags(ctx, &implicitOutputs)
- if Bool(d.properties.Metalava_enabled) {
- flags.metalavaAnnotationsFlags = d.collectMetalavaAnnotationsFlags(ctx, &implicits, &implicitOutputs)
- outDir := android.PathForModuleOut(ctx, "out").String()
- docStubsDir := android.PathForModuleOut(ctx, "docStubsDir").String()
- // TODO(nanzhang): Add a Soong property to handle documentation args.
- if strings.Contains(flags.args, "--generate-documentation") { // enable docs generation
- if Bool(d.properties.Dokka_enabled) {
- flags.metalavaDokkaFlags = d.collectMetalavaDokkaFlags(ctx, &implicits,
- flags.dokkaClasspathArgs, outDir, docStubsDir)
- d.transformMetalava(ctx, implicits, implicitOutputs, outDir, docStubsDir, javaVersion,
- flags.bootClasspathArgs, flags.classpathArgs, flags.metalavaStubsFlags+
- flags.metalavaAnnotationsFlags+" "+
- strings.Split(flags.args, "--generate-documentation")[0]+
- flags.metalavaDokkaFlags+" "+strings.Split(flags.args, "--generate-documentation")[1])
- } else {
- flags.metalavaJavadocFlags = d.collectMetalavaJavadocFlags(
- ctx, flags.bootClasspathArgs, flags.classpathArgs, outDir, docStubsDir)
- flags.doclavaDocsFlags = d.collectDoclavaDocsFlags(ctx, &implicits, jsilver, doclava)
- d.transformMetalava(ctx, implicits, implicitOutputs, outDir, docStubsDir, javaVersion,
- flags.bootClasspathArgs, flags.classpathArgs, flags.metalavaStubsFlags+
- flags.metalavaAnnotationsFlags+" "+
- strings.Split(flags.args, "--generate-documentation")[0]+
- flags.metalavaJavadocFlags+flags.doclavaDocsFlags+
- " "+strings.Split(flags.args, "--generate-documentation")[1])
- }
- } else {
- d.transformMetalava(ctx, implicits, implicitOutputs, outDir, docStubsDir, javaVersion,
- flags.bootClasspathArgs, flags.classpathArgs,
- flags.metalavaStubsFlags+flags.metalavaAnnotationsFlags+" "+flags.args)
- }
- } else {
- flags.doclavaDocsFlags = d.collectDoclavaDocsFlags(ctx, &implicits, jsilver, doclava)
- flags.postDoclavaCmds = d.getPostDoclavaCmds(ctx, &implicits)
- d.transformDoclava(ctx, implicits, implicitOutputs, flags.bootClasspathArgs, flags.classpathArgs,
- flags.doclavaDocsFlags+flags.doclavaStubsFlags+" "+flags.args,
- flags.postDoclavaCmds)
- }
+ flags.metalavaStubsFlags = d.collectStubsFlags(ctx, &implicitOutputs)
+ flags.metalavaAnnotationsFlags = d.collectAnnotationsFlags(ctx, &implicits, &implicitOutputs)
+ flags.metalavaApiLevelsAnnotationsFlags = d.collectAPILevelsAnnotationsFlags(ctx, &implicits, &implicitOutputs)
+ flags.metalavaApiToXmlFlags = d.collectApiToXmlFlags(ctx, &implicits, &implicitOutputs)
- if d.checkCurrentApi() && !ctx.Config().IsPdkBuild() {
+ if strings.Contains(d.Javadoc.args, "--generate-documentation") {
+ // Currently Metalava have the ability to invoke Javadoc in a seperate process.
+ // Pass "-nodocs" to suppress the Javadoc invocation when Metalava receives
+ // "--generate-documentation" arg. This is not needed when Metalava removes this feature.
+ d.Javadoc.args = d.Javadoc.args + " -nodocs "
+ }
+ d.transformMetalava(ctx, implicits, implicitOutputs, javaVersion,
+ flags.bootClasspathArgs, flags.classpathArgs, flags.sourcepathArgs,
+ flags.metalavaStubsFlags+flags.metalavaAnnotationsFlags+
+ flags.metalavaApiLevelsAnnotationsFlags+flags.metalavaApiToXmlFlags+" "+d.Javadoc.args)
+
+ if apiCheckEnabled(d.properties.Check_api.Current, "current") &&
+ !ctx.Config().IsPdkBuild() {
apiFile := ctx.ExpandSource(String(d.properties.Check_api.Current.Api_file),
"check_api.current.api_file")
removedApiFile := ctx.ExpandSource(String(d.properties.Check_api.Current.Removed_api_file),
"check_api.current_removed_api_file")
d.checkCurrentApiTimestamp = android.PathForModuleOut(ctx, "check_current_api.timestamp")
- if !Bool(d.properties.Metalava_enabled) {
- d.transformCheckApi(ctx, apiFile, removedApiFile, checkApiClasspath,
- fmt.Sprintf(`\n******************************\n`+
- `You have tried to change the API from what has been previously approved.\n\n`+
- `To make these errors go away, you have two choices:\n`+
- ` 1. You can add '@hide' javadoc comments to the methods, etc. listed in the\n`+
- ` errors above.\n\n`+
- ` 2. You can update current.txt by executing the following command:\n`+
- ` make %s-update-current-api\n\n`+
- ` To submit the revised current.txt to the main Android repository,\n`+
- ` you will need approval.\n`+
- `******************************\n`, ctx.ModuleName()), String(d.properties.Check_api.Current.Args),
- d.checkCurrentApiTimestamp)
- } else {
- opts := flags.args + " --check-compatibility:api:current " + apiFile.String() +
- " --check-compatibility:removed:current " + removedApiFile.String() + " "
+ opts := d.Javadoc.args + " --check-compatibility:api:current " + apiFile.String() +
+ " --check-compatibility:removed:current " + removedApiFile.String() + " "
- d.transformMetalavaCheckApi(ctx, apiFile, removedApiFile, metalavaCheckApiImplicits,
- javaVersion, flags.bootClasspathArgs, flags.classpathArgs, opts,
- fmt.Sprintf(`\n******************************\n`+
- `You have tried to change the API from what has been previously approved.\n\n`+
- `To make these errors go away, you have two choices:\n`+
- ` 1. You can add '@hide' javadoc comments to the methods, etc. listed in the\n`+
- ` errors above.\n\n`+
- ` 2. You can update current.txt by executing the following command:\n`+
- ` make %s-update-current-api\n\n`+
- ` To submit the revised current.txt to the main Android repository,\n`+
- ` you will need approval.\n`+
- `******************************\n`, ctx.ModuleName()),
- d.checkCurrentApiTimestamp)
- }
+ d.transformCheckApi(ctx, apiFile, removedApiFile, metalavaCheckApiImplicits,
+ javaVersion, flags.bootClasspathArgs, flags.classpathArgs, flags.sourcepathArgs, opts,
+ fmt.Sprintf(`\n******************************\n`+
+ `You have tried to change the API from what has been previously approved.\n\n`+
+ `To make these errors go away, you have two choices:\n`+
+ ` 1. You can add '@hide' javadoc comments to the methods, etc. listed in the\n`+
+ ` errors above.\n\n`+
+ ` 2. You can update current.txt by executing the following command:\n`+
+ ` make %s-update-current-api\n\n`+
+ ` To submit the revised current.txt to the main Android repository,\n`+
+ ` you will need approval.\n`+
+ `******************************\n`, ctx.ModuleName()),
+ d.checkCurrentApiTimestamp)
d.updateCurrentApiTimestamp = android.PathForModuleOut(ctx, "update_current_api.timestamp")
- d.transformUpdateApi(ctx, apiFile, removedApiFile, d.updateCurrentApiTimestamp)
+ transformUpdateApi(ctx, apiFile, removedApiFile, d.apiFile, d.removedApiFile,
+ d.updateCurrentApiTimestamp)
}
- if d.checkLastReleasedApi() && !ctx.Config().IsPdkBuild() {
+ if apiCheckEnabled(d.properties.Check_api.Last_released, "last_released") &&
+ !ctx.Config().IsPdkBuild() {
apiFile := ctx.ExpandSource(String(d.properties.Check_api.Last_released.Api_file),
"check_api.last_released.api_file")
removedApiFile := ctx.ExpandSource(String(d.properties.Check_api.Last_released.Removed_api_file),
"check_api.last_released.removed_api_file")
d.checkLastReleasedApiTimestamp = android.PathForModuleOut(ctx, "check_last_released_api.timestamp")
- if !Bool(d.properties.Metalava_enabled) {
- d.transformCheckApi(ctx, apiFile, removedApiFile, checkApiClasspath,
- `\n******************************\n`+
- `You have tried to change the API from what has been previously released in\n`+
- `an SDK. Please fix the errors listed above.\n`+
- `******************************\n`, String(d.properties.Check_api.Last_released.Args),
- d.checkLastReleasedApiTimestamp)
- } else {
- opts := flags.args + " --check-compatibility:api:released " + apiFile.String() +
- " --check-compatibility:removed:released " + removedApiFile.String() + " "
+ opts := d.Javadoc.args + " --check-compatibility:api:released " + apiFile.String() +
+ " --check-compatibility:removed:released " + removedApiFile.String() + " "
- d.transformMetalavaCheckApi(ctx, apiFile, removedApiFile, metalavaCheckApiImplicits,
- javaVersion, flags.bootClasspathArgs, flags.classpathArgs, opts,
- `\n******************************\n`+
- `You have tried to change the API from what has been previously released in\n`+
- `an SDK. Please fix the errors listed above.\n`+
- `******************************\n`,
- d.checkLastReleasedApiTimestamp)
- }
+ d.transformCheckApi(ctx, apiFile, removedApiFile, metalavaCheckApiImplicits,
+ javaVersion, flags.bootClasspathArgs, flags.classpathArgs, flags.sourcepathArgs, opts,
+ `\n******************************\n`+
+ `You have tried to change the API from what has been previously released in\n`+
+ `an SDK. Please fix the errors listed above.\n`+
+ `******************************\n`,
+ d.checkLastReleasedApiTimestamp)
+ }
+
+ if Bool(d.properties.Jdiff_enabled) && !ctx.Config().IsPdkBuild() {
+
+ // Please sync with android-api-council@ before making any changes for the name of jdiffDocZip below
+ // since there's cron job downstream that fetch this .zip file periodically.
+ // See b/116221385 for reference.
+ d.jdiffDocZip = android.PathForModuleOut(ctx, ctx.ModuleName()+"-"+"jdiff-docs.zip")
+ d.jdiffStubsSrcJar = android.PathForModuleOut(ctx, ctx.ModuleName()+"-"+"jdiff-stubs.srcjar")
+
+ var jdiffImplicitOutputs android.WritablePaths
+ jdiffImplicitOutputs = append(jdiffImplicitOutputs, d.jdiffDocZip)
+
+ jdiff := android.PathForOutput(ctx, "host", ctx.Config().PrebuiltOS(), "framework", "jdiff.jar")
+ jdiffImplicits = append(jdiffImplicits, android.Paths{jdiff, d.apiXmlFile, d.lastReleasedApiXmlFile}...)
+
+ opts := " -encoding UTF-8 -source 1.8 -J-Xmx1600m -XDignore.symbol.file " +
+ "-doclet jdiff.JDiff -docletpath " + jdiff.String() + " -quiet " +
+ "-newapi " + strings.TrimSuffix(d.apiXmlFile.Base(), d.apiXmlFile.Ext()) +
+ " -newapidir " + filepath.Dir(d.apiXmlFile.String()) +
+ " -oldapi " + strings.TrimSuffix(d.lastReleasedApiXmlFile.Base(), d.lastReleasedApiXmlFile.Ext()) +
+ " -oldapidir " + filepath.Dir(d.lastReleasedApiXmlFile.String())
+
+ d.transformJdiff(ctx, jdiffImplicits, jdiffImplicitOutputs, flags.bootClasspathArgs, flags.classpathArgs,
+ flags.sourcepathArgs, opts)
}
}
@@ -1282,6 +1694,8 @@
//
var droiddocTemplateTag = dependencyTag{name: "droiddoc-template"}
var metalavaMergeAnnotationsDirTag = dependencyTag{name: "metalava-merge-annotations-dir"}
+var metalavaMergeInclusionAnnotationsDirTag = dependencyTag{name: "metalava-merge-inclusion-annotations-dir"}
+var metalavaAPILevelsAnnotationsDirTag = dependencyTag{name: "metalava-api-levels-annotations-dir"}
type ExportedDroiddocDirProperties struct {
// path to the directory containing Droiddoc related files.
@@ -1338,3 +1752,16 @@
return module
}
+
+func StubsDefaultsFactory() android.Module {
+ module := &DocDefaults{}
+
+ module.AddProperties(
+ &JavadocProperties{},
+ &DroidstubsProperties{},
+ )
+
+ android.InitDefaultsModule(module)
+
+ return module
+}
diff --git a/java/java.go b/java/java.go
index 6c664d8..3332482 100644
--- a/java/java.go
+++ b/java/java.go
@@ -75,7 +75,7 @@
// list of files to use as Java resources
Java_resources []string `android:"arch_variant"`
- // list of files that should be excluded from java_resources
+ // list of files that should be excluded from java_resources and java_resource_dirs
Exclude_java_resources []string `android:"arch_variant"`
// don't build against the default libraries (bootclasspath, legacy-test, core-junit,
@@ -138,7 +138,7 @@
// supported at compile time. It should only be needed to compile tests in
// packages that exist in libcore and which are inconvenient to move
// elsewhere.
- Patch_module *string
+ Patch_module *string `android:"arch_variant"`
Jacoco struct {
// List of classes to include for instrumentation with jacoco to collect coverage
@@ -311,6 +311,10 @@
// list of SDK lib names that this java moudule is exporting
exportedSdkLibs []string
+
+ // list of source files, collected from compiledJavaSrcs and compiledSrcJars
+ // filter out Exclude_srcs, will be used by android.IDEInfo struct
+ expandIDEInfoCompiledSrcs []string
}
func (j *Module) Srcs() android.Paths {
@@ -412,7 +416,7 @@
func sdkVersionOrDefault(ctx android.BaseContext, v string) string {
switch v {
- case "", "current", "system_current", "test_current", "core_current":
+ case "", "current", "system_current", "test_current", "core_current", "core_platform_current":
return ctx.Config().DefaultAppTargetSdk()
default:
return v
@@ -423,7 +427,7 @@
// it returns android.FutureApiLevel (10000).
func sdkVersionToNumber(ctx android.BaseContext, v string) (int, error) {
switch v {
- case "", "current", "test_current", "system_current", "core_current":
+ case "", "current", "test_current", "system_current", "core_current", "core_platform_current":
return ctx.Config().DefaultAppTargetSdkInt(), nil
default:
n := android.GetNumericSdkVersion(v)
@@ -520,6 +524,8 @@
}
if m == "core.current.stubs" {
ret.systemModules = "core-system-modules"
+ } else if m == "core.platform.api.stubs" {
+ ret.systemModules = "core-platform-api-stubs-system-modules"
}
return ret
}
@@ -542,6 +548,8 @@
return toModule("android_test_stubs_current", "framework-res")
case "core_current":
return toModule("core.current.stubs", "")
+ case "core_platform_current":
+ return toModule("core.platform.api.stubs", "")
default:
return toPrebuilt(v)
}
@@ -553,16 +561,12 @@
sdkDep := decodeSdkDep(ctx, sdkContext(j))
if sdkDep.useDefaultLibs {
ctx.AddVariationDependencies(nil, bootClasspathTag, config.DefaultBootclasspathLibraries...)
- if ctx.Config().TargetOpenJDK9() {
- ctx.AddVariationDependencies(nil, systemModulesTag, config.DefaultSystemModules)
- }
+ ctx.AddVariationDependencies(nil, systemModulesTag, config.DefaultSystemModules)
if !Bool(j.properties.No_framework_libs) {
ctx.AddVariationDependencies(nil, libTag, config.DefaultLibraries...)
}
} else if sdkDep.useModule {
- if ctx.Config().TargetOpenJDK9() {
- ctx.AddVariationDependencies(nil, systemModulesTag, sdkDep.systemModules)
- }
+ ctx.AddVariationDependencies(nil, systemModulesTag, sdkDep.systemModules)
ctx.AddVariationDependencies(nil, bootClasspathTag, sdkDep.modules...)
if Bool(j.deviceProperties.Optimize.Enabled) {
ctx.AddVariationDependencies(nil, proguardRaiseTag, config.DefaultBootclasspathLibraries...)
@@ -572,7 +576,7 @@
} else if j.deviceProperties.System_modules == nil {
ctx.PropertyErrorf("no_standard_libs",
"system_modules is required to be set when no_standard_libs is true, did you mean no_framework_libs?")
- } else if *j.deviceProperties.System_modules != "none" && ctx.Config().TargetOpenJDK9() {
+ } else if *j.deviceProperties.System_modules != "none" {
ctx.AddVariationDependencies(nil, systemModulesTag, *j.deviceProperties.System_modules)
}
if (ctx.ModuleName() == "framework") || (ctx.ModuleName() == "framework-annotation-proc") {
@@ -708,8 +712,9 @@
ver := m.sdkVersion()
noStdLibs := Bool(m.properties.No_standard_libs)
switch {
- case name == "core.current.stubs" || ver == "core_current" || noStdLibs || name == "stub-annotations" ||
- name == "private-stub-annotations-jar":
+ case name == "core.current.stubs" || ver == "core_current" ||
+ name == "core.platform.api.stubs" || ver == "core_platform_current" ||
+ noStdLibs || name == "stub-annotations" || name == "private-stub-annotations-jar":
return javaCore
case name == "android_system_stubs_current" || strings.HasPrefix(ver, "system_"):
return javaSystem
@@ -900,9 +905,12 @@
var flags javaBuilderFlags
+ // javaVersion flag.
+ flags.javaVersion = getJavaVersion(ctx, String(j.properties.Java_version), sdkContext(j))
+
// javac flags.
javacFlags := j.properties.Javacflags
- if ctx.Config().TargetOpenJDK9() {
+ if flags.javaVersion == "1.9" {
javacFlags = append(javacFlags, j.properties.Openjdk9.Javacflags...)
}
if ctx.Config().MinimizeJavaDebugInfo() {
@@ -927,15 +935,12 @@
flags.errorProneProcessorPath = classpath(android.PathsForSource(ctx, config.ErrorProneClasspath))
}
- // javaVersion flag.
- flags.javaVersion = getJavaVersion(ctx, String(j.properties.Java_version), sdkContext(j))
-
// classpath
flags.bootClasspath = append(flags.bootClasspath, deps.bootClasspath...)
flags.classpath = append(flags.classpath, deps.classpath...)
flags.processorPath = append(flags.processorPath, deps.processorPath...)
- if len(flags.bootClasspath) == 0 && ctx.Host() && !ctx.Config().TargetOpenJDK9() &&
+ if len(flags.bootClasspath) == 0 && ctx.Host() && flags.javaVersion != "1.9" &&
!Bool(j.properties.No_standard_libs) &&
inList(flags.javaVersion, []string{"1.6", "1.7", "1.8"}) {
// Give host-side tools a version of OpenJDK's standard libraries
@@ -961,7 +966,7 @@
}
}
- if j.properties.Patch_module != nil && ctx.Config().TargetOpenJDK9() {
+ if j.properties.Patch_module != nil && flags.javaVersion == "1.9" {
patchClasspath := ".:" + flags.classpath.FormJavaClassPath("")
javacFlags = append(javacFlags, "--patch-module="+String(j.properties.Patch_module)+"="+patchClasspath)
}
@@ -995,7 +1000,7 @@
deps := j.collectDeps(ctx)
flags := j.collectBuilderFlags(ctx, deps)
- if ctx.Config().TargetOpenJDK9() {
+ if flags.javaVersion == "1.9" {
j.properties.Srcs = append(j.properties.Srcs, j.properties.Openjdk9.Srcs...)
}
srcFiles := ctx.ExpandSources(j.properties.Srcs, j.properties.Exclude_srcs)
@@ -1009,6 +1014,10 @@
srcJars = append(srcJars, deps.srcJars...)
srcJars = append(srcJars, extraSrcJars...)
+ // Collect source files from compiledJavaSrcs, compiledSrcJars and filter out Exclude_srcs
+ // that IDEInfo struct will use
+ j.expandIDEInfoCompiledSrcs = append(j.expandIDEInfoCompiledSrcs, srcFiles.Strings()...)
+
jarName := ctx.ModuleName() + ".jar"
javaSrcFiles := srcFiles.FilterByExt(".java")
@@ -1118,7 +1127,8 @@
}
}
- dirArgs, dirDeps := ResourceDirsToJarArgs(ctx, j.properties.Java_resource_dirs, j.properties.Exclude_java_resource_dirs)
+ dirArgs, dirDeps := ResourceDirsToJarArgs(ctx, j.properties.Java_resource_dirs,
+ j.properties.Exclude_java_resource_dirs, j.properties.Exclude_java_resources)
fileArgs, fileDeps := ResourceFilesToJarArgs(ctx, j.properties.Java_resources, j.properties.Exclude_java_resources)
var resArgs []string
@@ -1360,6 +1370,23 @@
return j.logtagsSrcs
}
+// Collect information for opening IDE project files in java/jdeps.go.
+func (j *Module) IDEInfo(dpInfo *android.IdeInfo) {
+ dpInfo.Deps = append(dpInfo.Deps, j.CompilerDeps()...)
+ dpInfo.Srcs = append(dpInfo.Srcs, j.expandIDEInfoCompiledSrcs...)
+ dpInfo.Aidl_include_dirs = append(dpInfo.Aidl_include_dirs, j.deviceProperties.Aidl.Include_dirs...)
+ if j.properties.Jarjar_rules != nil {
+ dpInfo.Jarjar_rules = append(dpInfo.Jarjar_rules, *j.properties.Jarjar_rules)
+ }
+}
+
+func (j *Module) CompilerDeps() []string {
+ jdeps := []string{}
+ jdeps = append(jdeps, j.properties.Libs...)
+ jdeps = append(jdeps, j.properties.Static_libs...)
+ return jdeps
+}
+
//
// Java libraries (.jar file)
//
@@ -1689,6 +1716,26 @@
return j.exportedSdkLibs
}
+// Collect information for opening IDE project files in java/jdeps.go.
+const (
+ removedPrefix = "prebuilt_"
+)
+
+func (j *Import) IDEInfo(dpInfo *android.IdeInfo) {
+ dpInfo.Jars = append(dpInfo.Jars, j.PrebuiltSrcs()...)
+}
+
+func (j *Import) IDECustomizedModuleName() string {
+ // TODO(b/113562217): Extract the base module name from the Import name, often the Import name
+ // has a prefix "prebuilt_". Remove the prefix explicitly if needed until we find a better
+ // solution to get the Import name.
+ name := j.Name()
+ if strings.HasPrefix(name, removedPrefix) {
+ name = strings.Trim(name, removedPrefix)
+ }
+ return name
+}
+
var _ android.PrebuiltInterface = (*Import)(nil)
func ImportFactory() android.Module {
diff --git a/java/java_resources.go b/java/java_resources.go
index e02709d..4d8a757 100644
--- a/java/java_resources.go
+++ b/java/java_resources.go
@@ -20,6 +20,8 @@
"strings"
"android/soong/android"
+
+ "github.com/google/blueprint/pathtools"
)
var resourceExcludes = []string{
@@ -32,7 +34,7 @@
}
func ResourceDirsToJarArgs(ctx android.ModuleContext,
- resourceDirs, excludeResourceDirs []string) (args []string, deps android.Paths) {
+ resourceDirs, excludeResourceDirs, excludeResourceFiles []string) (args []string, deps android.Paths) {
var excludeDirs []string
var excludeFiles []string
@@ -44,6 +46,8 @@
}
}
+ excludeFiles = append(excludeFiles, ctx.ExpandSources(excludeResourceFiles, nil).Strings()...)
+
excludeFiles = append(excludeFiles, resourceExcludes...)
for _, resourceDir := range resourceDirs {
@@ -62,7 +66,7 @@
if !strings.HasPrefix(path, dir.String()) {
panic(fmt.Errorf("path %q does not start with %q", path, dir))
}
- args = append(args, "-f", path)
+ args = append(args, "-f", pathtools.MatchEscape(path))
}
}
}
@@ -105,7 +109,7 @@
if i == 0 || dir != lastDir {
args = append(args, "-C", dir)
}
- args = append(args, "-f", path)
+ args = append(args, "-f", pathtools.MatchEscape(path))
lastDir = dir
}
diff --git a/java/java_test.go b/java/java_test.go
index 3ace528..82accd5 100644
--- a/java/java_test.go
+++ b/java/java_test.go
@@ -702,6 +702,30 @@
prop: `java_resource_dirs: ["java-res/*"], exclude_java_resource_dirs: ["java-res/b"]`,
args: "-C java-res/a -f java-res/a/a",
},
+ {
+ // Test wildcards in java_resources
+ name: "wildcard files",
+ prop: `java_resources: ["java-res/**/*"]`,
+ args: "-C . -f java-res/a/a -f java-res/b/b",
+ },
+ {
+ // Test exclude_java_resources with java_resources
+ name: "wildcard files with exclude",
+ prop: `java_resources: ["java-res/**/*"], exclude_java_resources: ["java-res/b/*"]`,
+ args: "-C . -f java-res/a/a",
+ },
+ {
+ // Test exclude_java_resources with java_resource_dirs
+ name: "resource dirs with exclude files",
+ prop: `java_resource_dirs: ["java-res"], exclude_java_resources: ["java-res/b/b"]`,
+ args: "-C java-res -f java-res/a/a",
+ },
+ {
+ // Test exclude_java_resource_dirs with java_resource_dirs
+ name: "resource dirs with exclude files",
+ prop: `java_resource_dirs: ["java-res", "java-res2"], exclude_java_resource_dirs: ["java-res2"]`,
+ args: "-C java-res -f java-res/a/a -f java-res/b/b",
+ },
}
for _, test := range table {
@@ -734,42 +758,6 @@
}
}
-func TestExcludeResources(t *testing.T) {
- ctx := testJava(t, `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- java_resource_dirs: ["java-res", "java-res2"],
- exclude_java_resource_dirs: ["java-res2"],
- }
-
- java_library {
- name: "bar",
- srcs: ["a.java"],
- java_resources: ["java-res/*/*"],
- exclude_java_resources: ["java-res/b/*"],
- }
- `)
-
- fooRes := ctx.ModuleForTests("foo", "android_common").Output("res/foo.jar")
-
- expected := "-C java-res -f java-res/a/a -f java-res/b/b"
- if fooRes.Args["jarArgs"] != expected {
- t.Errorf("foo resource jar args %q is not %q",
- fooRes.Args["jarArgs"], expected)
-
- }
-
- barRes := ctx.ModuleForTests("bar", "android_common").Output("res/bar.jar")
-
- expected = "-C . -f java-res/a/a"
- if barRes.Args["jarArgs"] != expected {
- t.Errorf("bar resource jar args %q is not %q",
- barRes.Args["jarArgs"], expected)
-
- }
-}
-
func TestGeneratedSources(t *testing.T) {
ctx := testJava(t, `
java_library {
diff --git a/java/jdeps.go b/java/jdeps.go
new file mode 100644
index 0000000..c7fa42a
--- /dev/null
+++ b/java/jdeps.go
@@ -0,0 +1,109 @@
+// Copyright 2018 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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 java
+
+import (
+ "encoding/json"
+ "fmt"
+ "os"
+
+ "android/soong/android"
+)
+
+// This singleton generates android java dependency into to a json file. It does so for each
+// blueprint Android.bp resulting in a java.Module when either make, mm, mma, mmm or mmma is
+// called. Dependency info file is generated in $OUT/module_bp_java_depend.json.
+
+func init() {
+ android.RegisterSingletonType("jdeps_generator", jDepsGeneratorSingleton)
+}
+
+func jDepsGeneratorSingleton() android.Singleton {
+ return &jdepsGeneratorSingleton{}
+}
+
+type jdepsGeneratorSingleton struct {
+}
+
+const (
+ // Environment variables used to modify behavior of this singleton.
+ envVariableCollectJavaDeps = "SOONG_COLLECT_JAVA_DEPS"
+ jdepsJsonFileName = "module_bp_java_deps.json"
+)
+
+func (j *jdepsGeneratorSingleton) GenerateBuildActions(ctx android.SingletonContext) {
+ if !ctx.Config().IsEnvTrue(envVariableCollectJavaDeps) {
+ return
+ }
+
+ moduleInfos := make(map[string]android.IdeInfo)
+
+ ctx.VisitAllModules(func(module android.Module) {
+ ideInfoProvider, ok := module.(android.IDEInfo)
+ if !ok {
+ return
+ }
+ name := ideInfoProvider.BaseModuleName()
+ ideModuleNameProvider, ok := module.(android.IDECustomizedModuleName)
+ if ok {
+ name = ideModuleNameProvider.IDECustomizedModuleName()
+ }
+
+ dpInfo := moduleInfos[name]
+ ideInfoProvider.IDEInfo(&dpInfo)
+ dpInfo.Deps = android.FirstUniqueStrings(dpInfo.Deps)
+ dpInfo.Srcs = android.FirstUniqueStrings(dpInfo.Srcs)
+ dpInfo.Aidl_include_dirs = android.FirstUniqueStrings(dpInfo.Aidl_include_dirs)
+ dpInfo.Jarjar_rules = android.FirstUniqueStrings(dpInfo.Jarjar_rules)
+ dpInfo.Jars = android.FirstUniqueStrings(dpInfo.Jars)
+ moduleInfos[name] = dpInfo
+
+ mkProvider, ok := module.(android.AndroidMkDataProvider)
+ if !ok {
+ return
+ }
+ data := mkProvider.AndroidMk()
+ if data.Class != "" {
+ dpInfo.Classes = append(dpInfo.Classes, data.Class)
+ }
+ out := data.OutputFile.String()
+ if out != "" {
+ dpInfo.Installed_paths = append(dpInfo.Installed_paths, out)
+ }
+ dpInfo.Classes = android.FirstUniqueStrings(dpInfo.Classes)
+ dpInfo.Installed_paths = android.FirstUniqueStrings(dpInfo.Installed_paths)
+ moduleInfos[name] = dpInfo
+ })
+
+ jfpath := android.PathForOutput(ctx, jdepsJsonFileName).String()
+ err := createJsonFile(moduleInfos, jfpath)
+ if err != nil {
+ ctx.Errorf(err.Error())
+ }
+}
+
+func createJsonFile(moduleInfos map[string]android.IdeInfo, jfpath string) error {
+ file, err := os.Create(jfpath)
+ if err != nil {
+ return fmt.Errorf("Failed to create file: %s, relative: %v", jdepsJsonFileName, err)
+ }
+ defer file.Close()
+ buf, err := json.MarshalIndent(moduleInfos, "", "\t")
+ if err != nil {
+ return fmt.Errorf("Write file failed: %s, relative: %v", jdepsJsonFileName, err)
+ }
+ fmt.Fprintf(file, string(buf))
+ return nil
+}
diff --git a/java/jdeps_test.go b/java/jdeps_test.go
new file mode 100644
index 0000000..ca8a3cd
--- /dev/null
+++ b/java/jdeps_test.go
@@ -0,0 +1,87 @@
+// Copyright 2018 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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 java
+
+import (
+ "reflect"
+ "testing"
+
+ "android/soong/android"
+)
+
+func TestCollectJavaLibraryPropertiesAddLibsDeps(t *testing.T) {
+ expected := []string{"Foo", "Bar"}
+ module := LibraryFactory().(*Library)
+ module.properties.Libs = append(module.properties.Libs, expected...)
+ dpInfo := &android.IdeInfo{}
+
+ module.IDEInfo(dpInfo)
+
+ if !reflect.DeepEqual(dpInfo.Deps, expected) {
+ t.Errorf("Library.IDEInfo() Deps = %v, want %v", dpInfo.Deps, expected)
+ }
+}
+
+func TestCollectJavaLibraryPropertiesAddStaticLibsDeps(t *testing.T) {
+ expected := []string{"Foo", "Bar"}
+ module := LibraryFactory().(*Library)
+ module.properties.Static_libs = append(module.properties.Static_libs, expected...)
+ dpInfo := &android.IdeInfo{}
+
+ module.IDEInfo(dpInfo)
+
+ if !reflect.DeepEqual(dpInfo.Deps, expected) {
+ t.Errorf("Library.IDEInfo() Deps = %v, want %v", dpInfo.Deps, expected)
+ }
+}
+
+func TestCollectJavaLibraryPropertiesAddScrs(t *testing.T) {
+ expected := []string{"Foo", "Bar"}
+ module := LibraryFactory().(*Library)
+ module.expandIDEInfoCompiledSrcs = append(module.expandIDEInfoCompiledSrcs, expected...)
+ dpInfo := &android.IdeInfo{}
+
+ module.IDEInfo(dpInfo)
+
+ if !reflect.DeepEqual(dpInfo.Srcs, expected) {
+ t.Errorf("Library.IDEInfo() Srcs = %v, want %v", dpInfo.Srcs, expected)
+ }
+}
+
+func TestCollectJavaLibraryPropertiesAddAidlIncludeDirs(t *testing.T) {
+ expected := []string{"Foo", "Bar"}
+ module := LibraryFactory().(*Library)
+ module.deviceProperties.Aidl.Include_dirs = append(module.deviceProperties.Aidl.Include_dirs, expected...)
+ dpInfo := &android.IdeInfo{}
+
+ module.IDEInfo(dpInfo)
+
+ if !reflect.DeepEqual(dpInfo.Aidl_include_dirs, expected) {
+ t.Errorf("Library.IDEInfo() Aidl_include_dirs = %v, want %v", dpInfo.Aidl_include_dirs, expected)
+ }
+}
+
+func TestCollectJavaLibraryPropertiesAddJarjarRules(t *testing.T) {
+ expected := "Jarjar_rules.txt"
+ module := LibraryFactory().(*Library)
+ module.properties.Jarjar_rules = &expected
+ dpInfo := &android.IdeInfo{}
+
+ module.IDEInfo(dpInfo)
+
+ if dpInfo.Jarjar_rules[0] != expected {
+ t.Errorf("Library.IDEInfo() Jarjar_rules = %v, want %v", dpInfo.Jarjar_rules[0], expected)
+ }
+}
diff --git a/java/sdk_library.go b/java/sdk_library.go
index d588801..3e6908b 100644
--- a/java/sdk_library.go
+++ b/java/sdk_library.go
@@ -217,38 +217,45 @@
fmt.Fprintln(w, "LOCAL_MODULE :=", name)
fmt.Fprintln(w, "LOCAL_REQUIRED_MODULES := "+module.implName())
fmt.Fprintln(w, "include $(BUILD_PHONY_PACKAGE)")
+ owner := module.ModuleBase.Owner()
+ if owner == "" {
+ owner = "android"
+ }
// Create dist rules to install the stubs libs to the dist dir
if len(module.publicApiStubsPath) == 1 {
fmt.Fprintln(w, "$(call dist-for-goals,sdk win_sdk,"+
module.publicApiStubsPath.Strings()[0]+
- ":"+path.Join("apistubs", "public", module.BaseModuleName()+".jar")+")")
+ ":"+path.Join("apistubs", owner, "public",
+ module.BaseModuleName()+".jar")+")")
}
if len(module.systemApiStubsPath) == 1 {
fmt.Fprintln(w, "$(call dist-for-goals,sdk win_sdk,"+
module.systemApiStubsPath.Strings()[0]+
- ":"+path.Join("apistubs", "system", module.BaseModuleName()+".jar")+")")
+ ":"+path.Join("apistubs", owner, "system",
+ module.BaseModuleName()+".jar")+")")
}
if len(module.testApiStubsPath) == 1 {
fmt.Fprintln(w, "$(call dist-for-goals,sdk win_sdk,"+
module.testApiStubsPath.Strings()[0]+
- ":"+path.Join("apistubs", "test", module.BaseModuleName()+".jar")+")")
+ ":"+path.Join("apistubs", owner, "test",
+ module.BaseModuleName()+".jar")+")")
}
if module.publicApiFilePath != nil {
fmt.Fprintln(w, "$(call dist-for-goals,sdk win_sdk,"+
module.publicApiFilePath.String()+
- ":"+path.Join("apistubs", "public", "api",
+ ":"+path.Join("apistubs", owner, "public", "api",
module.BaseModuleName()+".txt")+")")
}
if module.systemApiFilePath != nil {
fmt.Fprintln(w, "$(call dist-for-goals,sdk win_sdk,"+
module.systemApiFilePath.String()+
- ":"+path.Join("apistubs", "system", "api",
+ ":"+path.Join("apistubs", owner, "system", "api",
module.BaseModuleName()+".txt")+")")
}
if module.testApiFilePath != nil {
fmt.Fprintln(w, "$(call dist-for-goals,sdk win_sdk,"+
module.testApiFilePath.String()+
- ":"+path.Join("apistubs", "test", "api",
+ ":"+path.Join("apistubs", owner, "test", "api",
module.BaseModuleName()+".txt")+")")
}
},
diff --git a/scripts/manifest_fixer.py b/scripts/manifest_fixer.py
index db35c8d..b6fe34e 100755
--- a/scripts/manifest_fixer.py
+++ b/scripts/manifest_fixer.py
@@ -49,6 +49,10 @@
parser = argparse.ArgumentParser()
parser.add_argument('--minSdkVersion', default='', dest='min_sdk_version',
help='specify minSdkVersion used by the build system')
+ parser.add_argument('--targetSdkVersion', default='', dest='target_sdk_version',
+ help='specify targetSdkVersion used by the build system')
+ parser.add_argument('--raise-min-sdk-version', dest='raise_min_sdk_version', action='store_true',
+ help='raise the minimum sdk version in the manifest if necessary')
parser.add_argument('--library', dest='library', action='store_true',
help='manifest is for a static library')
parser.add_argument('--uses-library', dest='uses_libraries', action='append',
@@ -130,12 +134,13 @@
return indent
-def raise_min_sdk_version(doc, requested, library):
+def raise_min_sdk_version(doc, min_sdk_version, target_sdk_version, library):
"""Ensure the manifest contains a <uses-sdk> tag with a minSdkVersion.
Args:
doc: The XML document. May be modified by this function.
- requested: The requested minSdkVersion attribute.
+ min_sdk_version: The requested minSdkVersion attribute.
+ target_sdk_version: The requested targetSdkVersion attribute.
Raises:
RuntimeError: invalid manifest
"""
@@ -162,11 +167,11 @@
min_attr = element.getAttributeNodeNS(android_ns, 'minSdkVersion')
if min_attr is None:
min_attr = doc.createAttributeNS(android_ns, 'android:minSdkVersion')
- min_attr.value = requested
+ min_attr.value = min_sdk_version
element.setAttributeNode(min_attr)
else:
- if compare_version_gt(requested, min_attr.value):
- min_attr.value = requested
+ if compare_version_gt(min_sdk_version, min_attr.value):
+ min_attr.value = min_sdk_version
# Insert the targetSdkVersion attribute if it is missing. If it is already
# present leave it as is.
@@ -176,7 +181,7 @@
if library:
target_attr.value = '1'
else:
- target_attr.value = requested
+ target_attr.value = target_sdk_version
element.setAttributeNode(target_attr)
@@ -271,8 +276,8 @@
ensure_manifest_android_ns(doc)
- if args.min_sdk_version:
- raise_min_sdk_version(doc, args.min_sdk_version, args.library)
+ if args.raise_min_sdk_version:
+ raise_min_sdk_version(doc, args.min_sdk_version, args.target_sdk_version, args.library)
if args.uses_libraries:
add_uses_libraries(doc, args.uses_libraries)
diff --git a/scripts/manifest_fixer_test.py b/scripts/manifest_fixer_test.py
index ac72e6d..66a2317 100755
--- a/scripts/manifest_fixer_test.py
+++ b/scripts/manifest_fixer_test.py
@@ -54,9 +54,11 @@
class RaiseMinSdkVersionTest(unittest.TestCase):
"""Unit tests for raise_min_sdk_version function."""
- def raise_min_sdk_version_test(self, input_manifest, min_sdk_version, library):
+ def raise_min_sdk_version_test(self, input_manifest, min_sdk_version,
+ target_sdk_version, library):
doc = minidom.parseString(input_manifest)
- manifest_fixer.raise_min_sdk_version(doc, min_sdk_version, library)
+ manifest_fixer.raise_min_sdk_version(doc, min_sdk_version,
+ target_sdk_version, library)
output = StringIO.StringIO()
manifest_fixer.write_xml(output, doc)
return output.getvalue()
@@ -69,13 +71,13 @@
# pylint: disable=redefined-builtin
def uses_sdk(self, min=None, target=None, extra=''):
- attrs = ""
+ attrs = ''
if min:
attrs += ' android:minSdkVersion="%s"' % (min)
if target:
attrs += ' android:targetSdkVersion="%s"' % (target)
if extra:
- attrs += ' ' + extra
+ attrs += ' ' + extra
return ' <uses-sdk%s/>\n' % (attrs)
def test_no_uses_sdk(self):
@@ -83,7 +85,7 @@
manifest_input = self.manifest_tmpl % ''
expected = self.manifest_tmpl % self.uses_sdk(min='28', target='28')
- output = self.raise_min_sdk_version_test(manifest_input, '28', False)
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '28', False)
self.assertEqual(output, expected)
def test_no_min(self):
@@ -92,47 +94,47 @@
manifest_input = self.manifest_tmpl % ' <uses-sdk extra="foo"/>\n'
expected = self.manifest_tmpl % self.uses_sdk(min='28', target='28',
extra='extra="foo"')
- output = self.raise_min_sdk_version_test(manifest_input, '28', False)
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '28', False)
self.assertEqual(output, expected)
def test_raise_min(self):
"""Tests inserting a minSdkVersion attribute into a uses-sdk element."""
manifest_input = self.manifest_tmpl % self.uses_sdk(min='27')
- expected = self.manifest_tmpl % self.uses_sdk(min='28', target='27')
- output = self.raise_min_sdk_version_test(manifest_input, '28', False)
+ expected = self.manifest_tmpl % self.uses_sdk(min='28', target='28')
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '28', False)
self.assertEqual(output, expected)
def test_raise(self):
"""Tests raising a minSdkVersion attribute."""
manifest_input = self.manifest_tmpl % self.uses_sdk(min='27')
- expected = self.manifest_tmpl % self.uses_sdk(min='28', target='27')
- output = self.raise_min_sdk_version_test(manifest_input, '28', False)
+ expected = self.manifest_tmpl % self.uses_sdk(min='28', target='28')
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '28', False)
self.assertEqual(output, expected)
def test_no_raise_min(self):
"""Tests a minSdkVersion that doesn't need raising."""
manifest_input = self.manifest_tmpl % self.uses_sdk(min='28')
- expected = self.manifest_tmpl % self.uses_sdk(min='28', target='28')
- output = self.raise_min_sdk_version_test(manifest_input, '27', False)
+ expected = self.manifest_tmpl % self.uses_sdk(min='28', target='27')
+ output = self.raise_min_sdk_version_test(manifest_input, '27', '27', False)
self.assertEqual(output, expected)
def test_raise_codename(self):
"""Tests raising a minSdkVersion attribute to a codename."""
manifest_input = self.manifest_tmpl % self.uses_sdk(min='28')
- expected = self.manifest_tmpl % self.uses_sdk(min='P', target='28')
- output = self.raise_min_sdk_version_test(manifest_input, 'P', False)
+ expected = self.manifest_tmpl % self.uses_sdk(min='P', target='P')
+ output = self.raise_min_sdk_version_test(manifest_input, 'P', 'P', False)
self.assertEqual(output, expected)
def test_no_raise_codename(self):
"""Tests a minSdkVersion codename that doesn't need raising."""
manifest_input = self.manifest_tmpl % self.uses_sdk(min='P')
- expected = self.manifest_tmpl % self.uses_sdk(min='P', target='P')
- output = self.raise_min_sdk_version_test(manifest_input, '28', False)
+ expected = self.manifest_tmpl % self.uses_sdk(min='P', target='28')
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '28', False)
self.assertEqual(output, expected)
def test_target(self):
@@ -140,56 +142,56 @@
manifest_input = self.manifest_tmpl % self.uses_sdk(min='26', target='27')
expected = self.manifest_tmpl % self.uses_sdk(min='28', target='27')
- output = self.raise_min_sdk_version_test(manifest_input, '28', False)
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '29', False)
self.assertEqual(output, expected)
def test_no_target(self):
"""Tests inserting targetSdkVersion when minSdkVersion exists."""
manifest_input = self.manifest_tmpl % self.uses_sdk(min='27')
- expected = self.manifest_tmpl % self.uses_sdk(min='28', target='27')
- output = self.raise_min_sdk_version_test(manifest_input, '28', False)
+ expected = self.manifest_tmpl % self.uses_sdk(min='28', target='29')
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '29', False)
self.assertEqual(output, expected)
def test_target_no_min(self):
- """Tests inserting targetSdkVersion when minSdkVersion exists."""
+ """"Tests inserting targetSdkVersion when minSdkVersion exists."""
- manifest_input = self.manifest_tmpl % self.uses_sdk(target='27')
- expected = self.manifest_tmpl % self.uses_sdk(min='28', target='27')
- output = self.raise_min_sdk_version_test(manifest_input, '28', False)
- self.assertEqual(output, expected)
+ manifest_input = self.manifest_tmpl % self.uses_sdk(target='27')
+ expected = self.manifest_tmpl % self.uses_sdk(min='28', target='27')
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '29', False)
+ self.assertEqual(output, expected)
def test_no_target_no_min(self):
"""Tests inserting targetSdkVersion when minSdkVersion does not exist."""
manifest_input = self.manifest_tmpl % ''
- expected = self.manifest_tmpl % self.uses_sdk(min='28', target='28')
- output = self.raise_min_sdk_version_test(manifest_input, '28', False)
+ expected = self.manifest_tmpl % self.uses_sdk(min='28', target='29')
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '29', False)
self.assertEqual(output, expected)
def test_library_no_target(self):
- """Tests inserting targetSdkVersion when minSdkVersion exists."""
+ """Tests inserting targetSdkVersion when minSdkVersion exists."""
- manifest_input = self.manifest_tmpl % self.uses_sdk(min='27')
- expected = self.manifest_tmpl % self.uses_sdk(min='28', target='27')
- output = self.raise_min_sdk_version_test(manifest_input, '28', True)
- self.assertEqual(output, expected)
+ manifest_input = self.manifest_tmpl % self.uses_sdk(min='27')
+ expected = self.manifest_tmpl % self.uses_sdk(min='28', target='1')
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '29', True)
+ self.assertEqual(output, expected)
def test_library_target_no_min(self):
- """Tests inserting targetSdkVersion when minSdkVersion exists."""
+ """Tests inserting targetSdkVersion when minSdkVersion exists."""
- manifest_input = self.manifest_tmpl % self.uses_sdk(target='27')
- expected = self.manifest_tmpl % self.uses_sdk(min='28', target='27')
- output = self.raise_min_sdk_version_test(manifest_input, '28', True)
- self.assertEqual(output, expected)
+ manifest_input = self.manifest_tmpl % self.uses_sdk(target='27')
+ expected = self.manifest_tmpl % self.uses_sdk(min='28', target='27')
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '29', True)
+ self.assertEqual(output, expected)
def test_library_no_target_no_min(self):
- """Tests inserting targetSdkVersion when minSdkVersion does not exist."""
+ """Tests inserting targetSdkVersion when minSdkVersion does not exist."""
- manifest_input = self.manifest_tmpl % ''
- expected = self.manifest_tmpl % self.uses_sdk(min='28', target='1')
- output = self.raise_min_sdk_version_test(manifest_input, '28', True)
- self.assertEqual(output, expected)
+ manifest_input = self.manifest_tmpl % ''
+ expected = self.manifest_tmpl % self.uses_sdk(min='28', target='1')
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '29', True)
+ self.assertEqual(output, expected)
def test_extra(self):
"""Tests that extra attributes and elements are maintained."""
@@ -202,10 +204,10 @@
# pylint: disable=line-too-long
expected = self.manifest_tmpl % (
' <!-- comment -->\n'
- ' <uses-sdk android:minSdkVersion="28" android:targetSdkVersion="27" extra="foo"/>\n'
+ ' <uses-sdk android:minSdkVersion="28" android:targetSdkVersion="29" extra="foo"/>\n'
' <application/>\n')
- output = self.raise_min_sdk_version_test(manifest_input, '28', False)
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '29', False)
self.assertEqual(output, expected)
@@ -216,10 +218,10 @@
# pylint: disable=line-too-long
expected = self.manifest_tmpl % (
- ' <uses-sdk android:minSdkVersion="28" android:targetSdkVersion="28"/>\n'
+ ' <uses-sdk android:minSdkVersion="28" android:targetSdkVersion="29"/>\n'
' <!-- comment -->\n')
- output = self.raise_min_sdk_version_test(manifest_input, '28', False)
+ output = self.raise_min_sdk_version_test(manifest_input, '28', '29', False)
self.assertEqual(output, expected)
diff --git a/scripts/strip.sh b/scripts/strip.sh
index d184a97..bfc66ee 100755
--- a/scripts/strip.sh
+++ b/scripts/strip.sh
@@ -29,6 +29,8 @@
# --keep-symbols
# --use-llvm-strip
+set -o pipefail
+
OPTSTRING=d:i:o:-:
usage() {
@@ -63,9 +65,9 @@
# we have not found a use case that is broken by objcopy yet.
REMOVE_SECTIONS=`"${CROSS_COMPILE}readelf" -S "${infile}" | awk '/.debug_/ {print "--remove-section " $2}' | xargs`
if [ ! -z "${use_llvm_strip}" ]; then
- "${CROSS_COMPILE}objcopy" "${infile}" "${outfile}.tmp" ${REMOVE_SECTIONS}
- else
"${CLANG_BIN}/llvm-objcopy" "${infile}" "${outfile}.tmp" ${REMOVE_SECTIONS}
+ else
+ "${CROSS_COMPILE}objcopy" "${infile}" "${outfile}.tmp" ${REMOVE_SECTIONS}
fi
}
@@ -83,7 +85,7 @@
# For the following use cases, ${CROSS_COMPILE}objcopy does fine with lld linked files,
# except the --add-section flag.
"${CROSS_COMPILE}objcopy" --only-keep-debug "${infile}" "${outfile}.debug"
- "${CROSS_COMPILE}nm" -D "${infile}" --format=posix --defined-only | awk '{ print $1 }' | sort >"${outfile}.dynsyms"
+ "${CROSS_COMPILE}nm" -D "${infile}" --format=posix --defined-only 2> /dev/null | awk '{ print $1 }' | sort >"${outfile}.dynsyms"
"${CROSS_COMPILE}nm" "${infile}" --format=posix --defined-only | awk '{ if ($2 == "T" || $2 == "t" || $2 == "D") print $1 }' | sort > "${outfile}.funcsyms"
comm -13 "${outfile}.dynsyms" "${outfile}.funcsyms" > "${outfile}.keep_symbols"
echo >> "${outfile}.keep_symbols" # Ensure that the keep_symbols file is not empty.
diff --git a/scripts/toc.sh b/scripts/toc.sh
index bd6425b..8b1d25f 100755
--- a/scripts/toc.sh
+++ b/scripts/toc.sh
@@ -22,6 +22,7 @@
# -i ${file}: input file (required)
# -o ${file}: output file (required)
# -d ${file}: deps file (required)
+# --elf | --macho | --pe: format (required)
OPTSTRING=d:i:o:-:
@@ -36,13 +37,34 @@
do_elf() {
("${CROSS_COMPILE}readelf" -d "${infile}" | grep SONAME || echo "No SONAME for ${infile}") > "${outfile}.tmp"
"${CROSS_COMPILE}readelf" --dyn-syms "${infile}" | awk '{$2=""; $3=""; print}' >> "${outfile}.tmp"
+
+ cat <<EOF > "${depsfile}"
+${outfile}: \\
+ ${CROSS_COMPILE}readelf \\
+EOF
}
do_macho() {
"${CROSS_COMPILE}/otool" -l "${infile}" | grep LC_ID_DYLIB -A 5 > "${outfile}.tmp"
- "${CROSS_COMPILE}/nm" -gP "${infile}" | cut -f1-2 -d" " | grep -v 'U$' >> "${outfile}.tmp"
+ "${CROSS_COMPILE}/nm" -gP "${infile}" | cut -f1-2 -d" " | (grep -v 'U$' >> "${outfile}.tmp" || true)
+
+ cat <<EOF > "${depsfile}"
+${outfile}: \\
+ ${CROSS_COMPILE}/otool \\
+ ${CROSS_COMPILE}/nm \\
+EOF
}
+do_pe() {
+ "${CROSS_COMPILE}objdump" -x "${infile}" | grep "^Name" | cut -f3 -d" " > "${outfile}.tmp"
+ "${CROSS_COMPILE}nm" -g -f p "${infile}" | cut -f1-2 -d" " >> "${outfile}.tmp"
+
+ cat <<EOF > "${depsfile}"
+${outfile}: \\
+ ${CROSS_COMPILE}objdump \\
+ ${CROSS_COMPILE}nm \\
+EOF
+}
while getopts $OPTSTRING opt; do
case "$opt" in
@@ -51,6 +73,9 @@
o) outfile="${OPTARG}" ;;
-)
case "${OPTARG}" in
+ elf) elf=1 ;;
+ macho) macho=1 ;;
+ pe) pe=1 ;;
*) echo "Unknown option --${OPTARG}"; usage ;;
esac;;
?) usage ;;
@@ -58,21 +83,26 @@
esac
done
-if [ -z "${infile}" ]; then
+if [ -z "${infile:-}" ]; then
echo "-i argument is required"
usage
fi
-if [ -z "${outfile}" ]; then
+if [ -z "${outfile:-}" ]; then
echo "-o argument is required"
usage
fi
-if [ -z "${depsfile}" ]; then
+if [ -z "${depsfile:-}" ]; then
echo "-d argument is required"
usage
fi
+if [ -z "${CROSS_COMPILE:-}" ]; then
+ echo "CROSS_COMPILE environment variable must be set"
+ usage
+fi
+
rm -f "${outfile}.tmp"
cat <<EOF > "${depsfile}"
@@ -80,7 +110,15 @@
${CROSS_COMPILE}readelf \\
EOF
-do_elf
+if [ -n "${elf:-}" ]; then
+ do_elf
+elif [ -n "${macho:-}" ]; then
+ do_macho
+elif [ -n "${pe:-}" ]; then
+ do_pe
+else
+ echo "--elf, --macho or --pe is required"; usage
+fi
if cmp "${outfile}" "${outfile}.tmp" > /dev/null 2> /dev/null; then
rm -f "${outfile}.tmp"
diff --git a/ui/build/build.go b/ui/build/build.go
index 96cfdbb..52ef005 100644
--- a/ui/build/build.go
+++ b/ui/build/build.go
@@ -71,6 +71,17 @@
BuildAll = BuildProductConfig | BuildSoong | BuildKati | BuildNinja
)
+func checkProblematicFiles(ctx Context) {
+ files := []string{"Android.mk", "CleanSpec.mk"}
+ for _, file := range files {
+ if _, err := os.Stat(file); !os.IsNotExist(err) {
+ absolute := absPath(ctx, file)
+ ctx.Printf("Found %s in tree root. This file needs to be removed to build.\n", file)
+ ctx.Fatalf(" rm %s\n", absolute)
+ }
+ }
+}
+
func checkCaseSensitivity(ctx Context, config Config) {
outDir := config.OutDir()
lowerCase := filepath.Join(outDir, "casecheck.txt")
@@ -131,6 +142,8 @@
buildLock := BecomeSingletonOrFail(ctx, config)
defer buildLock.Unlock()
+ checkProblematicFiles(ctx)
+
SetupOutDir(ctx, config)
checkCaseSensitivity(ctx, config)
diff --git a/ui/build/dumpvars.go b/ui/build/dumpvars.go
index fadf6c6..ffea841 100644
--- a/ui/build/dumpvars.go
+++ b/ui/build/dumpvars.go
@@ -198,5 +198,5 @@
config.SetPdkBuild(make_vars["TARGET_BUILD_PDK"] == "true")
config.SetBuildBrokenDupRules(make_vars["BUILD_BROKEN_DUP_RULES"] == "true")
- config.SetBuildBrokenPhonyTargets(make_vars["BUILD_BROKEN_PHONY_TARGETS"] != "false")
+ config.SetBuildBrokenPhonyTargets(make_vars["BUILD_BROKEN_PHONY_TARGETS"] == "true")
}
diff --git a/zip/cmd/main.go b/zip/cmd/main.go
index 60017aa..c4e1196 100644
--- a/zip/cmd/main.go
+++ b/zip/cmd/main.go
@@ -21,8 +21,8 @@
"io"
"io/ioutil"
"os"
- "path/filepath"
"runtime"
+ "strconv"
"strings"
"android/soong/zip"
@@ -65,13 +65,14 @@
}
func (f *file) Set(s string) error {
- if *relativeRoot == "" {
- return fmt.Errorf("must pass -C before -f")
+ if relativeRoot == "" && !junkPaths {
+ return fmt.Errorf("must pass -C or -j before -f")
}
fArgs = append(fArgs, zip.FileArg{
- PathPrefixInZip: filepath.Clean(*rootPrefix),
- SourcePrefixToStrip: filepath.Clean(*relativeRoot),
+ PathPrefixInZip: *rootPrefix,
+ SourcePrefixToStrip: relativeRoot,
+ JunkPaths: junkPaths,
SourceFiles: []string{s},
})
@@ -83,8 +84,8 @@
}
func (l *listFiles) Set(s string) error {
- if *relativeRoot == "" {
- return fmt.Errorf("must pass -C before -l")
+ if relativeRoot == "" && !junkPaths {
+ return fmt.Errorf("must pass -C or -j before -l")
}
list, err := ioutil.ReadFile(s)
@@ -93,8 +94,9 @@
}
fArgs = append(fArgs, zip.FileArg{
- PathPrefixInZip: filepath.Clean(*rootPrefix),
- SourcePrefixToStrip: filepath.Clean(*relativeRoot),
+ PathPrefixInZip: *rootPrefix,
+ SourcePrefixToStrip: relativeRoot,
+ JunkPaths: junkPaths,
SourceFiles: strings.Split(string(list), "\n"),
})
@@ -106,21 +108,47 @@
}
func (d *dir) Set(s string) error {
- if *relativeRoot == "" {
- return fmt.Errorf("must pass -C before -D")
+ if relativeRoot == "" && !junkPaths {
+ return fmt.Errorf("must pass -C or -j before -D")
}
fArgs = append(fArgs, zip.FileArg{
- PathPrefixInZip: filepath.Clean(*rootPrefix),
- SourcePrefixToStrip: filepath.Clean(*relativeRoot),
- GlobDir: filepath.Clean(s),
+ PathPrefixInZip: *rootPrefix,
+ SourcePrefixToStrip: relativeRoot,
+ JunkPaths: junkPaths,
+ GlobDir: s,
})
return nil
}
+type relativeRootImpl struct{}
+
+func (*relativeRootImpl) String() string { return relativeRoot }
+
+func (*relativeRootImpl) Set(s string) error {
+ relativeRoot = s
+ junkPaths = false
+ return nil
+}
+
+type junkPathsImpl struct{}
+
+func (*junkPathsImpl) IsBoolFlag() bool { return true }
+
+func (*junkPathsImpl) String() string { return relativeRoot }
+
+func (*junkPathsImpl) Set(s string) error {
+ var err error
+ junkPaths, err = strconv.ParseBool(s)
+ relativeRoot = ""
+ return err
+}
+
var (
- rootPrefix, relativeRoot *string
+ rootPrefix *string
+ relativeRoot string
+ junkPaths bool
fArgs zip.FileArgs
nonDeflatedFiles = make(uniqueSet)
@@ -154,12 +182,13 @@
manifest := flags.String("m", "", "input jar manifest file name")
directories := flags.Bool("d", false, "include directories in zip")
rootPrefix = flags.String("P", "", "path prefix within the zip at which to place files")
- relativeRoot = flags.String("C", "", "path to use as relative root of files in following -f, -l, or -D arguments")
- parallelJobs := flags.Int("j", runtime.NumCPU(), "number of parallel threads to use")
compLevel := flags.Int("L", 5, "deflate compression level (0-9)")
emulateJar := flags.Bool("jar", false, "modify the resultant .zip to emulate the output of 'jar'")
writeIfChanged := flags.Bool("write_if_changed", false, "only update resultant .zip if it has changed")
+ symlinks := flags.Bool("symlinks", true, "store symbolic links in zip instead of following them")
+
+ parallelJobs := flags.Int("parallel", runtime.NumCPU(), "number of parallel threads to use")
cpuProfile := flags.String("cpuprofile", "", "write cpu profile to file")
traceFile := flags.String("trace", "", "write trace to file")
@@ -167,9 +196,16 @@
flags.Var(&dir{}, "D", "directory to include in zip")
flags.Var(&file{}, "f", "file to include in zip")
flags.Var(&nonDeflatedFiles, "s", "file path to be stored within the zip without compression")
+ flags.Var(&relativeRootImpl{}, "C", "path to use as relative root of files in following -f, -l, or -D arguments")
+ flags.Var(&junkPathsImpl{}, "j", "junk paths, zip files without directory names")
flags.Parse(expandedArgs[1:])
+ if flags.NArg() > 0 {
+ fmt.Fprintf(os.Stderr, "unexpected arguments %s\n", strings.Join(flags.Args(), " "))
+ usage()
+ }
+
err := zip.Run(zip.ZipArgs{
FileArgs: fArgs,
OutputFilePath: *out,
@@ -182,9 +218,10 @@
NumParallelJobs: *parallelJobs,
NonDeflatedFiles: nonDeflatedFiles,
WriteIfChanged: *writeIfChanged,
+ StoreSymlinks: *symlinks,
})
if err != nil {
- fmt.Fprintln(os.Stderr, err.Error())
+ fmt.Fprintln(os.Stderr, "error:", err.Error())
os.Exit(1)
}
}
diff --git a/zip/zip.go b/zip/zip.go
index a89fa9f..d9645b8 100644
--- a/zip/zip.go
+++ b/zip/zip.go
@@ -87,6 +87,7 @@
type FileArg struct {
PathPrefixInZip, SourcePrefixToStrip string
SourceFiles []string
+ JunkPaths bool
GlobDir string
}
@@ -106,6 +107,7 @@
compressorPool sync.Pool
compLevel int
+ followSymlinks pathtools.ShouldFollowSymlinks
}
type zipEntry struct {
@@ -131,6 +133,7 @@
NumParallelJobs int
NonDeflatedFiles map[string]bool
WriteIfChanged bool
+ StoreSymlinks bool
}
const NOQUOTE = '\x00'
@@ -211,23 +214,40 @@
args.AddDirectoryEntriesToZip = true
}
+ // Have Glob follow symlinks if they are not being stored as symlinks in the zip file.
+ followSymlinks := pathtools.ShouldFollowSymlinks(!args.StoreSymlinks)
+
w := &ZipWriter{
- time: jar.DefaultTime,
- createdDirs: make(map[string]string),
- createdFiles: make(map[string]string),
- directories: args.AddDirectoryEntriesToZip,
- compLevel: args.CompressionLevel,
+ time: jar.DefaultTime,
+ createdDirs: make(map[string]string),
+ createdFiles: make(map[string]string),
+ directories: args.AddDirectoryEntriesToZip,
+ compLevel: args.CompressionLevel,
+ followSymlinks: followSymlinks,
}
pathMappings := []pathMapping{}
+ noCompression := args.CompressionLevel == 0
+
for _, fa := range args.FileArgs {
- srcs := fa.SourceFiles
+ var srcs []string
+ for _, s := range fa.SourceFiles {
+ globbed, _, err := pathtools.Glob(s, nil, followSymlinks)
+ if err != nil {
+ return err
+ }
+ srcs = append(srcs, globbed...)
+ }
if fa.GlobDir != "" {
- srcs = append(srcs, recursiveGlobFiles(fa.GlobDir)...)
+ globbed, _, err := pathtools.Glob(filepath.Join(fa.GlobDir, "**/*"), nil, followSymlinks)
+ if err != nil {
+ return err
+ }
+ srcs = append(srcs, globbed...)
}
for _, src := range srcs {
- if err := fillPathPairs(fa.PathPrefixInZip,
- fa.SourcePrefixToStrip, src, &pathMappings, args.NonDeflatedFiles); err != nil {
+ err := fillPathPairs(fa, src, &pathMappings, args.NonDeflatedFiles, noCompression)
+ if err != nil {
log.Fatal(err)
}
}
@@ -267,20 +287,29 @@
return nil
}
-func fillPathPairs(prefix, rel, src string, pathMappings *[]pathMapping, nonDeflatedFiles map[string]bool) error {
+func fillPathPairs(fa FileArg, src string, pathMappings *[]pathMapping,
+ nonDeflatedFiles map[string]bool, noCompression bool) error {
+
src = strings.TrimSpace(src)
if src == "" {
return nil
}
src = filepath.Clean(src)
- dest, err := filepath.Rel(rel, src)
- if err != nil {
- return err
+ var dest string
+
+ if fa.JunkPaths {
+ dest = filepath.Base(src)
+ } else {
+ var err error
+ dest, err = filepath.Rel(fa.SourcePrefixToStrip, src)
+ if err != nil {
+ return err
+ }
}
- dest = filepath.Join(prefix, dest)
+ dest = filepath.Join(fa.PathPrefixInZip, dest)
zipMethod := zip.Deflate
- if _, found := nonDeflatedFiles[dest]; found {
+ if _, found := nonDeflatedFiles[dest]; found || noCompression {
zipMethod = zip.Store
}
*pathMappings = append(*pathMappings,
@@ -449,7 +478,15 @@
var fileSize int64
var executable bool
- if s, err := os.Lstat(src); err != nil {
+ var s os.FileInfo
+ var err error
+ if z.followSymlinks {
+ s, err = os.Stat(src)
+ } else {
+ s, err = os.Lstat(src)
+ }
+
+ if err != nil {
return err
} else if s.IsDir() {
if z.directories {