Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ddfcfb8e authored by Bob Badour's avatar Bob Badour Committed by Gerrit Code Review
Browse files

Merge changes from topic "revert-1541855-revert-1377717-metalics-BOEMJWNSHV-PBOZXBJQZD" 

* changes:
  Revert^2 "Rough-in license metadata support to make."
  Revert^2 "Add variables for notice deps, license kinds etc."
parents 1ed887f2 7a958209

core/clear_vars.mk

+5 −0
Original line number Diff line number Diff line
@@ -159,6 +159,10 @@ LOCAL_JNI_SHARED_LIBRARIES_ABI:= 
LOCAL_CERTIFICATE_LINEAGE:=

LOCAL_LDFLAGS:=

LOCAL_LDLIBS:=

LOCAL_LICENSE_CONDITIONS:=

LOCAL_LICENSE_KINDS:=

LOCAL_LICENSE_INSTALL_MAP:=

LOCAL_LICENSE_PACKAGE_NAME:=

LOCAL_LOGTAGS_FILES:=

LOCAL_MANIFEST_FILE:=

LOCAL_MANIFEST_INSTRUMENTATION_FOR:=
@@ -170,6 +174,7 @@ LOCAL_MODULE_HOST_ARCH:= 
LOCAL_MODULE_HOST_ARCH_WARN:=

LOCAL_MODULE_HOST_CROSS_ARCH:=

LOCAL_MODULE_HOST_OS:=

LOCAL_MODULE_IS_CONTAINER:=

LOCAL_MODULE_OWNER:=

LOCAL_MODULE_PATH:=

LOCAL_MODULE_RELATIVE_PATH :=

core/definitions.mk

+90 −0
Original line number Diff line number Diff line
@@ -524,6 +524,96 @@ define reverse-list 
$(if $(1),$(call reverse-list,$(wordlist 2,$(words $(1)),$(1)))) $(firstword $(1))

endef



###########################################################

## Sometimes a notice dependency will reference an unadorned

## module name that only appears in ALL_MODULES adorned with

## an ARCH suffix or a `host_cross_` prefix.

##

## After all of the modules are processed in base_rules.mk,

## replace all such dependencies with every matching adorned

## module name.

###########################################################



define fix-notice-deps

$(strip \

  $(eval _all_module_refs := \

    $(sort \

      $(foreach m,$(sort $(ALL_MODULES)), \

        $(ALL_MODULES.$(m).NOTICE_DEPS) \

      ) \

    ) \

  ) \

  $(foreach m, $(_all_module_refs), \

    $(eval _lookup.$(m) := \

      $(sort \

        $(if $(strip $(ALL_MODULES.$(m).PATH)), \

          $(m), \

          $(filter $(m)_32 $(m)_64 host_cross_$(m) host_cross_$(m)_32 host_cross_$(m)_64, $(ALL_MODULES)) \

        ) \

      ) \

    ) \

  ) \

  $(foreach m, $(ALL_MODULES), \

    $(eval ALL_MODULES.$(m).NOTICE_DEPS := \

      $(sort \

         $(foreach d,$(ALL_MODULES.$(m).NOTICE_DEPS), \

           $(_lookup.$(d)) \

        ) \

      ) \

    ) \

  ) \

)

endef



###########################################################

## Target directory for license metadata files.

###########################################################

define license-metadata-dir

$(call generated-sources-dir-for,META,lic,)

endef



###########################################################

## License metadata build rule for my_register_name $1

###########################################################

define license-metadata-rule

$(strip $(eval _dir := $(call license-metadata-dir)))

$(strip $(eval _deps := $(sort $(filter-out $(_dir)/$(1).meta_lic,$(foreach d,$(ALL_MODULES.$(1).NOTICE_DEPS), $(_dir)/$(d).meta_lic)))))

