github.com/westcoastroms/westcoastroms-build@v0.0.0-20190928114312-2350e5a73030/build/make/core/math.mk (about)

     1  #
     2  # Copyright (C) 2017 The Android Open Source Project
     3  #
     4  # Licensed under the Apache License, Version 2.0 (the "License");
     5  # you may not use this file except in compliance with the License.
     6  # You may obtain a copy of the License at
     7  #
     8  #      http://www.apache.org/licenses/LICENSE-2.0
     9  #
    10  # Unless required by applicable law or agreed to in writing, software
    11  # distributed under the License is distributed on an "AS IS" BASIS,
    12  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  # See the License for the specific language governing permissions and
    14  # limitations under the License.
    15  #
    16  
    17  ###########################################################
    18  # Basic math functions for positive integers <= 100
    19  #
    20  # (SDK versions for example)
    21  ###########################################################
    22  __MATH_NUMBERS :=  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 \
    23                    21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 \
    24                    41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 \
    25                    61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 \
    26                    81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
    27  
    28  # Returns true if $(1) is a positive integer <= 100, otherwise returns nothing.
    29  define math_is_number
    30  $(strip \
    31    $(if $(1),,$(error Argument missing)) \
    32    $(if $(word 2,$(1)),$(error Multiple words in a single argument: $(1))) \
    33    $(if $(filter $(1),$(__MATH_NUMBERS)),true))
    34  endef
    35  
    36  #$(warning true == $(call math_is_number,2))
    37  #$(warning == $(call math_is_number,foo))
    38  #$(call math_is_number,1 2)
    39  #$(call math_is_number,no 2)
    40  
    41  define _math_check_valid
    42  $(if $(call math_is_number,$(1)),,$(error Only positive integers <= 100 are supported (not $(1))))
    43  endef
    44  
    45  # return a list containing integers ranging from [$(1),$(2)]
    46  define int_range_list
    47  $(call _math_check_valid,$(1))$(call _math_check_valid,$(2))$(wordlist $(1),$(2),$(__MATH_NUMBERS))
    48  endef
    49  
    50  #$(call _math_check_valid,0)
    51  #$(call _math_check_valid,1)
    52  #$(call _math_check_valid,100)
    53  #$(call _math_check_valid,101)
    54  #$(call _math_check_valid,)
    55  #$(call _math_check_valid,1 2)
    56  
    57  # Returns the greater of $1 or $2.
    58  # If $1 or $2 is not a positive integer <= 100, then an error is generated.
    59  define math_max
    60  $(strip $(call _math_check_valid,$(1)) $(call _math_check_valid,$(2)) \
    61    $(lastword $(filter $(1) $(2),$(__MATH_NUMBERS))))
    62  endef
    63  
    64  #$(call math_max)
    65  #$(call math_max,1)
    66  #$(call math_max,1 2,3)
    67  #$(warning 1 == $(call math_max,1,1))
    68  #$(warning 42 == $(call math_max,5,42))
    69  #$(warning 42 == $(call math_max,42,5))
    70  
    71  define math_gt_or_eq
    72  $(if $(filter $(1),$(call math_max,$(1),$(2))),true)
    73  endef
    74  
    75  define math_lt
    76  $(if $(call math_gt_or_eq,$(1),$(2)),,true)
    77  endef
    78  
    79  #$(warning $(call math_gt_or_eq, 2, 1))
    80  #$(warning $(call math_gt_or_eq, 1, 1))
    81  #$(warning $(if $(call math_gt_or_eq, 1, 2),false,true))
    82  
    83  # $1 is the variable name to increment
    84  define inc_and_print
    85  $(strip $(eval $(1) := $($(1)) .)$(words $($(1))))
    86  endef
    87  
    88  # Returns the words in $2 that are numbers and are less than $1
    89  define numbers_less_than
    90  $(strip \
    91    $(foreach n,$2, \
    92      $(if $(call math_is_number,$(n)), \
    93        $(if $(call math_lt,$(n),$(1)), \
    94          $(n)))))
    95  endef
    96  
    97  _INT_LIMIT_WORDS := $(foreach a,x x,$(foreach b,x x x x x x x x x x x x x x x x,\
    98    $(foreach c,x x x x x x x x x x x x x x x x,x x x x x x x x x x x x x x x x)))
    99  
   100  define _int_encode
   101  $(if $(filter $(words x $(_INT_LIMIT_WORDS)),$(words $(wordlist 1,$(1),x $(_INT_LIMIT_WORDS)))),\
   102    $(call pretty-error,integer greater than $(words $(_INT_LIMIT_WORDS)) is not supported!),\
   103      $(wordlist 1,$(1),$(_INT_LIMIT_WORDS)))
   104  endef
   105  
   106  # _int_max returns the maximum of the two arguments
   107  # input: two (x) lists; output: one (x) list
   108  # integer cannot be passed in directly. It has to be converted using _int_encode.
   109  define _int_max
   110  $(subst xx,x,$(join $(1),$(2)))
   111  endef
   112  
   113  # first argument is greater than second argument
   114  # output: non-empty if true
   115  # integer cannot be passed in directly. It has to be converted using _int_encode.
   116  define _int_greater-than
   117  $(filter-out $(words $(2)),$(words $(call _int_max,$(1),$(2))))
   118  endef
   119  
   120  # first argument equals to second argument
   121  # output: non-empty if true
   122  # integer cannot be passed in directly. It has to be converted using _int_encode.
   123  define _int_equal
   124  $(filter $(words $(1)),$(words $(2)))
   125  endef
   126  
   127  # first argument is greater than or equal to second argument
   128  # output: non-empty if true
   129  # integer cannot be passed in directly. It has to be converted using _int_encode.
   130  define _int_greater-or-equal
   131  $(call _int_greater-than,$(1),$(2))$(call _int_equal,$(1),$(2))
   132  endef
   133  
   134  define int_plus
   135  $(words $(call _int_encode,$(1)) $(call _int_encode,$(2)))
   136  endef
   137  
   138  define int_subtract
   139  $(if $(call _int_greater-or-equal,$(call _int_encode,$(1)),$(call _int_encode,$(2))),\
   140    $(words $(filter-out xx,$(join $(call _int_encode,$(1)),$(call _int_encode,$(2))))),\
   141      $(call pretty-error,$(1) subtract underflow $(2)))
   142  endef
   143  
   144  define int_multiply
   145  $(words $(foreach a,$(call _int_encode,$(1)),$(call _int_encode,$(2))))
   146  endef
   147  
   148  define int_divide
   149  $(if $(filter 0,$(2)),$(call pretty-error,division by zero is not allowed!),$(strip \
   150    $(if $(call _int_greater-or-equal,$(call _int_encode,$(1)),$(call _int_encode,$(2))), \
   151      $(call int_plus,$(call int_divide,$(call int_subtract,$(1),$(2)),$(2)),1),0)))
   152  endef