1 # ---------------------------------------------------------------------------- 2 # 3 # GNU Make Standard Library (GMSL) 4 # 5 # A library of functions to be used with GNU Make's $(call) that 6 # provides functionality not available in standard GNU Make. 7 # 8 # Copyright (c) 2005-2007 John Graham-Cumming 9 # 10 # This file is part of GMSL 11 # 12 # Redistribution and use in source and binary forms, with or without 13 # modification, are permitted provided that the following conditions 14 # are met: 15 # 16 # Redistributions of source code must retain the above copyright 17 # notice, this list of conditions and the following disclaimer. 18 # 19 # Redistributions in binary form must reproduce the above copyright 20 # notice, this list of conditions and the following disclaimer in the 21 # documentation and/or other materials provided with the distribution. 22 # 23 # Neither the name of the John Graham-Cumming nor the names of its 24 # contributors may be used to endorse or promote products derived from 25 # this software without specific prior written permission. 26 # 27 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 28 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 29 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 30 # FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 31 # COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 32 # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 33 # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 34 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 35 # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 37 # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 38 # POSSIBILITY OF SUCH DAMAGE. 39 # 40 # ---------------------------------------------------------------------------- 41 42 # This is the GNU Make Standard Library version number as a list with 43 # three items: major, minor, revision 44 45 gmsl_version := 1 0 11 46 47 # Used to output warnings and error from the library, it's possible to 48 # disable any warnings or errors by overriding these definitions 49 # manually or by setting GMSL_NO_WARNINGS or GMSL_NO_ERRORS 50 51 __gmsl_name := GNU Make Standard Library 52 __gmsl_warning = $(warning $(__gmsl_name): $1) 53 __gmsl_error = $(error $(__gmsl_name): $1) 54 55 ifdef GMSL_NO_WARNINGS 56 __gmsl_warning := 57 endif 58 ifdef GMSL_NO_ERRORS 59 __gmsl_error := 60 endif 61 62 # If GMSL_TRACE is enabled then calls to the library functions are 63 # traced to stdout using warning messages with their arguments 64 65 ifdef GMSL_TRACE 66 __gmsl_tr1 = $(warning $0('$1')) 67 __gmsl_tr2 = $(warning $0('$1','$2')) 68 __gmsl_tr3 = $(warning $0('$1','$2','$3')) 69 else 70 __gmsl_tr1 := 71 __gmsl_tr2 := 72 __gmsl_tr3 := 73 endif 74 75 # Figure out whether we have $(eval) or not (GNU Make 3.80 and above) 76 # if we do not then output a warning message, if we do then some 77 # functions will be enabled. 78 79 __gmsl_have_eval := $(false) 80 __gmsl_ignore := $(eval __gmsl_have_eval := $(true)) 81 82 # If this is being run with Electric Cloud's emake then warn that 83 # their $(eval) support is incomplete. 84 85 ifdef ECLOUD_BUILD_ID 86 $(warning You are using Electric Cloud's emake which has incomplete $$(eval) support) 87 __gmsl_have_eval := $(false) 88 endif 89 90 # See if we have $(lastword) (GNU Make 3.81 and above) 91 92 __gmsl_have_lastword := $(lastword $(false) $(true)) 93 94 # See if we have native or and and (GNU Make 3.81 and above) 95 96 __gmsl_have_or := $(if $(filter-out undefined, \ 97 $(origin or)),$(call or,$(true),$(false))) 98 __gmsl_have_and := $(if $(filter-out undefined, \ 99 $(origin and)),$(call and,$(true),$(true))) 100 101 ifneq ($(__gmsl_have_eval),$(true)) 102 $(call __gmsl_warning,GNU Make $(MAKE_VERSION) does not support $$$$(eval): some functions disabled) 103 endif 104 105 # ---------------------------------------------------------------------------- 106 # Function: gmsl_compatible 107 # Arguments: List containing the desired library version number (maj min rev) 108 # Returns: $(true) if this version of the library is compatible 109 # with the requested version number, otherwise $(false) 110 # ---------------------------------------------------------------------------- 111 gmsl_compatible = $(strip \ 112 $(if $(call gt,$(word 1,$1),$(word 1,$(gmsl_version))), \ 113 $(false), \ 114 $(if $(call lt,$(word 1,$1),$(word 1,$(gmsl_version))), \ 115 $(true), \ 116 $(if $(call gt,$(word 2,$1),$(word 2,$(gmsl_version))), \ 117 $(false), \ 118 $(if $(call lt,$(word 2,$1),$(word 2,$(gmsl_version))), \ 119 $(true), \ 120 $(call lte,$(word 3,$1),$(word 3,$(gmsl_version)))))))) 121 122 # ########################################################################### 123 # LOGICAL OPERATORS 124 # ########################################################################### 125 126 # not is defined in gmsl 127 128 # ---------------------------------------------------------------------------- 129 # Function: and 130 # Arguments: Two boolean values 131 # Returns: Returns $(true) if both of the booleans are true 132 # ---------------------------------------------------------------------------- 133 ifneq ($(__gmsl_have_and),$(true)) 134 and = $(__gmsl_tr2)$(if $1,$(if $2,$(true),$(false)),$(false)) 135 endif 136 137 # ---------------------------------------------------------------------------- 138 # Function: or 139 # Arguments: Two boolean values 140 # Returns: Returns $(true) if either of the booleans is true 141 # ---------------------------------------------------------------------------- 142 ifneq ($(__gmsl_have_or),$(true)) 143 or = $(__gmsl_tr2)$(if $1$2,$(true),$(false)) 144 endif 145 146 # ---------------------------------------------------------------------------- 147 # Function: xor 148 # Arguments: Two boolean values 149 # Returns: Returns $(true) if exactly one of the booleans is true 150 # ---------------------------------------------------------------------------- 151 xor = $(__gmsl_tr2)$(if $1,$(if $2,$(false),$(true)),$(if $2,$(true),$(false))) 152 153 # ---------------------------------------------------------------------------- 154 # Function: nand 155 # Arguments: Two boolean values 156 # Returns: Returns value of 'not and' 157 # ---------------------------------------------------------------------------- 158 nand = $(__gmsl_tr2)$(if $1,$(if $2,$(false),$(true)),$(true)) 159 160 # ---------------------------------------------------------------------------- 161 # Function: nor 162 # Arguments: Two boolean values 163 # Returns: Returns value of 'not or' 164 # ---------------------------------------------------------------------------- 165 nor = $(__gmsl_tr2)$(if $1$2,$(false),$(true)) 166 167 # ---------------------------------------------------------------------------- 168 # Function: xnor 169 # Arguments: Two boolean values 170 # Returns: Returns value of 'not xor' 171 # ---------------------------------------------------------------------------- 172 xnor =$(__gmsl_tr2)$(if $1,$(if $2,$(true),$(false)),$(if $2,$(false),$(true))) 173 174 # ########################################################################### 175 # LIST MANIPULATION FUNCTIONS 176 # ########################################################################### 177 178 # ---------------------------------------------------------------------------- 179 # Function: first (same as LISP's car, or head) 180 # Arguments: 1: A list 181 # Returns: Returns the first element of a list 182 # ---------------------------------------------------------------------------- 183 first = $(__gmsl_tr1)$(firstword $1) 184 185 # ---------------------------------------------------------------------------- 186 # Function: last 187 # Arguments: 1: A list 188 # Returns: Returns the last element of a list 189 # ---------------------------------------------------------------------------- 190 ifeq ($(__gmsl_have_lastword),$(true)) 191 last = $(__gmsl_tr1)$(lastword $1) 192 else 193 last = $(__gmsl_tr1)$(if $1,$(word $(words $1),$1)) 194 endif 195 196 # ---------------------------------------------------------------------------- 197 # Function: rest (same as LISP's cdr, or tail) 198 # Arguments: 1: A list 199 # Returns: Returns the list with the first element removed 200 # ---------------------------------------------------------------------------- 201 rest = $(__gmsl_tr1)$(wordlist 2,$(words $1),$1) 202 203 # ---------------------------------------------------------------------------- 204 # Function: chop 205 # Arguments: 1: A list 206 # Returns: Returns the list with the last element removed 207 # ---------------------------------------------------------------------------- 208 chop = $(__gmsl_tr1)$(wordlist 2,$(words $1),x $1) 209 210 # ---------------------------------------------------------------------------- 211 # Function: map 212 # Arguments: 1: Name of function to $(call) for each element of list 213 # 2: List to iterate over calling the function in 1 214 # Returns: The list after calling the function on each element 215 # ---------------------------------------------------------------------------- 216 map = $(__gmsl_tr2)$(strip $(foreach a,$2,$(call $1,$a))) 217 218 # ---------------------------------------------------------------------------- 219 # Function: pairmap 220 # Arguments: 1: Name of function to $(call) for each pair of elements 221 # 2: List to iterate over calling the function in 1 222 # 3: Second list to iterate over calling the function in 1 223 # Returns: The list after calling the function on each pair of elements 224 # ---------------------------------------------------------------------------- 225 pairmap = $(strip $(__gmsl_tr3)\ 226 $(if $2$3,$(call $1,$(call first,$2),$(call first,$3)) \ 227 $(call pairmap,$1,$(call rest,$2),$(call rest,$3)))) 228 229 # ---------------------------------------------------------------------------- 230 # Function: leq 231 # Arguments: 1: A list to compare against... 232 # 2: ...this list 233 # Returns: Returns $(true) if the two lists are identical 234 # ---------------------------------------------------------------------------- 235 leq = $(__gmsl_tr2)$(strip $(if $(call seq,$(words $1),$(words $2)), \ 236 $(call __gmsl_list_equal,$1,$2),$(false))) 237 238 __gmsl_list_equal = $(if $(strip $1), \ 239 $(if $(call seq,$(call first,$1),$(call first,$2)), \ 240 $(call __gmsl_list_equal, \ 241 $(call rest,$1), \ 242 $(call rest,$2)), \ 243 $(false)), \ 244 $(true)) 245 246 # ---------------------------------------------------------------------------- 247 # Function: lne 248 # Arguments: 1: A list to compare against... 249 # 2: ...this list 250 # Returns: Returns $(true) if the two lists are different 251 # ---------------------------------------------------------------------------- 252 lne = $(__gmsl_tr2)$(call not,$(call leq,$1,$2)) 253 254 # ---------------------------------------------------------------------------- 255 # Function: reverse 256 # Arguments: 1: A list to reverse 257 # Returns: The list with its elements in reverse order 258 # ---------------------------------------------------------------------------- 259 reverse =$(__gmsl_tr1)$(strip $(if $1,$(call reverse,$(call rest,$1)) \ 260 $(call first,$1))) 261 262 # ---------------------------------------------------------------------------- 263 # Function: uniq 264 # Arguments: 1: A list from which to remove repeated elements 265 # Returns: The list with duplicate elements removed without reordering 266 # ---------------------------------------------------------------------------- 267 uniq = $(strip $(__gmsl_tr1)$(if $1,$(call uniq,$(call chop,$1)) \ 268 $(if $(filter $(call last,$1),$(call chop,$1)),,$(call last,$1)))) 269 270 # ---------------------------------------------------------------------------- 271 # Function: length 272 # Arguments: 1: A list 273 # Returns: The number of elements in the list 274 # ---------------------------------------------------------------------------- 275 length = $(__gmsl_tr1)$(words $1) 276 277 # ########################################################################### 278 # STRING MANIPULATION FUNCTIONS 279 # ########################################################################### 280 281 # Helper function that translates any GNU Make 'true' value (i.e. a 282 # non-empty string) to our $(true) 283 284 __gmsl_make_bool = $(if $(strip $1),$(true),$(false)) 285 286 # ---------------------------------------------------------------------------- 287 # Function: seq 288 # Arguments: 1: A string to compare against... 289 # 2: ...this string 290 # Returns: Returns $(true) if the two strings are identical 291 # ---------------------------------------------------------------------------- 292 seq = $(__gmsl_tr2)$(if $(filter-out xx,x$(subst $1,,$2)$(subst $2,,$1)x),$(false),$(true)) 293 294 # ---------------------------------------------------------------------------- 295 # Function: sne 296 # Arguments: 1: A string to compare against... 297 # 2: ...this string 298 # Returns: Returns $(true) if the two strings are not the same 299 # ---------------------------------------------------------------------------- 300 sne = $(__gmsl_tr2)$(call not,$(call seq,$1,$2)) 301 302 # ---------------------------------------------------------------------------- 303 # Function: split 304 # Arguments: 1: The character to split on 305 # 2: A string to split 306 # Returns: Splits a string into a list separated by spaces at the split 307 # character in the first argument 308 # ---------------------------------------------------------------------------- 309 split = $(__gmsl_tr2)$(strip $(subst $1, ,$2)) 310 311 # ---------------------------------------------------------------------------- 312 # Function: merge 313 # Arguments: 1: The character to put between fields 314 # 2: A list to merge into a string 315 # Returns: Merges a list into a single string, list elements are separated 316 # by the character in the first argument 317 # ---------------------------------------------------------------------------- 318 merge = $(__gmsl_tr2)$(strip $(if $2, \ 319 $(if $(call seq,1,$(words $2)), \ 320 $2,$(call first,$2)$1$(call merge,$1,$(call rest,$2))))) 321 322 ifdef __gmsl_have_eval 323 # ---------------------------------------------------------------------------- 324 # Function: tr 325 # Arguments: 1: The list of characters to translate from 326 # 2: The list of characters to translate to 327 # 3: The text to translate 328 # Returns: Returns the text after translating characters 329 # ---------------------------------------------------------------------------- 330 tr = $(strip $(__gmsl_tr3)$(call assert_no_dollar,$0,$1$2$3) \ 331 $(eval __gmsl_t := $3) \ 332 $(foreach c, \ 333 $(join $(addsuffix :,$1),$2), \ 334 $(eval __gmsl_t := \ 335 $(subst $(word 1,$(subst :, ,$c)),$(word 2,$(subst :, ,$c)), \ 336 $(__gmsl_t))))$(__gmsl_t)) 337 338 # Common character classes for use with the tr function. Each of 339 # these is actually a variable declaration and must be wrapped with 340 # $() or ${} to be used. 341 342 [A-Z] := A B C D E F G H I J K L M N O P Q R S T U V W X Y Z # 343 [a-z] := a b c d e f g h i j k l m n o p q r s t u v w x y z # 344 [0-9] := 0 1 2 3 4 5 6 7 8 9 # 345 [A-F] := A B C D E F # 346 347 # ---------------------------------------------------------------------------- 348 # Function: uc 349 # Arguments: 1: Text to upper case 350 # Returns: Returns the text in upper case 351 # ---------------------------------------------------------------------------- 352 uc = $(__gmsl_tr1)$(call assert_no_dollar,$0,$1)$(call tr,$([a-z]),$([A-Z]),$1) 353 354 # ---------------------------------------------------------------------------- 355 # Function: lc 356 # Arguments: 1: Text to lower case 357 # Returns: Returns the text in lower case 358 # ---------------------------------------------------------------------------- 359 lc = $(__gmsl_tr1)$(call assert_no_dollar,$0,$1)$(call tr,$([A-Z]),$([a-z]),$1) 360 361 # ---------------------------------------------------------------------------- 362 # Function: strlen 363 # Arguments: 1: A string 364 # Returns: Returns the length of the string 365 # ---------------------------------------------------------------------------- 366 __gmsl_characters := A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 367 __gmsl_characters += a b c d e f g h i j k l m n o p q r s t u v w x y z 368 __gmsl_characters += 0 1 2 3 4 5 6 7 8 9 369 __gmsl_characters += ` ~ ! @ \# $$ % ^ & * ( ) - _ = + 370 __gmsl_characters += { } [ ] \ : ; ' " < > , . / ? | 371 372 # Aside: if you read the above you might think that the lower-case 373 # letter x is missing, and that that's an error. It is missing, but 374 # it's not an error. __gmsl_characters is used by the strlen 375 # function. strlen works by transforming every character and space 376 # into the letter x and then counting the x's. Since there's no need 377 # to transform x into x I omitted it. 378 379 # This results in __gmsl_space containing just a space 380 381 __gmsl_space := 382 __gmsl_space += 383 384 strlen = $(__gmsl_tr1)$(call assert_no_dollar,$0,$1)$(strip $(eval __temp := $(subst $(__gmsl_space),x,$1))$(foreach a,$(__gmsl_characters),$(eval __temp := $$(subst $$a,x,$(__temp))))$(eval __temp := $(subst x,x ,$(__temp)))$(words $(__temp))) 385 386 # This results in __gmsl_newline containing just a newline 387 388 define __gmsl_newline 389 390 391 endef 392 393 # This results in __gmsl_tab containing a tab 394 395 __gmsl_tab := # 396 397 # ---------------------------------------------------------------------------- 398 # Function: substr 399 # Arguments: 1: A string 400 # 2: Start position (first character is 1) 401 # 3: End position (inclusive) 402 # Returns: A substring. 403 # Note: The string in $1 must not contain a 404 # ---------------------------------------------------------------------------- 405 406 substr = $(__gmsl_tr3)$(call assert_no_dollar,$0,$1$2$3)$(strip $(eval __temp := $$(subst $$(__gmsl_space), ,$$1))$(foreach a,$(__gmsl_characters),$(eval __temp := $$(subst $$a,$$a$$(__gmsl_space),$(__temp))))$(eval __temp := $(wordlist $2,$3,$(__temp))))$(subst ,$(__gmsl_space),$(subst $(__gmsl_space),,$(__temp))) 407 408 endif # __gmsl_have_eval 409 410 # ########################################################################### 411 # SET MANIPULATION FUNCTIONS 412 # ########################################################################### 413 414 # Sets are represented by sorted, deduplicated lists. To create a set 415 # from a list use set_create, or start with the empty_set and 416 # set_insert individual elements 417 418 # This is the empty set 419 empty_set := 420 421 # ---------------------------------------------------------------------------- 422 # Function: set_create 423 # Arguments: 1: A list of set elements 424 # Returns: Returns the newly created set 425 # ---------------------------------------------------------------------------- 426 set_create = $(__gmsl_tr1)$(sort $1) 427 428 # ---------------------------------------------------------------------------- 429 # Function: set_insert 430 # Arguments: 1: A single element to add to a set 431 # 2: A set 432 # Returns: Returns the set with the element added 433 # ---------------------------------------------------------------------------- 434 set_insert = $(__gmsl_tr2)$(sort $1 $2) 435 436 # ---------------------------------------------------------------------------- 437 # Function: set_remove 438 # Arguments: 1: A single element to remove from a set 439 # 2: A set 440 # Returns: Returns the set with the element removed 441 # ---------------------------------------------------------------------------- 442 set_remove = $(__gmsl_tr2)$(filter-out $1,$2) 443 444 # ---------------------------------------------------------------------------- 445 # Function: set_is_member 446 # Arguments: 1: A single element 447 # 2: A set 448 # Returns: Returns $(true) if the element is in the set 449 # ---------------------------------------------------------------------------- 450 set_is_member = $(__gmsl_tr2)$(if $(filter $1,$2),$(true),$(false)) 451 452 # ---------------------------------------------------------------------------- 453 # Function: set_union 454 # Arguments: 1: A set 455 # 2: Another set 456 # Returns: Returns the union of the two sets 457 # ---------------------------------------------------------------------------- 458 set_union = $(__gmsl_tr2)$(sort $1 $2) 459 460 # ---------------------------------------------------------------------------- 461 # Function: set_intersection 462 # Arguments: 1: A set 463 # 2: Another set 464 # Returns: Returns the intersection of the two sets 465 # ---------------------------------------------------------------------------- 466 set_intersection = $(__gmsl_tr2)$(filter $1,$2) 467 468 # ---------------------------------------------------------------------------- 469 # Function: set_is_subset 470 # Arguments: 1: A set 471 # 2: Another set 472 # Returns: Returns $(true) if the first set is a subset of the second 473 # ---------------------------------------------------------------------------- 474 set_is_subset = $(__gmsl_tr2)$(call set_equal,$(call set_intersection,$1,$2),$1) 475 476 # ---------------------------------------------------------------------------- 477 # Function: set_equal 478 # Arguments: 1: A set 479 # 2: Another set 480 # Returns: Returns $(true) if the two sets are identical 481 # ---------------------------------------------------------------------------- 482 set_equal = $(__gmsl_tr2)$(call seq,$1,$2) 483 484 # ########################################################################### 485 # ARITHMETIC LIBRARY 486 # ########################################################################### 487 488 # Integers a represented by lists with the equivalent number of x's. 489 # For example the number 4 is x x x x. The maximum integer that the 490 # library can handle as _input_ is __gmsl_input_int which is defined 491 # here as 65536 492 493 __gmsl_sixteen := x x x x x x x x x x x x x x x x 494 __gmsl_input_int := $(foreach a,$(__gmsl_sixteen), \ 495 $(foreach b,$(__gmsl_sixteen), \ 496 $(foreach c,$(__gmsl_sixteen), \ 497 $(__gmsl_sixteen))))) 498 499 # ---------------------------------------------------------------------------- 500 # Function: int_decode 501 # Arguments: 1: A number of x's representation 502 # Returns: Returns the integer for human consumption that is represented 503 # by the string of x's 504 # ---------------------------------------------------------------------------- 505 int_decode = $(__gmsl_tr1)$(words $1) 506 507 # ---------------------------------------------------------------------------- 508 # Function: int_encode 509 # Arguments: 1: A number in human-readable integer form 510 # Returns: Returns the integer encoded as a string of x's 511 # ---------------------------------------------------------------------------- 512 int_encode = $(__gmsl_tr1)$(wordlist 1,$1,$(__gmsl_input_int)) 513 514 # The arithmetic library functions come in two forms: one form of each 515 # function takes integers as arguments and the other form takes the 516 # encoded form (x's created by a call to int_encode). For example, 517 # there are two plus functions: 518 # 519 # plus Called with integer arguments and returns an integer 520 # int_plus Called with encoded arguments and returns an encoded result 521 # 522 # plus will be slower than int_plus because its arguments and result 523 # have to be translated between the x's format and integers. If doing 524 # a complex calculation use the int_* forms with a single encoding of 525 # inputs and single decoding of the output. For simple calculations 526 # the direct forms can be used. 527 528 # Helper function used to wrap an int_* function into a function that 529 # takes a pair of integers, perhaps a function and returns an integer 530 # result 531 __gmsl_int_wrap = $(call int_decode,$(call $1,$(call int_encode,$2),$(call int_encode,$3))) 532 __gmsl_int_wrap1 = $(call int_decode,$(call $1,$(call int_encode,$2))) 533 __gmsl_int_wrap2 = $(call $1,$(call int_encode,$2),$(call int_encode,$3)) 534 535 # ---------------------------------------------------------------------------- 536 # Function: int_plus 537 # Arguments: 1: A number in x's representation 538 # 2: Another number in x's represntation 539 # Returns: Returns the sum of the two numbers in x's representation 540 # ---------------------------------------------------------------------------- 541 int_plus = $(strip $(__gmsl_tr2)$1 $2) 542 543 # ---------------------------------------------------------------------------- 544 # Function: plus (wrapped version of int_plus) 545 # Arguments: 1: An integer 546 # 2: Another integer 547 # Returns: Returns the sum of the two integers 548 # ---------------------------------------------------------------------------- 549 plus = $(__gmsl_tr2)$(call __gmsl_int_wrap,int_plus,$1,$2) 550 551 # ---------------------------------------------------------------------------- 552 # Function: int_subtract 553 # Arguments: 1: A number in x's representation 554 # 2: Another number in x's represntation 555 # Returns: Returns the difference of the two numbers in x's representation, 556 # or outputs an error on a numeric underflow 557 # ---------------------------------------------------------------------------- 558 int_subtract = $(strip $(__gmsl_tr2)$(if $(call int_gte,$1,$2), \ 559 $(filter-out xx,$(join $1,$2)), \ 560 $(call __gmsl_warning,Subtraction underflow))) 561 562 # ---------------------------------------------------------------------------- 563 # Function: subtract (wrapped version of int_subtract) 564 # Arguments: 1: An integer 565 # 2: Another integer 566 # Returns: Returns the difference of the two integers, 567 # or outputs an error on a numeric underflow 568 # ---------------------------------------------------------------------------- 569 subtract = $(__gmsl_tr2)$(call __gmsl_int_wrap,int_subtract,$1,$2) 570 571 # ---------------------------------------------------------------------------- 572 # Function: int_multiply 573 # Arguments: 1: A number in x's representation 574 # 2: Another number in x's represntation 575 # Returns: Returns the product of the two numbers in x's representation 576 # ---------------------------------------------------------------------------- 577 int_multiply = $(strip $(__gmsl_tr2)$(foreach a,$1,$2)) 578 579 # ---------------------------------------------------------------------------- 580 # Function: multiply (wrapped version of int_multiply) 581 # Arguments: 1: An integer 582 # 2: Another integer 583 # Returns: Returns the product of the two integers 584 # ---------------------------------------------------------------------------- 585 multiply = $(__gmsl_tr2)$(call __gmsl_int_wrap,int_multiply,$1,$2) 586 587 # ---------------------------------------------------------------------------- 588 # Function: int_divide 589 # Arguments: 1: A number in x's representation 590 # 2: Another number in x's represntation 591 # Returns: Returns the result of integer division of argument 1 divided 592 # by argument 2 in x's representation 593 # ---------------------------------------------------------------------------- 594 int_divide = $(__gmsl_tr2)$(strip $(if $2, \ 595 $(if $(call int_gte,$1,$2), \ 596 x $(call int_divide,$(call int_subtract,$1,$2),$2),), \ 597 $(call __gmsl_error,Division by zero))) 598 599 # ---------------------------------------------------------------------------- 600 # Function: divide (wrapped version of int_divide) 601 # Arguments: 1: An integer 602 # 2: Another integer 603 # Returns: Returns the integer division of the first argument by the second 604 # ---------------------------------------------------------------------------- 605 divide = $(__gmsl_tr2)$(call __gmsl_int_wrap,int_divide,$1,$2) 606 607 # ---------------------------------------------------------------------------- 608 # Function: int_max, int_min 609 # Arguments: 1: A number in x's representation 610 # 2: Another number in x's represntation 611 # Returns: Returns the maximum or minimum of its arguments in x's 612 # representation 613 # ---------------------------------------------------------------------------- 614 int_max = $(__gmsl_tr2)$(subst xx,x,$(join $1,$2)) 615 int_min = $(__gmsl_tr2)$(subst xx,x,$(filter xx,$(join $1,$2))) 616 617 # ---------------------------------------------------------------------------- 618 # Function: max, min 619 # Arguments: 1: An integer 620 # 2: Another integer 621 # Returns: Returns the maximum or minimum of its integer arguments 622 # ---------------------------------------------------------------------------- 623 max = $(__gmsl_tr2)$(call __gmsl_int_wrap,int_max,$1,$2) 624 min = $(__gmsl_tr2)$(call __gmsl_int_wrap,int_min,$1,$2) 625 626 # ---------------------------------------------------------------------------- 627 # Function: int_gt, int_gte, int_lt, int_lte, int_eq, int_ne 628 # Arguments: Two x's representation numbers to be compared 629 # Returns: $(true) or $(false) 630 # 631 # int_gt First argument greater than second argument 632 # int_gte First argument greater than or equal to second argument 633 # int_lt First argument less than second argument 634 # int_lte First argument less than or equal to second argument 635 # int_eq First argument is numerically equal to the second argument 636 # int_ne First argument is not numerically equal to the second argument 637 # ---------------------------------------------------------------------------- 638 int_gt = $(__gmsl_tr2)$(call __gmsl_make_bool, \ 639 $(filter-out $(words $2), \ 640 $(words $(call int_max,$1,$2)))) 641 int_gte = $(__gmsl_tr2)$(call __gmsl_make_bool, \ 642 $(call int_gt,$1,$2)$(call int_eq,$1,$2)) 643 int_lt = $(__gmsl_tr2)$(call __gmsl_make_bool, \ 644 $(filter-out $(words $1), \ 645 $(words $(call int_max,$1,$2)))) 646 int_lte = $(__gmsl_tr2)$(call __gmsl_make_bool, \ 647 $(call int_lt,$1,$2)$(call int_eq,$1,$2)) 648 int_eq = $(__gmsl_tr2)$(call __gmsl_make_bool, \ 649 $(filter $(words $1),$(words $2))) 650 int_ne = $(__gmsl_tr2)$(call __gmsl_make_bool, \ 651 $(filter-out $(words $1),$(words $2))) 652 653 # ---------------------------------------------------------------------------- 654 # Function: gt, gte, lt, lte, eq, ne 655 # Arguments: Two integers to be compared 656 # Returns: $(true) or $(false) 657 # 658 # gt First argument greater than second argument 659 # gte First argument greater than or equal to second argument 660 # lt First argument less than second argument 661 # lte First argument less than or equal to second argument 662 # eq First argument is numerically equal to the second argument 663 # ne First argument is not numerically equal to the second argument 664 # ---------------------------------------------------------------------------- 665 gt = $(__gmsl_tr2)$(call __gmsl_int_wrap2,int_gt,$1,$2) 666 gte = $(__gmsl_tr2)$(call __gmsl_int_wrap2,int_gte,$1,$2) 667 lt = $(__gmsl_tr2)$(call __gmsl_int_wrap2,int_lt,$1,$2) 668 lte = $(__gmsl_tr2)$(call __gmsl_int_wrap2,int_lte,$1,$2) 669 eq = $(__gmsl_tr2)$(call __gmsl_int_wrap2,int_eq,$1,$2) 670 ne = $(__gmsl_tr2)$(call __gmsl_int_wrap2,int_ne,$1,$2) 671 672 # increment adds 1 to its argument, decrement subtracts 1. Note that 673 # decrement does not range check and hence will not underflow, but 674 # will incorrectly say that 0 - 1 = 0 675 676 # ---------------------------------------------------------------------------- 677 # Function: int_inc 678 # Arguments: 1: A number in x's representation 679 # Returns: The number incremented by 1 in x's representation 680 # ---------------------------------------------------------------------------- 681 int_inc = $(strip $(__gmsl_tr1)$1 x) 682 683 # ---------------------------------------------------------------------------- 684 # Function: inc 685 # Arguments: 1: An integer 686 # Returns: The argument incremented by 1 687 # ---------------------------------------------------------------------------- 688 inc = $(__gmsl_tr1)$(call __gmsl_int_wrap1,int_inc,$1) 689 690 # ---------------------------------------------------------------------------- 691 # Function: int_dec 692 # Arguments: 1: A number in x's representation 693 # Returns: The number decremented by 1 in x's representation 694 # ---------------------------------------------------------------------------- 695 int_dec = $(__gmsl_tr1)$(strip $(if $(call sne,0,$(words $1)), \ 696 $(wordlist 2,$(words $1),$1), \ 697 $(call __gmsl_warning,Decrement underflow))) 698 699 # ---------------------------------------------------------------------------- 700 # Function: dec 701 # Arguments: 1: An integer 702 # Returns: The argument decremented by 1 703 # ---------------------------------------------------------------------------- 704 dec = $(__gmsl_tr1)$(call __gmsl_int_wrap1,int_dec,$1) 705 706 # double doubles its argument, and halve halves it 707 708 # ---------------------------------------------------------------------------- 709 # Function: int_double 710 # Arguments: 1: A number in x's representation 711 # Returns: The number doubled (i.e. * 2) and returned in x's representation 712 # ---------------------------------------------------------------------------- 713 int_double = $(strip $(__gmsl_tr1)$1 $1) 714 715 # ---------------------------------------------------------------------------- 716 # Function: double 717 # Arguments: 1: An integer 718 # Returns: The integer times 2 719 # ---------------------------------------------------------------------------- 720 double = $(__gmsl_tr1)$(call __gmsl_int_wrap1,int_double,$1) 721 722 # ---------------------------------------------------------------------------- 723 # Function: int_halve 724 # Arguments: 1: A number in x's representation 725 # Returns: The number halved (i.e. / 2) and returned in x's representation 726 # ---------------------------------------------------------------------------- 727 int_halve = $(__gmsl_tr1)$(strip $(subst xx,x,$(filter-out xy x y, \ 728 $(join $1,$(foreach a,$1,y x))))) 729 730 # ---------------------------------------------------------------------------- 731 # Function: halve 732 # Arguments: 1: An integer 733 # Returns: The integer divided by 2 734 # ---------------------------------------------------------------------------- 735 halve = $(__gmsl_tr1)$(call __gmsl_int_wrap1,int_halve,$1) 736 737 ifdef __gmsl_have_eval 738 # ########################################################################### 739 # ASSOCIATIVE ARRAYS 740 # ########################################################################### 741 742 # ---------------------------------------------------------------------------- 743 # Function: set 744 # Arguments: 1: Name of associative array 745 # 2: The key value to associate 746 # 3: The value associated with the key 747 # Returns: None 748 # ---------------------------------------------------------------------------- 749 set = $(__gmsl_tr3)$(call assert_no_dollar,$0,$1$2$3)$(eval __gmsl_aa_$1_$2 = $3) 750 751 # ---------------------------------------------------------------------------- 752 # Function: get 753 # Arguments: 1: Name of associative array 754 # 2: The key to retrieve 755 # Returns: The value stored in the array for that key 756 # ---------------------------------------------------------------------------- 757 get = $(strip $(__gmsl_tr2)$(call assert_no_dollar,$0,$1$2)$(if $(filter-out undefined,$(origin __gmsl_aa_$1_$2)), \ 758 $(__gmsl_aa_$1_$2))) 759 760 # ---------------------------------------------------------------------------- 761 # Function: keys 762 # Arguments: 1: Name of associative array 763 # Returns: Returns a list of all defined keys in the array 764 # ---------------------------------------------------------------------------- 765 keys = $(__gmsl_tr1)$(call assert_no_dollar,$0,$1)$(sort $(patsubst __gmsl_aa_$1_%,%, \ 766 $(filter __gmsl_aa_$1_%,$(.VARIABLES)))) 767 768 # ---------------------------------------------------------------------------- 769 # Function: defined 770 # Arguments: 1: Name of associative array 771 # 2: The key to test 772 # Returns: Returns true if the key is defined (i.e. not empty) 773 # ---------------------------------------------------------------------------- 774 defined = $(__gmsl_tr2)$(call assert_no_dollar,$0,$1$2)$(call sne,$(call get,$1,$2),) 775 776 endif # __gmsl_have_eval 777 778 ifdef __gmsl_have_eval 779 # ########################################################################### 780 # NAMED STACKS 781 # ########################################################################### 782 783 # ---------------------------------------------------------------------------- 784 # Function: push 785 # Arguments: 1: Name of stack 786 # 2: Value to push onto the top of the stack (must not contain 787 # a space) 788 # Returns: None 789 # ---------------------------------------------------------------------------- 790 push = $(__gmsl_tr2)$(call assert_no_dollar,$0,$1$2)$(eval __gmsl_stack_$1 := $2 $(if $(filter-out undefined,\ 791 $(origin __gmsl_stack_$1)),$(__gmsl_stack_$1))) 792 793 # ---------------------------------------------------------------------------- 794 # Function: pop 795 # Arguments: 1: Name of stack 796 # Returns: Top element from the stack after removing it 797 # ---------------------------------------------------------------------------- 798 pop = $(__gmsl_tr1)$(call assert_no_dollar,$0,$1)$(strip $(if $(filter-out undefined,$(origin __gmsl_stack_$1)), \ 799 $(call first,$(__gmsl_stack_$1)) \ 800 $(eval __gmsl_stack_$1 := $(call rest,$(__gmsl_stack_$1))))) 801 802 # ---------------------------------------------------------------------------- 803 # Function: peek 804 # Arguments: 1: Name of stack 805 # Returns: Top element from the stack without removing it 806 # ---------------------------------------------------------------------------- 807 peek = $(__gmsl_tr1)$(call assert_no_dollar,$0,$1)$(call first,$(__gmsl_stack_$1)) 808 809 # ---------------------------------------------------------------------------- 810 # Function: depth 811 # Arguments: 1: Name of stack 812 # Returns: Number of items on the stack 813 # ---------------------------------------------------------------------------- 814 depth = $(__gmsl_tr1)$(call assert_no_dollar,$0,$1)$(words $(__gmsl_stack_$1)) 815 816 endif # __gmsl_have_eval 817 818 # ########################################################################### 819 # DEBUGGING FACILITIES 820 # ########################################################################### 821 822 # ---------------------------------------------------------------------------- 823 # Target: gmsl-print-% 824 # Arguments: The % should be replaced by the name of a variable that you 825 # wish to print out. 826 # Action: Echos the name of the variable that matches the % and its value. 827 # For example, 'make gmsl-print-SHELL' will output the value of 828 # the SHELL variable 829 # ---------------------------------------------------------------------------- 830 gmsl-print-%: ; @echo $* = $($*) 831 832 # ---------------------------------------------------------------------------- 833 # Function: assert 834 # Arguments: 1: A boolean that must be true or the assertion will fail 835 # 2: The message to print with the assertion 836 # Returns: None 837 # ---------------------------------------------------------------------------- 838 assert = $(if $1,,$(call __gmsl_error,Assertion failure: $2)) 839 840 # ---------------------------------------------------------------------------- 841 # Function: assert_exists 842 # Arguments: 1: Name of file that must exist, if it is missing an assertion 843 # will be generated 844 # Returns: None 845 # ---------------------------------------------------------------------------- 846 assert_exists = $(call assert,$(wildcard $1),file '$1' missing) 847 848 # ---------------------------------------------------------------------------- 849 # Function: assert_no_dollar 850 # Arguments: 1: Name of a function being executd 851 # 2: Arguments to check 852 # Returns: None 853 # ---------------------------------------------------------------------------- 854 assert_no_dollar = $(call assert,$(call not,$(findstring $$,$2)),$1 called with a dollar sign in argument) 855