$(foreach b,$(sort $(ALL_MODULES.$(1).BUILT) $(ALL_MODULES.$(1).INSTALLED)),

$(_dir)/$(b).meta_module ::

	mkdir -p $$(dir $$@)

	echo $(_dir)/$(1).meta_lic >> $$@

	sort -u $$@ -o $$@



)

$(_dir)/$(1).meta_lic: PRIVATE_KINDS := $(sort $(ALL_MODULES.$(1).LICENSE_KINDS))

$(_dir)/$(1).meta_lic: PRIVATE_CONDITIONS := $(sort $(ALL_MODULES.$(1).LICENSE_CONDITIONS))

$(_dir)/$(1).meta_lic: PRIVATE_NOTICES := $(sort $(ALL_MODULES.$(1).NOTICES))

$(_dir)/$(1).meta_lic: PRIVATE_NOTICE_DEPS := $(_deps)

$(_dir)/$(1).meta_lic: PRIVATE_TARGETS := $(sort $(ALL_MODULES.$(1).BUILT) $(ALL_MODULES.$(1).INSTALLED))

$(_dir)/$(1).meta_lic: PRIVATE_IS_CONTAINER := $(sort $(ALL_MODULES.$(1).IS_CONTAINER))

$(_dir)/$(1).meta_lic: PRIVATE_PACKAGE_NAME := $(ALL_MODULES.$(1).LICENSE_PACKAGE_NAME)

$(_dir)/$(1).meta_lic: PRIVATE_INSTALL_MAP := $(sort $(ALL_MODULES.$(1).LICENSE_INSTALL_MAP))

$(_dir)/$(1).meta_lic : $(_deps) $(ALL_MODULES.$(1).NOTICES) $(foreach b,$(sort $(ALL_MODULES.$(1).BUILT) $(ALL_MODULES.$(1).INSTALLED)), $(_dir)/$(b).meta_module) build/make/tools/build-license-metadata.sh

	rm -f $$@

	mkdir -p $$(dir $$@)

	build/make/tools/build-license-metadata.sh -k $$(PRIVATE_KINDS) -c $$(PRIVATE_CONDITIONS) -n $$(PRIVATE_NOTICES) -d $$(PRIVATE_NOTICE_DEPS) -m $$(PRIVATE_INSTALL_MAP) -t $$(PRIVATE_TARGETS) $$(if $$(filter-out false,$$(PRIVATE_IS_CONTAINER)),-is_container) -p $$(PRIVATE_PACKAGE_NAME) -o $$@



$(1) : $(_dir)/$(1).meta_lic



$(if $(ALL_MODULES.$(1).INSTALLED_NOTICE_FILE),$(ALL_MODULES.$(1).INSTALLED_NOTICE_FILE) : $(_dir)/$(1).meta_lic)



.PHONY: $(1).meta_lic

$(1).meta_lic : $(_dir)/$(1).meta_lic



endef



###########################################################

## Declares a license metadata build rule for ALL_MODULES

###########################################################

define build-license-metadata

$(foreach m,$(ALL_MODULES),$(eval $(call license-metadata-rule,$(m))))

endef



###########################################################

## Returns correct _idfPrefix from the list:

##   { HOST, HOST_CROSS, TARGET }

core/main.mk

+11 −0
Original line number Diff line number Diff line
@@ -1404,6 +1404,17 @@ modules_to_install := $(sort $(ALL_DEFAULT_INSTALLED_MODULES)) 
ALL_DEFAULT_INSTALLED_MODULES :=





# Some notice deps refer to module names without prefix or arch suffix where

# only the variants with them get built.

# fix-notice-deps replaces those unadorned module names with every built variant.

$(call fix-notice-deps)



# Create a license metadata rule per module. Could happen in base_rules.mk or

# notice_files.mk; except, it has to happen after fix-notice-deps to avoid

# missing dependency errors.

$(call build-license-metadata)





# These are additional goals that we build, in order to make sure that there

# is as little code as possible in the tree that doesn't build.

