1 divert(-1)# -*- Autoconf -*- 2 # This file is part of Autoconf. 3 # Base M4 layer. 4 # Requires GNU M4. 5 # 6 # Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software 7 # Foundation, Inc. 8 # 9 # This program is free software; you can redistribute it and/or modify 10 # it under the terms of the GNU General Public License as published by 11 # the Free Software Foundation; either version 2, or (at your option) 12 # any later version. 13 # 14 # This program is distributed in the hope that it will be useful, 15 # but WITHOUT ANY WARRANTY; without even the implied warranty of 16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 # GNU General Public License for more details. 18 # 19 # You should have received a copy of the GNU General Public License 20 # along with this program; if not, write to the Free Software 21 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 22 # 02110-1301, USA. 23 # 24 # As a special exception, the Free Software Foundation gives unlimited 25 # permission to copy, distribute and modify the configure scripts that 26 # are the output of Autoconf. You need not follow the terms of the GNU 27 # General Public License when using or distributing such scripts, even 28 # though portions of the text of Autoconf appear in them. The GNU 29 # General Public License (GPL) does govern all other use of the material 30 # that constitutes the Autoconf program. 31 # 32 # Certain portions of the Autoconf source text are designed to be copied 33 # (in certain cases, depending on the input) into the output of 34 # Autoconf. We call these the "data" portions. The rest of the Autoconf 35 # source text consists of comments plus executable code that decides which 36 # of the data portions to output in any given case. We call these 37 # comments and executable code the "non-data" portions. Autoconf never 38 # copies any of the non-data portions into its output. 39 # 40 # This special exception to the GPL applies to versions of Autoconf 41 # released by the Free Software Foundation. When you make and 42 # distribute a modified version of Autoconf, you may extend this special 43 # exception to the GPL to apply to your modified version as well, *unless* 44 # your modified version has the potential to copy into its output some 45 # of the text that was the non-data portion of the version that you started 46 # with. (In other words, unless your change moves or copies text from 47 # the non-data portions to the data portions.) If your modification has 48 # such potential, you must delete any notice of this special exception 49 # to the GPL from your modified version. 50 # 51 # Written by Akim Demaille. 52 # 53 54 # Set the quotes, whatever the current quoting system. 55 changequote() 56 changequote([, ]) 57 58 # Some old m4's don't support m4exit. But they provide 59 # equivalent functionality by core dumping because of the 60 # long macros we define. 61 ifdef([__gnu__], , 62 [errprint(M4sugar requires GNU M4. Install it before installing M4sugar or 63 set the M4 environment variable to its absolute file name.) 64 m4exit(2)]) 65 66 67 ## ------------------------------- ## 68 ## 1. Simulate --prefix-builtins. ## 69 ## ------------------------------- ## 70 71 # m4_define 72 # m4_defn 73 # m4_undefine 74 define([m4_define], defn([define])) 75 define([m4_defn], defn([defn])) 76 define([m4_undefine], defn([undefine])) 77 78 m4_undefine([define]) 79 m4_undefine([defn]) 80 m4_undefine([undefine]) 81 82 83 # m4_copy(SRC, DST) 84 # ----------------- 85 # Define DST as the definition of SRC. 86 # What's the difference between: 87 # 1. m4_copy([from], [to]) 88 # 2. m4_define([to], [from($@)]) 89 # Well, obviously 1 is more expensive in space. Maybe 2 is more expensive 90 # in time, but because of the space cost of 1, it's not that obvious. 91 # Nevertheless, one huge difference is the handling of `$0'. If `from' 92 # uses `$0', then with 1, `to''s `$0' is `to', while it is `from' in 2. 93 # The user will certainly prefer to see `to'. 94 m4_define([m4_copy], 95 [m4_define([$2], m4_defn([$1]))]) 96 97 98 # m4_rename(SRC, DST) 99 # ------------------- 100 # Rename the macro SRC as DST. 101 m4_define([m4_rename], 102 [m4_copy([$1], [$2])m4_undefine([$1])]) 103 104 105 # m4_rename_m4(MACRO-NAME) 106 # ------------------------ 107 # Rename MACRO-NAME as m4_MACRO-NAME. 108 m4_define([m4_rename_m4], 109 [m4_rename([$1], [m4_$1])]) 110 111 112 # m4_copy_unm4(m4_MACRO-NAME) 113 # --------------------------- 114 # Copy m4_MACRO-NAME as MACRO-NAME. 115 m4_define([m4_copy_unm4], 116 [m4_copy([$1], m4_bpatsubst([$1], [^m4_\(.*\)], [[\1]]))]) 117 118 119 # Some m4 internals have names colliding with tokens we might use. 120 # Rename them a` la `m4 --prefix-builtins'. 121 m4_rename_m4([builtin]) 122 m4_rename_m4([changecom]) 123 m4_rename_m4([changequote]) 124 m4_rename_m4([debugfile]) 125 m4_rename_m4([debugmode]) 126 m4_rename_m4([decr]) 127 m4_undefine([divert]) 128 m4_rename_m4([divnum]) 129 m4_rename_m4([dumpdef]) 130 m4_rename_m4([errprint]) 131 m4_rename_m4([esyscmd]) 132 m4_rename_m4([eval]) 133 m4_rename_m4([format]) 134 m4_rename_m4([ifdef]) 135 m4_rename([ifelse], [m4_if]) 136 m4_undefine([include]) 137 m4_rename_m4([incr]) 138 m4_rename_m4([index]) 139 m4_rename_m4([indir]) 140 m4_rename_m4([len]) 141 m4_rename([m4exit], [m4_exit]) 142 m4_rename([m4wrap], [m4_wrap]) 143 m4_rename_m4([maketemp]) 144 m4_rename([patsubst], [m4_bpatsubst]) 145 m4_undefine([popdef]) 146 m4_rename_m4([pushdef]) 147 m4_rename([regexp], [m4_bregexp]) 148 m4_rename_m4([shift]) 149 m4_undefine([sinclude]) 150 m4_rename_m4([substr]) 151 m4_rename_m4([symbols]) 152 m4_rename_m4([syscmd]) 153 m4_rename_m4([sysval]) 154 m4_rename_m4([traceoff]) 155 m4_rename_m4([traceon]) 156 m4_rename_m4([translit]) 157 m4_undefine([undivert]) 158 159 160 ## ------------------- ## 161 ## 2. Error messages. ## 162 ## ------------------- ## 163 164 165 # m4_location 166 # ----------- 167 m4_define([m4_location], 168 [__file__:__line__]) 169 170 171 # m4_errprintn(MSG) 172 # ----------------- 173 # Same as `errprint', but with the missing end of line. 174 m4_define([m4_errprintn], 175 [m4_errprint([$1 176 ])]) 177 178 179 # m4_warning(MSG) 180 # --------------- 181 # Warn the user. 182 m4_define([m4_warning], 183 [m4_errprintn(m4_location[: warning: $1])]) 184 185 186 # m4_fatal(MSG, [EXIT-STATUS]) 187 # ---------------------------- 188 # Fatal the user. :) 189 m4_define([m4_fatal], 190 [m4_errprintn(m4_location[: error: $1])dnl 191 m4_expansion_stack_dump()dnl 192 m4_exit(m4_if([$2],, 1, [$2]))]) 193 194 195 # m4_assert(EXPRESSION, [EXIT-STATUS = 1]) 196 # ---------------------------------------- 197 # This macro ensures that EXPRESSION evaluates to true, and exits if 198 # EXPRESSION evaluates to false. 199 m4_define([m4_assert], 200 [m4_if(m4_eval([$1]), 0, 201 [m4_fatal([assert failed: $1], [$2])])]) 202 203 204 205 ## ------------- ## 206 ## 3. Warnings. ## 207 ## ------------- ## 208 209 210 # _m4_warn(CATEGORY, MESSAGE, STACK-TRACE) 211 # ---------------------------------------- 212 # Report a MESSAGE to the user if the CATEGORY of warnings is enabled. 213 # This is for traces only. 214 # The STACK-TRACE is a \n-separated list of "LOCATION: MESSAGE". 215 m4_define([_m4_warn], []) 216 217 218 # m4_warn(CATEGORY, MESSAGE) 219 # -------------------------- 220 # Report a MESSAGE to the user if the CATEGORY of warnings is enabled. 221 m4_define([m4_warn], 222 [_m4_warn([$1], [$2], 223 m4_ifdef([m4_expansion_stack], 224 [m4_defn([m4_expansion_stack]) 225 m4_location[: the top level]]))dnl 226 ]) 227 228 229 230 ## ------------------- ## 231 ## 4. File inclusion. ## 232 ## ------------------- ## 233 234 235 # We also want to neutralize include (and sinclude for symmetry), 236 # but we want to extend them slightly: warn when a file is included 237 # several times. This is in general a dangerous operation because 238 # quite nobody quotes the first argument of m4_define. 239 # 240 # For instance in the following case: 241 # m4_define(foo, [bar]) 242 # then a second reading will turn into 243 # m4_define(bar, [bar]) 244 # which is certainly not what was meant. 245 246 # m4_include_unique(FILE) 247 # ----------------------- 248 # Declare that the FILE was loading; and warn if it has already 249 # been included. 250 m4_define([m4_include_unique], 251 [m4_ifdef([m4_include($1)], 252 [m4_warn([syntax], [file `$1' included several times])])dnl 253 m4_define([m4_include($1)])]) 254 255 256 # m4_include(FILE) 257 # ---------------- 258 # As the builtin include, but warns against multiple inclusions. 259 m4_define([m4_include], 260 [m4_include_unique([$1])dnl 261 m4_builtin([include], [$1])]) 262 263 264 # m4_sinclude(FILE) 265 # ----------------- 266 # As the builtin sinclude, but warns against multiple inclusions. 267 m4_define([m4_sinclude], 268 [m4_include_unique([$1])dnl 269 m4_builtin([sinclude], [$1])]) 270 271 272 273 ## ------------------------------------ ## 274 ## 5. Additional branching constructs. ## 275 ## ------------------------------------ ## 276 277 # Both `m4_ifval' and `m4_ifset' tests against the empty string. The 278 # difference is that `m4_ifset' is specialized on macros. 279 # 280 # In case of arguments of macros, eg $[1], it makes little difference. 281 # In the case of a macro `FOO', you don't want to check `m4_ifval(FOO, 282 # TRUE)', because if `FOO' expands with commas, there is a shifting of 283 # the arguments. So you want to run `m4_ifval([FOO])', but then you just 284 # compare the *string* `FOO' against `', which, of course fails. 285 # 286 # So you want a variation of `m4_ifset' that expects a macro name as $[1]. 287 # If this macro is both defined and defined to a non empty value, then 288 # it runs TRUE etc. 289 290 291 # m4_ifval(COND, [IF-TRUE], [IF-FALSE]) 292 # ------------------------------------- 293 # If COND is not the empty string, expand IF-TRUE, otherwise IF-FALSE. 294 # Comparable to m4_ifdef. 295 m4_define([m4_ifval], 296 [m4_if([$1], [], [$3], [$2])]) 297 298 299 # m4_n(TEXT) 300 # ---------- 301 # If TEXT is not empty, return TEXT and a new line, otherwise nothing. 302 m4_define([m4_n], 303 [m4_if([$1], 304 [], [], 305 [$1 306 ])]) 307 308 309 # m4_ifvaln(COND, [IF-TRUE], [IF-FALSE]) 310 # -------------------------------------- 311 # Same as `m4_ifval', but add an extra newline to IF-TRUE or IF-FALSE 312 # unless that argument is empty. 313 m4_define([m4_ifvaln], 314 [m4_if([$1], 315 [], [m4_n([$3])], 316 [m4_n([$2])])]) 317 318 319 # m4_ifset(MACRO, [IF-TRUE], [IF-FALSE]) 320 # -------------------------------------- 321 # If MACRO has no definition, or of its definition is the empty string, 322 # expand IF-FALSE, otherwise IF-TRUE. 323 m4_define([m4_ifset], 324 [m4_ifdef([$1], 325 [m4_ifval(m4_defn([$1]), [$2], [$3])], 326 [$3])]) 327 328 329 # m4_ifndef(NAME, [IF-NOT-DEFINED], [IF-DEFINED]) 330 # ----------------------------------------------- 331 m4_define([m4_ifndef], 332 [m4_ifdef([$1], [$3], [$2])]) 333 334 335 # m4_case(SWITCH, VAL1, IF-VAL1, VAL2, IF-VAL2, ..., DEFAULT) 336 # ----------------------------------------------------------- 337 # m4 equivalent of 338 # switch (SWITCH) 339 # { 340 # case VAL1: 341 # IF-VAL1; 342 # break; 343 # case VAL2: 344 # IF-VAL2; 345 # break; 346 # ... 347 # default: 348 # DEFAULT; 349 # break; 350 # }. 351 # All the values are optional, and the macro is robust to active 352 # symbols properly quoted. 353 m4_define([m4_case], 354 [m4_if([$#], 0, [], 355 [$#], 1, [], 356 [$#], 2, [$2], 357 [$1], [$2], [$3], 358 [$0([$1], m4_shiftn(3, $@))])]) 359 360 361 # m4_bmatch(SWITCH, RE1, VAL1, RE2, VAL2, ..., DEFAULT) 362 # ----------------------------------------------------- 363 # m4 equivalent of 364 # 365 # if (SWITCH =~ RE1) 366 # VAL1; 367 # elif (SWITCH =~ RE2) 368 # VAL2; 369 # elif ... 370 # ... 371 # else 372 # DEFAULT 373 # 374 # All the values are optional, and the macro is robust to active symbols 375 # properly quoted. 376 m4_define([m4_bmatch], 377 [m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], 378 [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], 379 [$#], 2, [$2], 380 [m4_if(m4_bregexp([$1], [$2]), -1, [$0([$1], m4_shiftn(3, $@))], 381 [$3])])]) 382 383 384 # m4_car(LIST) 385 # m4_cdr(LIST) 386 # ------------ 387 # Manipulate m4 lists. 388 m4_define([m4_car], [[$1]]) 389 m4_define([m4_cdr], 390 [m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], 391 [$#], 1, [], 392 [m4_dquote(m4_shift($@))])]) 393 394 395 # m4_map(MACRO, LIST) 396 # ------------------- 397 # Invoke MACRO($1), MACRO($2) etc. where $1, $2... are the elements 398 # of LIST (which can be lists themselves, for multiple arguments MACROs). 399 m4_define([m4_fst], [$1]) 400 m4_define([m4_map], 401 [m4_if([$2], [[]], [], 402 [_m4_map([$1], [$2])])]) 403 m4_define([_m4_map], 404 [m4_ifval([$2], 405 [$1(m4_fst($2))[]_m4_map([$1], m4_cdr($2))])]) 406 407 408 # m4_map_sep(MACRO, SEPARATOR, LIST) 409 # ---------------------------------- 410 # Invoke MACRO($1), SEPARATOR, MACRO($2), ..., MACRO($N) where $1, $2... $N 411 # are the elements of LIST (which can be lists themselves, for multiple 412 # arguments MACROs). 413 m4_define([m4_map_sep], 414 [m4_if([$3], [[]], [], 415 [$1(m4_fst($3))[]_m4_map([$2[]$1], m4_cdr($3))])]) 416 417 418 ## ---------------------------------------- ## 419 ## 6. Enhanced version of some primitives. ## 420 ## ---------------------------------------- ## 421 422 # m4_bpatsubsts(STRING, RE1, SUBST1, RE2, SUBST2, ...) 423 # ---------------------------------------------------- 424 # m4 equivalent of 425 # 426 # $_ = STRING; 427 # s/RE1/SUBST1/g; 428 # s/RE2/SUBST2/g; 429 # ... 430 # 431 # All the values are optional, and the macro is robust to active symbols 432 # properly quoted. 433 # 434 # I would have liked to name this macro `m4_bpatsubst', unfortunately, 435 # due to quotation problems, I need to double quote $1 below, therefore 436 # the anchors are broken :( I can't let users be trapped by that. 437 m4_define([m4_bpatsubsts], 438 [m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], 439 [$#], 1, [m4_fatal([$0: too few arguments: $#: $1])], 440 [$#], 2, [m4_builtin([patsubst], $@)], 441 [$0(m4_builtin([patsubst], [[$1]], [$2], [$3]), 442 m4_shiftn(3, $@))])]) 443 444 445 446 # m4_do(STRING, ...) 447 # ------------------ 448 # This macro invokes all its arguments (in sequence, of course). It is 449 # useful for making your macros more structured and readable by dropping 450 # unnecessary dnl's and have the macros indented properly. 451 m4_define([m4_do], 452 [m4_if($#, 0, [], 453 $#, 1, [$1], 454 [$1[]m4_do(m4_shift($@))])]) 455 456 457 # m4_define_default(MACRO, VALUE) 458 # ------------------------------- 459 # If MACRO is undefined, set it to VALUE. 460 m4_define([m4_define_default], 461 [m4_ifndef([$1], [m4_define($@)])]) 462 463 464 # m4_default(EXP1, EXP2) 465 # ---------------------- 466 # Returns EXP1 if non empty, otherwise EXP2. 467 m4_define([m4_default], 468 [m4_ifval([$1], [$1], [$2])]) 469 470 471 # m4_defn(NAME) 472 # ------------- 473 # Unlike to the original, don't tolerate popping something which is 474 # undefined. 475 m4_define([m4_defn], 476 [m4_ifndef([$1], 477 [m4_fatal([$0: undefined macro: $1])])dnl 478 m4_builtin([defn], $@)]) 479 480 481 # _m4_dumpdefs_up(NAME) 482 # --------------------- 483 m4_define([_m4_dumpdefs_up], 484 [m4_ifdef([$1], 485 [m4_pushdef([_m4_dumpdefs], m4_defn([$1]))dnl 486 m4_dumpdef([$1])dnl 487 m4_popdef([$1])dnl 488 _m4_dumpdefs_up([$1])])]) 489 490 491 # _m4_dumpdefs_down(NAME) 492 # ----------------------- 493 m4_define([_m4_dumpdefs_down], 494 [m4_ifdef([_m4_dumpdefs], 495 [m4_pushdef([$1], m4_defn([_m4_dumpdefs]))dnl 496 m4_popdef([_m4_dumpdefs])dnl 497 _m4_dumpdefs_down([$1])])]) 498 499 500 # m4_dumpdefs(NAME) 501 # ----------------- 502 # Similar to `m4_dumpdef(NAME)', but if NAME was m4_pushdef'ed, display its 503 # value stack (most recent displayed first). 504 m4_define([m4_dumpdefs], 505 [_m4_dumpdefs_up([$1])dnl 506 _m4_dumpdefs_down([$1])]) 507 508 509 # m4_popdef(NAME) 510 # --------------- 511 # Unlike to the original, don't tolerate popping something which is 512 # undefined. 513 m4_define([m4_popdef], 514 [m4_ifndef([$1], 515 [m4_fatal([$0: undefined macro: $1])])dnl 516 m4_builtin([popdef], $@)]) 517 518 519 # m4_quote(ARGS) 520 # -------------- 521 # Return ARGS as a single arguments. 522 # 523 # It is important to realize the difference between `m4_quote(exp)' and 524 # `[exp]': in the first case you obtain the quoted *result* of the 525 # expansion of EXP, while in the latter you just obtain the string 526 # `exp'. 527 m4_define([m4_quote], [[$*]]) 528 m4_define([m4_dquote], [[$@]]) 529 530 531 # m4_noquote(STRING) 532 # ------------------ 533 # Return the result of ignoring all quotes in STRING and invoking the 534 # macros it contains. Amongst other things useful for enabling macro 535 # invocations inside strings with [] blocks (for instance regexps and 536 # help-strings). 537 m4_define([m4_noquote], 538 [m4_changequote(-=<{,}>=-)$1-=<{}>=-m4_changequote([,])]) 539 540 541 # m4_shiftn(N, ...) 542 # ----------------- 543 # Returns ... shifted N times. Useful for recursive "varargs" constructs. 544 m4_define([m4_shiftn], 545 [m4_assert(($1 >= 0) && ($# > $1))dnl 546 _m4_shiftn($@)]) 547 548 m4_define([_m4_shiftn], 549 [m4_if([$1], 0, 550 [m4_shift($@)], 551 [_m4_shiftn(m4_eval([$1]-1), m4_shift(m4_shift($@)))])]) 552 553 554 # m4_undefine(NAME) 555 # ----------------- 556 # Unlike to the original, don't tolerate undefining something which is 557 # undefined. 558 m4_define([m4_undefine], 559 [m4_ifndef([$1], 560 [m4_fatal([$0: undefined macro: $1])])dnl 561 m4_builtin([undefine], $@)]) 562 563 564 ## -------------------------- ## 565 ## 7. Implementing m4 loops. ## 566 ## -------------------------- ## 567 568 569 # m4_for(VARIABLE, FIRST, LAST, [STEP = +/-1], EXPRESSION) 570 # -------------------------------------------------------- 571 # Expand EXPRESSION defining VARIABLE to FROM, FROM + 1, ..., TO. 572 # Both limits are included, and bounds are checked for consistency. 573 m4_define([m4_for], 574 [m4_case(m4_sign(m4_eval($3 - $2)), 575 1, [m4_assert(m4_sign(m4_default($4, 1)) == 1)], 576 -1, [m4_assert(m4_sign(m4_default($4, -1)) == -1)])dnl 577 m4_pushdef([$1], [$2])dnl 578 m4_if(m4_eval([$3 > $2]), 1, 579 [_m4_for([$1], [$3], m4_default([$4], 1), [$5])], 580 [_m4_for([$1], [$3], m4_default([$4], -1), [$5])])dnl 581 m4_popdef([$1])]) 582 583 584 # _m4_for(VARIABLE, FIRST, LAST, STEP, EXPRESSION) 585 # ------------------------------------------------ 586 # Core of the loop, no consistency checks. 587 m4_define([_m4_for], 588 [$4[]dnl 589 m4_if($1, [$2], [], 590 [m4_define([$1], m4_eval($1+[$3]))_m4_for([$1], [$2], [$3], [$4])])]) 591 592 593 # Implementing `foreach' loops in m4 is much more tricky than it may 594 # seem. Actually, the example of a `foreach' loop in the m4 595 # documentation is wrong: it does not quote the arguments properly, 596 # which leads to undesirable expansions. 597 # 598 # The example in the documentation is: 599 # 600 # | # foreach(VAR, (LIST), STMT) 601 # | m4_define([foreach], 602 # | [m4_pushdef([$1])_foreach([$1], [$2], [$3])m4_popdef([$1])]) 603 # | m4_define([_arg1], [$1]) 604 # | m4_define([_foreach], 605 # | [m4_if([$2], [()], , 606 # | [m4_define([$1], _arg1$2)$3[]_foreach([$1], 607 # | (shift$2), 608 # | [$3])])]) 609 # 610 # But then if you run 611 # 612 # | m4_define(a, 1) 613 # | m4_define(b, 2) 614 # | m4_define(c, 3) 615 # | foreach([f], [([a], [(b], [c)])], [echo f 616 # | ]) 617 # 618 # it gives 619 # 620 # => echo 1 621 # => echo (2,3) 622 # 623 # which is not what is expected. 624 # 625 # Of course the problem is that many quotes are missing. So you add 626 # plenty of quotes at random places, until you reach the expected 627 # result. Alternatively, if you are a quoting wizard, you directly 628 # reach the following implementation (but if you really did, then 629 # apply to the maintenance of m4sugar!). 630 # 631 # | # foreach(VAR, (LIST), STMT) 632 # | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) 633 # | m4_define([_arg1], [[$1]]) 634 # | m4_define([_foreach], 635 # | [m4_if($2, [()], , 636 # | [m4_define([$1], [_arg1$2])$3[]_foreach([$1], 637 # | [(shift$2)], 638 # | [$3])])]) 639 # 640 # which this time answers 641 # 642 # => echo a 643 # => echo (b 644 # => echo c) 645 # 646 # Bingo! 647 # 648 # Well, not quite. 649 # 650 # With a better look, you realize that the parens are more a pain than 651 # a help: since anyway you need to quote properly the list, you end up 652 # with always using an outermost pair of parens and an outermost pair 653 # of quotes. Rejecting the parens both eases the implementation, and 654 # simplifies the use: 655 # 656 # | # foreach(VAR, (LIST), STMT) 657 # | m4_define([foreach], [m4_pushdef([$1])_foreach($@)m4_popdef([$1])]) 658 # | m4_define([_arg1], [$1]) 659 # | m4_define([_foreach], 660 # | [m4_if($2, [], , 661 # | [m4_define([$1], [_arg1($2)])$3[]_foreach([$1], 662 # | [shift($2)], 663 # | [$3])])]) 664 # 665 # 666 # Now, just replace the `$2' with `m4_quote($2)' in the outer `m4_if' 667 # to improve robustness, and you come up with a quite satisfactory 668 # implementation. 669 670 671 # m4_foreach(VARIABLE, LIST, EXPRESSION) 672 # -------------------------------------- 673 # 674 # Expand EXPRESSION assigning each value of the LIST to VARIABLE. 675 # LIST should have the form `item_1, item_2, ..., item_n', i.e. the 676 # whole list must *quoted*. Quote members too if you don't want them 677 # to be expanded. 678 # 679 # This macro is robust to active symbols: 680 # | m4_define(active, [ACT, IVE]) 681 # | m4_foreach(Var, [active, active], [-Var-]) 682 # => -ACT--IVE--ACT--IVE- 683 # 684 # | m4_foreach(Var, [[active], [active]], [-Var-]) 685 # => -ACT, IVE--ACT, IVE- 686 # 687 # | m4_foreach(Var, [[[active]], [[active]]], [-Var-]) 688 # => -active--active- 689 m4_define([m4_foreach], 690 [m4_pushdef([$1])_m4_foreach($@)m4_popdef([$1])]) 691 692 m4_define([_m4_foreach], 693 [m4_ifval([$2], 694 [m4_define([$1], m4_car($2))$3[]dnl 695 _m4_foreach([$1], m4_cdr($2), [$3])])]) 696 697 698 # m4_foreach_w(VARIABLE, LIST, EXPRESSION) 699 # ---------------------------------------- 700 # 701 # Like m4_foreach, but the list is whitespace separated. 702 # 703 # This macro is robust to active symbols: 704 # m4_foreach_w([Var], [ active 705 # b act\ 706 # ive ], [-Var-])end 707 # => -active--b--active-end 708 # 709 m4_define([m4_foreach_w], 710 [m4_foreach([$1], m4_split(m4_normalize([$2])), [$3])]) 711 712 713 714 ## --------------------------- ## 715 ## 8. More diversion support. ## 716 ## --------------------------- ## 717 718 719 # _m4_divert(DIVERSION-NAME or NUMBER) 720 # ------------------------------------ 721 # If DIVERSION-NAME is the name of a diversion, return its number, 722 # otherwise if it is a NUMBER return it. 723 m4_define([_m4_divert], 724 [m4_ifdef([_m4_divert($1)], 725 [m4_indir([_m4_divert($1)])], 726 [$1])]) 727 728 # KILL is only used to suppress output. 729 m4_define([_m4_divert(KILL)], -1) 730 731 732 # _m4_divert_n_stack 733 # ------------------ 734 # Print m4_divert_stack with newline prepended, if it's nonempty. 735 m4_define([_m4_divert_n_stack], 736 [m4_ifdef([m4_divert_stack], [ 737 m4_defn([m4_divert_stack])])]) 738 739 740 # m4_divert(DIVERSION-NAME) 741 # ------------------------- 742 # Change the diversion stream to DIVERSION-NAME. 743 m4_define([m4_divert], 744 [m4_define([m4_divert_stack], m4_location[: $0: $1]_m4_divert_n_stack)dnl 745 m4_builtin([divert], _m4_divert([$1]))dnl 746 ]) 747 748 749 # m4_divert_push(DIVERSION-NAME) 750 # ------------------------------ 751 # Change the diversion stream to DIVERSION-NAME, while stacking old values. 752 m4_define([m4_divert_push], 753 [m4_pushdef([m4_divert_stack], m4_location[: $0: $1]_m4_divert_n_stack)dnl 754 m4_pushdef([_m4_divert_diversion], [$1])dnl 755 m4_builtin([divert], _m4_divert([$1]))dnl 756 ]) 757 758 759 # m4_divert_pop([DIVERSION-NAME]) 760 # ------------------------------- 761 # Change the diversion stream to its previous value, unstacking it. 762 # If specified, verify we left DIVERSION-NAME. 763 # When we pop the last value from the stack, we divert to -1. 764 m4_define([m4_divert_pop], 765 [m4_ifndef([_m4_divert_diversion], 766 [m4_fatal([too many m4_divert_pop])])dnl 767 m4_if([$1], [], [], 768 [$1], m4_defn([_m4_divert_diversion]), [], 769 [m4_fatal([$0($1): diversion mismatch: ]_m4_divert_n_stack)])dnl 770 m4_popdef([m4_divert_stack])dnl 771 m4_popdef([_m4_divert_diversion])dnl 772 m4_builtin([divert], 773 m4_ifdef([_m4_divert_diversion], 774 [_m4_divert(m4_defn([_m4_divert_diversion]))], 775 -1))dnl 776 ]) 777 778 779 # m4_divert_text(DIVERSION-NAME, CONTENT) 780 # --------------------------------------- 781 # Output CONTENT into DIVERSION-NAME (which may be a number actually). 782 # An end of line is appended for free to CONTENT. 783 m4_define([m4_divert_text], 784 [m4_divert_push([$1])dnl 785 $2 786 m4_divert_pop([$1])dnl 787 ]) 788 789 790 # m4_divert_once(DIVERSION-NAME, CONTENT) 791 # --------------------------------------- 792 # Output once CONTENT into DIVERSION-NAME (which may be a number 793 # actually). An end of line is appended for free to CONTENT. 794 m4_define([m4_divert_once], 795 [m4_expand_once([m4_divert_text([$1], [$2])])]) 796 797 798 # m4_undivert(DIVERSION-NAME) 799 # --------------------------- 800 # Undivert DIVERSION-NAME. 801 m4_define([m4_undivert], 802 [m4_builtin([undivert], _m4_divert([$1]))]) 803 804 805 ## -------------------------------------------- ## 806 ## 8. Defining macros with bells and whistles. ## 807 ## -------------------------------------------- ## 808 809 # `m4_defun' is basically `m4_define' but it equips the macro with the 810 # needed machinery for `m4_require'. A macro must be m4_defun'd if 811 # either it is m4_require'd, or it m4_require's. 812 # 813 # Two things deserve attention and are detailed below: 814 # 1. Implementation of m4_require 815 # 2. Keeping track of the expansion stack 816 # 817 # 1. Implementation of m4_require 818 # =============================== 819 # 820 # Of course m4_defun AC_PROVIDE's the macro, so that a macro which has 821 # been expanded is not expanded again when m4_require'd, but the 822 # difficult part is the proper expansion of macros when they are 823 # m4_require'd. 824 # 825 # The implementation is based on two ideas, (i) using diversions to 826 # prepare the expansion of the macro and its dependencies (by Franc,ois 827 # Pinard), and (ii) expand the most recently m4_require'd macros _after_ 828 # the previous macros (by Axel Thimm). 829 # 830 # 831 # The first idea: why using diversions? 832 # ------------------------------------- 833 # 834 # When a macro requires another, the other macro is expanded in new 835 # diversion, GROW. When the outer macro is fully expanded, we first 836 # undivert the most nested diversions (GROW - 1...), and finally 837 # undivert GROW. To understand why we need several diversions, 838 # consider the following example: 839 # 840 # | m4_defun([TEST1], [Test...REQUIRE([TEST2])1]) 841 # | m4_defun([TEST2], [Test...REQUIRE([TEST3])2]) 842 # | m4_defun([TEST3], [Test...3]) 843 # 844 # Because m4_require is not required to be first in the outer macros, we 845 # must keep the expansions of the various level of m4_require separated. 846 # Right before executing the epilogue of TEST1, we have: 847 # 848 # GROW - 2: Test...3 849 # GROW - 1: Test...2 850 # GROW: Test...1 851 # BODY: 852 # 853 # Finally the epilogue of TEST1 undiverts GROW - 2, GROW - 1, and 854 # GROW into the regular flow, BODY. 855 # 856 # GROW - 2: 857 # GROW - 1: 858 # GROW: 859 # BODY: Test...3; Test...2; Test...1 860 # 861 # (The semicolons are here for clarification, but of course are not 862 # emitted.) This is what Autoconf 2.0 (I think) to 2.13 (I'm sure) 863 # implement. 864 # 865 # 866 # The second idea: first required first out 867 # ----------------------------------------- 868 # 869 # The natural implementation of the idea above is buggy and produces 870 # very surprising results in some situations. Let's consider the 871 # following example to explain the bug: 872 # 873 # | m4_defun([TEST1], [REQUIRE([TEST2a])REQUIRE([TEST2b])]) 874 # | m4_defun([TEST2a], []) 875 # | m4_defun([TEST2b], [REQUIRE([TEST3])]) 876 # | m4_defun([TEST3], [REQUIRE([TEST2a])]) 877 # | 878 # | AC_INIT 879 # | TEST1 880 # 881 # The dependencies between the macros are: 882 # 883 # 3 --- 2b 884 # / \ is m4_require'd by 885 # / \ left -------------------- right 886 # 2a ------------ 1 887 # 888 # If you strictly apply the rules given in the previous section you get: 889 # 890 # GROW - 2: TEST3 891 # GROW - 1: TEST2a; TEST2b 892 # GROW: TEST1 893 # BODY: 894 # 895 # (TEST2a, although required by TEST3 is not expanded in GROW - 3 896 # because is has already been expanded before in GROW - 1, so it has 897 # been AC_PROVIDE'd, so it is not expanded again) so when you undivert 898 # the stack of diversions, you get: 899 # 900 # GROW - 2: 901 # GROW - 1: 902 # GROW: 903 # BODY: TEST3; TEST2a; TEST2b; TEST1 904 # 905 # i.e., TEST2a is expanded after TEST3 although the latter required the 906 # former. 907 # 908 # Starting from 2.50, uses an implementation provided by Axel Thimm. 909 # The idea is simple: the order in which macros are emitted must be the 910 # same as the one in which macro are expanded. (The bug above can 911 # indeed be described as: a macro has been AC_PROVIDE'd, but it is 912 # emitted after: the lack of correlation between emission and expansion 913 # order is guilty). 914 # 915 # How to do that? You keeping the stack of diversions to elaborate the 916 # macros, but each time a macro is fully expanded, emit it immediately. 917 # 918 # In the example above, when TEST2a is expanded, but it's epilogue is 919 # not run yet, you have: 920 # 921 # GROW - 2: 922 # GROW - 1: TEST2a 923 # GROW: Elaboration of TEST1 924 # BODY: 925 # 926 # The epilogue of TEST2a emits it immediately: 927 # 928 # GROW - 2: 929 # GROW - 1: 930 # GROW: Elaboration of TEST1 931 # BODY: TEST2a 932 # 933 # TEST2b then requires TEST3, so right before the epilogue of TEST3, you 934 # have: 935 # 936 # GROW - 2: TEST3 937 # GROW - 1: Elaboration of TEST2b 938 # GROW: Elaboration of TEST1 939 # BODY: TEST2a 940 # 941 # The epilogue of TEST3 emits it: 942 # 943 # GROW - 2: 944 # GROW - 1: Elaboration of TEST2b 945 # GROW: Elaboration of TEST1 946 # BODY: TEST2a; TEST3 947 # 948 # TEST2b is now completely expanded, and emitted: 949 # 950 # GROW - 2: 951 # GROW - 1: 952 # GROW: Elaboration of TEST1 953 # BODY: TEST2a; TEST3; TEST2b 954 # 955 # and finally, TEST1 is finished and emitted: 956 # 957 # GROW - 2: 958 # GROW - 1: 959 # GROW: 960 # BODY: TEST2a; TEST3; TEST2b: TEST1 961 # 962 # The idea is simple, but the implementation is a bit evolved. If you 963 # are like me, you will want to see the actual functioning of this 964 # implementation to be convinced. The next section gives the full 965 # details. 966 # 967 # 968 # The Axel Thimm implementation at work 969 # ------------------------------------- 970 # 971 # We consider the macros above, and this configure.ac: 972 # 973 # AC_INIT 974 # TEST1 975 # 976 # You should keep the definitions of _m4_defun_pro, _m4_defun_epi, and 977 # m4_require at hand to follow the steps. 978 # 979 # This implements tries not to assume that the current diversion is 980 # BODY, so as soon as a macro (m4_defun'd) is expanded, we first 981 # record the current diversion under the name _m4_divert_dump (denoted 982 # DUMP below for short). This introduces an important difference with 983 # the previous versions of Autoconf: you cannot use m4_require if you 984 # are not inside an m4_defun'd macro, and especially, you cannot 985 # m4_require directly from the top level. 986 # 987 # We have not tried to simulate the old behavior (better yet, we 988 # diagnose it), because it is too dangerous: a macro m4_require'd from 989 # the top level is expanded before the body of `configure', i.e., before 990 # any other test was run. I let you imagine the result of requiring 991 # AC_STDC_HEADERS for instance, before AC_PROG_CC was actually run.... 992 # 993 # After AC_INIT was run, the current diversion is BODY. 994 # * AC_INIT was run 995 # DUMP: undefined 996 # diversion stack: BODY |- 997 # 998 # * TEST1 is expanded 999 # The prologue of TEST1 sets _m4_divert_dump, which is the diversion 1000 # where the current elaboration will be dumped, to the current 1001 # diversion. It also m4_divert_push to GROW, where the full 1002 # expansion of TEST1 and its dependencies will be elaborated. 1003 # DUMP: BODY 1004 # BODY: empty 1005 # diversions: GROW, BODY |- 1006 # 1007 # * TEST1 requires TEST2a 1008 # _m4_require_call m4_divert_pushes another temporary diversion, 1009 # GROW - 1, and expands TEST2a in there. 1010 # DUMP: BODY 1011 # BODY: empty 1012 # GROW - 1: TEST2a 1013 # diversions: GROW - 1, GROW, BODY |- 1014 # Than the content of the temporary diversion is moved to DUMP and the 1015 # temporary diversion is popped. 1016 # DUMP: BODY 1017 # BODY: TEST2a 1018 # diversions: GROW, BODY |- 1019 # 1020 # * TEST1 requires TEST2b 1021 # Again, _m4_require_call pushes GROW - 1 and heads to expand TEST2b. 1022 # DUMP: BODY 1023 # BODY: TEST2a 1024 # diversions: GROW - 1, GROW, BODY |- 1025 # 1026 # * TEST2b requires TEST3 1027 # _m4_require_call pushes GROW - 2 and expands TEST3 here. 1028 # (TEST3 requires TEST2a, but TEST2a has already been m4_provide'd, so 1029 # nothing happens.) 1030 # DUMP: BODY 1031 # BODY: TEST2a 1032 # GROW - 2: TEST3 1033 # diversions: GROW - 2, GROW - 1, GROW, BODY |- 1034 # Than the diversion is appended to DUMP, and popped. 1035 # DUMP: BODY 1036 # BODY: TEST2a; TEST3 1037 # diversions: GROW - 1, GROW, BODY |- 1038 # 1039 # * TEST1 requires TEST2b (contd.) 1040 # The content of TEST2b is expanded... 1041 # DUMP: BODY 1042 # BODY: TEST2a; TEST3 1043 # GROW - 1: TEST2b, 1044 # diversions: GROW - 1, GROW, BODY |- 1045 # ... and moved to DUMP. 1046 # DUMP: BODY 1047 # BODY: TEST2a; TEST3; TEST2b 1048 # diversions: GROW, BODY |- 1049 # 1050 # * TEST1 is expanded: epilogue 1051 # TEST1's own content is in GROW... 1052 # DUMP: BODY 1053 # BODY: TEST2a; TEST3; TEST2b 1054 # GROW: TEST1 1055 # diversions: BODY |- 1056 # ... and it's epilogue moves it to DUMP and then undefines DUMP. 1057 # DUMP: undefined 1058 # BODY: TEST2a; TEST3; TEST2b; TEST1 1059 # diversions: BODY |- 1060 # 1061 # 1062 # 2. Keeping track of the expansion stack 1063 # ======================================= 1064 # 1065 # When M4 expansion goes wrong it is often extremely hard to find the 1066 # path amongst macros that drove to the failure. What is needed is 1067 # the stack of macro `calls'. One could imagine that GNU M4 would 1068 # maintain a stack of macro expansions, unfortunately it doesn't, so 1069 # we do it by hand. This is of course extremely costly, but the help 1070 # this stack provides is worth it. Nevertheless to limit the 1071 # performance penalty this is implemented only for m4_defun'd macros, 1072 # not for define'd macros. 1073 # 1074 # The scheme is simplistic: each time we enter an m4_defun'd macros, 1075 # we prepend its name in m4_expansion_stack, and when we exit the 1076 # macro, we remove it (thanks to pushdef/popdef). 1077 # 1078 # In addition, we want to detect circular m4_require dependencies. 1079 # Each time we expand a macro FOO we define _m4_expanding(FOO); and 1080 # m4_require(BAR) simply checks whether _m4_expanding(BAR) is defined. 1081 1082 1083 # m4_expansion_stack_push(TEXT) 1084 # ----------------------------- 1085 m4_define([m4_expansion_stack_push], 1086 [m4_pushdef([m4_expansion_stack], 1087 [$1]m4_ifdef([m4_expansion_stack], [ 1088 m4_defn([m4_expansion_stack])]))]) 1089 1090 1091 # m4_expansion_stack_pop 1092 # ---------------------- 1093 m4_define([m4_expansion_stack_pop], 1094 [m4_popdef([m4_expansion_stack])]) 1095 1096 1097 # m4_expansion_stack_dump 1098 # ----------------------- 1099 # Dump the expansion stack. 1100 m4_define([m4_expansion_stack_dump], 1101 [m4_ifdef([m4_expansion_stack], 1102 [m4_errprintn(m4_defn([m4_expansion_stack]))])dnl 1103 m4_errprintn(m4_location[: the top level])]) 1104 1105 1106 # _m4_divert(GROW) 1107 # ---------------- 1108 # This diversion is used by the m4_defun/m4_require machinery. It is 1109 # important to keep room before GROW because for each nested 1110 # AC_REQUIRE we use an additional diversion (i.e., two m4_require's 1111 # will use GROW - 2. More than 3 levels has never seemed to be 1112 # needed.) 1113 # 1114 # ... 1115 # - GROW - 2 1116 # m4_require'd code, 2 level deep 1117 # - GROW - 1 1118 # m4_require'd code, 1 level deep 1119 # - GROW 1120 # m4_defun'd macros are elaborated here. 1121 1122 m4_define([_m4_divert(GROW)], 10000) 1123 1124 1125 # _m4_defun_pro(MACRO-NAME) 1126 # ------------------------- 1127 # The prologue for Autoconf macros. 1128 m4_define([_m4_defun_pro], 1129 [m4_ifndef([m4_expansion_stack], [_m4_defun_pro_outer[]])dnl 1130 m4_expansion_stack_push(m4_defn([m4_location($1)])[: $1 is expanded from...])dnl 1131 m4_pushdef([_m4_expanding($1)])dnl 1132 ]) 1133 1134 m4_define([_m4_defun_pro_outer], 1135 [m4_copy([_m4_divert_diversion], [_m4_divert_dump])dnl 1136 m4_divert_push([GROW])dnl 1137 ]) 1138 1139 # _m4_defun_epi(MACRO-NAME) 1140 # ------------------------- 1141 # The Epilogue for Autoconf macros. MACRO-NAME only helps tracing 1142 # the PRO/EPI pairs. 1143 m4_define([_m4_defun_epi], 1144 [m4_popdef([_m4_expanding($1)])dnl 1145 m4_expansion_stack_pop()dnl 1146 m4_ifndef([m4_expansion_stack], [_m4_defun_epi_outer[]])dnl 1147 m4_provide([$1])dnl 1148 ]) 1149 1150 m4_define([_m4_defun_epi_outer], 1151 [m4_undefine([_m4_divert_dump])dnl 1152 m4_divert_pop([GROW])dnl 1153 m4_undivert([GROW])dnl 1154 ]) 1155 1156 1157 # m4_defun(NAME, EXPANSION) 1158 # ------------------------- 1159 # Define a macro which automatically provides itself. Add machinery 1160 # so the macro automatically switches expansion to the diversion 1161 # stack if it is not already using it. In this case, once finished, 1162 # it will bring back all the code accumulated in the diversion stack. 1163 # This, combined with m4_require, achieves the topological ordering of 1164 # macros. We don't use this macro to define some frequently called 1165 # macros that are not involved in ordering constraints, to save m4 1166 # processing. 1167 m4_define([m4_defun], 1168 [m4_define([m4_location($1)], m4_location)dnl 1169 m4_define([$1], 1170 [_m4_defun_pro([$1])$2[]_m4_defun_epi([$1])])]) 1171 1172 1173 # m4_defun_once(NAME, EXPANSION) 1174 # ------------------------------ 1175 # As m4_defun, but issues the EXPANSION only once, and warns if used 1176 # several times. 1177 m4_define([m4_defun_once], 1178 [m4_define([m4_location($1)], m4_location)dnl 1179 m4_define([$1], 1180 [m4_provide_if([$1], 1181 [m4_warn([syntax], [$1 invoked multiple times])], 1182 [_m4_defun_pro([$1])$2[]_m4_defun_epi([$1])])])]) 1183 1184 1185 # m4_pattern_forbid(ERE, [WHY]) 1186 # ----------------------------- 1187 # Declare that no token matching the extended regular expression ERE 1188 # should be seen in the output but if... 1189 m4_define([m4_pattern_forbid], []) 1190 1191 1192 # m4_pattern_allow(ERE) 1193 # --------------------- 1194 # ... but if that token matches the extended regular expression ERE. 1195 # Both used via traces. 1196 m4_define([m4_pattern_allow], []) 1197 1198 1199 ## ----------------------------- ## 1200 ## Dependencies between macros. ## 1201 ## ----------------------------- ## 1202 1203 1204 # m4_before(THIS-MACRO-NAME, CALLED-MACRO-NAME) 1205 # --------------------------------------------- 1206 m4_define([m4_before], 1207 [m4_provide_if([$2], 1208 [m4_warn([syntax], [$2 was called before $1])])]) 1209 1210 1211 # m4_require(NAME-TO-CHECK, [BODY-TO-EXPAND = NAME-TO-CHECK]) 1212 # ----------------------------------------------------------- 1213 # If NAME-TO-CHECK has never been expanded (actually, if it is not 1214 # m4_provide'd), expand BODY-TO-EXPAND *before* the current macro 1215 # expansion. Once expanded, emit it in _m4_divert_dump. Keep track 1216 # of the m4_require chain in m4_expansion_stack. 1217 # 1218 # The normal cases are: 1219 # 1220 # - NAME-TO-CHECK == BODY-TO-EXPAND 1221 # Which you can use for regular macros with or without arguments, e.g., 1222 # m4_require([AC_PROG_CC], [AC_PROG_CC]) 1223 # m4_require([AC_CHECK_HEADERS(limits.h)], [AC_CHECK_HEADERS(limits.h)]) 1224 # which is just the same as 1225 # m4_require([AC_PROG_CC]) 1226 # m4_require([AC_CHECK_HEADERS(limits.h)]) 1227 # 1228 # - BODY-TO-EXPAND == m4_indir([NAME-TO-CHECK]) 1229 # In the case of macros with irregular names. For instance: 1230 # m4_require([AC_LANG_COMPILER(C)], [indir([AC_LANG_COMPILER(C)])]) 1231 # which means `if the macro named `AC_LANG_COMPILER(C)' (the parens are 1232 # part of the name, it is not an argument) has not been run, then 1233 # call it.' 1234 # Had you used 1235 # m4_require([AC_LANG_COMPILER(C)], [AC_LANG_COMPILER(C)]) 1236 # then m4_require would have tried to expand `AC_LANG_COMPILER(C)', i.e., 1237 # call the macro `AC_LANG_COMPILER' with `C' as argument. 1238 # 1239 # You could argue that `AC_LANG_COMPILER', when it receives an argument 1240 # such as `C' should dispatch the call to `AC_LANG_COMPILER(C)'. But this 1241 # `extension' prevents `AC_LANG_COMPILER' from having actual arguments that 1242 # it passes to `AC_LANG_COMPILER(C)'. 1243 m4_define([m4_require], 1244 [m4_ifdef([_m4_expanding($1)], 1245 [m4_fatal([$0: circular dependency of $1])])dnl 1246 m4_ifndef([_m4_divert_dump], 1247 [m4_fatal([$0($1): cannot be used outside of an m4_defun'd macro])])dnl 1248 m4_provide_if([$1], 1249 [], 1250 [_m4_require_call([$1], [$2])])dnl 1251 ]) 1252 1253 1254 # _m4_require_call(BODY-TO-EXPAND) 1255 # -------------------------------- 1256 # If m4_require decides to expand the body, it calls this macro. 1257 m4_define([_m4_require_call], 1258 [m4_define([_m4_divert_grow], m4_decr(_m4_divert_grow))dnl 1259 m4_divert_push(_m4_divert_grow)dnl 1260 m4_default([$2], [$1]) 1261 m4_provide_if([$1], 1262 [], 1263 [m4_warn([syntax], 1264 [$1 is m4_require'd but not m4_defun'd])])dnl 1265 m4_divert(m4_defn([_m4_divert_dump]))dnl 1266 m4_undivert(_m4_divert_grow)dnl 1267 m4_divert_pop(_m4_divert_grow)dnl 1268 m4_define([_m4_divert_grow], m4_incr(_m4_divert_grow))dnl 1269 ]) 1270 1271 1272 # _m4_divert_grow 1273 # --------------- 1274 # The counter for _m4_require_call. 1275 m4_define([_m4_divert_grow], _m4_divert([GROW])) 1276 1277 1278 # m4_expand_once(TEXT, [WITNESS = TEXT]) 1279 # -------------------------------------- 1280 # If TEXT has never been expanded, expand it *here*. Use WITNESS as 1281 # as a memory that TEXT has already been expanded. 1282 m4_define([m4_expand_once], 1283 [m4_provide_if(m4_ifval([$2], [[$2]], [[$1]]), 1284 [], 1285 [m4_provide(m4_ifval([$2], [[$2]], [[$1]]))[]$1])]) 1286 1287 1288 # m4_provide(MACRO-NAME) 1289 # ---------------------- 1290 m4_define([m4_provide], 1291 [m4_define([m4_provide($1)])]) 1292 1293 1294 # m4_provide_if(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED) 1295 # ------------------------------------------------------- 1296 # If MACRO-NAME is provided do IF-PROVIDED, else IF-NOT-PROVIDED. 1297 # The purpose of this macro is to provide the user with a means to 1298 # check macros which are provided without letting her know how the 1299 # information is coded. 1300 m4_define([m4_provide_if], 1301 [m4_ifdef([m4_provide($1)], 1302 [$2], [$3])]) 1303 1304 1305 ## -------------------- ## 1306 ## 9. Text processing. ## 1307 ## -------------------- ## 1308 1309 1310 # m4_cr_letters 1311 # m4_cr_LETTERS 1312 # m4_cr_Letters 1313 # ------------- 1314 m4_define([m4_cr_letters], [abcdefghijklmnopqrstuvwxyz]) 1315 m4_define([m4_cr_LETTERS], [ABCDEFGHIJKLMNOPQRSTUVWXYZ]) 1316 m4_define([m4_cr_Letters], 1317 m4_defn([m4_cr_letters])dnl 1318 m4_defn([m4_cr_LETTERS])dnl 1319 ) 1320 1321 1322 # m4_cr_digits 1323 # ------------ 1324 m4_define([m4_cr_digits], [0123456789]) 1325 1326 1327 # m4_cr_symbols1 & m4_cr_symbols2 1328 # ------------------------------- 1329 m4_define([m4_cr_symbols1], 1330 m4_defn([m4_cr_Letters])dnl 1331 _) 1332 1333 m4_define([m4_cr_symbols2], 1334 m4_defn([m4_cr_symbols1])dnl 1335 m4_defn([m4_cr_digits])dnl 1336 ) 1337 1338 1339 # m4_re_escape(STRING) 1340 # -------------------- 1341 # Escape RE active characters in STRING. 1342 m4_define([m4_re_escape], 1343 [m4_bpatsubst([$1], 1344 [[][*+.?\^$]], [\\\&])]) 1345 1346 1347 # m4_re_string 1348 # ------------ 1349 # Regexp for `[a-zA-Z_0-9]*' 1350 # m4_dquote provides literal [] for the character class. 1351 m4_define([m4_re_string], 1352 m4_dquote(m4_defn([m4_cr_symbols2]))dnl 1353 [*]dnl 1354 ) 1355 1356 1357 # m4_re_word 1358 # ---------- 1359 # Regexp for `[a-zA-Z_][a-zA-Z_0-9]*' 1360 m4_define([m4_re_word], 1361 m4_dquote(m4_defn([m4_cr_symbols1]))dnl 1362 m4_defn([m4_re_string])dnl 1363 ) 1364 1365 1366 # m4_tolower(STRING) 1367 # m4_toupper(STRING) 1368 # ------------------ 1369 # These macros lowercase and uppercase strings. 1370 m4_define([m4_tolower], 1371 [m4_translit([$1], m4_defn([m4_cr_LETTERS]), m4_defn([m4_cr_letters]))]) 1372 m4_define([m4_toupper], 1373 [m4_translit([$1], m4_defn([m4_cr_letters]), m4_defn([m4_cr_LETTERS]))]) 1374 1375 1376 # m4_split(STRING, [REGEXP]) 1377 # -------------------------- 1378 # 1379 # Split STRING into an m4 list of quoted elements. The elements are 1380 # quoted with [ and ]. Beginning spaces and end spaces *are kept*. 1381 # Use m4_strip to remove them. 1382 # 1383 # REGEXP specifies where to split. Default is [\t ]+. 1384 # 1385 # If STRING is empty, the result is an empty list. 1386 # 1387 # Pay attention to the m4_changequotes. When m4 reads the definition of 1388 # m4_split, it still has quotes set to [ and ]. Luckily, these are matched 1389 # in the macro body, so the definition is stored correctly. 1390 # 1391 # Also, notice that $1 is quoted twice, since we want the result to 1392 # be quoted. Then you should understand that the argument of 1393 # patsubst is ``STRING'' (i.e., with additional `` and ''). 1394 # 1395 # This macro is safe on active symbols, i.e.: 1396 # m4_define(active, ACTIVE) 1397 # m4_split([active active ])end 1398 # => [active], [active], []end 1399 1400 m4_define([m4_split], 1401 [m4_ifval([$1], [_m4_split($@)])]) 1402 1403 m4_define([_m4_split], 1404 [m4_changequote(``, '')dnl 1405 [dnl Can't use m4_default here instead of m4_if, because m4_default uses 1406 dnl [ and ] as quotes. 1407 m4_bpatsubst(````$1'''', 1408 m4_if(``$2'',, ``[ ]+'', ``$2''), 1409 ``], ['')]dnl 1410 m4_changequote([, ])]) 1411 1412 1413 1414 # m4_flatten(STRING) 1415 # ------------------ 1416 # If STRING contains end of lines, replace them with spaces. If there 1417 # are backslashed end of lines, remove them. This macro is safe with 1418 # active symbols. 1419 # m4_define(active, ACTIVE) 1420 # m4_flatten([active 1421 # act\ 1422 # ive])end 1423 # => active activeend 1424 m4_define([m4_flatten], 1425 [m4_translit(m4_bpatsubst([[[$1]]], [\\ 1426 ]), [ 1427 ], [ ])]) 1428 1429 1430 # m4_strip(STRING) 1431 # ---------------- 1432 # Expands into STRING with tabs and spaces singled out into a single 1433 # space, and removing leading and trailing spaces. 1434 # 1435 # This macro is robust to active symbols. 1436 # m4_define(active, ACTIVE) 1437 # m4_strip([ active <tab> <tab>active ])end 1438 # => active activeend 1439 # 1440 # Because we want to preserve active symbols, STRING must be double-quoted. 1441 # 1442 # Then notice the 2 last patterns: they are in charge of removing the 1443 # leading/trailing spaces. Why not just `[^ ]'? Because they are 1444 # applied to doubly quoted strings, i.e. more or less [[STRING]]. So 1445 # if there is a leading space in STRING, then it is the *third* 1446 # character, since there are two leading `['; equally for the last pattern. 1447 m4_define([m4_strip], 1448 [m4_bpatsubsts([[$1]], 1449 [[ ]+], [ ], 1450 [^\(..\) ], [\1], 1451 [ \(..\)$], [\1])]) 1452 1453 1454 # m4_normalize(STRING) 1455 # -------------------- 1456 # Apply m4_flatten and m4_strip to STRING. 1457 # 1458 # The argument is quoted, so that the macro is robust to active symbols: 1459 # 1460 # m4_define(active, ACTIVE) 1461 # m4_normalize([ act\ 1462 # ive 1463 # active ])end 1464 # => active activeend 1465 1466 m4_define([m4_normalize], 1467 [m4_strip(m4_flatten([$1]))]) 1468 1469 1470 1471 # m4_join(SEP, ARG1, ARG2...) 1472 # --------------------------- 1473 # Produce ARG1SEPARG2...SEPARGn. 1474 m4_defun([m4_join], 1475 [m4_case([$#], 1476 [1], [], 1477 [2], [[$2]], 1478 [[$2][$1]$0([$1], m4_shiftn(2, $@))])]) 1479 1480 1481 1482 # m4_append(MACRO-NAME, STRING, [SEPARATOR]) 1483 # ------------------------------------------ 1484 # Redefine MACRO-NAME to hold its former content plus `SEPARATOR`'STRING' 1485 # at the end. It is valid to use this macro with MACRO-NAME undefined, 1486 # in which case no SEPARATOR is added. Be aware that the criterion is 1487 # `not being defined', and not `not being empty'. 1488 # 1489 # This macro is robust to active symbols. It can be used to grow 1490 # strings. 1491 # 1492 # | m4_define(active, ACTIVE) 1493 # | m4_append([sentence], [This is an]) 1494 # | m4_append([sentence], [ active ]) 1495 # | m4_append([sentence], [symbol.]) 1496 # | sentence 1497 # | m4_undefine([active])dnl 1498 # | sentence 1499 # => This is an ACTIVE symbol. 1500 # => This is an active symbol. 1501 # 1502 # It can be used to define hooks. 1503 # 1504 # | m4_define(active, ACTIVE) 1505 # | m4_append([hooks], [m4_define([act1], [act2])]) 1506 # | m4_append([hooks], [m4_define([act2], [active])]) 1507 # | m4_undefine([active]) 1508 # | act1 1509 # | hooks 1510 # | act1 1511 # => act1 1512 # => 1513 # => active 1514 m4_define([m4_append], 1515 [m4_define([$1], 1516 m4_ifdef([$1], [m4_defn([$1])$3])[$2])]) 1517 1518 # m4_prepend(MACRO-NAME, STRING, [SEPARATOR]) 1519 # ------------------------------------------- 1520 # Same, but prepend. 1521 m4_define([m4_prepend], 1522 [m4_define([$1], 1523 [$2]m4_ifdef([$1], [$3[]m4_defn([$1])]))]) 1524 1525 # m4_append_uniq(MACRO-NAME, STRING, [SEPARATOR]) 1526 # ----------------------------------------------- 1527 # As `m4_append', but append only if not yet present. 1528 m4_define([m4_append_uniq], 1529 [m4_ifdef([$1], 1530 [m4_bmatch([$3]m4_defn([$1])[$3], m4_re_escape([$3$2$3]), [], 1531 [m4_append($@)])], 1532 [m4_append($@)])]) 1533 1534 1535 # m4_text_wrap(STRING, [PREFIX], [FIRST-PREFIX], [WIDTH]) 1536 # ------------------------------------------------------- 1537 # Expands into STRING wrapped to hold in WIDTH columns (default = 79). 1538 # If PREFIX is given, each line is prefixed with it. If FIRST-PREFIX is 1539 # specified, then the first line is prefixed with it. As a special case, 1540 # if the length of FIRST-PREFIX is greater than that of PREFIX, then 1541 # FIRST-PREFIX will be left alone on the first line. 1542 # 1543 # Typical outputs are: 1544 # 1545 # m4_text_wrap([Short string */], [ ], [/* ], 20) 1546 # => /* Short string */ 1547 # 1548 # m4_text_wrap([Much longer string */], [ ], [/* ], 20) 1549 # => /* Much longer 1550 # => string */ 1551 # 1552 # m4_text_wrap([Short doc.], [ ], [ --short ], 30) 1553 # => --short Short doc. 1554 # 1555 # m4_text_wrap([Short doc.], [ ], [ --too-wide ], 30) 1556 # => --too-wide 1557 # => Short doc. 1558 # 1559 # m4_text_wrap([Super long documentation.], [ ], [ --too-wide ], 30) 1560 # => --too-wide 1561 # => Super long 1562 # => documentation. 1563 # 1564 # FIXME: there is no checking of a longer PREFIX than WIDTH, but do 1565 # we really want to bother with people trying each single corner 1566 # of a software? 1567 # 1568 # more important: 1569 # FIXME: handle quadrigraphs correctly, both in TEXT and in FIRST_PREFIX. 1570 # 1571 # This macro does not leave a trailing space behind the last word, 1572 # what complicates it a bit. The algorithm is stupid simple: all the 1573 # words are preceded by m4_Separator which is defined to empty for the 1574 # first word, and then ` ' (single space) for all the others. 1575 m4_define([m4_text_wrap], 1576 [m4_pushdef([m4_Prefix], [$2])dnl 1577 m4_pushdef([m4_Prefix1], m4_default([$3], [m4_Prefix]))dnl 1578 m4_pushdef([m4_Width], m4_default([$4], 79))dnl 1579 m4_pushdef([m4_Cursor], m4_len(m4_Prefix1))dnl 1580 m4_pushdef([m4_Separator], [])dnl 1581 m4_Prefix1[]dnl 1582 m4_if(m4_eval(m4_Cursor > m4_len(m4_Prefix)), 1583 1, [m4_define([m4_Cursor], m4_len(m4_Prefix)) 1584 m4_Prefix])[]dnl 1585 m4_foreach_w([m4_Word], [$1], 1586 [m4_define([m4_Cursor], m4_eval(m4_Cursor + m4_len(m4_defn([m4_Word])) + 1))dnl 1587 dnl New line if too long, else insert a space unless it is the first 1588 dnl of the words. 1589 m4_if(m4_eval(m4_Cursor > m4_Width), 1590 1, [m4_define([m4_Cursor], 1591 m4_eval(m4_len(m4_Prefix) + m4_len(m4_defn([m4_Word])) + 1))] 1592 m4_Prefix, 1593 [m4_Separator])[]dnl 1594 m4_defn([m4_Word])[]dnl 1595 m4_define([m4_Separator], [ ])])dnl 1596 m4_popdef([m4_Separator])dnl 1597 m4_popdef([m4_Cursor])dnl 1598 m4_popdef([m4_Width])dnl 1599 m4_popdef([m4_Prefix1])dnl 1600 m4_popdef([m4_Prefix])dnl 1601 ]) 1602 1603 1604 # m4_text_box(MESSAGE, [FRAME-CHARACTER = `-']) 1605 # --------------------------------------------- 1606 m4_define([m4_text_box], 1607 [@%:@@%:@ m4_bpatsubst([$1], [.], m4_if([$2], [], [[-]], [[$2]])) @%:@@%:@ 1608 @%:@@%:@ $1 @%:@@%:@ 1609 @%:@@%:@ m4_bpatsubst([$1], [.], m4_if([$2], [], [[-]], [[$2]])) @%:@@%:@[]dnl 1610 ]) 1611 1612 1613 # m4_qlen(STRING) 1614 # --------------- 1615 # Expands to the length of STRING after autom4te converts all quadrigraphs. 1616 m4_define([m4_qlen], 1617 [m4_len(m4_bpatsubsts([[$1]], [@\(<:\|:>\|S|\|%:\)@], [P], [@&t@]))]) 1618 1619 1620 # m4_qdelta(STRING) 1621 # ----------------- 1622 # Expands to the net change in the length of STRING from autom4te converting the 1623 # quadrigraphs in STRING. This number is always negative or zero. 1624 m4_define([m4_qdelta], 1625 [m4_eval(m4_qlen([$1]) - m4_len([$1]))]) 1626 1627 1628 1629 ## ----------------------- ## 1630 ## 10. Number processing. ## 1631 ## ----------------------- ## 1632 1633 # m4_sign(A) 1634 # ---------- 1635 # 1636 # The sign of the integer A. 1637 m4_define([m4_sign], 1638 [m4_bmatch([$1], 1639 [^-], -1, 1640 [^0+], 0, 1641 1)]) 1642 1643 # m4_cmp(A, B) 1644 # ------------ 1645 # 1646 # Compare two integers. 1647 # A < B -> -1 1648 # A = B -> 0 1649 # A > B -> 1 1650 m4_define([m4_cmp], 1651 [m4_sign(m4_eval([$1 - $2]))]) 1652 1653 1654 # m4_list_cmp(A, B) 1655 # ----------------- 1656 # 1657 # Compare the two lists of integers A and B. For instance: 1658 # m4_list_cmp((1, 0), (1)) -> 0 1659 # m4_list_cmp((1, 0), (1, 0)) -> 0 1660 # m4_list_cmp((1, 2), (1, 0)) -> 1 1661 # m4_list_cmp((1, 2, 3), (1, 2)) -> 1 1662 # m4_list_cmp((1, 2, -3), (1, 2)) -> -1 1663 # m4_list_cmp((1, 0), (1, 2)) -> -1 1664 # m4_list_cmp((1), (1, 2)) -> -1 1665 m4_define([m4_list_cmp], 1666 [m4_if([$1$2], [()()], 0, 1667 [$1], [()], [$0((0), [$2])], 1668 [$2], [()], [$0([$1], (0))], 1669 [m4_case(m4_cmp(m4_car$1, m4_car$2), 1670 -1, -1, 1671 1, 1, 1672 0, [$0((m4_shift$1), (m4_shift$2))])])]) 1673 1674 1675 1676 ## ------------------------ ## 1677 ## 11. Version processing. ## 1678 ## ------------------------ ## 1679 1680 1681 # m4_version_unletter(VERSION) 1682 # ---------------------------- 1683 # Normalize beta version numbers with letters to numbers only for comparison. 1684 # 1685 # Nl -> (N+1).-1.(l#) 1686 # 1687 #i.e., 2.14a -> 2.15.-1.1, 2.14b -> 2.15.-1.2, etc. 1688 # This macro is absolutely not robust to active macro, it expects 1689 # reasonable version numbers and is valid up to `z', no double letters. 1690 m4_define([m4_version_unletter], 1691 [m4_translit(m4_bpatsubsts([$1], 1692 [\([0-9]+\)\([abcdefghi]\)], 1693 [m4_eval(\1 + 1).-1.\2], 1694 [\([0-9]+\)\([jklmnopqrs]\)], 1695 [m4_eval(\1 + 1).-1.1\2], 1696 [\([0-9]+\)\([tuvwxyz]\)], 1697 [m4_eval(\1 + 1).-1.2\2]), 1698 [abcdefghijklmnopqrstuvwxyz], 1699 [12345678901234567890123456])]) 1700 1701 1702 # m4_version_compare(VERSION-1, VERSION-2) 1703 # ---------------------------------------- 1704 # Compare the two version numbers and expand into 1705 # -1 if VERSION-1 < VERSION-2 1706 # 0 if = 1707 # 1 if > 1708 m4_define([m4_version_compare], 1709 [m4_list_cmp((m4_split(m4_version_unletter([$1]), [\.])), 1710 (m4_split(m4_version_unletter([$2]), [\.])))]) 1711 1712 1713 # m4_PACKAGE_NAME 1714 # m4_PACKAGE_TARNAME 1715 # m4_PACKAGE_VERSION 1716 # m4_PACKAGE_STRING 1717 # m4_PACKAGE_BUGREPORT 1718 # -------------------- 1719 #m4_include([m4sugar/version.m4]) # This is needed for Autoconf, but not Bison. 1720 1721 1722 # m4_version_prereq(VERSION, [IF-OK], [IF-NOT = FAIL]) 1723 # ---------------------------------------------------- 1724 # Check this Autoconf version against VERSION. 1725 m4_define([m4_version_prereq], 1726 [m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]), [$1]), -1, 1727 [m4_default([$3], 1728 [m4_fatal([Autoconf version $1 or higher is required], 1729 63)])], 1730 [$2])[]dnl 1731 ]) 1732 1733 1734 1735 ## ------------------- ## 1736 ## 12. File handling. ## 1737 ## ------------------- ## 1738 1739 1740 # It is a real pity that M4 comes with no macros to bind a diversion 1741 # to a file. So we have to deal without, which makes us a lot more 1742 # fragile that we should. 1743 1744 1745 # m4_file_append(FILE-NAME, CONTENT) 1746 # ---------------------------------- 1747 m4_define([m4_file_append], 1748 [m4_syscmd([cat >>$1 <<_m4eof 1749 $2 1750 _m4eof 1751 ]) 1752 m4_if(m4_sysval, [0], [], 1753 [m4_fatal([$0: cannot write: $1])])]) 1754 1755 1756 1757 ## ------------------------ ## 1758 ## 13. Setting M4sugar up. ## 1759 ## ------------------------ ## 1760 1761 1762 # m4_init 1763 # ------- 1764 m4_define([m4_init], 1765 [# All the M4sugar macros start with `m4_', except `dnl' kept as is 1766 # for sake of simplicity. 1767 m4_pattern_forbid([^_?m4_]) 1768 m4_pattern_forbid([^dnl$]) 1769 1770 # Check the divert push/pop perfect balance. 1771 m4_wrap([m4_ifdef([_m4_divert_diversion], 1772 [m4_fatal([$0: unbalanced m4_divert_push:]_m4_divert_n_stack)])[]]) 1773 1774 m4_divert_push([KILL]) 1775 m4_wrap([m4_divert_pop([KILL])[]]) 1776 ]) 1777