modules_to_check := $(foreach m,$(ALL_MODULES),$(ALL_MODULES.$(m).CHECKED))

core/notice_files.mk

+87 −4
Original line number Diff line number Diff line
@@ -9,6 +9,32 @@ else 
notice_file:=$(strip $(wildcard $(LOCAL_PATH)/LICENSE $(LOCAL_PATH)/LICENCE $(LOCAL_PATH)/NOTICE))

endif



ifneq (,$(strip $(LOCAL_LICENSE_PACKAGE_NAME)))

license_package_name:=$(strip $(LOCAL_LICENSE_PACKAGE_NAME))

else ifdef my_register_name

license_package_name:=$(my_register_name)

else

license_package_name:=$(strip $(LOCAL_MODULE))

endif



ifneq (,$(strip $(LOCAL_LICENSE_INSTALL_MAP)))

install_map:=$(strip $(LOCAL_LICENSE_INSTALL_MAP))

else

install_map:=

endif



ifneq (,$(strip $(LOCAL_LICENSE_KINDS)))

license_kinds:=$(strip $(LOCAL_LICENSE_KINDS))

else

license_kinds:=legacy_by_exception_only

endif



ifneq (,$(strip $(LOCAL_LICENSE_CONDITIONS)))

license_conditions:=$(strip $(LOCAL_LICENSE_CONDITIONS))

else

license_conditions:=by_exception_only

endif



ifeq ($(LOCAL_MODULE_CLASS),GYP)

  # We ignore NOTICE files for modules of type GYP.

  notice_file :=
@@ -40,10 +66,64 @@ endif 


installed_notice_file :=



is_container:=$(strip $(LOCAL_MODULE_IS_CONTAINER))

ifeq (,$(is_container))

ifneq (,$(strip $(filter %.zip %.tar %.tgz %.tar.gz %.apk %.img %.srcszip %.apex, $(LOCAL_BUILT_MODULE))))

is_container:=true

else

is_container:=false

endif

else ifneq (,$(strip $(filter-out true false,$(is_container))))

$(error Unrecognized value '$(is_container)' for LOCAL_MODULE_IS_CONTAINER)

endif



ifeq (true,$(is_container))

# Include shared libraries' notices for "container" types, but not for binaries etc.

notice_deps := \

    $(sort \

        $(LOCAL_REQUIRED_MODULES) \

        $(LOCAL_STATIC_LIBRARIES) \

        $(LOCAL_WHOLE_STATIC_LIBRARIES) \

        $(LOCAL_SHARED_LIBRARIES) \

        $(LOCAL_DYLIB_LIBRARIES) \

        $(LOCAL_RLIB_LIBRARIES) \

        $(LOCAL_PROC_MACRO_LIBRARIES) \

        $(LOCAL_HEADER_LIBRARIES) \

        $(LOCAL_STATIC_JAVA_LIBRARIES) \

        $(LOCAL_JAVA_LIBRARIES) \

        $(LOCAL_JNI_SHARED_LIBRARIES) \

    )

else

notice_deps := \

    $(sort \

        $(LOCAL_REQUIRED_MODULES) \

        $(LOCAL_STATIC_LIBRARIES) \

        $(LOCAL_WHOLE_STATIC_LIBRARIES) \

        $(LOCAL_RLIB_LIBRARIES) \

        $(LOCAL_PROC_MACRO_LIBRARIES) \

        $(LOCAL_HEADER_LIBRARIES) \

        $(LOCAL_STATIC_JAVA_LIBRARIES) \

    )

endif

ifeq ($(LOCAL_IS_HOST_MODULE),true)

notice_deps := $(sort $(notice_deps) $(LOCAL_HOST_REQUIRED_MODULES))

else

notice_deps := $(sort $(notice_deps) $(LOCAL_TARGET_REQUIRED_MODULES))

endif



ifdef my_register_name

ALL_MODULES.$(my_register_name).LICENSE_PACKAGE_NAME := $(strip $(license_package_name))

ALL_MODULES.$(my_register_name).LICENSE_KINDS := $(sort $(ALL_MODULES.$(my_register_name).LICENSE_KINDS) $(license_kinds))

ALL_MODULES.$(my_register_name).LICENSE_CONDITIONS := $(sort $(ALL_MODULES.$(my_register_name).LICENSE_CONDITIONS) $(license_conditions))

ALL_MODULES.$(my_register_name).LICENSE_INSTALL_MAP := $(sort $(ALL_MODULES.$(my_register_name).LICENSE_INSTALL_MAP) $(install_map))

ALL_MODULES.$(my_register_name).NOTICE_DEPS := $(sort $(ALL_MODULES.$(my_register_name).NOTICE_DEPS) $(notice_deps))

ALL_MODULES.$(my_register_name).IS_CONTAINER := $(sort $(ALL_MODULES.$(my_register_name).IS_CONTAINER) $(is_container))

endif



ifdef notice_file



ifdef my_register_name

ALL_MODULES.$(my_register_name).NOTICES := $(ALL_MODULES.$(my_register_name).NOTICES) $(notice_file)

ALL_MODULES.$(my_register_name).NOTICES := $(sort $(ALL_MODULES.$(my_register_name).NOTICES) $(notice_file))

endif



# This relies on the name of the directory in PRODUCT_OUT matching where
@@ -87,8 +167,6 @@ else 
      # Soong produces uninstallable *.sdk shared libraries for embedding in APKs.

      module_installed_filename := \

          $(patsubst $(PRODUCT_OUT)/%,%,$($(LOCAL_2ND_ARCH_VAR_PREFIX)$(my_prefix)OUT_SHARED_LIBRARIES))/$(notdir $(LOCAL_BUILT_MODULE))

    else

      $(error Cannot determine where to install NOTICE file for $(LOCAL_MODULE))

    endif # JAVA_LIBRARIES

  endif # STATIC_LIBRARIES

endif
@@ -101,12 +179,17 @@ module_installed_filename := $(patsubst $(HOST_CROSS_OUT)/%,%,$(module_installed 


installed_notice_file := $($(my_prefix)OUT_NOTICE_FILES)/src/$(module_installed_filename).txt



ifdef my_register_name

ALL_MODULES.$(my_register_name).INSTALLED_NOTICE_FILE := $(installed_notice_file)

endif



$(installed_notice_file): PRIVATE_INSTALLED_MODULE := $(module_installed_filename)

$(installed_notice_file) : PRIVATE_NOTICES := $(notice_file)



$(installed_notice_file): $(notice_file)

	@echo Notice file: $< -- $@

	$(hide) mkdir -p $(dir $@)

	$(hide) awk 'FNR==1 && NR > 1 {print "\n"} {print}' $^ > $@

	$(hide) awk 'FNR==1 && NR > 1 {print "\n"} {print}' $(PRIVATE_NOTICES) > $@



ifdef LOCAL_INSTALLED_MODULE

# Make LOCAL_INSTALLED_MODULE depend on NOTICE files if they exist

tools/build-license-metadata.sh

0 → 100755
+312 −0
Original line number Diff line number Diff line 
#!/bin/sh



set -u



ME=$(basename $0)



USAGE="Usage: ${ME} {options}



Builds a license metadata specification and outputs it to stdout or {outfile}.



The available options are:



-k kind...              license kinds

-c condition...         license conditions

-p package...           license package name

-n notice...            license notice file

-d dependency...        license metadata file dependency

-t target...            targets

-m target:installed...  map dependent targets to their installed names

-is_container           preserved dependent target name when given

-o outfile              output file

"



# Global flag variables

license_kinds=

license_conditions=

license_package_name=

license_notice=

license_deps=

targets=

installmap=

is_container=false

ofile=



# Global variables

depfiles=" "

effective_conditions=





# Exits with a message.

#

# When the exit status is 2, assumes a usage error and outputs the usage message

# to stderr before outputting the specific error message to stderr.

#

# Parameters:

#   Optional numeric exit status (defaults to 2, i.e. a usage error.)

#   Remaining args treated as an error message sent to stderr.

die() {

  lstatus=2

  case "${1:-}" in *[^0-9]*) ;; *) lstatus="$1"; shift ;; esac

  case "${lstatus}" in 2) echo "${USAGE}" >&2; echo >&2 ;; esac

  if [ -n "$*" ]; then

    echo -e "$*\n" >&2

  fi

  exit $lstatus

}





# Sets the flag variables based on the command-line.

#

# invoke with: process_args "$@"

process_args() {

  lcurr_flag=

  while [ "$#" -gt '0' ]; do

    case "${1}" in

      -h)

        echo "${USAGE}"

        exit 0

        ;;

      -k)

        lcurr_flag=kind

        ;;

      -c)

        lcurr_flag=condition

        ;;

      -p)

        lcurr_flag=package

        ;;

      -n)

        lcurr_flag=notice

        ;;

      -d)

        lcurr_flag=dependency

        ;;

      -t)

        lcurr_flag=target

        ;;

      -m)

        lcurr_flag=installmap

        ;;

      -o)

        lcurr_flag=ofile

        ;;

      -is_container)

        lcurr_flag=

        is_container=true

        ;;

      -*)

        die "Unknown flag: \"${1}\""

        ;;

      *)

        case "${lcurr_flag}" in

          kind)

            license_kinds="${license_kinds}${license_kinds:+ }${1}"

            ;;

          condition)

            license_conditions="${license_conditions}${license_conditions:+ }${1}"

            ;;

          package)

            license_package_name="${license_package_name}${license_package_name:+ }${1}"

            ;;

          notice)

            license_notice="${license_notice}${license_notice:+ }${1}"

            ;;

          dependency)

            license_deps="${license_deps}${license_deps:+ }${1}"

            ;;

          target)

            targets="${targets}${targets:+ }${1}"

            ;;

          installmap)

            installmap="${installmap}${installmap:+ }${1}"

            ;;

          ofile)

            if [ -n "${ofile}" ]; then

              die "Output file -o appears twice as \"${ofile}\" and \"${1}\""

            fi

            ofile="${1}"

            ;;

          *)

            die "Must precede argument \"${1}\" with type flag."

            ;;

        esac

        ;;

    esac

    shift

  done

}



# Reads a license metadata file from stdin, and outputs the named dependencies.

#

# No parameters.

extract_deps() {

  awk '$1 == "dep_name:" { sub(/^"/, "", $2); sub(/"$/, "", $2); print $2; }'

}



# Populates the depfiles variable identifying dependency files.

#

# Starting with the dependencies enumerated in license_deps, calculates the

# transitive closure of all dependencies.

#

# Dependency names ending in .meta_module indirectly reference license

# metadata with 1 license metadata filename per line.

#

# No parameters; no output.

read_deps() {

  lnewdeps=

  for d in ${license_deps}; do

    case "${d}" in

      *.meta_module)

        lnewdeps="${lnewdeps}${lnewdeps:+ }"$(cat "${d}") ;;

      *)

        lnewdeps="${lnewdeps}${lnewdeps:+ }${d}" ;;

    esac

  done

  lnewdeps=$(echo "${lnewdeps}" | tr ' ' '\n' | sort -u)

  lalldeps=

  ldeps=

  lmod=

  ldep=

  while [ "${#lnewdeps}" -gt '0' ]; do

    ldeps="${lnewdeps}"

    lnewdeps=

    for ldep in ${ldeps}; do

      depfiles="${depfiles}${ldep} "

      lalldeps="${lalldeps}${lalldeps:+ }"$(cat "${ldep}" | extract_deps)

    done

    lalldeps=$(for d in ${lalldeps}; do echo "${d}"; done | sort -u)

    for d in ${lalldeps}; do

      ldeps="${d}"

      case "${d}" in *.meta_module) ldeps=$(cat "${d}") ;; esac

      for lmod in ${ldeps}; do

        if ! expr "${depfiles}" : ".* ${lmod} .*" >/dev/null 2>&1; then

          lnewdeps="${lnewdeps}${lnewdeps:+ }${lmod}"

        fi

      done

    done

    lalldeps=

  done

}



# Returns the effective license conditions for the current license metadata.

#

# If a module is restricted or links in a restricted module, the effective

# license has a restricted condition.

calculate_effective_conditions() {

  lconditions="${license_conditions}"

  case "${license_conditions}" in

    *restricted*) : do nothing ;;

    *)

       for d in ${depfiles}; do

         if cat "${d}" | egrep -q 'effective_condition\s*:.*restricted' ; then

           lconditions="${lconditions}${lconditions:+ }restricted"

         fi

       done

     ;;

  esac

  echo "${lconditions}"

}





process_args "$@"



if [ -n "${ofile}" ]; then

  # truncate the output file before appending results

  : >"${ofile}"

else

  ofile=/dev/stdout

fi



# spit out the license metadata file content

(

  echo 'license_package_name: "'${license_package_name}'"'

  for kind in ${license_kinds}; do

    echo 'license_kind: "'${kind}'"'

  done

  for condition in ${license_conditions}; do

    echo 'license_condition: "'${condition}'"'

  done

  for f in ${license_notice}; do

    echo 'license_text: "'${f}'"'

  done

  echo "is_container: ${is_container}"

  for t in ${targets}; do

    echo 'target: "'${t}'"'

  done

  for m in ${installmap}; do

    echo 'install_map: "'${m}'"'

  done

) >>"${ofile}"

read_deps

effective_conditions=$(calculate_effective_conditions)

for condition in ${effective_conditions}; do

  echo 'effective_condition: "'${condition}'"'

done >>"${ofile}"

for dep in ${depfiles}; do

  echo 'dep {'

  cat "${dep}" | \

    awk -v name="${dep}" '

      function strip_type() {

        $1 = ""

        sub(/^\s*/, "")

      }

      BEGIN {

        print "  dep_name: " name

      }

      $1 == "license_package_name:" {

        strip_type()

        print "  dep_package_name: "$0

      }

      $1 == "dep_name:" {

        print "  dep_sub_dep: "$2

      }

      $1 == "license_kind:" {

        print "  dep_license_kind: "$2

      }

      $1 == "license_condition:" {

        print "  dep_license_condition: "$2

      }

      $1 == "is_container:" {

        print "  dep_is_container: "$2

      }

      $1 == "license_text:" {

        strip_type()

        print "  dep_license_text: "$0

      }

      $1 == "target:" {

        print "  dep_target: "$2

      }

      $1 == "install_map:" {

        print "  dep_install_map: "$2

      }

  '

  # The restricted license kind is contagious to all linked dependencies.

  dep_conditions=$(echo $(

      cat "${dep}" | awk '

        $1 == "effective_condition:" {

          $1 = ""

          sub(/^\s*/, "")

          gsub(/"/, "")

          print

        }

      '

  ))

  for condition in ${dep_conditions}; do

    echo '  dep_effective_condition: "'${condition}'"'

  done

  if ! ${is_container}; then

    case "${dep_conditions}" in

      *restricted*) : already restricted -- nothing to inherit ;;

      *)

        case "${effective_conditions}" in

          *restricted*)

            # "contagious" restricted infects everything linked to restricted

            echo '  dep_effective_condition: "restricted"'

            ;;

        esac

        ;;

    esac

  fi

  echo '}'

done >>"${ofile}"